@githolon/dsl 0.108.7 → 0.110.0

package/src/compatibility_graph.ts

@@ -0,0 +1,759 @@
+// NOMOS — Nomos Sovereign: participants act · verify · remember LOCALLY; hosted
+// remotes are replaceable custody/transport, not truth.  ⇒ ONE Nomos GitHolon
+// wasm32-wasip1 artifact.  If a file isn't this / hosting this / authoring for this
+// / proving this — it's gone.
+//
+// COMPATIBILITY GRAPH — compiler-owned extraction only.
+//
+// This module projects the typed DSL/law graph into the language-neutral vocabulary
+// emitted as compatibility USDA and used to generate stateless facades. It does not
+// decide whether a client fits installed law. That authoritative comparison belongs
+// to the Rust kernel's Compatibility Desk.
+
+import { z } from "zod";
+import type { DomainModule } from "./codegen_dart.js";
+import { lowerLawValueType, type LawValueType } from "./law_value_type.js";
+import type { StableIds } from "./stable_ids_types.js";
+import type { Field } from "./fields.js";
+import type { GeometryKind } from "./value_object.js";
+import { isBusinessIntent } from "./intent.js";
+import { isFrameworkAggregate } from "./framework/framework_aggregates.js";
+import type {
+  LawAnonymousValueTypeNode,
+  LawAggregateNode,
+  LawFieldNode,
+  LawGraph,
+  LawIntentNode,
+  LawPayloadContractNode,
+  LawTypeNode,
+} from "./law_graph.js";
+
+/** One payload field's normalized shape: its kind + whether the schema makes it optional. */
+export interface PayloadFieldShape {
+  readonly kind: string;
+  readonly optional: boolean;
+  /** Canonical Protobuf allocation encoded by this client or emitted by this law. */
+  readonly wireKey?: string;
+  /** Previously shipped allocations accepted by installed law during an overlap window. */
+  readonly wireAliases?: readonly string[];
+  /** Exact value-contract fingerprint. It changes when the field's accepted shape changes. */
+  readonly schemaIdentity?: string;
+  /** Root in the domain-local recursive value-type graph. */
+  readonly type?: string;
+}
+
+/**
+ * The compatibility vocabulary for domain values. This is a graph rather than
+ * an inline tree so recursive values and shared nested value objects remain
+ * finite and retain their authored structure.
+ */
+export type CompatibilityValueShape =
+  | {
+      readonly kind:
+        | "string"
+        | "int"
+        | "double"
+        | "bool"
+        | "null"
+        | "unknown"
+        | "reference";
+    }
+  | { readonly kind: "enum"; readonly values: readonly string[] }
+  | { readonly kind: "geometry"; readonly geometry: GeometryKind }
+  | {
+      readonly kind: "literal";
+      readonly value: string | number | boolean | null;
+    }
+  | { readonly kind: "list"; readonly element: string }
+  | { readonly kind: "map"; readonly value: string }
+  | {
+      readonly kind: "record";
+      readonly fields: Readonly<
+        Record<string, { readonly required: boolean; readonly type: string }>
+      >;
+    }
+  | { readonly kind: "sum"; readonly variants: readonly string[] }
+  | { readonly kind: "recursive"; readonly body: string };
+/** A directive's payload contract — the field set + types the gate validates against. */
+export interface DirectivePayloadShape {
+  readonly fields: Record<string, PayloadFieldShape>;
+  /** Nominal refusal family SID -> output type graph root. */
+  readonly domainRefusals?: Readonly<Record<string, string>>;
+  /** New generated decisions preserve unsupported output contracts explicitly. */
+  readonly acceptsUnknownRefusals?: true;
+}
+/** An aggregate's read contract — fields keyed by STABLE ID (rename-safe), each carrying
+ *  its current label (for human-readable verdicts) + its read kind. */
+export interface AggregateReadShape {
+  readonly sid: string;
+  readonly label: string;
+  /** keyed by FIELD SID. */
+  readonly fields: Record<
+    string,
+    { kind: string; label: string; type?: string }
+  >;
+}
+/** A domain's full structural interface — the offer (a workspace's installed law) AND
+ *  the requirement (the law a client was generated from) are the SAME vocabulary. */
+export interface DomainInterface {
+  readonly v: 1;
+  readonly domain: string;
+  readonly domainSid?: string;
+  /** keyed by DIRECTIVE ID (the dispatched name). */
+  readonly directives: Record<string, DirectivePayloadShape>;
+  /** keyed by AGGREGATE SID. */
+  readonly aggregates: Record<string, AggregateReadShape>;
+  /** Domain-local recursive type graph referenced by directive and aggregate fields. */
+  readonly types?: Readonly<Record<string, CompatibilityValueShape>>;
+  /** ATTESTED READS (slice B + dynamic policies): directive id → its declared foreign-read edges —
+   *  a STATIC `{queryId, from}` edge or a dynamic `{queryId, policy, fromPayload}` edge — the
+   *  cross-workspace dependencies this law consumes on its write path. OMITTED when none (era rule). */
+  readonly foreignReads?: Record<
+    string,
+    { queryId: string; from?: string; policy?: string; fromPayload?: string }[]
+  >;
+}
+
+/** Remove framework-managed aggregate fields from the client-facing structural interface. Stable ids for
+ *  those fields remain in the law/lockfile; clients negotiate only the business shape they can see. */
+export function publicClientInterface(
+  modules: readonly DomainModule[],
+  offered: Readonly<Record<string, DomainInterface>>
+): Record<string, DomainInterface> {
+  const hidden = new Map<string, Map<string, Set<string>>>();
+  const publicAggregates = new Map<string, Set<string>>();
+  for (const mod of modules) {
+    const domain = mod.domain ?? mod.name;
+    const byAggregate = hidden.get(domain) ?? new Map<string, Set<string>>();
+    hidden.set(domain, byAggregate);
+    const visible = publicAggregates.get(domain) ?? new Set<string>();
+    publicAggregates.set(domain, visible);
+    for (const aggregate of mod.aggregates ?? []) {
+      if (
+        (aggregate as { businessBirthInternal?: unknown })
+          .businessBirthInternal !== true &&
+        !isFrameworkAggregate(aggregate)
+      ) {
+        visible.add(aggregate.id);
+      }
+      const fields =
+        (aggregate as { internalFields?: readonly string[] }).internalFields ??
+        [];
+      if (fields.length > 0) byAggregate.set(aggregate.id, new Set(fields));
+    }
+  }
+  const result: Record<string, DomainInterface> = {};
+  for (const [domain, value] of Object.entries(offered)) {
+    const byAggregate = hidden.get(domain);
+    const visible = publicAggregates.get(domain);
+    const aggregates: Record<string, AggregateReadShape> = {};
+    for (const [sid, aggregate] of Object.entries(value.aggregates)) {
+      if (visible !== undefined && !visible.has(aggregate.label)) continue;
+      const fields = byAggregate?.get(aggregate.label);
+      aggregates[sid] =
+        fields === undefined
+          ? aggregate
+          : {
+              ...aggregate,
+              fields: Object.fromEntries(
+                Object.entries(aggregate.fields).filter(
+                  ([, field]) => !fields.has(field.label)
+                )
+              ),
+            };
+    }
+    result[domain] = { ...value, aggregates };
+  }
+  return result;
+}
+
+/** Normalize the canonical language-neutral DSL value graph to the compatibility
+ * vocabulary. Language generators are projections of this graph, never authorities
+ * for it. */
+function payloadFieldKind(value: LawValueType): string {
+  switch (value.kind) {
+    case "enum":
+      return "enum";
+    case "string":
+      return "string";
+    case "integer":
+      return "int";
+    case "number":
+      return "double";
+    case "boolean":
+      return "bool";
+    case "literal":
+      return typeof value.value === "boolean"
+        ? "bool"
+        : typeof value.value === "number"
+        ? Number.isInteger(value.value)
+          ? "int"
+          : "double"
+        : typeof value.value === "string"
+        ? "string"
+        : "json";
+    case "list":
+      return value.element.kind === "string" ? "set" : "json";
+    case "nullable":
+    case "default":
+    case "recursive":
+      return payloadFieldKind(value.value);
+    case "map":
+    case "record":
+    case "sum":
+    case "null":
+    case "unknown":
+    case "recursive-ref":
+      return "json";
+  }
+}
+
+/** The aggregate read kind when no stable-id kind is recorded (pre-#58 fallback): the
+ *  field's own declared kind, with the read-collapsed CRDTs normalized to their scalar. */
+function aggFieldReadKind(f: Field): string {
+  switch (f.kind) {
+    case "counter":
+      return "int";
+    case "position":
+      return "string";
+    default:
+      return f.kind;
+  }
+}
+
+/** Extract a domain's structural interface from its loaded module + (optionally) its
+ *  stable-id surface. Without stable ids (pre-#58) aggregate fields key by NAME and the
+ *  kind comes from the field declaration — a graceful, rename-unaware fallback. */
+export function domainInterface(
+  mod: DomainModule,
+  stableIds?: StableIds
+): DomainInterface {
+  const isInternal = (value: unknown): boolean =>
+    !!value &&
+    typeof value === "object" &&
+    (value as { businessBirthInternal?: unknown }).businessBirthInternal ===
+      true;
+  const enumTypes = new Map<string, string>();
+  // DETERMINISTIC KEY ORDER — directive ids, aggregate sids, and field keys are SORTED, so the
+  // emitted interface is byte-stable and the layered-USD fold (which merges + sorts) reproduces it
+  // byte-identically (the `nomosStableIds`/`nomosReadGate` convention). architecture/shape_compatibility.md.
+  const sortedRec = <T>(entries: Array<[string, T]>): Record<string, T> => {
+    const out: Record<string, T> = {};
+    for (const [k, v] of entries.sort((a, b) =>
+      a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0
+    ))
+      out[k] = v;
+    return out;
+  };
+  const directives: Record<string, DirectivePayloadShape> = {};
+  const dirEntries: Array<[string, DirectivePayloadShape]> = [];
+  for (const d of (mod.directives ?? []) as Array<{
+    id?: unknown;
+    payloadSchema?: unknown;
+    businessBirth?: { publicPayloadSchema?: unknown };
+  }>) {
+    if (!d || typeof d.id !== "string") continue;
+    if (isInternal(d)) continue;
+    const fieldEntries: Array<[string, PayloadFieldShape]> = [];
+    const schema = d.businessBirth?.publicPayloadSchema ?? d.payloadSchema;
+    if (schema && typeof schema === "object") {
+      const payload = lowerLawValueType(schema as z.ZodTypeAny);
+      if (payload.kind !== "record") {
+        throw new Error(
+          `directive '${d.id}' payload must lower to a typed record`
+        );
+      }
+      for (const field of payload.fields) {
+        fieldEntries.push([
+          field.name,
+          { kind: payloadFieldKind(field.value), optional: !field.required },
+        ]);
+      }
+    }
+    dirEntries.push([
+      d.businessBirth === undefined || isBusinessIntent(d) ? d.id : "birth",
+      { fields: sortedRec(fieldEntries) },
+    ]);
+  }
+  Object.assign(directives, sortedRec(dirEntries));
+  const aggregates: Record<string, AggregateReadShape> = {};
+  const aggEntries: Array<[string, AggregateReadShape]> = [];
+  for (const agg of (mod.aggregates ?? []) as Array<{
+    id: string;
+    fields: Record<string, Field>;
+  }>) {
+    // This is also the stored-law evolution surface. Internal aggregates retain
+    // durable identities; only publicClientInterface hides them from app clients.
+    const label = agg.id;
+    const sa = stableIds?.aggregates?.[label];
+    const aggSid = sa?.sid ?? label;
+    const fieldEntries: Array<[string, { kind: string; label: string }]> = [];
+    for (const [fname, f] of Object.entries(agg.fields ?? {})) {
+      // This is the workspace's complete structural offer and the input to law-evolution
+      // checking, so framework-managed stored fields belong here too. Only the generated
+      // client's view hides them, in publicClientInterface below. Filtering them at both
+      // seams makes an unchanged private field look deleted when the current offer is
+      // compared with the committed identity ledger.
+      if (!f || f.kind === "hasMany") continue;
+      const fsid = sa?.fields?.[fname]?.sid ?? fname;
+      const kind = sa?.fields?.[fname]?.kind ?? aggFieldReadKind(f);
+      fieldEntries.push([fsid, { kind, label: fname }]);
+    }
+    aggEntries.push([
+      aggSid,
+      { sid: aggSid, label, fields: sortedRec(fieldEntries) },
+    ]);
+  }
+  Object.assign(aggregates, sortedRec(aggEntries));
+  // ATTESTED READS (slice B): the declared trust edges — so shape-compat + client codegen can
+  // SEE the cross-workspace dependency (typed clients don't call it; it's write-path-internal).
+  type ForeignEdge = {
+    queryId: string;
+    from?: string;
+    policy?: string;
+    fromPayload?: string;
+  };
+  const foreignReadEntries: Array<[string, ForeignEdge[]]> = [];
+  for (const d of (mod.directives ?? []) as Array<{
+    id?: unknown;
+    declaredForeignReads?: ForeignEdge[];
+  }>) {
+    if (!d || typeof d.id !== "string") continue;
+    if (isInternal(d)) continue;
+    if (
+      d.declaredForeignReads !== undefined &&
+      d.declaredForeignReads.length > 0
+    ) {
+      foreignReadEntries.push([
+        d.id,
+        d.declaredForeignReads.map((e) => ({ ...e })),
+      ]);
+    }
+  }
+  const foreignReads = sortedRec(foreignReadEntries);
+  return {
+    v: 1,
+    domain:
+      (mod as { domain?: string; name?: string }).domain ??
+      (mod as { name?: string }).name ??
+      "",
+    ...(stableIds?.domain !== undefined ? { domainSid: stableIds.domain } : {}),
+    directives,
+    aggregates,
+    ...(foreignReadEntries.length > 0 ? { foreignReads } : {}),
+  };
+}
+
+/**
+ * Project the compatibility contract from canonical typed law.
+ *
+ * This is deliberately the TypeScript twin of the kernel's
+ * `interface_offer_from_stage`: generated client requirements and installed
+ * workspace offers are now two projections of the same graph/USDA, rather than
+ * independently interpreting DomainModule and hoping the shapes coincide.
+ */
+export function domainInterfaceFromLawGraph(graph: LawGraph): DomainInterface {
+  const nodes = new Map<string, LawGraph["nodes"][number]>(
+    graph.nodes.map((node) => [node.entity.id, node])
+  );
+  const sorted = <T>(
+    entries: readonly (readonly [string, T])[]
+  ): Record<string, T> =>
+    Object.fromEntries([...entries].sort(([a], [b]) => a.localeCompare(b)));
+  const valueNode = (id: string): LawAnonymousValueTypeNode | undefined => {
+    const node = nodes.get(id);
+    return node?.kind === "structural" && node.structuralKind === "value-type"
+      ? node
+      : undefined;
+  };
+  const valueFieldNode = (id: string) => {
+    const node = nodes.get(id);
+    return node?.kind === "structural" && node.structuralKind === "value-field"
+      ? node
+      : undefined;
+  };
+  const valueVariantNode = (id: string) => {
+    const node = nodes.get(id);
+    return node?.kind === "structural" &&
+      node.structuralKind === "value-variant"
+      ? node
+      : undefined;
+  };
+  const resolvedTypeId = (id: string, seen = new Set<string>()): string => {
+    if (seen.has(id))
+      throw new Error(`compatibility value wrapper cycle at '${id}'`);
+    const node = valueNode(id);
+    // Compatibility describes the exact language-neutral value accepted at the installed law
+    // boundary. A semantic value-object declaration names that value for generated APIs, but it
+    // is not a substitute wire shape: discriminated-union arms, defaults and other schema
+    // refinements live on the structural graph rooted at this exact field. Redirecting to the
+    // named declaration erased required `type` discriminators and made the generated client look
+    // incompatible with the very law from which it was compiled.
+    if (
+      node?.expression.kind !== "nullable" &&
+      node?.expression.kind !== "default"
+    )
+      return id;
+    seen.add(id);
+    return resolvedTypeId(node.expression.value.id, seen);
+  };
+  const kindOf = (type: LawAnonymousValueTypeNode | undefined): string => {
+    if (type === undefined) return "json";
+    switch (type.expression.kind) {
+      case "enum":
+        return "enum";
+      case "string":
+        return "string";
+      case "integer":
+        return "int";
+      case "number":
+        return "double";
+      case "boolean":
+        return "bool";
+      case "list":
+        return valueNode(type.expression.element.id)?.expression.kind ===
+          "string"
+          ? "set"
+          : "json";
+      // Match the installed USDA projection exactly. Structured, wrapped and
+      // nullable values remain one typed aggregate at the law boundary, exposed
+      // as a structured compatibility leaf rather than guessed from Zod.
+      case "default":
+      case "nullable":
+      case "record":
+      case "map":
+      case "sum":
+      case "null":
+      case "literal":
+      case "recursive":
+      case "unknown":
+        return "json";
+    }
+  };
+
+  const directives = sorted(
+    graph.nodes
+      .filter(
+        (node): node is LawIntentNode =>
+          node.kind === "intent" &&
+          node.public &&
+          !node.entity.label.startsWith("nomos_internal_")
+      )
+      .map((intent): readonly [string, DirectivePayloadShape] => {
+        const contract = nodes.get(
+          (intent.publicAccepts ?? intent.accepts).id
+        ) as LawPayloadContractNode | undefined;
+        const fields =
+          contract?.kind === "payload-contract"
+            ? contract.fields.flatMap((ref) => {
+                const field = nodes.get(ref.id);
+                if (
+                  field?.kind !== "structural" ||
+                  field.structuralKind !== "value-field"
+                )
+                  return [];
+                return [
+                  [
+                    field.name,
+                    {
+                      kind: kindOf(valueNode(field.value.id)),
+                      optional: !field.required,
+                      wireKey: field.entity.wireKey ?? field.entity.sid,
+                      ...(field.entity.wireAliases === undefined
+                        ? {}
+                        : { wireAliases: field.entity.wireAliases }),
+                      schemaIdentity: field.entity.sid,
+                      type: resolvedTypeId(field.value.id),
+                    },
+                  ] as const,
+                ];
+              })
+            : [];
+        const domainRefusals = sorted((intent.domainRefusals ?? []).map(ref => {
+          const type = nodes.get(ref.id);
+          if (type?.kind !== "type") throw new Error(`refusal output ${ref.id} is not nominal`);
+          return [type.entity.sid, type.entity.id] as const;
+        }));
+        return [intent.publicRoute, { fields: sorted(fields),
+          ...(Object.keys(domainRefusals).length === 0 ? {} : { domainRefusals, acceptsUnknownRefusals: true }),
+        }];
+      })
+  );
+
+  const referenceTypeId = (field: LawFieldNode): string =>
+    `reference:${field.entity.sid}`;
+
+  const aggregates = sorted(
+    graph.nodes
+      .filter(
+        (node): node is LawAggregateNode =>
+          node.kind === "aggregate" &&
+          !node.entity.label.startsWith("nomos_internal_")
+      )
+      .map((aggregate): readonly [string, AggregateReadShape] => {
+        const fields = aggregate.fields.flatMap((ref) => {
+          const field = nodes.get(ref.id) as LawFieldNode | undefined;
+          if (field?.kind !== "field") return [];
+          return [
+            [
+              field.entity.sid,
+              {
+                kind:
+                  field.refTarget === undefined
+                    ? field.storageKind ?? "json"
+                    : "reference",
+                label: field.entity.label,
+                type:
+                  field.refTarget === undefined
+                    ? resolvedTypeId(field.value.id)
+                    : referenceTypeId(field),
+              },
+            ] as const,
+          ];
+        });
+        return [
+          aggregate.entity.sid,
+          {
+            sid: aggregate.entity.sid,
+            label: aggregate.entity.label,
+            fields: sorted(fields),
+          },
+        ];
+      })
+  );
+
+  // A reference remains a nominal application value whether its transport is a local ID or a
+  // structured workspace/type/id address. Preserve the semantic category in compatibility;
+  // the operation schema independently describes that transport. The target can become an additional opinion
+  // without changing this vocabulary.
+  const referenceTypes = graph.nodes
+    .filter(
+      (node): node is LawFieldNode =>
+        node.kind === "field" && node.refTarget !== undefined
+    )
+    .map((field): readonly [string, CompatibilityValueShape] => [
+      referenceTypeId(field),
+      { kind: "reference" },
+    ]);
+
+  const anonymousTypes = graph.nodes
+    .filter(
+      (node): node is LawAnonymousValueTypeNode =>
+        node.kind === "structural" &&
+        node.structuralKind === "value-type" &&
+        node.expression.kind !== "nullable" &&
+        node.expression.kind !== "default"
+    )
+    .map((node): readonly [string, CompatibilityValueShape] => {
+      const expression = node.expression;
+      switch (expression.kind) {
+        case "string":
+          return [node.entity.id, { kind: "string" }];
+        case "integer":
+          return [node.entity.id, { kind: "int" }];
+        case "number":
+          return [node.entity.id, { kind: "double" }];
+        case "boolean":
+          return [node.entity.id, { kind: "bool" }];
+        case "null":
+          return [node.entity.id, { kind: "null" }];
+        case "unknown":
+          return [node.entity.id, { kind: "unknown" }];
+        case "enum":
+          return [
+            node.entity.id,
+            { kind: "enum", values: [...expression.values].sort() },
+          ];
+        case "literal":
+          return [node.entity.id, { kind: "literal", value: expression.value }];
+        case "list":
+          return [
+            node.entity.id,
+            { kind: "list", element: resolvedTypeId(expression.element.id) },
+          ];
+        case "map":
+          return [
+            node.entity.id,
+            { kind: "map", value: resolvedTypeId(expression.value.id) },
+          ];
+        case "record": {
+          const fields = expression.fields.flatMap((ref) => {
+            const field = valueFieldNode(ref.id);
+            return field === undefined
+              ? []
+              : [
+                  [
+                    field.name,
+                    {
+                      required: field.required,
+                      type: resolvedTypeId(field.value.id),
+                    },
+                  ] as const,
+                ];
+          });
+          return [node.entity.id, { kind: "record", fields: sorted(fields) }];
+        }
+        case "sum": {
+          const variants = expression.variants
+            .flatMap((ref) => {
+              const variant = valueVariantNode(ref.id);
+              return variant === undefined
+                ? []
+                : [resolvedTypeId(variant.value.id)];
+            })
+            .sort();
+          return [node.entity.id, { kind: "sum", variants }];
+        }
+        case "recursive":
+          return [
+            node.entity.id,
+            { kind: "recursive", body: resolvedTypeId(expression.value.id) },
+          ];
+        case "nullable":
+        case "default":
+          throw new Error(
+            "compatibility wrappers are resolved before type emission"
+          );
+      }
+    });
+  const declaredTypes = graph.nodes
+    .filter((node): node is LawTypeNode => node.kind === "type")
+    .map((node): readonly [string, CompatibilityValueShape] => {
+      if (node.form === "geometry") {
+        if (node.geometry === undefined) {
+          throw new Error(
+            `compatibility type '${node.entity.label}' has no geometry kind`
+          );
+        }
+        return [node.entity.id, { kind: "geometry", geometry: node.geometry }];
+      }
+      if (node.form === "sum") {
+        return [
+          node.entity.id,
+          {
+            kind: "sum",
+            variants: node.variants
+              .flatMap((ref) => {
+                const variant = valueVariantNode(ref.id);
+                return variant === undefined
+                  ? []
+                  : [resolvedTypeId(variant.value.id)];
+              })
+              .sort(),
+          },
+        ];
+      }
+      const fields = node.fields.flatMap((ref) => {
+        const field = nodes.get(ref.id);
+        return field?.kind !== "field"
+          ? []
+          : [
+              [
+                field.entity.label,
+                {
+                  required: field.required,
+                  type: resolvedTypeId(field.value.id),
+                },
+              ] as const,
+            ];
+      });
+      return [node.entity.id, { kind: "record", fields: sorted(fields) }];
+    });
+  const allTypes = sorted([
+    ...anonymousTypes,
+    ...declaredTypes,
+    ...referenceTypes,
+  ]);
+  const reachable = new Set<string>();
+  const visitType = (id: string, path: string): void => {
+    const resolved = resolvedTypeId(id);
+    if (reachable.has(resolved)) return;
+    const type = allTypes[resolved];
+    if (type === undefined)
+      throw new Error(
+        `compatibility member '${path}' references missing value type '${resolved}'`
+      );
+    if (type.kind === "unknown") {
+      throw new Error(
+        `compatibility member '${path}' exposes an opaque JSON/unknown value; ` +
+          `declare a typed value object so the generated client and installed law can be compared ` +
+          `(law type ${resolved}: ${JSON.stringify(
+            graph.nodes
+              .filter((node) => node.entity.id === resolved)
+              .map((node) => ({
+                label: node.entity.label,
+                owner:
+                  node.kind === "structural" && "owner" in node
+                    ? node.owner.id
+                    : null,
+                expression:
+                  node.kind === "structural" &&
+                  node.structuralKind === "value-type"
+                    ? node.expression
+                    : node.kind,
+              }))
+          )})`
+      );
+    }
+    reachable.add(resolved);
+    switch (type.kind) {
+      case "list":
+        visitType(type.element, `${path}[]`);
+        break;
+      case "map":
+        visitType(type.value, `${path}{}`);
+        break;
+      case "record":
+        for (const [name, field] of Object.entries(type.fields))
+          visitType(field.type, `${path}.${name}`);
+        break;
+      case "sum":
+        for (const [index, variant] of type.variants.entries())
+          visitType(variant, `${path}|${index}`);
+        break;
+      case "recursive":
+        visitType(type.body, `${path}↻`);
+        break;
+      case "string":
+      case "int":
+      case "double":
+      case "bool":
+      case "null":
+      case "enum":
+      case "literal":
+      case "geometry":
+      case "reference":
+        break;
+    }
+  };
+  for (const [route, directive] of Object.entries(directives)) {
+    for (const [family, type] of Object.entries(directive.domainRefusals ?? {})) {
+      visitType(type, `${graph.domain.entity.label}.${route} refusal ${family}`);
+    }
+    for (const [name, field] of Object.entries(directive.fields)) {
+      if (field.type !== undefined)
+        visitType(field.type, `${graph.domain.entity.label}.${route}.${name}`);
+    }
+  }
+  for (const aggregate of Object.values(aggregates)) {
+    for (const field of Object.values(aggregate.fields)) {
+      if (field.type !== undefined)
+        visitType(
+          field.type,
+          `${graph.domain.entity.label}.${aggregate.label}.${field.label}`
+        );
+    }
+  }
+  const types = sorted(
+    Object.entries(allTypes).filter(([id]) => reachable.has(id))
+  );
+
+  return {
+    v: 1,
+    domain: graph.domain.entity.label,
+    domainSid: graph.domain.entity.sid,
+    directives,
+    aggregates,
+    types,
+  };
+}