@githolon/dsl 0.119.13 → 0.119.28

package/src/law_identity.ts

@@ -19,6 +19,7 @@ export const LAW_ENTITY_KINDS = [
   "workspace-type",
   "contract",
   "operation-field",
+  "value-field",
   "type",
   "object-type",
 ] as const;
@@ -48,7 +49,7 @@ export interface LawIdentityEntity {
   readonly priorLabels?: readonly string[];
   readonly generation: number;
   readonly status: LawIdentityStatus;
-  /** Present only on an operation-field ledger row. The row's label + lineage carry meaning. */
+  /** Present on operation-field and value-field wire custody rows. The row's label + lineage carry meaning. */
   readonly operationFieldWire?: LawOperationFieldWire;
 }
 
@@ -114,6 +115,7 @@ const KIND_PREFIX: Readonly<Record<LawEntityKind, string>> = {
   "workspace-type": "x",
   contract: "c",
   "operation-field": "u",
+  "value-field": "v",
   type: "t",
   "object-type": "o",
 };
@@ -348,8 +350,8 @@ export function validateLawIdentityRegistry(registry: LawIdentityRegistry): void
       throw new Error(`NMS-ID-001 ${key} has invalid status`);
     }
     if (entity.operationFieldWire !== undefined) {
-      if (entity.kind !== "operation-field") {
-        throw new Error(`NMS-ID-001 ${key} carries operation-field wire custody but is not an operation field`);
+      if (entity.kind !== "operation-field" && entity.kind !== "value-field") {
+        throw new Error(`NMS-ID-001 ${key} carries wire custody but is not a wire field`);
       }
       const keys = [
         entity.operationFieldWire.protobuf.canonical,

package/src/openusd_compiled_layer.ts

@@ -58,10 +58,15 @@ export async function flattenOpenUsdToUsda(
   }
   args.push(request.sourcePath);
   try {
-    const { stdout: usda } = await execFileAsync(request.usdcat, args, {
+    const { stdout: usda, stderr: diagnostics } = await execFileAsync(request.usdcat, args, {
       encoding: "utf8",
       maxBuffer: 256 * 1024 * 1024,
     });
+    // OpenUSD can exit successfully after skipping an invalid sublayer. Its
+    // partial stage is not the complete authenticated law we asked to compile.
+    if (diagnostics.trim().length > 0) {
+      throw new Error(diagnostics.trim());
+    }
     if (!usda.startsWith("#usda 1.0")) {
       throw new Error(
         `stock OpenUSD returned a non-USDA ${request.description}`
@@ -78,7 +83,7 @@ export async function flattenOpenUsdToUsda(
       "$1$2"
     );
   } catch (error) {
-    const stderr = stderrOf(error);
+    const stderr = stderrOf(error) || (error instanceof Error ? error.message : String(error));
     const maskDetail =
       populationMask === undefined
         ? ""

package/src/value_wire_continuity.ts

@@ -0,0 +1,150 @@
+// CAP-983: public wire allocations outlive the compiler's structural representatives.
+// See architecture/value_wire_identity.md. This is compiler custody, not a second
+// compatibility judge. The kernel still judges the emitted contract.
+import type {
+  LawAnonymousValueFieldNode, LawAnonymousValueTypeNode, LawAnonymousValueVariantNode,
+  LawFieldNode, LawTypeNode, LawReadContractNode, LawValueTypeRef,
+} from "./law_graph.js";
+import type { LawIdentityReconciler, LawIdentityRegistry, LawOperationFieldWire } from "./law_identity.js";
+import { anonymousTypeOwnsPrim, internAnonymousValues } from "./anonymous_value_interning.js";
+import { listElementPath, mapValuePath, nestedMemberPath, unionVariantPath } from "./wire_paths.js";
+
+type ValueNode = LawAnonymousValueFieldNode | LawAnonymousValueTypeNode | LawAnonymousValueVariantNode;
+type Wire = LawOperationFieldWire["protobuf"];
+interface Scope { kind: "operation-field" | "value-field"; owner: string; paths: Map<string, string> }
+
+export function retainValueWireAllocations(input: {
+  nodes: readonly ValueNode[];
+  fields: readonly LawFieldNode[];
+  types: readonly LawTypeNode[];
+  reads: readonly LawReadContractNode[];
+  operations: ReadonlyMap<string, Map<string, string>>;
+  identities: LawIdentityReconciler;
+  registry: LawIdentityRegistry;
+}): { nodes: ValueNode[]; registry: LawIdentityRegistry } {
+  const byId = new Map<string, ValueNode>(input.nodes.map(n => [n.entity.id, n]));
+  const scopes: Scope[] = [...input.operations].map(([owner, paths]) => ({ kind: "operation-field", owner, paths }));
+  const walk = (ref: LawValueTypeRef, path: string, paths: Map<string, string>, visiting: ReadonlySet<string>): void => {
+    if (visiting.has(ref.id)) return;
+    const node = byId.get(ref.id);
+    // A named type owns its own continuity; do not duplicate it under every caller.
+    if (node?.structuralKind !== "value-type") return;
+    const next = new Set(visiting).add(ref.id);
+    const e = node.expression;
+    switch (e.kind) {
+      case "record":
+        for (const ref of e.fields) {
+          const field = byId.get(ref.id);
+          if (field?.structuralKind !== "value-field") continue;
+          const member = nestedMemberPath(path, field.name);
+          paths.set(member, field.entity.id);
+          walk(field.value, member, paths, next);
+        }
+        break;
+      case "list": walk(e.element, listElementPath(path), paths, next); break;
+      case "map": walk(e.value, mapValuePath(path), paths, next); break;
+      case "sum":
+        for (const ref of e.variants) {
+          const variant = byId.get(ref.id);
+          if (variant?.structuralKind === "value-variant") {
+            const arm = unionVariantPath(path, variant.label ?? variant.entity.label);
+            paths.set(arm, variant.entity.id);
+            walk(variant.value, arm, paths, next);
+          }
+        }
+        break;
+      case "nullable": case "default": case "recursive": walk(e.value, path, paths, next); break;
+    }
+  };
+  for (const field of input.fields) {
+    if (input.registry.entities[field.entity.id]?.kind !== "field") continue;
+    const paths = new Map<string, string>();
+    walk(field.value, "$", paths, new Set());
+    scopes.push({ kind: "value-field", owner: field.entity.id, paths });
+  }
+  for (const type of input.types) {
+    const paths = new Map<string, string>();
+    for (const ref of type.variants) {
+      const variant = byId.get(ref.id);
+      if (variant?.structuralKind === "value-variant") {
+        const arm = unionVariantPath("$", variant.label ?? variant.entity.label);
+        paths.set(arm, variant.entity.id);
+        walk(variant.value, arm, paths, new Set());
+      }
+    }
+    scopes.push({ kind: "value-field", owner: type.entity.id, paths });
+  }
+  for (const read of input.reads) {
+    const paths = new Map<string, string>();
+    if (read.returns.kind === "scalar") walk(read.returns.value, "$returns", paths, new Set());
+    for (const parameter of read.parameters) if (parameter.value !== undefined) {
+      walk(parameter.value, nestedMemberPath("$parameters", parameter.name), paths, new Set());
+    }
+    scopes.push({ kind: "value-field", owner: read.owner.id, paths });
+  }
+  const fields = input.nodes.filter((n): n is LawAnonymousValueFieldNode => n.structuralKind === "value-field");
+  const intern = internAnonymousValues({
+    types: input.nodes.filter((n): n is LawAnonymousValueTypeNode => n.structuralKind === "value-type"), fields,
+    variants: input.nodes.filter((n): n is LawAnonymousValueVariantNode => n.structuralKind === "value-variant"),
+    ownsPrim: anonymousTypeOwnsPrim, ignoreWireAllocations: true,
+  });
+  const members = input.nodes.filter((n): n is LawAnonymousValueFieldNode | LawAnonymousValueVariantNode => n.structuralKind !== "value-type");
+  const canonical = (id: string): string => intern.canonicalFieldIdById.get(id) ?? intern.canonicalVariantIdById.get(id) ?? id;
+  const held = new Map<string, Wire>();
+  const classes = new Map<string, Map<string, Wire>>();
+  const remember = (id: string, wire: Wire): void => {
+    if (byId.get(id)?.structuralKind === "value-variant" && wire.aliases?.length) {
+      throw new Error(`NMS-WIRE-002 ${id}: this runtime has no union-arm alias protocol; retain the published arm key`);
+    }
+    const prior = held.get(id);
+    if (prior && prior.canonical !== wire.canonical) throw new Error(`NMS-WIRE-001 ${id} has conflicting retained wire allocations; one source member cannot serve two contracts`);
+    const merged = { canonical: wire.canonical, aliases: [...new Set([...(prior?.aliases ?? []), ...(wire.aliases ?? [])])].sort() };
+    held.set(id, merged);
+    const key = canonical(id);
+    const group = classes.get(key) ?? new Map<string, Wire>();
+    const existing = group.get(merged.canonical);
+    group.set(merged.canonical, { canonical: merged.canonical, aliases: [...new Set([...(existing?.aliases ?? []), ...merged.aliases])].sort() });
+    classes.set(key, group);
+  };
+  for (const field of members) if (field.entity.wireKey) remember(field.entity.id, { canonical: field.entity.wireKey, ...(field.entity.wireAliases === undefined ? {} : { aliases: field.entity.wireAliases }) });
+  const coordinates = new Map(Object.values(input.registry.entities).filter(e => e.status === "active")
+    .map(e => [`${e.kind}\0${e.parent}\0${e.label}`, e]));
+  // All retained allocations are collected before allocating any new use: traversal order cannot win.
+  for (const scope of scopes) for (const [path, id] of scope.paths) {
+    const wire = coordinates.get(`${scope.kind}\0${scope.owner}\0${path}`)?.operationFieldWire?.protobuf;
+    if (wire) remember(id, wire);
+  }
+  const preferred = (id: string): Wire => {
+    const own = held.get(id);
+    if (own) return own;
+    const group = classes.get(canonical(id));
+    if (group?.size === 1) return [...group.values()][0]!;
+    const node = byId.get(canonical(id))!;
+    // No unique inherited allocation: a new use gets the historical first-allocation rule.
+    return { canonical: node.entity.sid };
+  };
+  // Freeze preferences before reconciliation so new uses cannot influence one another.
+  const preferences = new Map(members.map(field => [field.entity.id as string, preferred(field.entity.id)]));
+  const existingScopes = new Set(Object.values(input.registry.entities)
+    .filter(e => e.kind === "value-field" && e.status === "active").map(e => e.parent));
+  let registry = input.registry;
+  for (const scope of scopes) {
+    // Scalar/named references have no anonymous members. Avoid a full ledger scan for each;
+    // previously populated scopes still reconcile empty so removals get tombstones.
+    if (scope.paths.size === 0 && !existingScopes.has(scope.owner)) continue;
+    const result = input.identities.reconcile({
+      kind: scope.kind, parent: scope.owner, labels: [...scope.paths.keys()],
+      preferredOperationFieldWire: Object.fromEntries([...scope.paths].map(([path, id]) => [path, { protobuf: preferences.get(id)! }])),
+      // Operation retirement already uses accepts/publicAccepts together. A value owner is complete here.
+      retireAbsent: scope.kind === "value-field",
+    });
+    registry = result.registry;
+    for (const [path, id] of scope.paths) remember(id, registry.entities[result.resolved[path]!]!.operationFieldWire!.protobuf);
+  }
+  return { registry, nodes: input.nodes.map(node => {
+    if (node.structuralKind === "value-type") return node;
+    const wire = held.get(node.entity.id) ?? preferences.get(node.entity.id)!;
+    if (node.structuralKind === "value-variant") return { ...node, entity: { ...node.entity, wireKey: wire.canonical } };
+    return { ...node, entity: { ...node.entity, wireKey: wire.canonical, ...(wire.aliases?.length ? { wireAliases: wire.aliases } : {}) } };
+  }) };
+}