(ancestors, PathComparer) { real };
+
+ // Sorted so traversal is deterministic across filesystems, matching the
+ // full-path ordinal sort Expand() applies to the result.
+ var entries = System.IO.Directory.GetFileSystemEntries(directory);
+ Array.Sort(entries, StringComparer.Ordinal);
+
+ foreach (var entry in entries)
+ {
+ // Directory.Exists follows symlinks, so a symlinked subdirectory is
+ // traversed rather than reported as a file — the behaviour the old
+ // AllDirectories enumeration had, and the cross-port contract.
+ if (System.IO.Directory.Exists(entry))
+ {
+ if (!Opts.Recurse) continue;
+ foreach (var f in Collect(entry, nextAncestors)) yield return f;
+ }
+ else
+ {
+ yield return entry;
+ }
+ }
+ }
+
+ ///
+ /// The fully symlink-resolved form of — .NET's
+ /// realpath(3) stand-in, since only
+ /// normalizes ./.. and resolves no links at all.
+ ///
+ ///
+ /// Resolution is component-by-component from the root because
+ /// Directory.ResolveLinkTarget canonicalizes ONLY the final segment. Using it
+ /// alone would leave a symlinked ANCESTOR unresolved, and the cycle guard would then
+ /// compare a half-resolved path against a real one and miss the loop — recursing
+ /// forever on exactly the input it exists to catch. Falls back to the lexical path if
+ /// the filesystem refuses an answer (the directory vanished mid-walk, or a permission
+ /// error): that is the enumeration's problem to report, not this guard's.
+ ///
+ private static string RealPath(string path)
+ {
+ var full = Path.GetFullPath(path);
+ var root = Path.GetPathRoot(full);
+ if (string.IsNullOrEmpty(root)) return full;
+
+ var current = root;
+ foreach (var segment in full.Substring(root.Length)
+ .Split(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar },
+ StringSplitOptions.RemoveEmptyEntries))
+ {
+ current = Path.Combine(current, segment);
+ try
+ {
+ // returnFinalTarget walks a chain of links (relative or absolute
+ // targets, either) in one call and hands back an already
+ // fully-qualified target. Every path this loop resolves is a
+ // directory — Collect only ever calls RealPath on one it has
+ // already confirmed exists — so Directory.ResolveLinkTarget alone
+ // is authoritative; a link cycle here surfaces as an IOException
+ // we fall back on.
+ var target = System.IO.Directory.ResolveLinkTarget(current, returnFinalTarget: true);
+ if (target is not null) current = target.FullName;
+ }
+ catch (IOException) { /* unresolvable — keep the lexical form for this segment */ }
+ catch (UnauthorizedAccessException) { /* ditto */ }
+ }
+ return current;
+ }
+
/// True when any ancestor path component between and
/// (i.e. excluding the file's own name) is
/// exactly .
diff --git a/server/java/metadata/src/test/java/com/metaobjects/config/SourceResolutionConformanceTest.java b/server/java/metadata/src/test/java/com/metaobjects/config/SourceResolutionConformanceTest.java
index d24765fbf..ceef14eb5 100644
--- a/server/java/metadata/src/test/java/com/metaobjects/config/SourceResolutionConformanceTest.java
+++ b/server/java/metadata/src/test/java/com/metaobjects/config/SourceResolutionConformanceTest.java
@@ -44,6 +44,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
/**
@@ -72,12 +73,18 @@ public class SourceResolutionConformanceTest {
*/
/**
* {@code expectError}: a JSON string pins the exact error code raised; JSON
- * {@code true} pins only that resolution RAISES — the malformed-config error
- * code is deliberately not pinned cross-port (see the corpus README).
+ * {@code true} leaves the CODE unpinned but still requires the port's coded
+ * {@link MetaDataException} — the malformed-config error code is deliberately
+ * not pinned cross-port (see the corpus README), the TYPE is.
+ *
+ * {@code errorIsNative}: this case's failure surfaces as a PLATFORM-native
+ * error rather than a coded exception, lifting the type requirement for it
+ * alone — the symlink-cycle case, whose raise comes from the filesystem walk
+ * ({@code FileSystemLoopException}) and never reaches a coded-error constructor.
*/
private record Case(String name, Map tree, JsonObject config,
String resolveFrom, List expectFiles, JsonElement expectError,
- Map symlinks) {}
+ Map symlinks, boolean errorIsNative) {}
/** Package-private (not private): shared with {@link SourceResolutionCorpusNotEmptyTest},
* which needs to locate the same committed corpus file without a second definition
@@ -142,7 +149,9 @@ public static Collection cases() throws IOException {
}
}
- rows.add(new Object[]{name, new Case(name, tree, config, resolveFrom, expectFiles, expectError, symlinks)});
+ boolean errorIsNative = c.has("errorIsNative") && c.get("errorIsNative").getAsBoolean();
+
+ rows.add(new Object[]{name, new Case(name, tree, config, resolveFrom, expectFiles, expectError, symlinks, errorIsNative)});
}
return rows;
}
@@ -192,15 +201,30 @@ public void resolvesTheSameFileSet() throws IOException {
}
if (testCase.expectError() != null) {
+ JsonElement expected = testCase.expectError();
+ boolean codePinned = expected.isJsonPrimitive() && expected.getAsJsonPrimitive().isString();
try {
SourceResolver.resolveCollection(invokeDir);
fail("expected " + testCase.expectError() + " for case " + testCase.name());
- } catch (MetaDataException e) {
- JsonElement expected = testCase.expectError();
- // A string pins the exact code; `true` only pins that it raises —
- // see the Case record's javadoc above.
- if (expected.isJsonPrimitive() && expected.getAsJsonPrimitive().isString()) {
- assertEquals(expected.getAsString(), e.getCode().orElseThrow().name());
+ } catch (Exception e) {
+ // The catch is on Exception so a native raise can reach the body at
+ // all; the TYPE requirement is asserted here rather than by the catch
+ // clause. `true` leaves the CODE unpinned but still demands
+ // MetaDataException — a malformed config that crashes with a raw NPE
+ // must FAIL this case, not pass it. `errorIsNative` lifts that for the
+ // one case whose raise comes from the filesystem walk
+ // (FileSystemLoopException) and never reaches a coded-error
+ // constructor; widening the whole arm instead would quietly relax the
+ // six malformed-config cases to "anything at all".
+ // (`fail` above throws AssertionError, an Error — so it still escapes.)
+ if (!testCase.errorIsNative()) {
+ assertTrue("case " + testCase.name()
+ + " must raise MetaDataException, got " + e,
+ e instanceof MetaDataException);
+ if (codePinned) {
+ assertEquals(expected.getAsString(),
+ ((MetaDataException) e).getCode().orElseThrow().name());
+ }
}
}
return;
diff --git a/server/java/metadata/src/test/java/com/metaobjects/config/SourceResolverTest.java b/server/java/metadata/src/test/java/com/metaobjects/config/SourceResolverTest.java
index c33d4f108..32ac1f9b8 100644
--- a/server/java/metadata/src/test/java/com/metaobjects/config/SourceResolverTest.java
+++ b/server/java/metadata/src/test/java/com/metaobjects/config/SourceResolverTest.java
@@ -21,10 +21,13 @@
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
+import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
+import java.util.stream.Stream;
+import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
@@ -65,4 +68,50 @@ public void twoUnresolvablePathsReportsTheContentFirstOne() throws IOException {
Files.delete(root);
}
}
+
+ /**
+ * The tolerant half of a ruled asymmetry. A genuinely unknown top-level key
+ * resolves normally here and THROWS in TypeScript. Intended, and ruled in the
+ * source-resolution corpus README: TypeScript owns this file and models its whole
+ * vocabulary, so only it can tell a typo from a key a sibling owns. This port
+ * models the neutral subset ({@code schema_version} + {@code sources}), for which
+ * every other key is indistinguishable from a TypeScript-owned one — imitating
+ * strictness would mean carrying TS's key list and rejecting a config a newer
+ * {@code meta} had just written.
+ *
+ * Deliberately NOT a shared corpus case: a shared case asserts one outcome and
+ * the correct outcome differs by port, so adding one could only make some port wrong.
+ */
+ @Test
+ public void anUnknownTopLevelConfigKeyIsIgnoredNotRejected() throws IOException {
+ Path root = Files.createTempDirectory("source-resolver-unknownkey-");
+ try {
+ Path model = Files.createDirectory(root.resolve("model"));
+ Path file = model.resolve("meta.a.json");
+ Files.writeString(file, "{\"metadata.root\":{\"children\":[]}}");
+
+ Path dotMo = Files.createDirectory(root.resolve(".metaobjects"));
+ Files.writeString(dotMo.resolve("config.json"),
+ "{\"schema_version\":1,\"sources\":[{\"path\":\"model\"}],\"foo\":1}");
+
+ List resolved = SourceResolver.resolveCollection(root);
+
+ assertEquals(List.of(file.toAbsolutePath().normalize()), resolved);
+ } finally {
+ deleteRecursive(root);
+ }
+ }
+
+ private static void deleteRecursive(Path dir) throws IOException {
+ if (!Files.exists(dir)) return;
+ try (Stream walk = Files.walk(dir)) {
+ walk.sorted(Comparator.reverseOrder()).forEach(p -> {
+ try {
+ Files.delete(p);
+ } catch (IOException ignored) {
+ // best-effort temp-dir cleanup
+ }
+ });
+ }
+ }
}
diff --git a/server/python/tests/config/test_source_resolver.py b/server/python/tests/config/test_source_resolver.py
index 5dfef894c..03ba41b12 100644
--- a/server/python/tests/config/test_source_resolver.py
+++ b/server/python/tests/config/test_source_resolver.py
@@ -92,6 +92,30 @@ def test_collection_with_no_config_and_no_default_raises(tmp_path: Path) -> None
assert e.value.code == ErrorCode.ERR_COLLECTION_NOT_FOUND
+def test_an_unknown_top_level_config_key_is_ignored_not_rejected(tmp_path: Path) -> None:
+ """The tolerant half of a ruled asymmetry.
+
+ A genuinely unknown top-level key resolves normally here and THROWS in
+ TypeScript. Intended, and ruled in the source-resolution corpus README:
+ TypeScript owns this file and models its whole vocabulary, so only it can tell
+ a typo from a key a sibling owns. This port models the neutral subset
+ (``schema_version`` + ``sources``), for which every other key is
+ indistinguishable from a TypeScript-owned one — imitating strictness would mean
+ carrying TS's key list and rejecting a config a newer ``meta`` had just written.
+
+ Deliberately NOT a shared corpus case: a shared case asserts one outcome and the
+ correct outcome differs by port, so adding one could only make some port wrong.
+ """
+ (tmp_path / ".metaobjects").mkdir()
+ (tmp_path / ".metaobjects" / "config.json").write_text(
+ json.dumps({"schema_version": 1, "sources": [{"path": "model"}], "foo": 1})
+ )
+ (tmp_path / "model").mkdir()
+ (tmp_path / "model" / "meta.a.json").write_text("{}")
+ got = resolve_collection(tmp_path)
+ assert _rel(tmp_path, got) == {"model/meta.a.json"}
+
+
def test_declared_sources_replace_the_default(tmp_path: Path) -> None:
(tmp_path / ".metaobjects").mkdir()
(tmp_path / ".metaobjects" / "config.json").write_text(
diff --git a/server/python/tests/conformance/test_source_resolution_conformance.py b/server/python/tests/conformance/test_source_resolution_conformance.py
index ec5bee412..da5d71725 100644
--- a/server/python/tests/conformance/test_source_resolution_conformance.py
+++ b/server/python/tests/conformance/test_source_resolution_conformance.py
@@ -68,13 +68,19 @@ def test_source_resolution_conformance(case: dict, tmp_path: Path) -> None:
resolve_from = _materialize(case, tmp_path)
if "expectError" in case:
- with pytest.raises(ParseError) as e:
+ # A string pins the exact code. `True` leaves the CODE unpinned but still
+ # requires ParseError — a malformed config that crashes with a raw
+ # TypeError must fail this case, not pass it. `errorIsNative` lifts only
+ # the type requirement, for the one case whose raise comes from the
+ # filesystem walk (SymlinkLoopError) and never reaches a coded-error
+ # constructor; widening the whole arm instead would quietly relax the six
+ # malformed-config cases from "a coded parse failure" to "anything".
+ expected = case["expectError"]
+ expected_type = Exception if case.get("errorIsNative") else ParseError
+ with pytest.raises(expected_type) as e:
resolve_collection(resolve_from)
- # A string pins the exact code; `True` only pins that resolution
- # RAISES — the malformed-config error code is deliberately not
- # pinned cross-port (see the corpus README).
- if isinstance(case["expectError"], str):
- assert e.value.code.value == case["expectError"]
+ if isinstance(expected, str):
+ assert e.value.code.value == expected
return
# `expectFiles` is project-root-relative even when `resolveFrom` points
diff --git a/server/typescript/packages/cli/src/commands/init.ts b/server/typescript/packages/cli/src/commands/init.ts
index e82fa7033..9f0f2c5c3 100644
--- a/server/typescript/packages/cli/src/commands/init.ts
+++ b/server/typescript/packages/cli/src/commands/init.ts
@@ -218,6 +218,23 @@ async function stackForAgentContext(opts: InitOptions, prior: Manifest | undefin
return resolveStack(opts.cwd, overrides);
}
+/** Writes `contents` to `path` (relative to `cwd`), unless `dryRun` — in which case
+ * the write is skipped entirely and the caller still records what WOULD have
+ * landed. Factors the mkdir+writeFile pair shared by every write site below. */
+async function writeUnlessDryRun(cwd: string, dryRun: boolean, path: string, contents: string): Promise {
+ if (dryRun) return;
+ const abs = join(cwd, path);
+ await mkdir(dirname(abs), { recursive: true });
+ await writeFile(abs, contents, "utf8");
+}
+
+/** "would be VERBED" during a dry run, plain VERBED otherwise — the one tense
+ * marker every reported write shares, so each call site states only its own
+ * past participle instead of writing out both tenses of the whole sentence. */
+function verbed(dryRun: boolean, pastParticiple: string): string {
+ return dryRun ? `would be ${pastParticiple}` : pastParticiple;
+}
+
async function writeAgentContext(opts: InitOptions, result: InitResult): Promise {
warnIfMonorepoSubdir(opts, result);
const prior = await readManifest(opts.cwd);
@@ -244,32 +261,45 @@ async function writeAgentContext(opts: InitOptions, result: InitResult): Promise
: decision.writes;
const conflicts = opts.force ? [] : decision.conflicts;
+ // --print-only must win outright: a documented dry run must never write. Both
+ // callers of this function (`--docs-only` and `--refresh-docs`) return from
+ // `init()` ABOVE the full-scaffold path's own printOnly guard, so without this
+ // the dry run silently scaffolded for real — the same defect `--config-only`
+ // carried. The guard lives HERE rather than as a path list beside that one
+ // because this write set is dynamic (it depends on the resolved stack), and
+ // `decision` is already the complete plan: suppressing just the I/O reports
+ // exactly the paths a real run would touch, with no second list to drift.
+ const dryRun = opts.printOnly === true;
+
for (const w of writes) {
- const abs = join(opts.cwd, w.path);
- await mkdir(dirname(abs), { recursive: true });
- await writeFile(abs, w.contents, "utf8");
+ await writeUnlessDryRun(opts.cwd, dryRun, w.path, w.contents);
result.created.push(w.path);
}
for (const c of conflicts) {
- const abs = join(opts.cwd, c.newPath);
- await mkdir(dirname(abs), { recursive: true });
- await writeFile(abs, c.contents, "utf8");
+ await writeUnlessDryRun(opts.cwd, dryRun, c.newPath, c.contents);
result.created.push(c.newPath);
- result.warnings.push(`${c.path} appears hand-edited; refreshed version written to ${c.newPath}`);
+ // Past tense only when it actually happened — a dry run that reports "written
+ // to .new" is claiming an edit-preserving side effect the user can go
+ // look for and will not find.
+ result.warnings.push(
+ `${c.path} appears hand-edited; refreshed version ${verbed(dryRun, "written")} to ${c.newPath}`,
+ );
}
- const manifestAbs = join(opts.cwd, AGENT_CONTEXT_MANIFEST_PATH);
- await mkdir(dirname(manifestAbs), { recursive: true });
- await writeFile(manifestAbs, JSON.stringify(decision.manifest, null, 2) + "\n", "utf8");
+ await writeUnlessDryRun(
+ opts.cwd, dryRun, AGENT_CONTEXT_MANIFEST_PATH,
+ JSON.stringify(decision.manifest, null, 2) + "\n",
+ );
+ result.created.push(AGENT_CONTEXT_MANIFEST_PATH);
for (const orphan of decision.removed) {
result.warnings.push(`${orphan} is no longer part of this stack; orphaned (safe to delete).`);
}
- if (opts.wireRoot) await wireRootMemory(opts.cwd, result);
+ if (opts.wireRoot) await wireRootMemory(opts.cwd, result, dryRun);
}
const ROOT_IMPORT_LINE = "@.metaobjects/AGENTS.md";
-async function wireRootMemory(cwd: string, result: InitResult): Promise {
+async function wireRootMemory(cwd: string, result: InitResult, dryRun = false): Promise {
const claudePath = join(cwd, "CLAUDE.md");
const agentsPath = join(cwd, "AGENTS.md");
const claudeExists = await fileExists(claudePath);
@@ -277,8 +307,8 @@ async function wireRootMemory(cwd: string, result: InitResult): Promise {
// If neither root memory file exists, create CLAUDE.md (Claude Code's canonical) with the import.
if (!claudeExists && !agentsExists) {
- await writeFile(claudePath, `# Project memory\n\n${ROOT_IMPORT_LINE}\n`, "utf8");
- result.created.push("CLAUDE.md (created with MetaObjects @import)");
+ await writeUnlessDryRun(cwd, dryRun, "CLAUDE.md", `# Project memory\n\n${ROOT_IMPORT_LINE}\n`);
+ result.created.push(`CLAUDE.md (${verbed(dryRun, "created")} with MetaObjects @import)`);
return;
}
// Otherwise append the import to whichever exist (idempotent — never double-add).
@@ -286,8 +316,11 @@ async function wireRootMemory(cwd: string, result: InitResult): Promise {
if (!exists) continue;
const body = await readFile(path, "utf8");
if (body.includes(ROOT_IMPORT_LINE)) continue;
- await writeFile(path, `${body.replace(/\n*$/, "\n")}\n${ROOT_IMPORT_LINE}\n`, "utf8");
- result.warnings.push(`wired ${ROOT_IMPORT_LINE} into ${path.endsWith("AGENTS.md") ? "AGENTS.md" : "CLAUDE.md"} so the MetaObjects context loads`);
+ const target = path.endsWith("AGENTS.md") ? "AGENTS.md" : "CLAUDE.md";
+ await writeUnlessDryRun(cwd, dryRun, target, `${body.replace(/\n*$/, "\n")}\n${ROOT_IMPORT_LINE}\n`);
+ // Past tense only when it actually happened — this one mutates a file the user
+ // owns, so a dry run reporting it as done is the most misleading of the three.
+ result.warnings.push(`${verbed(dryRun, "wired")} ${ROOT_IMPORT_LINE} into ${target} so the MetaObjects context loads`);
}
}
diff --git a/server/typescript/packages/cli/test/unit/init-docs-only.test.ts b/server/typescript/packages/cli/test/unit/init-docs-only.test.ts
index 2a9a399fc..9e7d404a6 100644
--- a/server/typescript/packages/cli/test/unit/init-docs-only.test.ts
+++ b/server/typescript/packages/cli/test/unit/init-docs-only.test.ts
@@ -1,5 +1,5 @@
import { test, expect, describe, beforeEach, afterEach } from "bun:test";
-import { mkdtempSync, rmSync, existsSync } from "node:fs";
+import { mkdtempSync, rmSync, existsSync, mkdirSync, readdirSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { init } from "../../src/commands/init.js";
@@ -28,4 +28,52 @@ describe("init() --docs-only", () => {
expect(existsSync(join(cwd, "metaobjects.config.ts"))).toBe(false);
expect(existsSync(join(cwd, ".metaobjects/config.json"))).toBe(false);
});
+
+ // Same shape as the `--config-only --print-only` bug: the agent-context branches
+ // return ABOVE the `--print-only` guard the full-scaffold path checks below them,
+ // so a documented dry run silently wrote the real files. Unlike that one, the write
+ // set here is DYNAMIC (it depends on the resolved stack), so the guard cannot be a
+ // hardcoded path list in `init()` — it belongs inside `writeAgentContext`, which
+ // already computes the exact plan before performing a single write.
+ test("--docs-only --print-only reports the real write set and writes nothing", async () => {
+ const planned = await init({
+ cwd, docsOnly: true, printOnly: true, wireRoot: true,
+ servers: ["java"], clients: ["react"],
+ });
+
+ // Reported set is the REAL one, not a hardcoded guess: it names the docs, the
+ // stack-scoped skill reference, and the manifest.
+ expect(planned.created).toContain(".metaobjects/AGENTS.md");
+ expect(planned.created).toContain(".claude/skills/metaobjects-codegen/references/java.md");
+ expect(planned.created).toContain(".metaobjects/.agent-context.json");
+
+ // ...and the directory is untouched.
+ expect(readdirSync(cwd)).toEqual([]);
+
+ // Nothing reports in the PAST tense. A dry run claiming it "created" a root
+ // CLAUDE.md or "wired" an @import names a side effect on a file the user owns,
+ // which they can go look for and will not find — a more expensive lie than the
+ // silent write, because it reads as a completed action.
+ // Anchored, not `\bcreated with\b` — that also matches the CORRECT "(would be
+ // created with …)" and the assertion fails on its own fix.
+ const past = [...planned.created, ...planned.warnings].filter(
+ (m) => m.includes("(created with") || /^wired /.test(m) || m.includes("version written to"),
+ );
+ expect(past).toEqual([]);
+ expect(planned.created).toContain("CLAUDE.md (would be created with MetaObjects @import)");
+ });
+
+ test("--refresh-docs --print-only writes nothing", async () => {
+ // The second door onto the same guard: refresh short-circuits on its own branch,
+ // which also sat above the --print-only check. It only engages once the project
+ // exists, so seed the marker directory first.
+ mkdirSync(join(cwd, ".metaobjects"), { recursive: true });
+
+ const planned = await init({ cwd, refreshDocs: true, printOnly: true, servers: ["java"] });
+
+ expect(planned.created).toContain(".metaobjects/AGENTS.md");
+ expect(existsSync(join(cwd, ".metaobjects/AGENTS.md"))).toBe(false);
+ expect(existsSync(join(cwd, ".metaobjects/.agent-context.json"))).toBe(false);
+ expect(readdirSync(join(cwd, ".metaobjects"))).toEqual([]);
+ });
});
diff --git a/server/typescript/packages/sdk/test/config.test.ts b/server/typescript/packages/sdk/test/config.test.ts
index 1a17d27d5..98972872c 100644
--- a/server/typescript/packages/sdk/test/config.test.ts
+++ b/server/typescript/packages/sdk/test/config.test.ts
@@ -160,6 +160,20 @@ describe("ConfigSchema — phase-1 source resolution", () => {
ConfigSchema.parse({ schema_version: 1, migrate: { d1: { bindingg: "DB" } } }),
).toThrow();
});
+ test("rejects a genuinely unknown TOP-LEVEL key — TypeScript's half of a ruled asymmetry", () => {
+ // Java, C# and Python model only `schema_version` + `sources`, so they resolve
+ // this config successfully, ignoring `foo`. That divergence is INTENDED and is
+ // ruled in fixtures/source-resolution-conformance/README.md: TypeScript owns
+ // this file and is the only port that knows its whole vocabulary, so it is the
+ // only one that can tell a typo from a key a sibling owns. A partial reader
+ // could only imitate strictness by embedding TS's key list, and would then
+ // reject a config a newer `meta` had just written.
+ //
+ // Deliberately kept OFF the shared corpus: a shared case asserts one outcome,
+ // and the correct outcome here differs by port. This is TS's half; the tolerant
+ // half is pinned in each of the other three ports.
+ expect(() => ConfigSchema.parse({ schema_version: 1, foo: 1 })).toThrow();
+ });
test("an existing config with no new keys still parses (back-compat)", () => {
const p = ConfigSchema.parse({
schema_version: 1, pending_in_git: true,
diff --git a/server/typescript/packages/sdk/test/source-resolution-conformance.test.ts b/server/typescript/packages/sdk/test/source-resolution-conformance.test.ts
index f9f387a93..d1c61d17b 100644
--- a/server/typescript/packages/sdk/test/source-resolution-conformance.test.ts
+++ b/server/typescript/packages/sdk/test/source-resolution-conformance.test.ts
@@ -19,6 +19,12 @@ interface Case {
* resolution RAISES — the malformed-config error code is deliberately not
* pinned cross-port (see the corpus README). */
readonly expectError?: string | true;
+ /** Optional: the failure surfaces as a PLATFORM-native error rather than a coded
+ * one, lifting the coded-TYPE requirement for this case. Java/C#/Python honour
+ * it; TypeScript has nothing to lift — it propagates the raw parser error, which
+ * is why the code is unpinned here in the first place — so it is unread. Declared
+ * anyway so this interface stays a faithful mirror of the case schema. */
+ readonly errorIsNative?: boolean;
/** Optional: linkPath -> targetPath, both project-root-relative, materialized
* AFTER `tree` (I1 — a symlinked source root, or a symlinked subdirectory
* inside a walked tree). */