Conflict resolution details with original conflict hunks and resolved hunks.

1. Deleted module mega-test vs main never-cache regression

Related PRs: beta #11812, main #13298.

Original conflict: 1.0-beta deleted the old module mega-test after splitting module coverage, while main added the never-cache object-return regression to the deleted file.

```diff
diff --git a/core/integration/module_test.go b/core/integration/module_test.go
@@ -7531,6 +7531,24 @@ func (m *Test) ObjsWithNothing() ([]*Test, error) {
+
+func (ModuleSuite) TestNeverCacheModuleObjectReturn(ctx context.Context, t *testctx.T) {
+    c := connect(ctx, t)
+    modGen := modInit(t, c, "go", `package main
+
+type Test struct{}
+
+// +cache="never"
+func (m *Test) Touch() *Test {
+    return m
+}
+`)
+    out, err := modGen.With(daggerCall("touch")).Stdout(ctx)
+    require.NoError(t, err)
+    require.Contains(t, out, "Test@")
+}
```

Resolution: keep beta's deleted mega-test because the regression is already ported to beta's split runtime behavior test and runtime cache-control fixture from the previous merge.

```diff
diff --git a/core/integration/module_runtime_behavior_test.go b/core/integration/module_runtime_behavior_test.go
@@
 func (ModuleSuite) TestNeverCacheModuleObjectReturn(ctx context.Context, t *testctx.T) {
     c := connect(ctx, t)
     modGen := moduleFixture(t, c, "go/runtime-cache-control")
     out, err := modGen.With(daggerCall("touch")).Stdout(ctx)
     require.NoError(t, err)
     require.Contains(t, out, "Test@")
 }
diff --git a/core/integration/testdata/modules/go/runtime-cache-control/main.go b/core/integration/testdata/modules/go/runtime-cache-control/main.go
@@
 // +cache="never"
 func (m *Test) Touch() *Test {
     return m
 }
```

2. Shell helper command path

Related PRs: beta #11812, main #13239.

Original conflict: main's helper calls `dagger shell`, while beta's helper supports root-shell module paths through `daggerShellAt`.

```diff
diff --cc core/integration/shell_test.go
@@
 func daggerShellAt(modPath, script string) dagger.WithContainerFunc {
     return func(c *dagger.Container) *dagger.Container {
++<<<<<<< HEAD:core/integration/shell_test.go
+        execArgs := []string{"dagger", "shell"}
+        if modPath != "" {
+            execArgs = append(execArgs, "-m", modPath)
+        }
+        return c.WithExec(execArgs, dagger.ContainerWithExecOpts{
++=======
+        return c.WithExec([]string{"dagger", "shell"}, dagger.ContainerWithExecOpts{
++>>>>>>> origin/main:core/integration/module_shell_test.go
```

Resolution: combine both concerns: always invoke `dagger shell`, and append beta's `-m <path>` only when the helper receives a module path. `daggerShellNoMod` already remains `dagger shell -M`.

```diff
diff --git a/core/integration/shell_test.go b/core/integration/shell_test.go
@@
 func daggerShellAt(modPath, script string) dagger.WithContainerFunc {
     return func(c *dagger.Container) *dagger.Container {
         execArgs := []string{"dagger", "shell"}
         if modPath != "" {
             execArgs = append(execArgs, "-m", modPath)
         }
         return c.WithExec(execArgs, dagger.ContainerWithExecOpts{
```

3. Release dry-run workspace loading

Related PRs: beta #13327, main #13285.

Original conflict: beta fixed the cache-persistence release dry-run to load the synthetic repo as a workspace; main still loaded it as an extra module. The synthetic repo root uses workspace-only toolchains, so `-m` fails with the workspace migration error.

```diff
diff --cc core/integration/engine_persistence_test.go
@@
 script := `set +e
++<<<<<<< HEAD
+/bin/dagger --progress=plain -W "$MODULE_REF" call release publish --tag "$RELEASE_TAG" --commit "$RELEASE_COMMIT" --dry-run=true markdown > /tmp/publish.log 2>&1
++=======
+/bin/dagger --progress=plain -m "$MODULE_REF" call release publish --tag "$RELEASE_TAG" --commit "$RELEASE_COMMIT" --dry-run=true markdown > /tmp/publish.log 2>&1
++>>>>>>> origin/main
```

Resolution: keep beta's `-W "$MODULE_REF"` workspace load, preserving the previous CI fix and the dry-run assertions.

```diff
diff --git a/core/integration/engine_persistence_test.go b/core/integration/engine_persistence_test.go
@@
 /bin/dagger --progress=plain -W "$MODULE_REF" call release publish --tag "$RELEASE_TAG" --commit "$RELEASE_COMMIT" --dry-run=true markdown > /tmp/publish.log 2>&1
```

4. Module workspace config fields

Related PRs: beta #13300, main #13329.

Original conflict: main added legacy argument customizations to `Module`, while beta renamed and documented workspace settings from `dagger.toml`.

```diff
diff --cc core/module.go
@@
++<<<<<<< HEAD
+    // Workspace setting values from dagger.toml [modules.<name>.settings].
++=======
+    // LegacyArgCustomizations are workspace dagger.json argument customizations
+    // applied through asModule.
+    LegacyArgCustomizations []*modules.ModuleConfigArgument
+
+    // Config values from workspace config.toml [modules.<name>.config].
++>>>>>>> origin/main
     // Typed map: strings, bools, ints, floats as-is from TOML.
     // When set, constructor args are resolved from this map first.
     WorkspaceConfig map[string]any
```

Resolution: keep both fields: main's `LegacyArgCustomizations` is still used by merged `modulesource.go`, and beta's `WorkspaceConfig` comment reflects the current 1.0-beta `dagger.toml` settings model.

```diff
diff --git a/core/module.go b/core/module.go
@@
     // LegacyArgCustomizations are workspace dagger.json argument customizations
     // applied through asModule.
     LegacyArgCustomizations []*modules.ModuleConfigArgument

     // Workspace setting values from dagger.toml [modules.<name>.settings].
     // Typed map: strings, bools, ints, floats as-is from TOML.
     // When set, constructor args are resolved from this map first.
     WorkspaceConfig map[string]any
```

5. Dang API rename vs beta closure fix

Related PRs: beta #13296, main #13318.

Original conflict: main upgraded Dang and renamed class APIs to object APIs; beta used the constructor closure to preserve imports in rehydrated method calls.

```diff
diff --cc core/sdk/dang_helpers.go
@@
 parentConstructor := parentModBase.(*dang.ConstructorFunction)
++<<<<<<< HEAD
+parentModType := parentConstructor.ClassType
+// Use the class file's captured env so rehydrated method calls keep the
+// imports that were in scope when the type was declared.
+parentClosure := parentConstructor.Closure
++=======
+parentModType := parentConstructor.ObjectType
++>>>>>>> origin/main
@@
++<<<<<<< HEAD
+bodyEnv := dang.CreateCompositeEnv(parentModEnv, parentClosure)
++=======
+bodyEnv := dang.CreateOverlayValueScope(parentModEnv, env)
++>>>>>>> origin/main
```

Resolution: take main's newer Dang API names and dependency, but keep beta's captured `Closure` for conversion and body evaluation. The newer `ConstructorFunction` still exposes `Closure`, so this preserves both the API upgrade and the import-scope fix.

```diff
diff --git a/core/sdk/dang_helpers.go b/core/sdk/dang_helpers.go
@@
 parentConstructor := parentModBase.(*dang.ConstructorFunction)
 parentModType := parentConstructor.ObjectType
 // Use the class file's captured env so rehydrated method calls keep the
 // imports that were in scope when the type was declared.
 parentClosure := parentConstructor.Closure
@@
 parentModEnv := dang.NewObject(parentModType)
@@
 bodyEnv := dang.CreateOverlayValueScope(parentModEnv, parentClosure)
 bodyEnv.EnterSelf(parentModEnv)
 _, err = dang.EvaluateFormsWithPhases(ctx, parentConstructor.ObjectBodyForms, bodyEnv)
```

6. Dang dependency version

Related PRs: beta #13306, main #13318.

Original conflict: beta had the older Dang pseudo-version; main had the newer version required by the merged object API names.

```diff
diff --cc go.mod
@@
++<<<<<<< HEAD
+    github.com/vito/dang v0.0.0-20260602175442-56ec0c007a23
++=======
+    github.com/vito/dang v0.0.0-20260603200027-0175bae9eb8f
++>>>>>>> origin/main
```

Resolution: take main's newer Dang dependency and matching go.sum entries because the source resolution uses the newer object API.

```diff
diff --git a/go.mod b/go.mod
@@
     github.com/vito/dang v0.0.0-20260603200027-0175bae9eb8f
```

7. Generated ConfigSchema comments

Related PRs: beta #13300, main #13035.

Original conflict: beta's generated clients document the expanded workspace config filenames; main's generated clients kept the old file list. Both sides already agreed on the shifted source line.

```diff
diff --cc modules/dev/internal/dagger/engine-dev.gen.go
@@
 // Generate the json schema for a dagger config file
++<<<<<<< HEAD
+// Currently supported: "dagger.json", "dagger-module.toml", "dagger.toml", "engine.json"
++=======
+// Currently supported: "dagger.json", "engine.json"
++>>>>>>> origin/main
 func (r *EngineDev) ConfigSchema(filename string) *File { // engine-dev (../../../../toolchains/engine-dev/main.go:362:1)
```

Resolution: keep beta's expanded filename list in every generated engine-dev/dagger-engine client because `toolchains/engine-dev/main.go` supports the workspace config files.

```diff
diff --git a/modules/dev/internal/dagger/engine-dev.gen.go b/modules/dev/internal/dagger/engine-dev.gen.go
@@
 // Generate the json schema for a dagger config file
 // Currently supported: "dagger.json", "dagger-module.toml", "dagger.toml", "engine.json"
 func (r *EngineDev) ConfigSchema(filename string) *File { // engine-dev (../../../../toolchains/engine-dev/main.go:362:1)
```

8. Current docs restructure vs main docs updates

Related PRs: beta #11812, main #13320 and #13223.

Original conflict: beta's current docs have been restructured and versioned for 1.0-beta, while main still modified or imported content from the older current-docs layout. The modify/delete conflicts were all old current-docs pages such as cookbook pages, old module pages, old quickstarts, old type pages, and old best-practice pages.

```diff
diff --git a/docs/current_docs/cookbook/containers.mdx b/docs/current_docs/cookbook/containers.mdx
deleted in HEAD, modified in origin/main
```

Resolution: keep beta's current-docs restructure and deletions. Non-conflicting main additions such as versioned docs and static reference assets stay in the merge, but old pre-restructure `current_docs` pages are not reintroduced.

```diff
diff --git a/docs/current_docs/cookbook/containers.mdx b/docs/current_docs/cookbook/containers.mdx
deleted file mode 100644
```

9. Existing 1.0-beta docs pages vs main old imports/links

Related PRs: beta #13338, main #13320 and #13223.

Original conflict: for pages that still exist on both sides, main tried to import old cookbook partials or link to old `dagger.json`/core-concepts pages, while beta uses current 1.0-beta aliases and workspace-era wording.

```diff
diff --cc docs/current_docs/extending/types/container.mdx
@@
++<<<<<<< HEAD:docs/current_docs/extending/types/container.mdx
+import ContainerType from "@daggerTypes/_container.mdx";
++=======
+import ContainerType from "../../partials/types/_container.mdx";
+import BuildImageFromDockerfile from '../../partials/cookbook/builds/_image-from-dockerfile.mdx';
++>>>>>>> origin/main:docs/current_docs/getting-started/types/container.mdx
```

Resolution: keep beta's existing 1.0-beta docs files for those content conflicts, including `@daggerTypes` aliases, workspace/checks links, and `dagger-module.toml` wording.

```diff
diff --git a/docs/current_docs/extending/types/container.mdx b/docs/current_docs/extending/types/container.mdx
@@
 import ContainerType from "@daggerTypes/_container.mdx";
```

Signed-off-by: Solomon Hykes <solomon@dagger.io>