@githolon/dsl 0.102.5 → 0.103.1

package/src/law_graph_usda.ts

@@ -0,0 +1,1799 @@
+import type {
+  LawAggregateNode,
+  LawAnonymousValueFieldNode,
+  LawAnonymousValueTypeNode,
+  LawAnonymousValueVariantNode,
+  LawContractNode,
+  LawDependencyRef,
+  LawCapabilityNode,
+  LawFieldNode,
+  LawFlowNode,
+  LawForeignReadNode,
+  LawGraph,
+  LawIntentEffectNode,
+  LawIntentNode,
+  LawPayloadContractNode,
+  LawPolicyNode,
+  LawPredicateNode,
+  LawReadContractNode,
+  LawReadNode,
+  LawRelationNode,
+  LawRelationObjectTypeNode,
+  LawRelationPredicateNode,
+  LawInvariantNode,
+  LawTargetRef,
+  LawTypeNode,
+  LawWorkspaceTypeNode,
+  LawWorkspaceRelationNode,
+} from "./law_graph.js";
+
+const FRAMEWORK_SCALAR: Readonly<Record<string, string>> = {
+  string: "/Nomos/Framework/Types/t_0000000000000001",
+  integer: "/Nomos/Framework/Types/t_0000000000000002",
+  boolean: "/Nomos/Framework/Types/t_0000000000000004",
+};
+
+const FRAMEWORK_RELATIONS = [
+  { key: "workspace#admin", id: "r_0000000000000001", object: "o_0000000000000001", subjects: ["user", "key"] },
+  { key: "workspace#creator", id: "r_0000000000000002", object: "o_0000000000000001", subjects: ["user", "key"] },
+  { key: "workspace#platformCreator", id: "r_0000000000000003", object: "o_0000000000000001", subjects: ["user", "key"] },
+  { key: "workspace#installDomain", id: "r_0000000000000004", object: "o_0000000000000001", subjects: ["user", "key"] },
+  { key: "identity#signer", id: "r_0000000000000005", object: "o_0000000000000002", subjects: ["key"] },
+] as const;
+
+const FRAMEWORK_RELATION_PATHS = new Map(
+  FRAMEWORK_RELATIONS.map((relation) => [
+    relation.key,
+    `/Nomos/Framework/Relations/${relation.id}`,
+  ] as const),
+);
+
+function frameworkRelationPath(relation: LawRelationNode): string | undefined {
+  const path = FRAMEWORK_RELATION_PATHS.get(
+    relation.entity.label as typeof FRAMEWORK_RELATIONS[number]["key"],
+  );
+  if (path === undefined) return undefined;
+  const frameworkObjectType = relation.entity.label.slice(0, relation.entity.label.indexOf("#"));
+  return relation.objectType === frameworkObjectType ? path : undefined;
+}
+
+/** The one compiler-owned v3 framework layer. Domain layers only author sparse opinions under
+ * `/Nomos/Domains`; their scalar relationships resolve here instead of repeating these definitions in
+ * every package/domain layer. Keep this vocabulary byte-stable with the W1 oracle. */
+export function emitFrameworkLawUsda(): string {
+  return [
+    "#usda 1.0",
+    "(",
+    "    customLayerData = {",
+    '        string "nomos:format" = "nomos.law-layer.v3"',
+    '        string "nomos:logicalPath" = "framework"',
+    "    }",
+    ")",
+    "",
+    'def Scope "Nomos"',
+    "{",
+    '    def Scope "Framework"',
+    "    {",
+    '        def Scope "Types"',
+    "        {",
+    ...[
+      ["t_0000000000000001", "String", "string"],
+      ["t_0000000000000002", "Integer", "int"],
+      ["t_0000000000000003", "Timestamp", "timestamp"],
+      ["t_0000000000000004", "Boolean", "bool"],
+    ].flatMap(([id, label, scalar]) => [
+      `            def Scope "${id}"`,
+      "            {",
+      '                custom uniform token nomos:typeKind = "scalar"',
+      `                custom uniform string nomos:label = "${label}"`,
+      `                custom uniform token nomos:scalar = "${scalar}"`,
+      "            }",
+      "",
+    ]),
+    "        }",
+    '        def Scope "ObjectTypes"',
+    "        {",
+    '            def NomosObjectType "o_0000000000000001"',
+    "            {",
+    '                custom uniform string nomos:label = "workspace"',
+    "            }",
+    "",
+    '            def NomosObjectType "o_0000000000000002"',
+    "            {",
+    '                custom uniform string nomos:label = "identity"',
+    "            }",
+    "        }",
+    "",
+    '        def Scope "Relations"',
+    "        {",
+    ...FRAMEWORK_RELATIONS.flatMap((relation) => {
+      const label = relation.key.slice(relation.key.indexOf("#") + 1);
+      const predicate = `p_${relation.id.slice(2)}`;
+      return [
+        `            def NomosRelation "${relation.id}"`,
+        "            {",
+        '                custom uniform token nomos:relationKind = "authorization"',
+        `                custom uniform string nomos:label = ${quote(label)}`,
+        `                custom uniform string nomos:relation = ${quote(label)}`,
+        "                custom uniform int nomos:maxDepth = 12",
+        "                custom uniform int nomos:maxFanout = 1024",
+        `                custom rel nomos:objectType = </Nomos/Framework/ObjectTypes/${relation.object}>`,
+        `                custom uniform token nomos:objectNamespace = ${quote(relation.key.slice(0, relation.key.indexOf("#")))}`,
+        `                custom uniform token[] nomos:subjectTypes = ${stringList(relation.subjects)}`,
+        `                custom rel nomos:rewrite = </Nomos/Framework/Relations/${relation.id}/Predicates/${predicate}>`,
+        "",
+        '                def Scope "Predicates"',
+        "                {",
+        `                    def NomosDirectUserset "${predicate}"`,
+        "                    {",
+        '                        custom uniform token nomos:operator = "this"',
+        "                    }",
+        "                }",
+        "            }",
+        "",
+      ];
+    }),
+    "        }",
+    "    }",
+    "",
+    '    def Scope "Domains"',
+    "    {",
+    "    }",
+    "}",
+    "",
+  ].join("\n");
+}
+type ResolveDependency = (dependency: LawDependencyRef<any>) => string;
+
+function entityLabelOpinions(
+  entity: { readonly label: string; readonly priorLabels: readonly string[] },
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  return [
+    `${pad}custom uniform string nomos:label = ${quote(entity.label)}`,
+    ...(entity.priorLabels.length === 0
+      ? []
+      : [`${pad}custom uniform string[] nomos:was = ${stringList(entity.priorLabels)}`]),
+  ];
+}
+
+/** First W4.4 vertical slice: render domain, aggregate, stored-field and reusable-contract opinions. */
+export function emitSparseLawGraphUsda(
+  graph: LawGraph,
+  logicalPath: string,
+  closure: readonly LawGraph[] = [graph],
+): string {
+  const domain = graph.domain;
+  const aggregates = graph.nodes.filter((node): node is LawAggregateNode => node.kind === "aggregate");
+  const contracts = graph.nodes.filter((node): node is LawContractNode => node.kind === "contract");
+  const payloadContracts = graph.nodes.filter((node): node is LawPayloadContractNode =>
+    node.kind === "payload-contract");
+  const fields = graph.nodes.filter((node): node is LawFieldNode => node.kind === "field");
+  const types = graph.nodes.filter((node): node is LawTypeNode => node.kind === "type");
+  const objectTypes = graph.nodes.filter((node): node is LawRelationObjectTypeNode => node.kind === "object-type");
+  const allRelations = graph.nodes.filter((node): node is LawRelationNode => node.kind === "relation");
+  // Framework relations have one canonical identity and definition in `/Nomos/Framework`.
+  // Domain modules may re-export the handles for authoring convenience, but those re-exports are
+  // references, not fresh policy definitions.
+  const relations = allRelations.filter((relation) => frameworkRelationPath(relation) === undefined);
+  const intents = graph.nodes.filter((node): node is LawIntentNode => node.kind === "intent");
+  const reads = graph.nodes.filter((node): node is LawReadNode => node.kind === "read");
+  const readContracts = graph.nodes.filter((node): node is LawReadContractNode => node.kind === "read-contract");
+  const readPredicates = graph.nodes.filter((node): node is LawPredicateNode =>
+    node.kind === "structural" && node.structuralKind === "predicate");
+  const effects = graph.nodes.filter((node): node is LawIntentEffectNode =>
+    node.kind === "structural" && node.structuralKind === "effect");
+  const foreignReads = graph.nodes.filter((node): node is LawForeignReadNode =>
+    node.kind === "structural" && node.structuralKind === "foreign-read");
+  const workspaceRelations = graph.nodes.filter((node): node is LawWorkspaceRelationNode =>
+    node.kind === "structural" && node.structuralKind === "workspace-relation");
+  const policies = graph.nodes.filter((node): node is LawPolicyNode => node.kind === "policy");
+  const invariants = graph.nodes.filter((node): node is LawInvariantNode => node.kind === "invariant");
+  const capabilities = graph.nodes.filter((node): node is LawCapabilityNode => node.kind === "capability");
+  const workspaceTypes = graph.nodes.filter((node): node is LawWorkspaceTypeNode => node.kind === "workspace-type");
+  const flows = graph.nodes.filter((node): node is LawFlowNode =>
+    node.kind === "structural" && node.structuralKind === "flow");
+  const relationPredicates = graph.nodes.filter((node): node is LawRelationPredicateNode =>
+    node.kind === "structural" && node.structuralKind === "relation-predicate");
+  const anonymousTypes = graph.nodes.filter((node): node is LawAnonymousValueTypeNode =>
+    node.kind === "structural" && node.structuralKind === "value-type");
+  const anonymousFields = graph.nodes.filter((node): node is LawAnonymousValueFieldNode =>
+    node.kind === "structural" && node.structuralKind === "value-field");
+  const anonymousVariants = graph.nodes.filter((node): node is LawAnonymousValueVariantNode =>
+    node.kind === "structural" && node.structuralKind === "value-variant");
+  const anonymousTypeById = new Map<string, LawAnonymousValueTypeNode>(
+    anonymousTypes.map((node) => [node.entity.id, node] as const),
+  );
+  const anonymousFieldsByOwner = new Map<string, LawAnonymousValueFieldNode[]>();
+  for (const field of anonymousFields) {
+    const owned = anonymousFieldsByOwner.get(field.owner.id) ?? [];
+    owned.push(field);
+    anonymousFieldsByOwner.set(field.owner.id, owned);
+  }
+  const anonymousVariantsByOwner = new Map<string, LawAnonymousValueVariantNode[]>();
+  for (const variant of anonymousVariants) {
+    const owned = anonymousVariantsByOwner.get(variant.owner.id) ?? [];
+    owned.push(variant);
+    anonymousVariantsByOwner.set(variant.owner.id, owned);
+  }
+  const pathById = new Map<string, string>([[domain.entity.id, `/Nomos/Domains/${domain.entity.id}`]]);
+  const dependencyPaths = new Map<string, string[]>();
+  const addDependency = (domainLabel: string, kind: string, label: string, path: string): void => {
+    for (const key of [`${domainLabel}:${kind}:${label}`, `*:${kind}:${label}`]) {
+      const values = dependencyPaths.get(key) ?? [];
+      if (!values.includes(path)) values.push(path);
+      dependencyPaths.set(key, values);
+    }
+  };
+  for (const candidate of closure) {
+    const domainPath = `/Nomos/Domains/${candidate.domain.entity.id}`;
+    pathById.set(candidate.domain.entity.id, domainPath);
+    addDependency(candidate.domain.entity.label, "domain", candidate.domain.entity.label, domainPath);
+    for (const node of candidate.nodes) {
+      let path: string | undefined;
+      let kind: string | undefined;
+      switch (node.kind) {
+        case "aggregate": path = `${domainPath}/Aggregates/${node.entity.id}`; kind = "aggregate"; break;
+        case "contract":
+        case "payload-contract":
+        case "read-contract": path = `${domainPath}/Contracts/${node.entity.id}`; kind = "contract"; break;
+        case "type": path = `${domainPath}/Types/${node.entity.id}`; kind = "type"; break;
+        case "object-type": path = `${domainPath}/ObjectTypes/${node.entity.id}`; kind = "object-type"; break;
+        case "intent": path = `${domainPath}/Intents/${node.entity.id}`; kind = "intent"; break;
+        case "read": path = `${domainPath}/Reads/${node.entity.id}`; kind = "read"; break;
+        case "relation":
+          path = frameworkRelationPath(node) ?? `${domainPath}/Relations/${node.entity.id}`;
+          kind = "relation";
+          break;
+        case "policy": path = `${domainPath}/Policies/${node.entity.id}`; kind = "policy"; break;
+        case "invariant": path = `${domainPath}/Invariants/${node.entity.id}`; kind = "invariant"; break;
+        case "capability": path = `${domainPath}/Capabilities/${node.entity.id}`; kind = "capability"; break;
+        case "workspace-type": path = `${domainPath}/WorkspaceTypes/s_${node.entity.sid}`; kind = "workspace-type"; break;
+        case "field":
+        case "structural": break;
+      }
+      if (path !== undefined && kind !== undefined) {
+        pathById.set(node.entity.id, path);
+        addDependency(candidate.domain.entity.label, kind, node.entity.label, path);
+      }
+    }
+    const entityLabels = new Map(candidate.nodes.map((node) => [node.entity.id, node.entity.label] as const));
+    for (const node of candidate.nodes) {
+      if (node.kind !== "field") continue;
+      const ownerPath = pathById.get(node.owner.id);
+      if (ownerPath === undefined) continue;
+      const path = `${ownerPath}/Fields/${node.entity.id}`;
+      pathById.set(node.entity.id, path);
+      const ownerLabel = entityLabels.get(node.owner.id);
+      addDependency(
+        candidate.domain.entity.label,
+        "field",
+        ownerLabel === undefined ? node.entity.label : `${ownerLabel}.${node.entity.label}`,
+        path,
+      );
+    }
+  }
+  const resolveDependency = (dependency: LawDependencyRef<any>): string => {
+    if (dependency.entityKind === "relation") {
+      const framework = FRAMEWORK_RELATION_PATHS.get(
+        dependency.label as typeof FRAMEWORK_RELATIONS[number]["key"],
+      );
+      if (framework !== undefined) return framework;
+    }
+    const key = `${dependency.domain ?? "*"}:${dependency.entityKind}:${dependency.label}`;
+    let candidates = dependencyPaths.get(key) ?? [];
+    // A runtime aggregate can live in `catalogue` while its reusable public shape is defined once
+    // in the package's schema-only `reference_data` layer. Domain qualification remains strict for
+    // aggregates and relations; contracts and their fields may fall back to the closure-wide index
+    // only when there is exactly one definition. Multiple shared definitions still refuse below.
+    if (
+      candidates.length === 0 &&
+      dependency.domain !== undefined &&
+      (dependency.entityKind === "contract" || dependency.entityKind === "field")
+    ) {
+      candidates = dependencyPaths.get(`*:${dependency.entityKind}:${dependency.label}`) ?? [];
+    }
+    if (candidates.length === 0) {
+      fail(`no closure path resolves dependency '${dependency.domain ?? "?"}:${dependency.entityKind}:${dependency.label}'`);
+    }
+    if (candidates.length > 1) {
+      fail(`dependency '${dependency.domain ?? "?"}:${dependency.entityKind}:${dependency.label}' is ambiguous in the closure`);
+    }
+    return candidates[0]!;
+  };
+  for (const aggregate of aggregates) {
+    pathById.set(aggregate.entity.id, `/Nomos/Domains/${domain.entity.id}/Aggregates/${aggregate.entity.id}`);
+  }
+  for (const contract of contracts) {
+    pathById.set(contract.entity.id, `/Nomos/Domains/${domain.entity.id}/Contracts/${contract.entity.id}`);
+  }
+  for (const contract of payloadContracts) {
+    pathById.set(contract.entity.id, `/Nomos/Domains/${domain.entity.id}/Contracts/${contract.entity.id}`);
+  }
+  for (const type of types) {
+    pathById.set(type.entity.id, `/Nomos/Domains/${domain.entity.id}/Types/${type.entity.id}`);
+  }
+  for (const objectType of objectTypes) {
+    pathById.set(objectType.entity.id, `/Nomos/Domains/${domain.entity.id}/ObjectTypes/${objectType.entity.id}`);
+  }
+  for (const relation of allRelations) {
+    pathById.set(
+      relation.entity.id,
+      frameworkRelationPath(relation) ?? `/Nomos/Domains/${domain.entity.id}/Relations/${relation.entity.id}`,
+    );
+  }
+  for (const intent of intents) {
+    pathById.set(intent.entity.id, `/Nomos/Domains/${domain.entity.id}/Intents/${intent.entity.id}`);
+  }
+  for (const effect of effects) {
+    const owner = pathById.get(effect.owner.id);
+    if (owner !== undefined) pathById.set(effect.entity.id, `${owner}/Effects/e_${effect.entity.sid}`);
+  }
+  for (const read of foreignReads) {
+    const owner = pathById.get(read.owner.id);
+    if (owner !== undefined) pathById.set(read.entity.id, `${owner}/ForeignReads/x_${read.entity.sid}`);
+  }
+  for (const read of reads) {
+    pathById.set(read.entity.id, `/Nomos/Domains/${domain.entity.id}/Reads/${read.entity.id}`);
+  }
+  for (const predicate of readPredicates) {
+    const owner = pathById.get(predicate.owner.id);
+    if (owner !== undefined) pathById.set(predicate.entity.id, `${owner}/Predicates/p_${predicate.entity.sid}`);
+  }
+  for (const policy of policies) {
+    pathById.set(policy.entity.id, `/Nomos/Domains/${domain.entity.id}/Policies/${policy.entity.id}`);
+  }
+  for (const invariant of invariants) {
+    pathById.set(invariant.entity.id, `/Nomos/Domains/${domain.entity.id}/Invariants/${invariant.entity.id}`);
+  }
+  for (const capability of capabilities) {
+    pathById.set(capability.entity.id, `/Nomos/Domains/${domain.entity.id}/Capabilities/${capability.entity.id}`);
+  }
+  for (const workspaceType of workspaceTypes) {
+    pathById.set(workspaceType.entity.id, `/Nomos/Domains/${domain.entity.id}/WorkspaceTypes/s_${workspaceType.entity.sid}`);
+  }
+  for (const flow of flows) {
+    pathById.set(flow.entity.id, `/Nomos/Domains/${domain.entity.id}/Flows/w_${flow.entity.sid}`);
+  }
+  for (const predicate of relationPredicates) {
+    const owner = pathById.get(predicate.owner.id);
+    if (owner !== undefined) pathById.set(predicate.entity.id, `${owner}/Predicates/p_${predicate.entity.sid}`);
+  }
+  const resolveAnonymousTypePath = (id: string, active = new Set<string>()): string => {
+    const prior = pathById.get(id);
+    if (prior !== undefined) return prior;
+    if (active.has(id)) fail(`anonymous type '${id}' contains an unsupported wrapper cycle`);
+    const node = anonymousTypeById.get(id);
+    if (node === undefined) fail(`anonymous type '${id}' is missing from the graph`);
+    active.add(id);
+    const expression = node.expression;
+    let path: string;
+    if (expression.kind === "string" && expression.constraints.length === 0) {
+      path = FRAMEWORK_SCALAR.string!;
+    } else if (expression.kind === "integer" && expression.constraints.length === 0) {
+      path = FRAMEWORK_SCALAR.integer!;
+    } else if (expression.kind === "boolean") {
+      path = FRAMEWORK_SCALAR.boolean!;
+    } else if (expression.kind === "nullable" || expression.kind === "default") {
+      path = resolveAnonymousTypePath(expression.value.id, active);
+    } else {
+      path = `/Nomos/Domains/${domain.entity.id}/Types/t_${node.entity.sid}`;
+    }
+    active.delete(id);
+    pathById.set(id, path);
+    return path;
+  };
+  for (const type of anonymousTypes) resolveAnonymousTypePath(type.entity.id);
+
+  // 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. Compute a semantic key which excludes owner identity,
+  // then point every equivalent type graph at one canonical prim. 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.
+  const semanticTypeKeyMemo = new Map<string, string | null>();
+  const semanticTypeKey = (id: string, active = new Set<string>()): string | undefined => {
+    const memoized = semanticTypeKeyMemo.get(id);
+    if (memoized !== undefined) return memoized ?? undefined;
+    if (active.has(id)) {
+      semanticTypeKeyMemo.set(id, null);
+      return undefined;
+    }
+    const node = anonymousTypeById.get(id);
+    if (node === undefined) return undefined;
+    active.add(id);
+    const childKey = (childId: string): string | undefined => semanticTypeKey(childId, active);
+    let key: string | undefined;
+    switch (node.expression.kind) {
+      case "string":
+      case "number":
+      case "integer":
+      case "boolean":
+      case "null":
+      case "unknown":
+      case "enum":
+      case "literal":
+        key = JSON.stringify(node.expression);
+        break;
+      case "list": {
+        const child = childKey(node.expression.element.id);
+        if (child !== undefined) key = JSON.stringify(["list", child]);
+        break;
+      }
+      case "map": {
+        const child = childKey(node.expression.value.id);
+        if (child !== undefined) key = JSON.stringify(["map", child]);
+        break;
+      }
+      case "nullable":
+      case "default": {
+        // These wrappers already resolve to their carried type rather than owning a USDA prim.
+        key = childKey(node.expression.value.id);
+        break;
+      }
+      case "record": {
+        const members: Array<readonly [string, boolean, string]> = [];
+        for (const field of anonymousFieldsByOwner.get(id) ?? []) {
+          const child = childKey(field.value.id);
+          if (child === undefined) break;
+          members.push([field.name, field.required, child]);
+        }
+        if (members.length === (anonymousFieldsByOwner.get(id)?.length ?? 0)) {
+          members.sort(([left], [right]) => left.localeCompare(right));
+          key = JSON.stringify(["record", members]);
+        }
+        break;
+      }
+      case "sum": {
+        const members: string[] = [];
+        for (const variant of anonymousVariantsByOwner.get(id) ?? []) {
+          const child = childKey(variant.value.id);
+          if (child === undefined) break;
+          members.push(child);
+        }
+        if (members.length === (anonymousVariantsByOwner.get(id)?.length ?? 0)) {
+          members.sort();
+          key = JSON.stringify(["sum", members]);
+        }
+        break;
+      }
+      case "recursive":
+        key = undefined;
+        break;
+    }
+    active.delete(id);
+    semanticTypeKeyMemo.set(id, key ?? null);
+    return key;
+  };
+
+  const canonicalTypeBySemanticKey = new Map<string, LawAnonymousValueTypeNode>();
+  const canonicalTypeIdById = new Map<string, string>();
+  for (const type of [...anonymousTypes].sort((left, right) => left.entity.sid.localeCompare(right.entity.sid))) {
+    const ownPath = pathById.get(type.entity.id);
+    if (ownPath?.endsWith(`/Types/t_${type.entity.sid}`) !== true) continue;
+    const key = semanticTypeKey(type.entity.id);
+    if (key === undefined) continue;
+    const canonical = canonicalTypeBySemanticKey.get(key);
+    if (canonical === undefined) {
+      canonicalTypeBySemanticKey.set(key, type);
+      canonicalTypeIdById.set(type.entity.id, type.entity.id);
+      continue;
+    }
+    canonicalTypeIdById.set(type.entity.id, canonical.entity.id);
+    pathById.set(type.entity.id, requiredPath(canonical.entity.id, pathById));
+  }
+
+  // Wrapper types do not own a USDA prim: their identity is the final path of the carried type.
+  // `resolveAnonymousTypePath` ran before semantic sharing, so a wrapper around a type which was
+  // subsequently aliased still holds the now-suppressed occurrence's old path. Refresh wrappers
+  // after all canonical aliases are known so contracts cannot retain a dangling relationship.
+  const finalAnonymousTypePath = (id: string, active = new Set<string>()): string => {
+    if (active.has(id)) fail(`anonymous type '${id}' contains an unsupported wrapper cycle`);
+    const node = anonymousTypeById.get(id);
+    if (node === undefined) return requiredPath(id, pathById);
+    if (node.expression.kind !== "nullable" && node.expression.kind !== "default") {
+      return requiredPath(id, pathById);
+    }
+    active.add(id);
+    const path = finalAnonymousTypePath(node.expression.value.id, active);
+    active.delete(id);
+    return path;
+  };
+  for (const type of anonymousTypes) {
+    if (type.expression.kind === "nullable" || type.expression.kind === "default") {
+      pathById.set(type.entity.id, finalAnonymousTypePath(type.entity.id));
+    }
+  }
+  for (const field of anonymousFields) {
+    const owner = pathById.get(field.owner.id);
+    if (owner !== undefined) pathById.set(field.entity.id, `${owner}/Fields/f_${field.entity.sid}`);
+  }
+  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}`);
+  }
+
+  // When two record/sum types share one canonical prim, their nested structural references must
+  // share the canonical child paths too. This preserves effects which target a nested payload field;
+  // no dangling path is allowed merely because its source owner was the non-canonical occurrence.
+  for (const [duplicateId, canonicalId] of canonicalTypeIdById) {
+    if (duplicateId === canonicalId) continue;
+    const canonicalFields = new Map<string, LawAnonymousValueFieldNode>();
+    for (const field of anonymousFieldsByOwner.get(canonicalId) ?? []) {
+      const child = semanticTypeKey(field.value.id);
+      if (child !== undefined) canonicalFields.set(JSON.stringify([field.name, field.required, child]), field);
+    }
+    for (const field of anonymousFieldsByOwner.get(duplicateId) ?? []) {
+      const child = semanticTypeKey(field.value.id);
+      const canonical = child === undefined
+        ? undefined
+        : canonicalFields.get(JSON.stringify([field.name, field.required, child]));
+      if (canonical !== undefined) {
+        pathById.set(field.entity.id, requiredPath(canonical.entity.id, pathById));
+      }
+    }
+
+    const canonicalVariants = new Map<string, LawAnonymousValueVariantNode[]>();
+    for (const variant of anonymousVariantsByOwner.get(canonicalId) ?? []) {
+      const child = semanticTypeKey(variant.value.id);
+      if (child === undefined) continue;
+      const matches = canonicalVariants.get(child) ?? [];
+      matches.push(variant);
+      canonicalVariants.set(child, matches);
+    }
+    for (const variant of anonymousVariantsByOwner.get(duplicateId) ?? []) {
+      const child = semanticTypeKey(variant.value.id);
+      if (child === undefined) continue;
+      const canonical = canonicalVariants.get(child)?.shift();
+      if (canonical !== undefined) {
+        pathById.set(variant.entity.id, requiredPath(canonical.entity.id, pathById));
+      }
+    }
+  }
+  for (const field of fields) {
+    const owner = pathById.get(field.owner.id);
+    if (owner !== undefined) pathById.set(field.entity.id, `${owner}/Fields/${field.entity.id}`);
+  }
+
+  const lines = [
+    "#usda 1.0",
+    "(",
+    "    customLayerData = {",
+    '        string "nomos:format" = "nomos.law-layer.v3"',
+    `        string "nomos:logicalPath" = ${quote(logicalPath)}`,
+    "    }",
+    ")",
+    "",
+    'over "Nomos"',
+    "{",
+    '    over "Domains"',
+    "    {",
+    `        def Scope "${domain.entity.id}"`,
+    "        {",
+    ...entityLabelOpinions(domain.entity, 12),
+  ];
+  if (domain.parentAttestedBirth !== undefined) {
+    lines.push(
+      `            custom uniform string nomos:parentOwnerObject = ${quote(domain.parentAttestedBirth.ownerObject)}`,
+      `            custom uniform string nomos:parentOwnerField = ${quote(domain.parentAttestedBirth.ownerField)}`,
+      `            custom uniform string nomos:parentCertObject = ${quote(domain.parentAttestedBirth.certObject)}`,
+      `            custom uniform string nomos:parentCertField = ${quote(domain.parentAttestedBirth.certField)}`,
+    );
+  }
+  lines.push("");
+  emitContainer(lines, "Aggregates", aggregates, 12, (aggregate, indent) =>
+    emitAggregate(aggregate, fields, pathById, resolveDependency, indent));
+  const emittedAnonymousTypes = anonymousTypes.filter((type) =>
+    pathById.get(type.entity.id)?.endsWith(`/Types/t_${type.entity.sid}`) === true);
+  if (types.length > 0 || emittedAnonymousTypes.length > 0) {
+    lines.push("");
+    const emittedTypes: Array<LawTypeNode | LawAnonymousValueTypeNode> = [...types, ...emittedAnonymousTypes]
+      .sort((a, b) => requiredPath(a.entity.id, pathById).localeCompare(requiredPath(b.entity.id, pathById)));
+    emitContainer(lines, "Types", emittedTypes, 12, (type, indent) =>
+      type.kind === "type"
+        ? emitType(type, fields, anonymousVariants, pathById, resolveDependency, indent)
+        : emitAnonymousType(type, anonymousFields, anonymousVariants, anonymousTypeById, pathById, indent),
+    (type) => type.kind === "type" ? type.entity.id : `t_${type.entity.sid}`);
+  }
+  if (objectTypes.length > 0) {
+    lines.push("");
+    emitContainer(lines, "ObjectTypes", objectTypes, 12, (objectType, indent) =>
+      [
+        ...entityLabelOpinions(objectType.entity, indent),
+        `${" ".repeat(indent)}custom uniform token nomos:objectNamespace = ${quote(objectType.namespace)}`,
+      ], undefined, () => "NomosObjectType");
+  }
+  if (contracts.length > 0 || payloadContracts.length > 0) {
+    lines.push("");
+    const emittedContracts: Array<LawContractNode | LawPayloadContractNode> = [...contracts, ...payloadContracts]
+      .sort((a, b) => a.entity.id.localeCompare(b.entity.id));
+    emitContainer(lines, "Contracts", emittedContracts, 12, (contract, indent) =>
+      contract.kind === "contract"
+        ? emitContract(contract, fields, pathById, resolveDependency, indent)
+        : emitPayloadContract(contract, anonymousFields, anonymousTypeById, pathById, indent));
+  }
+  if (relations.length > 0) {
+    lines.push("");
+    emitContainer(lines, "Relations", relations, 12, (relation, indent) =>
+      emitRelation(relation, relationPredicates, pathById, indent), undefined,
+      (relation) => authorizationDefinitionType(relation));
+  }
+  if (intents.length > 0) {
+    lines.push("");
+    emitContainer(lines, "Intents", intents, 12, (intent, indent) =>
+      emitIntent(intent, effects, foreignReads, workspaceRelations, pathById, resolveDependency, indent));
+  }
+  if (reads.length > 0) {
+    lines.push("");
+    emitContainer(lines, "Reads", reads, 12, (read, indent) =>
+      emitRead(read, readContracts, readPredicates, pathById, indent));
+  }
+  if (policies.length > 0) {
+    lines.push("");
+    emitContainer(lines, "Policies", policies, 12, (policy, indent) =>
+      emitPolicy(policy, pathById, indent));
+  }
+  if (invariants.length > 0) {
+    lines.push("");
+    emitContainer(lines, "Invariants", invariants, 12, (invariant, indent) =>
+      emitInvariant(invariant, pathById, indent));
+  }
+  if (capabilities.length > 0) {
+    lines.push("");
+    emitContainer(lines, "Capabilities", capabilities, 12, (capability, indent) =>
+      emitCapability(capability, pathById, indent));
+  }
+  if (workspaceTypes.length > 0) {
+    lines.push("");
+    emitContainer(lines, "WorkspaceTypes", workspaceTypes, 12, (workspaceType, indent) =>
+      emitWorkspaceType(workspaceType, pathById, indent),
+    (workspaceType) => `s_${workspaceType.entity.sid}`);
+  }
+  if (flows.length > 0) {
+    lines.push("");
+    emitContainer(lines, "Flows", flows, 12, (flow, indent) => emitFlow(flow, pathById, indent),
+      (flow) => `w_${flow.entity.sid}`);
+  }
+  lines.push("        }", "    }", "}", "");
+  return lines.join("\n");
+}
+
+function emitAggregate(
+  aggregate: LawAggregateNode,
+  fields: readonly LawFieldNode[],
+  paths: ReadonlyMap<string, string>,
+  resolveDependency: ResolveDependency,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const body = [
+    ...entityLabelOpinions(aggregate.entity, indent),
+    `${pad}custom uniform string nomos:wireType = ${quote(aggregate.wireType)}`,
+    `${pad}custom uniform bool nomos:public = ${aggregate.public}`,
+  ];
+  if (aggregate.cap !== undefined) body.push(`${pad}custom uniform uint64 nomos:cap = ${aggregate.cap}`);
+  if (aggregate.implements.length > 0) {
+    body.push(`${pad}custom rel nomos:implements = ${targets(aggregate.implements, paths, resolveDependency)}`);
+  }
+  if (aggregate.readPolicy !== undefined) {
+    body.push(`${pad}custom rel nomos:readPolicy = ${target(aggregate.readPolicy, paths, resolveDependency)}`);
+  }
+  if (aggregate.ownerField !== undefined) {
+    body.push(`${pad}custom rel nomos:ownerField = <${requiredPath(aggregate.ownerField.id, paths)}>`);
+  }
+  const owned = fields.filter((field) => field.owner.id === aggregate.entity.id);
+  if (owned.length > 0) {
+    body.push("", `${pad}def Scope "Fields"`, `${pad}{`);
+    for (const [index, field] of owned.entries()) {
+      if (index > 0) body.push("");
+      body.push(...emitField(field, paths, resolveDependency, indent + 4));
+    }
+    body.push(`${pad}}`);
+  }
+  return body;
+}
+
+function emitPolicy(
+  policy: LawPolicyNode,
+  paths: ReadonlyMap<string, string>,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const body = [
+    `${pad}custom uniform token nomos:policyKind = ${quote(policy.policyKind)}`,
+    ...entityLabelOpinions(policy.entity, indent),
+    `${pad}custom uniform bool nomos:monotone = ${policy.monotone}`,
+    `${pad}custom uniform token nomos:onDishonor = ${quote(policy.onDishonor)}`,
+  ];
+  if (policy.maxAgeMs !== undefined) body.push(`${pad}custom uniform uint64 nomos:maxAgeMs = ${policy.maxAgeMs}`);
+  if (policy.minSourceEpoch !== undefined) {
+    body.push(typeof policy.minSourceEpoch === "number"
+      ? `${pad}custom uniform uint64 nomos:minSourceEpoch = ${policy.minSourceEpoch}`
+      : `${pad}custom uniform token nomos:minSourceEpochMode = ${quote(policy.minSourceEpoch)}`);
+  }
+  if (policy.policyKind === "pinned-source") {
+    body.push(
+      `${pad}custom uniform string nomos:workspace = ${quote(policy.workspace)}`,
+      `${pad}custom uniform string nomos:genesis = ${quote(policy.genesis)}`,
+      `${pad}custom uniform token nomos:roster = ${quote(policy.roster)}`,
+    );
+    if (policy.keyHashes.length > 0) {
+      body.push(`${pad}custom uniform string[] nomos:keyHashes = ${stringList(policy.keyHashes)}`);
+    }
+  } else {
+    body.push(
+      `${pad}custom rel nomos:allowList = <${requiredPath(policy.allowList.id, paths)}>`,
+      `${pad}custom rel nomos:genesisField = <${requiredPath(policy.genesisField.id, paths)}>`,
+      `${pad}custom rel nomos:keysField = <${requiredPath(policy.keysField.id, paths)}>`,
+    );
+  }
+  return body;
+}
+
+function emitInvariant(
+  invariant: LawInvariantNode,
+  paths: ReadonlyMap<string, string>,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const target = invariant.invariantKind === "aggregate" ? invariant.onAggregate.id : invariant.on.id;
+  const body = [
+    ...entityLabelOpinions(invariant.entity, indent),
+    `${pad}custom rel nomos:on = <${requiredPath(target, paths)}>`,
+    ...(invariant.invariantKind === "workspace" && invariant.evaluator !== undefined
+      ? [`${pad}custom uniform token nomos:evaluator = ${quote(invariant.evaluator)}`]
+      : []),
+  ];
+  if (invariant.invariantKind === "workspace" && invariant.reads !== undefined) {
+    body.push(`${pad}custom uniform token nomos:readEvaluator = "point-v1"`);
+    for (const [index, read] of invariant.reads.entries()) {
+      body.push(
+        "",
+        `${pad}def NomosInvariantRead "Read_${index}"`,
+        `${pad}{`,
+        `${pad}    custom uniform string nomos:binding = ${quote(read.binding)}`,
+        `${pad}    custom rel nomos:aggregate = <${requiredPath(read.aggregate.id, paths)}>`,
+        `${pad}    custom uniform token nomos:state = ${quote(read.state)}`,
+        `${pad}    custom uniform token nomos:idSource = ${quote(read.id.source)}`,
+      );
+      if (read.eachPayloadPath !== undefined) {
+        body.push(`${pad}    custom uniform token[] nomos:eachPayloadPath = ${stringList(read.eachPayloadPath)}`);
+      }
+      if (read.id.source === "literal") {
+        body.push(`${pad}    custom uniform string nomos:idLiteral = ${quote(read.id.value)}`);
+      } else if (read.id.source === "payload") {
+        body.push(
+          `${pad}    custom uniform token[] nomos:idPayloadPath = ${stringList(read.id.path)}`,
+          `${pad}    custom uniform string nomos:idPrefix = ${quote(read.id.prefix)}`,
+          `${pad}    custom uniform string nomos:idSuffix = ${quote(read.id.suffix)}`,
+          `${pad}    custom uniform bool nomos:optional = ${read.id.optional}`,
+        );
+      } else {
+        body.push(
+          `${pad}    custom uniform bool nomos:optional = ${read.id.optional}`,
+          `${pad}    def NomosReadIdTemplate "Id"`,
+          `${pad}    {`,
+        );
+        for (const [partIndex, part] of read.id.parts.entries()) {
+          body.push(
+            `${pad}        def NomosReadIdPart "Part_${partIndex}"`,
+            `${pad}        {`,
+            `${pad}            custom uniform token nomos:source = ${quote(part.source)}`,
+          );
+          if (part.source === "literal") {
+            body.push(`${pad}            custom uniform string nomos:value = ${quote(part.value)}`);
+          } else {
+            body.push(
+              `${pad}            custom uniform token[] nomos:path = ${stringList(part.path)}`,
+              `${pad}            custom uniform token nomos:transform = ${quote(part.transform)}`,
+            );
+          }
+          body.push(`${pad}        }`);
+        }
+        body.push(`${pad}    }`);
+      }
+      body.push(`${pad}}`);
+    }
+  }
+  if (invariant.invariantKind === "workspace" && invariant.pointGuard !== undefined) {
+    const guard = invariant.pointGuard;
+    body.push(
+      `${pad}custom rel nomos:aggregate = <${requiredPath(guard.aggregate.id, paths)}>`,
+      `${pad}custom uniform token nomos:binding = ${quote(guard.binding)}`,
+      `${pad}custom uniform token nomos:state = ${quote(guard.state)}`,
+      `${pad}custom uniform token[] nomos:idPayloadPath = ${stringList(guard.idPayloadPath)}`,
+      `${pad}custom uniform string nomos:rejectCode = ${quote(guard.rejectCode)}`,
+      "",
+      ...emitPointGuardPredicate(guard.predicate, "Predicate", indent),
+    );
+  }
+  return body;
+}
+
+function emitPointGuardPredicate(
+  predicate: NonNullable<Extract<LawInvariantNode, { invariantKind: "workspace" }>["pointGuard"]>["predicate"],
+  name: string,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const type = predicate.kind === "exists" ? "NomosExists"
+    : predicate.kind === "absent" ? "NomosAbsent"
+    : predicate.kind === "present" ? "NomosPathPresent"
+    : predicate.kind === "missing" ? "NomosPathMissing"
+    : predicate.kind === "compare" ? "NomosCompare"
+    : predicate.kind === "all" ? "NomosAll"
+    : predicate.kind === "any" ? "NomosAny"
+    : "NomosNot";
+  const body = [`${pad}def ${type} ${quote(name)}`, `${pad}{`];
+  const prop = " ".repeat(indent + 4);
+  if (predicate.kind === "present" || predicate.kind === "missing") {
+    body.push(`${prop}custom uniform token[] nomos:path = ${stringList(predicate.operand.path)}`);
+  } else if (predicate.kind === "compare") {
+    body.push(
+      `${prop}custom uniform token nomos:operator = ${quote(predicate.operator)}`,
+      `${prop}custom uniform token[] nomos:leftPath = ${stringList(predicate.left.path)}`,
+      `${prop}custom uniform token nomos:rightSource = ${quote(predicate.right.source)}`,
+    );
+    if (predicate.right.source === "literal") {
+      const value = predicate.right.value;
+      if (typeof value === "string") body.push(`${prop}custom uniform string nomos:stringValue = ${quote(value)}`);
+      else if (typeof value === "boolean") body.push(`${prop}custom uniform bool nomos:boolValue = ${value}`);
+      else body.push(`${prop}custom uniform int64 nomos:intValue = ${value}`);
+    } else {
+      body.push(`${prop}custom uniform token[] nomos:rightPath = ${stringList(predicate.right.path)}`);
+    }
+  } else if (predicate.kind === "all" || predicate.kind === "any") {
+    body.push(`${prop}def Scope "Terms"`, `${prop}{`);
+    for (const [index, term] of predicate.terms.entries()) {
+      body.push(...emitPointGuardPredicate(term, `t_${index.toString().padStart(4, "0")}`, indent + 8));
+    }
+    body.push(`${prop}}`);
+  } else if (predicate.kind === "not") {
+    body.push(...emitPointGuardPredicate(predicate.term, "Term", indent + 4));
+  }
+  body.push(`${pad}}`);
+  return body;
+}
+
+function emitCapability(
+  capability: LawCapabilityNode,
+  paths: ReadonlyMap<string, string>,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  return [
+    ...entityLabelOpinions(capability.entity, indent),
+    `${pad}custom uniform token nomos:capability = ${quote(capability.capability ?? capability.entity.label)}`,
+    ...(capability.endpoint === undefined
+      ? []
+      : [`${pad}custom uniform asset nomos:endpoint = @${capability.endpoint.replaceAll("@", "@@")}@`]),
+    `${pad}custom rel nomos:aggregate = <${requiredPath(capability.task.id, paths)}>`,
+    `${pad}custom rel nomos:obligation = <${requiredPath(capability.obligation.id, paths)}>`,
+    `${pad}custom rel nomos:complete = <${requiredPath(capability.complete.id, paths)}>`,
+    `${pad}custom rel nomos:fail = <${requiredPath(capability.fail.id, paths)}>`,
+    `${pad}custom rel nomos:block = <${requiredPath(capability.block.id, paths)}>`,
+    `${pad}custom rel nomos:deadLetter = <${requiredPath(capability.deadLetter.id, paths)}>`,
+    ...(capability.tasks === undefined
+      ? []
+      : [`${pad}custom rel nomos:tasks = <${requiredPath(capability.tasks.id, paths)}>`]),
+  ];
+}
+
+function emitWorkspaceType(
+  workspaceType: LawWorkspaceTypeNode,
+  paths: ReadonlyMap<string, string>,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const body = [
+    ...entityLabelOpinions(workspaceType.entity, indent),
+    `${pad}custom uniform token nomos:mode = ${quote(workspaceType.mode)}`,
+  ];
+  if (workspaceType.root !== undefined) body.push(`${pad}custom rel nomos:root = <${requiredPath(workspaceType.root.id, paths)}>`);
+  if (workspaceType.children.length > 0) {
+    body.push(`${pad}custom rel nomos:children = ${relList(workspaceType.children
+      .map((child) => `<${requiredPath(child.id, paths)}>`))}`);
+  }
+  if (workspaceType.globals.length > 0) {
+    body.push(`${pad}custom rel nomos:globals = ${relList(workspaceType.globals
+      .map((aggregate) => `<${requiredPath(aggregate.id, paths)}>`))}`);
+  }
+  if (workspaceType.coordinatorLocal.length > 0) {
+    body.push(`${pad}custom rel nomos:coordinatorLocal = ${relList(workspaceType.coordinatorLocal
+      .map((aggregate) => `<${requiredPath(aggregate.id, paths)}>`))}`);
+  }
+  return body;
+}
+
+function emitFlow(flow: LawFlowNode, paths: ReadonlyMap<string, string>, indent: number): string[] {
+  const pad = " ".repeat(indent);
+  const body = [
+    `${pad}custom uniform token nomos:flowKind = ${quote(flow.flowKind)}`,
+    `${pad}custom rel nomos:on = <${requiredPath(flow.owner.id, paths)}>`,
+    `${pad}custom uniform string nomos:site = ${quote(flow.site)}`,
+    `${pad}custom uniform string nomos:reason = ${quote(flow.reason ?? "")}`,
+  ];
+  if (flow.sink !== undefined) body.push(`${pad}custom rel nomos:sink = <${requiredPath(flow.sink.id, paths)}>`);
+  if (flow.facet !== undefined) body.push(`${pad}custom uniform token nomos:facet = ${quote(flow.facet)}`);
+  return body;
+}
+
+function emitIntent(
+  intent: LawIntentNode,
+  effects: readonly LawIntentEffectNode[],
+  foreignReads: readonly LawForeignReadNode[],
+  workspaceRelations: readonly LawWorkspaceRelationNode[],
+  paths: ReadonlyMap<string, string>,
+  resolveDependency: ResolveDependency,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const body = [
+    ...entityLabelOpinions(intent.entity, indent),
+    `${pad}custom uniform token nomos:marker = ${quote(markerToken(intent.marker))}`,
+    `${pad}custom uniform bool nomos:active = true`,
+    `${pad}custom uniform bool nomos:public = ${intent.public}`,
+    `${pad}custom uniform string nomos:publicRoute = ${quote(intent.publicRoute ?? intent.entity.label)}`,
+    `${pad}custom rel nomos:target = ${targets([intent.target], paths, resolveDependency)}`,
+    `${pad}custom rel nomos:accepts = <${requiredPath(intent.accepts.id, paths)}>`,
+    ...(intent.publicAccepts === undefined
+      ? []
+      : [`${pad}custom rel nomos:publicAccepts = <${requiredPath(intent.publicAccepts.id, paths)}>`]),
+  ];
+  if (intent.reads.length > 0) {
+    body.push(`${pad}custom rel nomos:reads = ${targets(intent.reads, paths, resolveDependency)}`);
+  }
+  if (intent.authorization !== undefined) {
+    body.push(
+      `${pad}custom rel nomos:requires = ${targets([intent.authorization.relation], paths, resolveDependency)}`,
+      `${pad}custom uniform string nomos:requiresObject = ${quote(intent.authorization.object)}`,
+    );
+    if (intent.authorization.objectFrom !== undefined) {
+      body.push(
+        `${pad}custom uniform token nomos:requiresObjectType = ${quote(intent.authorization.objectFrom.recordType)}`,
+        `${pad}custom rel nomos:requiresObjectIdField = <${requiredPath(intent.authorization.objectFrom.idField.id, paths)}>`,
+      );
+    }
+  }
+  if (intent.requiresHostCapabilities.length > 0) {
+    body.push(
+      `${pad}custom uniform token[] nomos:requiresHostCapability = ${stringList(intent.requiresHostCapabilities)}`,
+    );
+  }
+  if (intent.resolves !== undefined) {
+    body.push(`${pad}custom rel nomos:resolves = <${requiredPath(intent.resolves.id, paths)}>`);
+  }
+  if (intent.births) body.push(`${pad}custom uniform bool nomos:births = true`);
+  if (intent.birthRecord !== undefined) {
+    body.push(
+      `${pad}custom rel nomos:birthRecord = <${requiredPath(intent.birthRecord.id, paths)}>`,
+      `${pad}custom uniform string nomos:birthPrefix = ${quote(intent.birthPrefix ?? "")}`,
+    );
+  }
+  if (intent.attestation !== undefined) {
+    body.push(
+      `${pad}custom uniform string nomos:attestationOwnerObject = ${quote(intent.attestation.ownerObject)}`,
+      `${pad}custom uniform string nomos:attestationOwnerField = ${quote(intent.attestation.ownerField)}`,
+      `${pad}custom rel nomos:attestationAsserterWorkspace = <${requiredPath(intent.attestation.asserterWorkspace.id, paths)}>`,
+      `${pad}custom rel nomos:attestationObject = <${requiredPath(intent.attestation.object.id, paths)}>`,
+      `${pad}custom rel nomos:attestationRelation = <${requiredPath(intent.attestation.relation.id, paths)}>`,
+      `${pad}custom rel nomos:attestationAt = <${requiredPath(intent.attestation.attestedAt.id, paths)}>`,
+      `${pad}custom rel nomos:attestationPublicKey = <${requiredPath(intent.attestation.publicKey.id, paths)}>`,
+      `${pad}custom rel nomos:attestationSignature = <${requiredPath(intent.attestation.signature.id, paths)}>`,
+    );
+  }
+  if (intent.delegation !== undefined) {
+    body.push(
+      `${pad}custom uniform token nomos:delegatedRelation = ${quote(intent.delegation.relation)}`,
+      `${pad}custom rel nomos:delegatedSubject = <${requiredPath(intent.delegation.subjectField.id, paths)}>`,
+      `${pad}custom rel nomos:delegationCertificate = <${requiredPath(intent.delegation.certField.id, paths)}>`,
+      `${pad}custom uniform string nomos:delegationParentKeyObject = ${quote(intent.delegation.parentKeyObject)}`,
+      `${pad}custom uniform string nomos:delegationParentKeyField = ${quote(intent.delegation.parentKeyField)}`,
+    );
+  }
+  if (intent.verifiedFirstEnroll !== undefined) {
+    body.push(
+      `${pad}custom rel nomos:firstEnrollToken = <${requiredPath(intent.verifiedFirstEnroll.tokenField.id, paths)}>`,
+      `${pad}custom rel nomos:firstEnrollKeyHash = <${requiredPath(intent.verifiedFirstEnroll.keyHashField.id, paths)}>`,
+      `${pad}custom rel nomos:firstEnrollVerifiedVia = <${requiredPath(intent.verifiedFirstEnroll.verifiedViaField.id, paths)}>`,
+    );
+  }
+  if (intent.eraCertification !== undefined) {
+    body.push(`${pad}custom rel nomos:eraCertificate = <${requiredPath(intent.eraCertification.certField.id, paths)}>`);
+  }
+  if (intent.foreignReads.length > 0) {
+    const byId = new Map(foreignReads.map((read) => [read.entity.id, read] as const));
+    body.push("", `${pad}def Scope "ForeignReads"`, `${pad}{`);
+    for (const ref of intent.foreignReads) {
+      const read = byId.get(ref.id);
+      if (read === undefined) fail(`intent '${intent.entity.label}' is missing foreign read '${ref.id}'`);
+      body.push(
+        `${pad}    def Scope "x_${read.entity.sid}"`,
+        `${pad}    {`,
+        `${pad}        custom uniform string nomos:query = ${quote(read.query)}`,
+        `${pad}        custom rel nomos:source = <${requiredPath(read.source.id, paths)}>`,
+        ...(read.fromField === undefined ? [] : [
+          `${pad}        custom rel nomos:fromField = <${requiredPath(read.fromField.id, paths)}>`,
+        ]),
+        `${pad}    }`,
+      );
+    }
+    body.push(`${pad}}`);
+  }
+  const ownedWorkspaceRelations = intent.workspaceRelations ?? [];
+  if (ownedWorkspaceRelations.length > 0) {
+    const byId = new Map(workspaceRelations.map((relation) => [relation.entity.id, relation] as const));
+    body.push("", `${pad}def Scope "WorkspaceRelations"`, `${pad}{`);
+    for (const ref of ownedWorkspaceRelations) {
+      const relation = byId.get(ref.id);
+      if (relation === undefined) fail(`intent '${intent.entity.label}' is missing workspace relation '${ref.id}'`);
+      body.push(
+        `${pad}    def NomosWorkspaceRelation "w_${relation.entity.sid}"`,
+        `${pad}    {`,
+        `${pad}        custom uniform string nomos:label = ${quote(relation.relation)}`,
+        `${pad}        custom uniform token nomos:sourceType = ${quote(relation.sourceType)}`,
+        `${pad}        custom uniform token nomos:targetType = ${quote(relation.targetType)}`,
+        `${pad}        custom rel nomos:proposes = <${requiredPath(intent.entity.id, paths)}>`,
+        `${pad}        custom uniform token nomos:evidenceAggregate = ${quote(relation.evidenceAggregate)}`,
+        `${pad}        custom uniform token[] nomos:evidenceSelect = ${stringList(relation.evidenceSelect)}`,
+        `${pad}        custom uniform token nomos:evidenceKind = ${quote(relation.evidenceKind)}`,
+        `${pad}        custom uniform bool nomos:hasInvariant = ${relation.hasInvariant}`,
+      );
+      if (relation.bindings.length > 0) {
+        body.push("", `${pad}        def Scope "Bindings"`, `${pad}        {`);
+        for (const [index, binding] of relation.bindings.entries()) {
+          body.push(
+            `${pad}            def NomosEvidenceBinding "b_${index.toString().padStart(4, "0")}"`,
+            `${pad}            {`,
+            `${pad}                custom uniform string nomos:evidenceField = ${quote(binding.evidenceField)}`,
+            `${pad}                custom uniform string nomos:directiveParameter = ${quote(binding.directiveParameter)}`,
+            `${pad}            }`,
+          );
+        }
+        body.push(`${pad}        }`);
+      }
+      body.push(`${pad}    }`);
+    }
+    body.push(`${pad}}`);
+  }
+  const byId = new Map(effects.map((effect) => [effect.entity.id, effect] as const));
+  const owned = intent.effects.map((effect) => {
+    const node = byId.get(effect.id);
+    if (node === undefined) fail(`intent '${intent.entity.label}' is missing effect '${effect.id}'`);
+    return node;
+  });
+  if (owned.length > 0) {
+    body.push("", `${pad}def Scope "Effects"`, `${pad}{`);
+    for (const [index, effect] of owned.entries()) {
+      if (index > 0) body.push("");
+      body.push(
+        `${pad}    def Scope "e_${effect.entity.sid}"`,
+        `${pad}    {`,
+        `${pad}        custom uniform token nomos:marker = ${quote(markerToken(effect.marker))}`,
+        ...(effect.cardinality === "many" ? [] : [`${pad}        custom uniform int nomos:max = 1`]),
+        `${pad}        custom rel nomos:target = ${targets([effect.aggregate], paths, resolveDependency)}`,
+        `${pad}    }`,
+      );
+    }
+    body.push(`${pad}}`);
+  }
+  return body;
+}
+
+function markerToken(marker: LawIntentNode["marker"]): "Create" | "Mutate" | "Ensure" | "Archive" {
+  switch (marker) {
+    case "creates": return "Create";
+    case "mutates": return "Mutate";
+    case "ensures": return "Ensure";
+    case "archives": return "Archive";
+  }
+}
+
+function emitRead(
+  read: LawReadNode,
+  contracts: readonly LawReadContractNode[],
+  predicates: readonly LawPredicateNode[],
+  paths: ReadonlyMap<string, string>,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const contract = contracts.find((candidate) => candidate.entity.id === read.contract.id);
+  if (contract === undefined) fail(`read '${read.entity.label}' is missing its result contract`);
+  const returns = contract.returns.kind === "rows"
+    ? contract.returns.aggregate.id
+    : contract.returns.value.id;
+  const body = [
+    ...entityLabelOpinions(read.entity, indent),
+    `${pad}custom uniform token nomos:readKind = ${quote(read.readKind)}`,
+    `${pad}custom uniform bool nomos:public = ${read.public ?? false}`,
+    `${pad}custom rel nomos:of = <${requiredPath(read.of.id, paths)}>`,
+    `${pad}custom rel nomos:returns = <${requiredPath(returns, paths)}>`,
+  ];
+  const fieldTarget = (field: { readonly field: { readonly id: string }; readonly path: readonly { readonly id: string }[] }): string => {
+    const terminal = field.path[field.path.length - 1] ?? field.field;
+    return `<${requiredPath(terminal.id, paths)}>`;
+  };
+  switch (read.readKind) {
+    case "query":
+      body.push(`${pad}custom rel nomos:key = ${relList(read.key.map(fieldTarget))}`);
+      body.push(`${pad}custom uniform string[] nomos:keyPath = ${stringList(read.key.map((field) => field.authoredPath))}`);
+      break;
+    case "count":
+    case "exists":
+      if (read.groupBy !== undefined) {
+        body.push(`${pad}custom rel nomos:groupBy = ${fieldTarget(read.groupBy)}`);
+        body.push(`${pad}custom uniform string nomos:groupByPath = ${quote(read.groupBy.authoredPath)}`);
+      }
+      break;
+    case "sum":
+    case "min":
+    case "max":
+      body.push(`${pad}custom rel nomos:field = ${fieldTarget(read.value)}`);
+      body.push(`${pad}custom uniform string nomos:fieldPath = ${quote(read.value.authoredPath)}`);
+      if (read.groupBy !== undefined) {
+        body.push(`${pad}custom rel nomos:groupBy = ${fieldTarget(read.groupBy)}`);
+        body.push(`${pad}custom uniform string nomos:groupByPath = ${quote(read.groupBy.authoredPath)}`);
+      }
+      break;
+    case "ordered":
+      body.push(`${pad}custom rel nomos:orderKey = ${fieldTarget(read.orderBy)}`);
+      body.push(`${pad}custom uniform string nomos:orderKeyPath = ${quote(read.orderBy.authoredPath)}`);
+      body.push(`${pad}custom uniform bool nomos:descending = ${read.descending}`);
+      body.push(`${pad}custom uniform int nomos:limit = ${read.limit}`);
+      break;
+    case "spatial":
+      body.push(`${pad}custom rel nomos:spatialOn = ${fieldTarget(read.geometry)}`);
+      body.push(`${pad}custom uniform string nomos:spatialPath = ${quote(read.geometry.authoredPath)}`);
+      break;
+    case "derived":
+      break;
+    case "combined":
+      body.push(`${pad}custom rel nomos:refField = ${fieldTarget(read.via)}`);
+      body.push(`${pad}custom uniform string nomos:refFieldPath = ${quote(read.via.authoredPath)}`);
+      body.push(`${pad}custom rel nomos:reads = <${requiredPath(read.reads.id, paths)}>`);
+      break;
+  }
+  if (read.predicate !== undefined) {
+    body.push(`${pad}custom rel nomos:where = <${requiredPath(read.predicate.id, paths)}>`);
+    const owned = predicates.filter((predicate) => predicate.owner.id === read.entity.id);
+    body.push("", `${pad}def Scope "Predicates"`, `${pad}{`);
+    for (const [index, predicate] of owned.entries()) {
+      if (index > 0) body.push("");
+      body.push(...emitReadPredicate(predicate, paths, indent + 4));
+    }
+    body.push(`${pad}}`);
+  }
+  return body;
+}
+
+function emitReadPredicate(
+  predicate: LawPredicateNode,
+  paths: ReadonlyMap<string, string>,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const expression = predicate.expression;
+  const body = [
+    `${pad}def Scope "p_${predicate.entity.sid}"`,
+    `${pad}{`,
+    `${pad}    custom uniform token nomos:operator = ${quote(expression.kind)}`,
+  ];
+  if ("field" in expression) {
+    const terminal = expression.field.path[expression.field.path.length - 1] ?? expression.field.field;
+    body.push(`${pad}    custom rel nomos:field = <${requiredPath(terminal.id, paths)}>`);
+    body.push(`${pad}    custom uniform string nomos:fieldPath = ${quote(expression.field.authoredPath)}`);
+    body.push(`${pad}    custom uniform string nomos:value = ${quote(expression.value)}`);
+  } else {
+    body.push(`${pad}    custom rel nomos:terms = ${relList(expression.terms
+      .map((term) => `<${requiredPath(term.id, paths)}>`))}`);
+  }
+  body.push(`${pad}}`);
+  return body;
+}
+
+function emitRelation(
+  relation: LawRelationNode,
+  predicates: readonly LawRelationPredicateNode[],
+  paths: ReadonlyMap<string, string>,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const objectType = requiredPath(relation.object.id, paths);
+  const body = [
+    `${pad}custom uniform token nomos:relationKind = "authorization"`,
+    ...entityLabelOpinions(relation.entity, indent),
+    `${pad}custom uniform string nomos:relation = ${quote(relation.relation)}`,
+    `${pad}custom uniform int nomos:maxDepth = ${relation.maxDepth}`,
+    `${pad}custom uniform int nomos:maxFanout = ${relation.maxFanout}`,
+    `${pad}custom rel nomos:objectType = <${objectType}>`,
+    `${pad}custom uniform token nomos:objectNamespace = ${quote(relation.objectType)}`,
+  ];
+  if (relation.allowed.length > 0) {
+    body.push(`${pad}custom uniform token[] nomos:subjectTypes = [${relation.allowed
+      .map((subject) => quote(subject.kind === "wildcard"
+        ? "user:*"
+        : subject.kind === "direct"
+          ? subject.type
+          : `${subject.type}#${subject.relationName}`))
+      .join(", ")}]`);
+  }
+  body.push(`${pad}custom rel nomos:rewrite = <${requiredPath(relation.rewrite.id, paths)}>`);
+  const owned = predicates.filter((predicate) => predicate.owner.id === relation.entity.id);
+  if (owned.length > 0) {
+    body.push("", `${pad}def Scope "Predicates"`, `${pad}{`);
+    for (const [index, predicate] of owned.entries()) {
+      if (index > 0) body.push("");
+      body.push(...emitRelationPredicate(predicate, paths, indent + 4));
+    }
+    body.push(`${pad}}`);
+  }
+  return body;
+}
+
+/** Zanzibar has two semantically different named edges. A relation admits directly asserted
+ * tuples (and may additionally compose them); a permission is computed only. Keep that distinction
+ * in the nominal USDA type so generic USD inspection and the kernel gate do not have to infer
+ * writability from an empty subject-type array. */
+function authorizationDefinitionType(relation: LawRelationNode): "NomosRelation" | "NomosPermission" {
+  return relation.allowed.length === 0 ? "NomosPermission" : "NomosRelation";
+}
+
+function emitRelationPredicate(
+  predicate: LawRelationPredicateNode,
+  paths: ReadonlyMap<string, string>,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const expression = predicate.expression;
+  const primType = (() => {
+    switch (expression.kind) {
+      case "this": return "NomosDirectUserset";
+      case "computed": return "NomosComputedUserset";
+      case "union": return "NomosUnion";
+      case "intersection": return "NomosIntersection";
+      case "exclusion": return "NomosExclusion";
+      case "ttu": return "NomosTupleToUserset";
+    }
+  })();
+  const body = [
+    `${pad}def ${primType} "p_${predicate.entity.sid}"`,
+    `${pad}{`,
+  ];
+  switch (expression.kind) {
+    case "this":
+      body.push(`${pad}    custom uniform token nomos:operator = "this"`);
+      break;
+    case "computed":
+      body.push(`${pad}    custom uniform token nomos:operator = "computedUserset"`);
+      body.push(`${pad}    custom rel nomos:relation = <${requiredPath(expression.relation.id, paths)}>`);
+      break;
+    case "union":
+    case "intersection":
+      body.push(`${pad}    custom uniform token nomos:operator = ${quote(expression.kind)}`);
+      body.push(`${pad}    custom rel nomos:terms = ${relList(expression.terms
+        .map((term) => `<${requiredPath(term.id, paths)}>`))}`);
+      break;
+    case "exclusion":
+      body.push(`${pad}    custom uniform token nomos:operator = "difference"`);
+      body.push(`${pad}    custom rel nomos:terms = ${relList([expression.base, expression.subtract]
+        .map((term) => `<${requiredPath(term.id, paths)}>`))}`);
+      break;
+    case "ttu":
+      body.push(`${pad}    custom uniform token nomos:operator = "tupleToUserset"`);
+      body.push(`${pad}    custom rel nomos:terms = ${relList([
+        `<${requiredPath(expression.tupleset.id, paths)}>`,
+        ...expression.computed.map((relation) => `<${requiredPath(relation.id, paths)}>`),
+      ])}`);
+      if (expression.all) body.push(`${pad}    custom uniform bool nomos:all = true`);
+      break;
+  }
+  body.push(`${pad}}`);
+  return body;
+}
+
+function emitContract(
+  contract: LawContractNode,
+  fields: readonly LawFieldNode[],
+  paths: ReadonlyMap<string, string>,
+  resolveDependency: ResolveDependency,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const body = [
+    ...entityLabelOpinions(contract.entity, indent),
+    `${pad}custom uniform bool nomos:public = ${contract.public}`,
+  ];
+  if (contract.implementedBy.length > 0) {
+    body.push(`${pad}custom rel nomos:implementedBy = ${relList(contract.implementedBy
+      .map((target) => `<${requiredPath(target.id, paths)}>`))}`);
+  }
+  const owned = fields.filter((field) => field.owner.id === contract.entity.id);
+  if (owned.length > 0) {
+    body.push("", `${pad}def Scope "Fields"`, `${pad}{`);
+    for (const [index, field] of owned.entries()) {
+      if (index > 0) body.push("");
+      body.push(...emitField(field, paths, resolveDependency, indent + 4));
+    }
+    body.push(`${pad}}`);
+  }
+  return body;
+}
+
+function emitPayloadContract(
+  contract: LawPayloadContractNode,
+  fields: readonly LawAnonymousValueFieldNode[],
+  types: ReadonlyMap<string, LawAnonymousValueTypeNode>,
+  paths: ReadonlyMap<string, string>,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const body = [...entityLabelOpinions(contract.entity, indent)];
+  const byId = new Map(fields.map((field) => [field.entity.id, field] as const));
+  const owned = contract.fields.map((field) => {
+    const node = byId.get(field.id);
+    if (node === undefined) fail(`payload contract '${contract.entity.label}' is missing field '${field.id}'`);
+    return node;
+  });
+  if (owned.length > 0) {
+    body.push("", `${pad}def Scope "Fields"`, `${pad}{`);
+    for (const [index, field] of owned.entries()) {
+      if (index > 0) body.push("");
+      body.push(...emitAnonymousField(field, types, paths, indent + 4));
+    }
+    body.push(`${pad}}`);
+  }
+  return body;
+}
+
+function emitType(
+  type: LawTypeNode,
+  fields: readonly LawFieldNode[],
+  variants: readonly LawAnonymousValueVariantNode[],
+  paths: ReadonlyMap<string, string>,
+  resolveDependency: ResolveDependency,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  if (type.form === "geometry") {
+    if (type.geometry === undefined) fail(`type '${type.entity.label}' is missing its geometry kind`);
+    return [
+      `${pad}custom uniform token nomos:typeKind = "geometry"`,
+      ...entityLabelOpinions(type.entity, indent),
+      `${pad}custom uniform token nomos:geometry = ${quote(type.geometry)}`,
+      `${pad}custom uniform token nomos:encoding = "rfc7946"`,
+    ];
+  }
+  const body = [
+    `${pad}custom uniform token nomos:typeKind = ${quote(type.form === "sum" ? "union" : "record")}`,
+    ...entityLabelOpinions(type.entity, indent),
+  ];
+  if (type.form === "sum") {
+    const byId = new Map(variants.map((variant) => [variant.entity.id, variant] as const));
+    const owned = type.variants.map((variant) => {
+      const node = byId.get(variant.id);
+      if (node === undefined) fail(`type '${type.entity.label}' is missing variant '${variant.id}'`);
+      return node;
+    });
+    if (owned.length > 0) {
+      body.push("", `${pad}def Scope "Variants"`, `${pad}{`);
+      for (const [index, variant] of owned.entries()) {
+        if (index > 0) body.push("");
+        body.push(
+          `${pad}    def Scope "v_${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)}>`,
+          `${pad}    }`,
+        );
+      }
+      body.push(`${pad}}`);
+    }
+    return body;
+  }
+  const owned = fields.filter((field) => field.owner.id === type.entity.id);
+  if (owned.length > 0) {
+    body.push("", `${pad}def Scope "Fields"`, `${pad}{`);
+    for (const [index, field] of owned.entries()) {
+      if (index > 0) body.push("");
+      body.push(...emitField(field, paths, resolveDependency, indent + 4));
+    }
+    body.push(`${pad}}`);
+  }
+  return body;
+}
+
+function emitAnonymousType(
+  type: LawAnonymousValueTypeNode,
+  fields: readonly LawAnonymousValueFieldNode[],
+  variants: readonly LawAnonymousValueVariantNode[],
+  types: ReadonlyMap<string, LawAnonymousValueTypeNode>,
+  paths: ReadonlyMap<string, string>,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const expression = type.expression;
+  const body: string[] = [];
+  switch (expression.kind) {
+    case "string":
+    case "number":
+    case "integer":
+      body.push(`${pad}custom uniform token nomos:typeKind = "scalar"`);
+      body.push(`${pad}custom uniform token nomos:scalar = ${quote(
+        expression.kind === "integer" ? "int" : expression.kind,
+      )}`);
+      {
+        const formats = expression.constraints
+          .filter((constraint) => constraint.kind === "format")
+          .map((constraint) => quote(constraint.value));
+        if (formats.length > 0) {
+          body.push(`${pad}custom uniform string[] nomos:formats = [${formats.join(", ")}]`);
+        }
+        const multiples = expression.constraints
+          .filter((constraint) => constraint.kind === "multiple-of")
+          .map((constraint) => constraint.value);
+        if (multiples.length > 0) {
+          body.push(`${pad}custom uniform double[] nomos:multiplesOf = [${multiples.join(", ")}]`);
+        }
+      }
+      for (const constraint of expression.constraints) {
+        switch (constraint.kind) {
+          case "min-length":
+            body.push(`${pad}custom uniform int nomos:minLength = ${constraint.value}`);
+            break;
+          case "max-length":
+            body.push(`${pad}custom uniform int nomos:maxLength = ${constraint.value}`);
+            break;
+          case "pattern":
+            body.push(`${pad}custom uniform string nomos:pattern = ${quote(constraint.value)}`);
+            break;
+          case "minimum":
+          case "maximum":
+            body.push(
+              `${pad}custom uniform double nomos:${constraint.inclusive ? constraint.kind : `exclusive${constraint.kind[0]!.toUpperCase()}${constraint.kind.slice(1)}`} = ${constraint.value}`,
+            );
+            break;
+          case "format":
+          case "multiple-of":
+            break;
+        }
+      }
+      break;
+    case "boolean":
+      body.push(`${pad}custom uniform token nomos:typeKind = "scalar"`);
+      body.push(`${pad}custom uniform token nomos:scalar = "bool"`);
+      break;
+    case "null":
+      body.push(`${pad}custom uniform token nomos:typeKind = "scalar"`);
+      body.push(`${pad}custom uniform token nomos:scalar = "null"`);
+      break;
+    case "unknown":
+      body.push(`${pad}custom uniform token nomos:typeKind = "scalar"`);
+      body.push(`${pad}custom uniform token nomos:scalar = "json"`);
+      break;
+    case "enum":
+      body.push(`${pad}custom uniform token nomos:typeKind = "scalar"`);
+      body.push(`${pad}custom uniform token nomos:scalar = "string"`);
+      body.push(`${pad}custom uniform token[] nomos:enum = [${expression.values.map(quote).join(", ")}]`);
+      break;
+    case "literal":
+      body.push(`${pad}custom uniform token nomos:typeKind = "scalar"`);
+      if (typeof expression.value === "string") {
+        body.push(`${pad}custom uniform token nomos:scalar = "string"`);
+        body.push(`${pad}custom uniform token[] nomos:enum = [${quote(expression.value)}]`);
+      } else if (typeof expression.value === "boolean") {
+        body.push(`${pad}custom uniform token nomos:scalar = "bool"`);
+        body.push(`${pad}custom uniform bool[] nomos:enum = [${expression.value}]`);
+      } else if (typeof expression.value === "number") {
+        const integer = Number.isInteger(expression.value);
+        body.push(`${pad}custom uniform token nomos:scalar = "${integer ? "int" : "number"}"`);
+        body.push(`${pad}custom uniform ${integer ? "int" : "double"}[] nomos:enum = [${expression.value}]`);
+      } else {
+        // `null` is already a singleton type: unlike strings/numbers/booleans it needs no
+        // additional enum opinion to distinguish the literal from its scalar family.
+        body.push(`${pad}custom uniform token nomos:scalar = "null"`);
+      }
+      break;
+    case "list":
+      body.push(`${pad}custom uniform token nomos:typeKind = "list"`);
+      body.push(`${pad}custom rel nomos:elementType = <${requiredPath(expression.element.id, paths)}>`);
+      break;
+    case "map":
+      body.push(`${pad}custom uniform token nomos:typeKind = "map"`);
+      body.push(`${pad}custom rel nomos:valueType = <${requiredPath(expression.value.id, paths)}>`);
+      break;
+    case "record": {
+      body.push(`${pad}custom uniform token nomos:typeKind = "record"`);
+      const owned = fields.filter((field) => field.owner.id === type.entity.id);
+      if (owned.length > 0) {
+        body.push("", `${pad}def Scope "Fields"`, `${pad}{`);
+        for (const [index, field] of owned.entries()) {
+          if (index > 0) body.push("");
+          body.push(...emitAnonymousField(field, types, paths, indent + 4));
+        }
+        body.push(`${pad}}`);
+      }
+      break;
+    }
+    case "sum": {
+      body.push(`${pad}custom uniform token nomos:typeKind = "union"`);
+      const owned = variants.filter((variant) => variant.owner.id === type.entity.id);
+      if (owned.length > 0) {
+        body.push("", `${pad}def Scope "Variants"`, `${pad}{`);
+        for (const [index, variant] of owned.entries()) {
+          if (index > 0) body.push("");
+          body.push(
+            `${pad}    def Scope "v_${variant.entity.sid}"`,
+            `${pad}    {`,
+            `${pad}        custom rel nomos:type = <${requiredPath(variant.value.id, paths)}>`,
+            `${pad}    }`,
+          );
+        }
+        body.push(`${pad}}`);
+      }
+      break;
+    }
+    case "nullable":
+    case "default":
+      fail(`anonymous type '${type.entity.label}' wrapper '${expression.kind}' cannot own a W1 type prim`);
+    case "recursive":
+      body.push(`${pad}custom uniform token nomos:typeKind = "recursive"`);
+      body.push(`${pad}custom rel nomos:body = <${requiredPath(expression.value.id, paths)}>`);
+      break;
+  }
+  return body;
+}
+
+function emitAnonymousField(
+  field: LawAnonymousValueFieldNode,
+  types: ReadonlyMap<string, LawAnonymousValueTypeNode>,
+  paths: ReadonlyMap<string, string>,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const body = [
+    `${pad}def Scope "f_${field.entity.sid}"`,
+    `${pad}{`,
+    `${pad}    custom uniform string nomos:label = ${quote(field.name)}`,
+    `${pad}    custom uniform bool nomos:required = ${field.required}`,
+    `${pad}    custom rel nomos:type = <${requiredPath(field.value.id, paths)}>`,
+  ];
+  let current = types.get(field.value.id);
+  const seen = new Set<string>();
+  while (current !== undefined && (current.expression.kind === "nullable" || current.expression.kind === "default")) {
+    if (seen.has(current.entity.id)) fail(`field '${field.name}' contains a value-wrapper cycle`);
+    seen.add(current.entity.id);
+    if (current.expression.kind === "nullable") {
+      body.push(`${pad}    custom uniform bool nomos:nullable = true`);
+    } else {
+      body.push(...defaultOpinions(current.expression.defaultValue, field.name, indent + 4));
+    }
+    current = types.get(current.expression.value.id);
+  }
+  body.push(`${pad}}`);
+  return body;
+}
+
+function defaultOpinions(
+  value: import("./law_value_type.js").LawConstant,
+  owner: string,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  if (typeof value === "string") return [`${pad}custom uniform string nomos:default = ${quote(value)}`];
+  if (typeof value === "boolean") return [`${pad}custom uniform bool nomos:default = ${value}`];
+  if (typeof value === "number") {
+    return [Number.isInteger(value)
+      ? `${pad}custom uniform int64 nomos:default = ${value}`
+      : `${pad}custom uniform double nomos:default = ${value}`];
+  }
+  if (value === null) return [`${pad}custom uniform token nomos:defaultKind = "null"`];
+
+  // USDA dictionaries cannot faithfully represent heterogeneous/nested arrays. Preserve the
+  // complete constant instead as a typed prim tree: generic USD tools can traverse it, humans can
+  // inspect it, and the kernel parser retains every opinion without an embedded JSON sub-language.
+  const kind = Array.isArray(value) ? "array" : "record";
+  return [
+    `${pad}custom uniform token nomos:defaultKind = ${quote(kind)}`,
+    `${pad}def Scope "Default"`,
+    `${pad}{`,
+    ...emitDefaultValue(value, owner, indent + 4),
+    `${pad}}`,
+  ];
+}
+
+function emitDefaultValue(
+  value: import("./law_value_type.js").LawConstant,
+  owner: string,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  if (typeof value === "string") {
+    return [
+      `${pad}custom uniform token nomos:valueKind = "string"`,
+      `${pad}custom uniform string nomos:value = ${quote(value)}`,
+    ];
+  }
+  if (typeof value === "boolean") {
+    return [
+      `${pad}custom uniform token nomos:valueKind = "bool"`,
+      `${pad}custom uniform bool nomos:value = ${value}`,
+    ];
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) fail(`field '${owner}' has a non-finite numeric default`);
+    return [
+      `${pad}custom uniform token nomos:valueKind = ${quote(Number.isInteger(value) ? "int" : "number")}`,
+      Number.isInteger(value)
+        ? `${pad}custom uniform int64 nomos:value = ${value}`
+        : `${pad}custom uniform double nomos:value = ${value}`,
+    ];
+  }
+  if (value === null) return [`${pad}custom uniform token nomos:valueKind = "null"`];
+
+  const entries: readonly [string, import("./law_value_type.js").LawConstant][] = Array.isArray(value)
+    ? value.map((item, index) => [String(index), item] as const)
+    : Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+  const kind = Array.isArray(value) ? "array" : "record";
+  const lines = [`${pad}custom uniform token nomos:valueKind = ${quote(kind)}`];
+  for (const [index, [key, item]] of entries.entries()) {
+    lines.push(
+      "",
+      `${pad}def Scope "v_${String(index).padStart(8, "0")}"`,
+      `${pad}{`,
+      `${pad}    custom uniform string nomos:key = ${quote(key)}`,
+      ...emitDefaultValue(item, owner, indent + 4),
+      `${pad}}`,
+    );
+  }
+  return lines;
+}
+
+function emitField(
+  field: LawFieldNode,
+  paths: ReadonlyMap<string, string>,
+  resolveDependency: ResolveDependency,
+  indent: number,
+): string[] {
+  const pad = " ".repeat(indent);
+  const body = [
+    `${pad}def Scope "${field.entity.id}"`,
+    `${pad}{`,
+    ...entityLabelOpinions(field.entity, indent + 4),
+  ];
+  if (field.storageKind !== undefined) {
+    body.push(`${pad}    custom uniform token nomos:storageKind = ${quote(field.storageKind)}`);
+  }
+  if (field.mapValueKind !== undefined) {
+    body.push(`${pad}    custom uniform token nomos:mapValueKind = ${quote(field.mapValueKind)}`);
+  }
+  if (field.schemaIdentity !== undefined) {
+    body.push(`${pad}    custom uniform string nomos:schemaIdentity = ${quote(field.schemaIdentity)}`);
+  }
+  const evolutions = [...(field.evolutions ?? [])].sort((left, right) => left.from.localeCompare(right.from));
+  if (evolutions.length > 0) {
+    body.push(`${pad}    def Scope "Evolutions"`, `${pad}    {`);
+    for (const [evolutionIndex, evolution] of evolutions.entries()) {
+      const evolutionName = `e_${String(evolutionIndex).padStart(8, "0")}`;
+      body.push(
+        `${pad}        def NomosFieldEvolution "${evolutionName}"`,
+        `${pad}        {`,
+        `${pad}            custom uniform string nomos:fromSchema = ${quote(evolution.from)}`,
+        `${pad}            custom uniform string nomos:toSchema = ${quote(evolution.to)}`,
+        `${pad}            custom uniform token nomos:sourceKind = ${quote(evolution.source.kind)}`,
+      );
+      if (evolution.source.mapValueKind !== undefined) {
+        body.push(`${pad}            custom uniform token nomos:sourceMapValueKind = ${quote(evolution.source.mapValueKind)}`);
+      }
+      body.push(`${pad}            custom uniform token nomos:mode = ${quote(evolution.mode)}`);
+      const cases = [...(evolution.cases ?? [])];
+      if (cases.length > 0) {
+        body.push(`${pad}            def Scope "Cases"`, `${pad}            {`);
+        for (const [caseIndex, evolutionCase] of cases.entries()) {
+          body.push(
+            `${pad}                def NomosFieldEvolutionCase "c_${String(caseIndex).padStart(8, "0")}"`,
+            `${pad}                {`,
+            `${pad}                    def Scope "From"`,
+            `${pad}                    {`,
+            ...emitDefaultValue(evolutionCase.from as import("./law_value_type.js").LawConstant, field.entity.label, indent + 24),
+            `${pad}                    }`,
+            `${pad}                    def Scope "To"`,
+            `${pad}                    {`,
+            ...emitDefaultValue(evolutionCase.to as import("./law_value_type.js").LawConstant, field.entity.label, indent + 24),
+            `${pad}                    }`,
+            `${pad}                }`,
+          );
+        }
+        body.push(`${pad}            }`);
+      }
+      body.push(`${pad}        }`);
+    }
+    body.push(`${pad}    }`);
+  }
+  if (field.mergeDrivers.length > 0) {
+    if (field.mergeDrivers.some((driver) => driver.principal !== undefined)) {
+      fail(`field '${field.entity.label}' uses a parameterised merge driver not yet ratified in W1 USDA`);
+    }
+    body.push(`${pad}    custom uniform token[] nomos:mergeDriver = [${field.mergeDrivers
+      .map((driver) => quote(driver.kind)).join(", ")}]`);
+  }
+  body.push(`${pad}    custom uniform bool nomos:required = ${field.required}`);
+  if (field.nullable) body.push(`${pad}    custom uniform bool nomos:nullable = true`);
+  if (field.encrypted) body.push(`${pad}    custom uniform bool nomos:encrypted = true`);
+  if (field.blindIndexed) body.push(`${pad}    custom uniform bool nomos:blindIndexed = true`);
+  if (field.refTarget === undefined) {
+    body.push(`${pad}    custom rel nomos:type = <${requiredPath(field.value.id, paths)}>`);
+  }
+  if (field.refTarget !== undefined) {
+    body.push(`${pad}    custom rel nomos:refTarget = ${targets([field.refTarget], paths, resolveDependency)}`);
+    body.push(`${pad}    custom uniform token nomos:referenceMode = ${quote(field.referenceMode ?? "current")}`);
+  }
+  if (field.workspaceField !== undefined) {
+    body.push(`${pad}    custom rel nomos:workspaceField = <${requiredPath(field.workspaceField.id, paths)}>`);
+  }
+  body.push(`${pad}}`);
+  return body;
+}
+
+function emitContainer<T extends { readonly entity: { readonly id: string } }>(
+  lines: string[],
+  name: string,
+  nodes: readonly T[],
+  indent: number,
+  body: (node: T, indent: number) => string[],
+  primName: (node: T) => string = (node) => node.entity.id,
+  primType: (node: T) => string = () => "Scope",
+): void {
+  const pad = " ".repeat(indent);
+  lines.push(`${pad}def Scope "${name}"`, `${pad}{`);
+  for (const [index, node] of nodes.entries()) {
+    if (index > 0) lines.push("");
+    lines.push(`${pad}    def ${primType(node)} "${primName(node)}"`, `${pad}    {`);
+    lines.push(...body(node, indent + 8));
+    lines.push(`${pad}    }`);
+  }
+  lines.push(`${pad}}`);
+}
+
+function targets(
+  refs: readonly LawTargetRef<"aggregate" | "contract" | "relation" | "policy" | "read">[],
+  paths: ReadonlyMap<string, string>,
+  resolveDependency: ResolveDependency,
+): string {
+  return relList(refs.map((target) => {
+    if ("kind" in target) {
+      return `<${resolveDependency(target)}>`;
+    }
+    return `<${requiredPath(target.id, paths)}>`;
+  }));
+}
+
+function target(
+  value: LawTargetRef<"aggregate" | "contract" | "relation" | "policy">,
+  paths: ReadonlyMap<string, string>,
+  resolveDependency: ResolveDependency,
+): string {
+  return targets([value], paths, resolveDependency);
+}
+
+function relList(paths: readonly string[]): string {
+  return paths.length === 1 ? paths[0]! : `[${paths.join(", ")}]`;
+}
+
+function stringList(values: readonly string[]): string {
+  return `[${values.map(quote).join(", ")}]`;
+}
+
+function requiredPath(id: string, paths: ReadonlyMap<string, string>): string {
+  const path = paths.get(id);
+  if (path === undefined) fail(`no USDA path exists for linked identity '${id}'`);
+  return path;
+}
+
+function quote(value: string): string {
+  return JSON.stringify(value);
+}
+
+function fail(message: string): never {
+  throw new Error(`NMS-USDA-001 ${message}`);
+}