@githolon/dsl 0.119.12 → 0.119.28

package/dart_types/pubspec.yaml

@@ -9,7 +9,7 @@ description: >-
   Pure kernel wire/data types for Nomos Dart frontends — no transport, no bridge,
   no runtime. Typed protobuf and USDA boundary values plus the offer codec,
   reactive read engine, schema validation, and data-only error/trace types.
-version: 0.15.3
+version: 0.16.0
 
 environment:
   sdk: ^3.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@githolon/dsl",
-  "version": "0.119.12",
+  "version": "0.119.28",
   "type": "module",
   "sideEffects": false,
   "description": "Nomos 2 domain-authoring DSL: aggregates + directives in TS, executed and encoded to the Rust kernel's wire shapes.",
@@ -82,16 +82,16 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@githolon/runtime": "^0.119.12",
-    "@bufbuild/protobuf": "^2.13.0",
-    "@bufbuild/protoc-gen-es": "^2.13.0",
+    "@githolon/runtime": "0.119.28",
+    "@bufbuild/protobuf": "2.13.0",
+    "@bufbuild/protoc-gen-es": "2.13.0",
     "esbuild": "0.24.2",
     "fflate": "0.8.2",
-    "tsx": "^4.19.2",
-    "typescript": "^5.6.3",
+    "tsx": "4.22.4",
+    "typescript": "5.9.3",
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.12",
-    "zod": "^4.4.3"
+    "zod": "4.4.3"
   },
   "devDependencies": {
     "@types/node": "^25.9.2",

package/src/anonymous_value_interning.ts

@@ -1,13 +1,15 @@
-// NOMOS — Structural interning of anonymous value types: one semantic shape, one canonical node.
+// NOMOS — Structural interning: one semantic shape AND wire contract, one canonical node.
 //
 // Anonymous value types are structural values, not independently lived declarations. The graph
 // deliberately retains their source owner for diagnostics, but USDA must not turn that provenance
 // into thousands of duplicate runtime prims. This computes a semantic key which excludes owner
-// identity, then points every equivalent type graph — and each of its member fields and union
-// variants — at one canonical node. Declared types remain untouched. Recursive graphs keep their
+// identity, retaining member wire allocations, then points equivalent type graphs and their member
+// fields and union variants at one canonical node. Declared types remain untouched. Recursive graphs keep their
 // owner-scoped identity for now: aliasing a cycle needs an explicit recursion-isomorphism proof,
 // whereas every acyclic case below is exact by construction.
 //
+// Discovery may ignore wire allocations to find candidates for a first allocation (CAP-983).
+// Final sharing always includes them: equal shapes with distinct released keys remain separate.
 // ONE interning, TWO consumers. The USDA emitter (law_graph_usda.ts) redirects duplicate prims to
 // the canonical prim; the graph discovery (law_graph.ts) ledgers a nested payload field's wire key
 // against the canonical member, because that is the key installed law serves and generated clients
@@ -23,6 +25,8 @@ export interface AnonymousValueInterningInput {
   readonly types: readonly LawAnonymousValueTypeNode[];
   readonly fields: readonly LawAnonymousValueFieldNode[];
   readonly variants: readonly LawAnonymousValueVariantNode[];
+  /** Discovery only: find shape equivalence before retaining transport allocations. */
+  readonly ignoreWireAllocations?: boolean;
   /** Whether this type is emitted as its own `Types/t_<sid>` prim (wrappers and framework scalars are not). */
   readonly ownsPrim: (type: LawAnonymousValueTypeNode) => boolean;
 }
@@ -108,11 +112,13 @@ export function internAnonymousValues(input: AnonymousValueInterningInput): Anon
         break;
       }
       case "record": {
-        const members: Array<readonly [string, boolean, string]> = [];
+        const members: Array<readonly [string, boolean, string, (string | undefined)?, (readonly string[])?]> = [];
         for (const field of fieldsByOwner.get(id) ?? []) {
           const child = childKey(field.value.id);
           if (child === undefined) break;
-          members.push([field.name, field.required, child]);
+          members.push(input.ignoreWireAllocations
+            ? [field.name, field.required, child]
+            : [field.name, field.required, child, field.entity.wireKey, [...(field.entity.wireAliases ?? [])].sort()]);
         }
         if (members.length === (fieldsByOwner.get(id)?.length ?? 0)) {
           members.sort(([left], [right]) => left.localeCompare(right));
@@ -122,7 +128,7 @@ export function internAnonymousValues(input: AnonymousValueInterningInput): Anon
         break;
       }
       case "sum": {
-        const members: Array<readonly [string, string]> = [];
+        const members: Array<readonly [string, string, (string | undefined)?]> = [];
         for (const variant of variantsByOwner.get(id) ?? []) {
           const child = childKey(variant.value.id);
           if (child === undefined) break;
@@ -130,7 +136,8 @@ export function internAnonymousValues(input: AnonymousValueInterningInput): Anon
           // with the same carried value shapes but different arm labels cannot
           // share one USDA prim: authoring reconstructs the nominal oneof from
           // these labels before it decodes the generated Protobuf call.
-          members.push([variant.label ?? variant.entity.label, child]);
+          members.push(input.ignoreWireAllocations ? [variant.label ?? variant.entity.label, child]
+            : [variant.label ?? variant.entity.label, child, variant.entity.wireKey]);
         }
         if (members.length === (variantsByOwner.get(id)?.length ?? 0)) {
           members.sort(([leftLabel, leftChild], [rightLabel, rightChild]) =>

package/src/baseline_export.ts

@@ -23,6 +23,7 @@ import { readInspectionUnits } from "./release_inspection.js";
 import { lawUnitSetIdentityWith } from "./law_unit_set_identity.js";
 import {
   LAW_FRAMEWORK_PARENT,
+  createLawIdentityReconciler,
   lawEntityKey,
   validateLawIdentityRegistry,
   type LawEntityKind,
@@ -48,6 +49,7 @@ import {
 } from "./law_layer_prims.js";
 import {
   BASELINE_NO_RELEASE,
+  NOMOS_BASELINE_FORMAT,
   serializeBaselineUsda,
   baselineSha256,
   type BaselineSource,
@@ -284,13 +286,14 @@ function scanWireAllocations(
   intentPrim: UsdaPrim,
   prims: ReadonlyMap<string, UsdaPrim>,
   out: BaselineWireAllocation[],
+  valueRoot?: { owner: string; declaredTypes: ReadonlySet<string> },
 ): void {
   const intentSid = sidOf(intentPrim);
   if (intentSid === undefined) return;
-  const intent = lawEntityKey("intent", intentSid);
+  const intent = valueRoot?.owner ?? lawEntityKey("intent", intentSid);
   const seen = new Set<string>();
   const allocate = (field: UsdaPrim, path: string): void => {
-    const canonical = usdaString(field, "wireKey");
+    const canonical = usdaString(field, "wireKey") ?? (field.name.startsWith("v_") ? sidOf(field) : undefined);
     if (canonical === undefined) return;
     const aliases = usdaStringList(field, "wireAliases") ?? [];
     const coordinate = `${intent}\u0000${path}`;
@@ -299,7 +302,7 @@ function scanWireAllocations(
     out.push({ intent, field: path, protobuf: { canonical, ...(aliases.length > 0 ? { aliases } : {}) } });
   };
   const walkType = (typePath: string | undefined, path: string, visiting: ReadonlySet<string>): void => {
-    if (typePath === undefined || visiting.has(typePath)) return;
+    if (typePath === undefined || visiting.has(typePath) || valueRoot?.declaredTypes.has(typePath)) return;
     const type = prims.get(typePath);
     if (type === undefined) return;
     const next = new Set(visiting).add(typePath);
@@ -317,7 +320,9 @@ function scanWireAllocations(
         const variants = usdaChild(type, "Variants")?.children ?? [];
         variants.forEach((variant, index) => {
           const label = usdaString(variant, "label") ?? String(index);
-          walkType(variant.rels.get("type")?.[0], unionVariantPath(path, label), next);
+          const arm = unionVariantPath(path, label);
+          allocate(variant, arm);
+          walkType(variant.rels.get("type")?.[0], arm, next);
         });
         break;
       }
@@ -335,6 +340,25 @@ function scanWireAllocations(
     allocate(field, path);
     walkType(field.rels.get("type")?.[0], path, visiting);
   };
+  if (valueRoot !== undefined) {
+    if (valueRoot.owner.startsWith("f_")) walkType(intentPrim.rels.get("type")?.[0], "$", new Set());
+    else if (valueRoot.owner.startsWith("q_")) {
+      walkType(intentPrim.rels.get("returns")?.[0], "$returns", new Set());
+      const contract = prims.get(intentPrim.rels.get("contract")?.[0] ?? "");
+      for (const parameter of (contract === undefined ? [] : usdaChild(contract, "Parameters")?.children ?? [])) {
+        const name = usdaString(parameter, "name");
+        if (name !== undefined) walkType(parameter.rels.get("type")?.[0], nestedMemberPath("$parameters", name), new Set());
+      }
+    }
+    else for (const variant of usdaChild(intentPrim, "Variants")?.children ?? []) {
+      const label = usdaString(variant, "label");
+      if (label === undefined) throw new Error("baseline export: a value variant lacks its discriminator");
+      const arm = unionVariantPath("$", label);
+      allocate(variant, arm);
+      walkType(variant.rels.get("type")?.[0], arm, new Set());
+    }
+    return;
+  }
   for (const relation of ["accepts", "publicAccepts"]) {
     const contract = prims.get(intentPrim.rels.get(relation)?.[0] ?? "");
     if (contract === undefined) continue;
@@ -404,11 +428,45 @@ export function exportBaselineFromUnits(input: BaselineExportInput): BaselineExp
     }
     entities[key] = entity;
   }
-  const identity: LawIdentityRegistry = {
+  let identity: LawIdentityRegistry = {
     v: 1,
     entities: Object.fromEntries(Object.entries(entities).sort(([l], [r]) => (l < r ? -1 : l > r ? 1 : 0))),
   };
   validateLawIdentityRegistry(identity);
+  // Recover read-value continuity from the bytes actually served, including pre-CAP-983 releases.
+  // Named declarations own their nested allocations. Anonymous representative IDs are not owners.
+  const declaredTypes = new Set([...prims].filter(([, prim]) => {
+    const sid = sidOf(prim);
+    return sid !== undefined && identity.entities[`t_${sid}`]?.kind === "type";
+  }).map(([path]) => path));
+  const valueAllocations: BaselineWireAllocation[] = [];
+  for (const [, prim] of prims) {
+    const sid = sidOf(prim);
+    if (sid === undefined) continue;
+    const owner = prim.name.startsWith("f_") ? `f_${sid}` : prim.name.startsWith("t_") ? `t_${sid}` : prim.name.startsWith("q_") ? `q_${sid}` : undefined;
+    if (owner === undefined || identity.entities[owner] === undefined) continue;
+    scanWireAllocations(prim, prims, valueAllocations, { owner, declaredTypes });
+  }
+  // Repeated framework declarations may expose the same coordinate in several layers.
+  // A baseline must report disagreement, not let preferred-first reconciliation hide it.
+  const releasedByCoordinate = new Map<string, BaselineWireAllocation>();
+  for (const allocation of valueAllocations) {
+    const coordinate = `${allocation.intent}\0${allocation.field}`;
+    const prior = releasedByCoordinate.get(coordinate);
+    if (prior !== undefined && prior.protobuf.canonical !== allocation.protobuf.canonical) {
+      throw new Error(`baseline export: conflicting released wire allocations for ${allocation.intent}.${allocation.field}: ${prior.protobuf.canonical}, ${allocation.protobuf.canonical}`);
+    }
+    const aliases = [...new Set([...(prior?.protobuf.aliases ?? []), ...(allocation.protobuf.aliases ?? [])])].sort();
+    releasedByCoordinate.set(coordinate, { ...allocation, protobuf: { canonical: allocation.protobuf.canonical,
+      ...(aliases.length === 0 ? {} : { aliases }),
+    } });
+  }
+  const reconciler = createLawIdentityReconciler(identity);
+  for (const allocation of releasedByCoordinate.values()) reconciler.reconcile({
+    kind: "value-field", parent: allocation.intent, labels: [allocation.field],
+    preferredOperationFieldWire: { [allocation.field]: { protobuf: allocation.protobuf } }, retireAbsent: false,
+  });
+  identity = reconciler.finish();
 
   const baselineBody: Omit<ReleasedBaseline, "format"> = {
     source: input.source,
@@ -424,7 +482,7 @@ export function exportBaselineFromUnits(input: BaselineExportInput): BaselineExp
   };
   const text = serializeBaselineUsda(baselineBody);
   return {
-    baseline: { format: "nomos.baseline.v1", ...baselineBody },
+    baseline: { format: NOMOS_BASELINE_FORMAT, ...baselineBody },
     text,
     sha256: baselineSha256(text),
     nonLedgerPrims: scanned.nonLedger.value,

package/src/baseline_import.ts

@@ -160,6 +160,15 @@ export function importBaseline(
         retirementDivergence.push(`${key} (${coordinateOf(releasedEntity)}): retired by the release, active in the ledger`);
         continue;
       }
+      if (releasedEntity.kind === "value-field") {
+        const expected = releasedEntity.operationFieldWire?.protobuf;
+        const actual = local.operationFieldWire?.protobuf;
+        if (expected === undefined || actual?.canonical !== expected.canonical ||
+            (expected.aliases ?? []).some(alias => !actual.aliases?.includes(alias))) {
+          throw new BaselineRefusal("baseline-wire-divergence", `nested value ${coordinateOf(releasedEntity)} disagrees with released wire custody`,
+            [`released ${expected?.canonical ?? "missing"}, ledger ${actual?.canonical ?? "missing"}`]);
+        }
+      }
       if (local.label === releasedEntity.label || local.priorLabels?.includes(releasedEntity.label) === true) {
         verified += 1;
         continue;
@@ -288,6 +297,14 @@ export function assertBaselineRetained(final: LawIdentityRegistry, baseline: Rel
       continue;
     }
     if (local.status !== "active") continue; // retired by a declared candidate-law retirement; the evolution gate judged it
+    if (releasedEntity.kind === "value-field") {
+      const expected = releasedEntity.operationFieldWire?.protobuf;
+      const actual = local.operationFieldWire?.protobuf;
+      if (expected === undefined || actual?.canonical !== expected.canonical ||
+          (expected.aliases ?? []).some(alias => !actual.aliases?.includes(alias))) {
+        details.push(`${coordinateOf(releasedEntity)}: released wire allocation changed`);
+      }
+    }
     const lineage = [releasedEntity.label, ...(releasedEntity.priorLabels ?? [])];
     const occupant = activeAt(final.entities, releasedEntity.kind, local.parent, lineage);
     if (occupant !== undefined && occupant[0] !== key) {

package/src/baseline_usda.ts

@@ -26,7 +26,7 @@ import {
 } from "./identity_usda.js";
 import type { LawOperationFieldWire } from "./law_identity.js";
 
-export const NOMOS_BASELINE_FORMAT = "nomos.baseline.v1";
+export const NOMOS_BASELINE_FORMAT = "nomos.baseline.v2";
 /** The pinned baseline's conventional filename, beside `nomos.project.ts`. */
 export const NOMOS_BASELINE_FILENAME = "nomos.baseline.usda";
 /** The baseline's own "no release" marker, matching release_publication.ts `NO_PREDECESSOR`. */
@@ -142,7 +142,7 @@ function attr(prim: IdentityPrim, name: string): string {
 /** Read a baseline back. Refuses anything that is not this exact format. */
 export function parseBaselineUsda(text: string): ReleasedBaseline {
   if (!isBaselineUsda(text)) {
-    throw new Error(`${NOMOS_BASELINE_FILENAME} is not ${NOMOS_BASELINE_FORMAT} — refusing to guess a baseline encoding`);
+    throw new Error(`${NOMOS_BASELINE_FILENAME} is not ${NOMOS_BASELINE_FORMAT} — re-export from the same released units to recover nested read wire allocations (CAP-983)`);
   }
   const roots = parseIdentityPrims(text, NOMOS_BASELINE_FILENAME);
   const root = roots.find((prim) => prim.name === "NomosBaseline");

package/src/codegen_result_usda.ts

@@ -97,7 +97,9 @@ export const TS_RESULT_USDA_PRELUDE = [
   `const _nmsUsdaJsonValue = (prim: _NmsUsdaPrim): unknown => {`,
   `  if (prim.typeName === "NomosNullValue") return null; if (prim.typeName === "NomosBoolValue") return _nmsUsdaBoolValue(prim);`,
   `  if (prim.typeName === "NomosIntValue" || prim.typeName === "NomosNumberValue") return _nmsUsdaNumberValue(prim); if (prim.typeName === "NomosStringValue" || prim.typeName === "NomosTokenValue") return _nmsUsdaStringValue(prim);`,
-  `  if (prim.typeName === "NomosJsonValue") { const value = prim.children.find((child) => child.name === "Value"); if (!value) throw new Error("NomosJsonValue has no Value"); return _nmsUsdaJsonValue(value); }`,
+  // Nominal records (including nomosRef) wrap their JSON in Value, just like
+  // NomosJsonValue. Keep parity with the kernel and Dart's result decoder.
+  `  if (prim.typeName === "NomosJsonValue" || prim.typeName === "NomosRecordValue") { const value = prim.children.find((child) => child.name === "Value"); if (!value) throw new Error(prim.typeName + " has no Value"); return _nmsUsdaJsonValue(value); }`,
   `  if (prim.typeName === "NomosJsonArray") return prim.children.map(_nmsUsdaJsonValue);`,
   `  if (prim.typeName === "NomosJsonObject") { const out: Record<string, unknown> = {}; for (const member of prim.children) { const key = _nmsUsdaProperty(member, "nomos:key"); const value = member.children.find((child) => child.name === "Value"); if (typeof key !== "string" || !value) throw new Error("invalid NomosJsonMember"); out[key] = _nmsUsdaJsonValue(value); } return out; }`,
   `  throw new Error("unsupported nominal JSON prim " + prim.typeName);`,

package/src/compile_package_main.ts

@@ -1,3 +1,5 @@
+import { assertCanonicalCompilerToolchain } from "./compiler_toolchain.js";
+import { dartAnalysisRoots } from "./dart_analysis_roots.js";
 import { collectPackageSources, findBirthKeyWrites, formatBirthKeyWriteWarnings } from "./birth_key_rule.js";
 import type { Directive } from "./directive.js";
 import { usdaString } from "./usda_text.js";
@@ -2587,12 +2589,12 @@ const dartTypesImportFor = (generatedSource: string): string => {
  *  just the floor generated code needs — a lagging pin forces tenants into dependency_overrides. */
 // 0.3.0: SurfacedValue<T>/SurfacedObservation/PendingConflictRow — generated Surfaced-field typing +
 //        the pendingConflicts read rows.
-const NOMOS_TYPES_DEP = "^0.15.3";
+const NOMOS_TYPES_DEP = "^0.16.0";
 // 0.48.x: session-bound clients (XClient.bind/NomosClientInterface/DomainClientSessionMismatch/
 //         DomainNotInstalledForSession, engine.follow, pendingConflicts lanes) — the generated client
 //         REQUIRES this surface. 0.48.1 fixes NomosSession.watchPendingConflicts delegation.
-const NOMOS_CLIENT_DEP = "^0.70.12";
-const NOMOS_FLUTTER_DEP = "^0.69.2";
+const NOMOS_CLIENT_DEP = "^0.70.27";
+const NOMOS_FLUTTER_DEP = "^0.69.18";
 // DRIFT TRIPWIRE: pubspec_pins.test.ts asserts these equal the CURRENT versions in the Dart and Flutter
 // package pubspecs — a release without this bump fails the suite, so tenants never
 // land back in dependency_overrides (the exact co2 report this closes, third occurrence).
@@ -4247,6 +4249,7 @@ async function assertOneDslInstance(lawDir: string): Promise<void> {
 }
 
 async function main(): Promise<void> {
+  assertCanonicalCompilerToolchain(DSL_DIR);
   const argv = process.argv.slice(2);
   const supportedFlags = new Set([
     "--require-usdcat",
@@ -9156,9 +9159,9 @@ async function main(): Promise<void> {
       // the analyzer reports unresolved `package:` imports as errors and the gate can't tell a codegen bug
       // from an un-got package (the co2 "analyze skipped → false success" trap).
       const dOut: string = dartOut;
-      // Analyze exactly THE FILES THIS COMPILE EMITTED (`dartFiles`) — never the whole dir, which would
-      // sweep in the transactional `.nomos-bak` backup and any stale legacy-layout leftovers and judge the
-      // compile on files it did not write. First `dart pub get` each emitted PACKAGE (a dir up-chain with a
+      // Analyze exactly THE FILES THIS COMPILE EMITTED (`dartFiles`). Compact directory roots only when
+      // their Dart coverage is identical; never sweep in transactional `.nomos-bak` backups, tenant source
+      // or stale legacy-layout leftovers. First `dart pub get` each emitted PACKAGE (a dir up-chain with a
       // pubspec) so fixed `package:` imports resolve.
       const emittedDart = dartFiles.filter((f) => f.endsWith(".dart"));
       const pkgDirOf = (file: string): string | undefined => {
@@ -9462,7 +9465,7 @@ async function main(): Promise<void> {
           if (!dartAnalysisCached) {
             execFileSync(
               "dart",
-              ["analyze", "--no-fatal-warnings", ...inPackage],
+              ["analyze", "--no-fatal-warnings", ...dartAnalysisRoots(inPackage, pkgDirs)],
               { stdio: "pipe", encoding: "utf8" }
             );
             mkdirSync(proofDir, { recursive: true });

package/src/compiler_toolchain.ts

@@ -0,0 +1,35 @@
+import { compilerPackageManifest } from "../compile_proof.mjs";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+
+/** These compiler dependencies emit or contribute bytes to immutable law units.
+ * Package-manager overrides must fail rather than silently author a different law.
+ * Tenant dependencies remain authored inputs; inspect the compiler's resolution. */
+export function assertCanonicalCompilerToolchain(dslDir: string): void {
+  const manifest = join(dslDir, "package.json");
+  const dependencies = JSON.parse(readFileSync(manifest, "utf8")).dependencies as Record<string, string>;
+  const compiler = createRequire(manifest);
+  const check = (name: string, expected: string | undefined, from: NodeJS.Require): string => {
+    const prefix = `NMS-TOOLCHAIN-001: non-canonical compiler toolchain: ${name}`;
+    if (expected === undefined || !/^\d+\.\d+\.\d+(?:-[\w.-]+)?$/.test(expected)) {
+      throw new Error(`${prefix} must have an exact compiler dependency pin (got ${expected}).`);
+    }
+    let file: string;
+    try { file = compilerPackageManifest(name, from); }
+    catch { throw new Error(`${prefix} is missing; reinstall @githolon/dsl with its declared dependencies.`); }
+    const actual = JSON.parse(readFileSync(file, "utf8")).version;
+    if (actual !== expected) {
+      throw new Error(`${prefix} resolved ${actual}, expected ${expected}. Remove compiler dependency overrides and reinstall @githolon/dsl; a toolchain upgrade requires a new compiler release.`);
+    }
+    return file;
+  };
+  for (const name of ["@githolon/runtime", "@bufbuild/protobuf", "esbuild", "fflate", "tsx", "typescript", "zod"]) {
+    check(name, dependencies[name], compiler);
+  }
+  const version = dependencies["@bufbuild/protoc-gen-es"];
+  const generator = createRequire(check("@bufbuild/protoc-gen-es", version, compiler));
+  const plugin = createRequire(check("@bufbuild/protoplugin", version, generator));
+  check("@bufbuild/protobuf", dependencies["@bufbuild/protobuf"], generator);
+  check("@bufbuild/protobuf", dependencies["@bufbuild/protobuf"], plugin);
+}

package/src/dart_analysis_roots.ts

@@ -0,0 +1,71 @@
+import { existsSync, readdirSync } from "node:fs";
+import path from "node:path";
+
+/** Compact analyzer roots without widening the set of generated Dart files judged.
+ * Each file root creates filesystem watches in the Dart analysis server. A layered
+ * package can have dozens of roots for the same directory; on macOS their FSEvents
+ * teardown can dominate analysis. A directory is equivalent only when every Dart
+ * file beneath it was emitted by this compile. Backups, tenant code and symlinks
+ * prevent compaction across that boundary.
+ */
+export function dartAnalysisRoots(
+  files: readonly string[],
+  packageRoots: readonly string[],
+): string[] {
+  const owned = new Set(files.map((file) => path.resolve(file)));
+  const packages = packageRoots.map((root) => path.resolve(root)).sort((a, b) => b.length - a.length);
+  const directories = new Set<string>();
+  const explicit = new Set<string>();
+  const incompressible = new Set<string>();
+  const options = new Map<string, boolean>();
+  const hasAnalysisOptions = (directory: string): boolean => {
+    const held = options.get(directory);
+    if (held !== undefined) return held;
+    const parent = path.dirname(directory);
+    const found = existsSync(path.join(directory, "analysis_options.yaml")) ||
+      (parent !== directory && hasAnalysisOptions(parent));
+    options.set(directory, found);
+    return found;
+  };
+  for (const file of owned) {
+    const pkg = packages.find((root) => file.startsWith(`${root}${path.sep}`));
+    const relative = pkg === undefined ? undefined : path.relative(pkg, file).split(path.sep);
+    // Directory roots can apply analyzer exclusions differently from explicit files.
+    // Keep the original invocation for inherited/custom options and hidden/build paths.
+    if (hasAnalysisOptions(path.dirname(file)) || relative?.some((part) => part.startsWith(".") || part === "build")) {
+      incompressible.add(file);
+    }
+    // Never analyze the package root itself: only the emitted source subtrees.
+    if (pkg === undefined || relative!.length === 1) explicit.add(file);
+    else directories.add(path.join(pkg, relative![0]!));
+  }
+  const seen = new Set<string>();
+  const visit = (directory: string): { roots: string[]; foreign: boolean } => {
+    const roots: string[] = [];
+    let foreign = false;
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      const file = path.join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        // Do not infer ownership of anything the analyzer may reach through a link.
+        foreign = true;
+      } else if (entry.isDirectory()) {
+        const child = visit(file);
+        roots.push(...child.roots);
+        foreign ||= child.foreign;
+      } else if (entry.isFile() && entry.name.endsWith(".dart")) {
+        if (owned.has(file)) {
+          seen.add(file);
+          roots.push(file);
+          foreign ||= incompressible.has(file);
+        } else foreign = true;
+      }
+    }
+    return { roots: roots.length > 0 && !foreign ? [directory] : roots, foreign };
+  };
+  for (const directory of directories) {
+    for (const root of visit(directory).roots) explicit.add(root);
+  }
+  // A missing file must remain an analyzer input, never silently lose coverage.
+  for (const file of owned) if (!seen.has(file)) explicit.add(file);
+  return [...explicit].sort();
+}

package/src/intent.ts

@@ -490,7 +490,9 @@ const dedupeBy = <T>(values: readonly T[], key: (value: T) => string): T[] => {
   const seen = new Set<string>();
   for (const value of values) {
     const k = key(value);
-    if (seen.add(k)) out.push(value);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(value);
   }
   return out;
 };

package/src/law_graph.ts

@@ -33,7 +33,7 @@ import {
 import type { StableFieldEvolution, StableIds } from "./stable_ids_types.js";
 import { isBusinessIntent, publicOfferRoute } from "./intent.js";
 import { listElementPath, mapValuePath, nestedMemberPath, unionVariantPath } from "./wire_paths.js";
-import { anonymousTypeOwnsPrim, internAnonymousValues } from "./anonymous_value_interning.js";
+import { retainValueWireAllocations } from "./value_wire_continuity.js";
 import {
   lowerLawValueType,
   type LawConstant,
@@ -1302,7 +1302,7 @@ export function discoverLawGraph(
       // (wire_paths.ts) in the intent's operation-field scope: the first allocation is still the
       // structural sid (unchanged law bytes for every existing package), and from then on the
       // ledger keeps it through named and structural generations.
-      const nestedByPath = new Map<string, LawAnonymousValueFieldNode>();
+      const nestedByPath = new Map<string, LawAnonymousValueFieldNode | LawAnonymousValueVariantNode>();
       const pathsByNode = new Map<string, string[]>();
       const walkNested = (valueRef: LawValueTypeRef, path: string, visiting: ReadonlySet<string>): void => {
         if (visiting.has(valueRef.id)) return;
@@ -1331,7 +1331,9 @@ export function discoverLawGraph(
             valueNode.expression.variants.forEach((variantRef, index) => {
               const variant = provisionalById.get(variantRef.id);
               if (variant?.kind !== "structural" || variant.structuralKind !== "value-variant") return;
-              walkNested(variant.value, unionVariantPath(path, variant.label ?? String(index)), next);
+              const arm = unionVariantPath(path, variant.label ?? String(index));
+              nestedByPath.set(arm, variant);
+              walkNested(variant.value, arm, next);
             });
             break;
           case "nullable":
@@ -2624,77 +2626,12 @@ export function discoverLawGraph(
       },
     }),
   };
-  // NESTED WIRE CONTINUITY, PHASE 2 (CAP-660). Every nested payload field is served on the wire key of
-  // the canonical interned member (the prim law_graph_usda.ts emits; the key codegen_call_proto.ts
-  // encodes). Its first allocation is exactly that member's structural sid — the key every existing
-  // package already serves, so law bytes do not move — and from then on the ledger keeps it under
-  // the field's path through named and structural generations. Paths that end up sharing one
-  // canonical member must agree on one allocation: two released keys for one served prim is an
-  // explicit evolution decision, never a compile's silent pick.
-  {
-    const valueNodes = [...anonymousValueNodes.values()];
-    const interning = internAnonymousValues({
-      types: valueNodes.filter((node): node is LawAnonymousValueTypeNode => node.structuralKind === "value-type"),
-      fields: valueNodes.filter((node): node is LawAnonymousValueFieldNode => node.structuralKind === "value-field"),
-      variants: valueNodes.filter((node): node is LawAnonymousValueVariantNode => node.structuralKind === "value-variant"),
-      ownsPrim: anonymousTypeOwnsPrim,
-    });
-    const canonicalFieldOf = (fieldId: string): string => interning.canonicalFieldIdById.get(fieldId) ?? fieldId;
-    const allocationByCanonical = new Map<string, { canonical: string; aliases: Set<string>; owners: string[] }>();
-    for (const [intentKey, paths] of nestedPathsByIntent) {
-      if (paths.size === 0) continue;
-      const intentLabel = registry.entities[intentKey]?.label ?? intentKey;
-      const preferredOperationFieldWire: Record<string, LawOperationFieldWire> = {};
-      for (const [path, fieldId] of paths) {
-        const canonical = anonymousValueNodes.get(canonicalFieldOf(fieldId));
-        if (canonical === undefined) fail(`directive '${intentLabel}': nested field '${path}' has no canonical value node`);
-        preferredOperationFieldWire[path] = { protobuf: { canonical: canonical.entity.sid } };
-      }
-      const ledger = identities.reconcile({
-        kind: "operation-field",
-        parent: intentKey,
-        labels: [...paths.keys()],
-        preferredOperationFieldWire,
-        retireAbsent: false,
-      });
-      registry = ledger.registry;
-      for (const [path, fieldId] of paths) {
-        const entity = registry.entities[ledger.resolved[path] ?? ""];
-        if (entity?.kind !== "operation-field" || entity.status !== "active" || entity.operationFieldWire === undefined) {
-          fail(`directive '${intentLabel}' has no active wire allocation for nested field '${path}'`);
-        }
-        const wire = entity.operationFieldWire.protobuf;
-        const canonicalId = canonicalFieldOf(fieldId);
-        const owner = `${intentLabel}.${path}`;
-        const prior = allocationByCanonical.get(canonicalId);
-        if (prior === undefined) {
-          allocationByCanonical.set(canonicalId, { canonical: wire.canonical, aliases: new Set(wire.aliases ?? []), owners: [owner] });
-          continue;
-        }
-        if (prior.canonical !== wire.canonical) {
-          fail(
-            `NMS-WIRE-001 nested fields ${[...prior.owners, owner].map((name) => `'${name}'`).join(" and ")} share one structural value ` +
-              `but hold different wire allocations (${prior.canonical}, ${wire.canonical}); ` +
-              "declare an evolution plan for the reallocation instead of letting a compile choose",
-          );
-        }
-        for (const alias of wire.aliases ?? []) prior.aliases.add(alias);
-        prior.owners.push(owner);
-      }
-    }
-    // Every node of an allocated equivalence class — the canonical member the law emits and each
-    // duplicate a generated client reads — carries the one allocation.
-    for (const node of valueNodes) {
-      if (node.structuralKind !== "value-field") continue;
-      const allocation = allocationByCanonical.get(canonicalFieldOf(node.entity.id));
-      if (allocation === undefined) continue;
-      const aliases = [...allocation.aliases].sort(compareText);
-      anonymousValueNodes.set(node.entity.id, {
-        ...node,
-        entity: { ...node.entity, wireKey: allocation.canonical, ...(aliases.length === 0 ? {} : { wireAliases: aliases }) },
-      });
-    }
-  }
+  const retainedWire = retainValueWireAllocations({
+    nodes: [...anonymousValueNodes.values()], fields: fieldNodes, types: typeNodes, reads: readContractNodes,
+    operations: nestedPathsByIntent, identities, registry,
+  });
+  registry = retainedWire.registry;
+  for (const node of retainedWire.nodes) anonymousValueNodes.set(node.entity.id, node);
   const nodes: DeclaredLawNode[] = [
     domainNode,
     ...aggregateNodes,

package/src/law_graph_usda.ts

@@ -423,7 +423,7 @@ export function compileSparseLawGraphUsda(
   for (const type of anonymousTypes) resolveAnonymousTypePath(type.entity.id);
 
   // Anonymous value types are structural values, not independently lived declarations: one semantic
-  // shape, one canonical prim (anonymous_value_interning.ts — the same interning the graph discovery
+  // shape and wire contract, one canonical prim (anonymous_value_interning.ts — the same interning the graph discovery
   // ledgers nested wire keys against). Declared types remain untouched.
   const interning = internAnonymousValues({
     types: anonymousTypes,
@@ -463,7 +463,7 @@ export function compileSparseLawGraphUsda(
   }
   for (const variant of anonymousVariants) {
     const owner = pathById.get(variant.owner.id);
-    if (owner !== undefined) pathById.set(variant.entity.id, `${owner}/Variants/v_${variant.entity.sid}`);
+    if (owner !== undefined) pathById.set(variant.entity.id, `${owner}/Variants/v_${variant.entity.wireKey ?? variant.entity.sid}`);
   }
 
   // When two record/sum types share one canonical prim, their nested structural references must
@@ -1489,7 +1489,7 @@ function emitType(
       for (const [index, variant] of owned.entries()) {
         if (index > 0) body.push("");
         body.push(
-          `${pad}    def Scope "v_${variant.entity.sid}"`,
+          `${pad}    def Scope "v_${variant.entity.wireKey ?? variant.entity.sid}"`,
           `${pad}    {`,
           `${pad}        custom uniform string nomos:label = ${quote(variant.label ?? variant.entity.label)}`,
           `${pad}        custom rel nomos:type = <${requiredPath(variant.value.id, paths)}>`,
@@ -1637,7 +1637,7 @@ function emitAnonymousType(
         for (const [index, variant] of owned.entries()) {
           if (index > 0) body.push("");
           body.push(
-            `${pad}    def Scope "v_${variant.entity.sid}"`,
+            `${pad}    def Scope "v_${variant.entity.wireKey ?? variant.entity.sid}"`,
             `${pad}    {`,
             `${pad}        custom uniform string nomos:label = ${quote(variant.label ?? variant.entity.label)}`,
             `${pad}        custom rel nomos:type = <${requiredPath(variant.value.id, paths)}>`,