@githolon/dsl 0.108.6 → 0.110.0

package/src/codegen_result_proto.ts

@@ -0,0 +1,931 @@
+import { admitsNull, isGitObjectIdSchema, isSha256DigestSchema, type Field } from "./fields.js";
+import type {
+  LawAnonymousValueFieldNode,
+  LawAnonymousValueTypeNode,
+  LawGraph,
+  LawRowReadNode,
+  LawReadNode,
+  LawStructuralRef,
+  LawTypeNode,
+  LawValueTypeRef,
+} from "./law_graph.js";
+import {
+  composedWireIdentity,
+  operationMessageIdentity,
+  protobufFieldNumber,
+  protoFieldName,
+  protoMessageName,
+  structuralGeometryKind,
+} from "./codegen_call_proto.js";
+import type { TsResultAggregate } from "./codegen_result_usda.js";
+import {
+  dartMemberName,
+  unionArmClassName,
+  type AggFieldSpec,
+} from "./codegen_dart.js";
+import { contractTypeName } from "./contract.js";
+import { zodEnumValues } from "./zod_introspection.js";
+import { provenanceRowIdentity, provenanceFieldIdentity, provenanceAuthorIdentity, provenanceContestedIdentity } from "./provenance_wire.js";
+
+const symbol = (value: string): string =>
+  value.replace(/[^A-Za-z0-9_$]+/g, "_").replace(/^[^A-Za-z_$]/, "_$&");
+
+const valueObjectDecoder = (name: string): string =>
+  `_nmsDecodeValueObject_${symbol(name)}`;
+
+/** Tiny generated-boundary helpers shared by every direct Protobuf result
+ * decoder. Presence is checked here rather than asserted away in each query,
+ * so an incompatible kernel result fails with the exact authored field path. */
+export const TS_RESULT_PROTO_PRELUDE = [
+  `const _nmsResultRequired = <T>(value: T | undefined, path: string): T => {`,
+  `  if (value === undefined) throw new TypeError(path + " is absent");`,
+  `  return value;`,
+  `};`,
+  `const _nmsResultInteger = (value: bigint, path: string): number => {`,
+  `  const result = Number(value);`,
+  `  if (!Number.isSafeInteger(result)) throw new TypeError(path + " is outside the exact integer range");`,
+  `  return result;`,
+  `};`,
+  ``,
+] as const;
+
+const dartInteger = (raw: string, path: string): string =>
+  `((Int64 integer) { if (integer > Int64(9007199254740991) || integer < Int64(-9007199254740991)) throw FormatException(${dartString(`${path} is outside the exact integer range`)}); return integer.toInt(); })(${raw})`;
+
+const dartNullable = (raw: string, explicitNull: string, present: string, path: string): string =>
+  `() { if (${raw}.hasIsNull() && ${raw}.isNull) return ${explicitNull}; if (${raw}.hasValue()) return ${present}; throw FormatException(${dartString(`${path} selects no valid nullable arm`)}); }()`;
+
+const tsNullable = (raw: string, present: string, path: string): string =>
+  `(() => { const nullable = ${raw}.selected; if (nullable.case === "isNull" && nullable.value === true) return null; if (nullable.case === "value") return ${present}; throw new TypeError(${JSON.stringify(`${path} selects no valid nullable arm`)}); })()`;
+
+const dartGeometryCoordinates = (
+  geometry: NonNullable<LawTypeNode["geometry"]>,
+  raw: string,
+): string => {
+  if (geometry === "Point") return `${raw}.coordinates.toList(growable: false)`;
+  const positions = `() { final flat = ${raw}.coordinates; var start = 0; final result = <List<double>>[]; for (final end in ${raw}.positionEnds) { result.add(flat.sublist(start, end)); start = end; } return result; }()`;
+  if (geometry !== "Polygon") return positions;
+  return `() { final positions = ${positions}; var start = 0; final result = <List<List<double>>>[]; for (final end in ${raw}.ringEnds) { result.add(positions.sublist(start, end)); start = end; } return result; }()`;
+};
+
+const tsGeometryCoordinates = (
+  geometry: NonNullable<LawTypeNode["geometry"]>,
+  raw: string,
+): string => {
+  if (geometry === "Point") return `[...${raw}.coordinates]`;
+  const positions = `(() => { let start = 0; return ${raw}.positionEnds.map((end) => { const position = ${raw}.coordinates.slice(start, end); start = end; return position; }); })()`;
+  if (geometry !== "Polygon") return positions;
+  return `(() => { const positions = ${positions}; let start = 0; return ${raw}.ringEnds.map((end) => { const ring = positions.slice(start, end); start = end; return ring; }); })()`;
+};
+
+const enumUnion = (field: Field): string => {
+  try {
+    const values = zodEnumValues(field.zod);
+    return values.length
+      ? values.map((value) => JSON.stringify(value)).join(" | ")
+      : "string";
+  } catch {
+    return "string";
+  }
+};
+
+function authoredFieldValue(
+  field: Field,
+  value: string,
+  workspace: string,
+  holon: string,
+  foreignWorkspace?: string,
+): string {
+  const decode = (selected: string): string => {
+    if (field.nomosRef !== undefined) {
+      const target = field.nomosRef.targetIsContract === true
+        ? contractTypeName(field.nomosRef.targetAggregateId)
+        : field.nomosRef.targetAggregateId;
+      return `((address) => _nmsRef<${target}>(address.workspace, address.type, address.id))(${selected})`;
+    }
+    if (field.versionedForeignRef !== undefined) {
+      const versioned = field.versionedForeignRef;
+      const target = versioned.targetIsContract === true
+        ? contractTypeName(versioned.targetAggregateId)
+        : versioned.targetAggregateId;
+      const series = versioned.seriesIsContract === true
+        ? contractTypeName(versioned.seriesAggregateId)
+        : versioned.seriesAggregateId;
+      return `_versionedNomosRef<${target}, ${series}>(${holon}, ${selected}, ${JSON.stringify(versioned.currentField)})`;
+    }
+    if (field.foreignRef !== undefined) {
+      if (foreignWorkspace === undefined) {
+        throw new Error(
+          `result Protobuf codegen: foreign ref '${field.foreignRef.targetAggregateId}' has no workspace value`,
+        );
+      }
+      const target = field.foreignRef.targetIsContract === true
+        ? contractTypeName(field.foreignRef.targetAggregateId)
+        : field.foreignRef.targetAggregateId;
+      return `foreignRef<${target}>(${holon}, ${JSON.stringify(field.foreignRef.targetAggregateId)}, ${selected}, ${foreignWorkspace})`;
+    }
+    switch (field.kind) {
+      case "string":
+        return isSha256DigestSchema(field.zod)
+          ? `sha256Digest(${selected})`
+          : isGitObjectIdSchema(field.zod)
+            ? `gitObjectId(${selected})`
+            : selected;
+      case "position": return selected;
+      case "ref":
+        return field.foreignRef === undefined &&
+          field.nomosRef === undefined &&
+          field.versionedForeignRef === undefined &&
+          field.refAggregateId !== undefined
+          ? `_nmsRef<${field.refAggregateId}>(${workspace}, ${JSON.stringify(field.refAggregateId)}, ${selected})`
+          : selected;
+      case "int":
+      case "counter": return selected;
+      case "bool": return selected;
+      case "enum": return `${selected} as ${enumUnion(field)}`;
+      case "set": return selected;
+      case "json":
+        return field.valueObject === undefined
+          ? selected
+          : `${valueObjectDecoder(field.valueObject.name)}(${selected}, ${workspace})`;
+      case "evidence": return `${selected} as EvidenceRef`;
+      case "map":
+        return field.mapValueVo === undefined
+          ? selected
+          : `Object.fromEntries(Object.entries(${selected}).map(([key, value]) => [key, ${valueObjectDecoder(field.mapValueVo.name)}(value, ${workspace})]))`;
+      default:
+        throw new Error(`result Protobuf codegen does not support field kind '${field.kind}'`);
+    }
+  };
+  if (!admitsNull(field)) return decode(value);
+  const selected = "_nmsAuthoredValue";
+  return `((${selected}) => ${selected} === null ? null : ${decode(selected)})(${value})`;
+}
+
+export interface TsQueryResultDecoder {
+  readonly rowsFunction: string;
+  readonly pageFunction: string;
+  readonly typeUrl: string;
+  readonly source: readonly string[];
+}
+
+export interface DartQueryResultAggregate {
+  readonly model: string;
+  readonly refType: string;
+  readonly runtimeType: string;
+  readonly baseFields: readonly {
+    readonly name: string;
+    readonly spec: AggFieldSpec;
+    readonly required: boolean;
+    readonly foreignWorkspaceName?: string;
+  }[];
+  readonly computedFields: readonly {
+    readonly name: string;
+    readonly required: boolean;
+    readonly enumType?: string;
+  }[];
+  readonly attributedFields: readonly string[];
+}
+
+export interface DartQueryResultDecoder {
+  readonly rowsFunction: string;
+  readonly pageFunction: string;
+  readonly typeUrl: string;
+  readonly source: readonly string[];
+}
+
+const dartString = (value: string): string =>
+  `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\$/g, "\\$")}'`;
+
+const dartHas = (member: string): string => `has${member[0]!.toUpperCase()}${member.slice(1)}()`;
+const protoBindingMember = (sid: string): string =>
+  protoFieldName(sid).replace(/_([a-zA-Z0-9])/g, (_match, next: string) => next.toUpperCase());
+
+/** Dart twin of {@link emitTsQueryResultProtoDecoder}. Public read methods and
+ * models do not change; only their private decoder moves from a handwritten
+ * USDA interpretation to the operation-specific protoc class emitted from the
+ * same law graph. */
+export function emitDartQueryResultProtoDecoder(
+  graph: LawGraph,
+  paths: ReadonlyMap<string, string>,
+  query: LawRowReadNode,
+  aggregate: DartQueryResultAggregate,
+): DartQueryResultDecoder {
+  const nodes = new Map<string, LawGraph["nodes"][number]>(
+    graph.nodes.map((node) => [node.entity.id, node]),
+  );
+  const contract = nodes.get(query.contract.id);
+  if (contract?.kind !== "read-contract" || contract.returns.kind !== "rows") {
+    throw new Error(`result Protobuf codegen: '${query.entity.label}' has no row contract`);
+  }
+  const aggregateNode = nodes.get(contract.returns.aggregate.id);
+  if (aggregateNode?.kind !== "aggregate") {
+    throw new Error(`result Protobuf codegen: '${query.entity.label}' returns no aggregate`);
+  }
+  const structuralField = (ref: LawStructuralRef<"value-field">): LawAnonymousValueFieldNode => {
+    const node = nodes.get(ref.id);
+    if (node?.kind !== "structural" || node.structuralKind !== "value-field") {
+      throw new Error(`result Protobuf codegen: '${ref.id}' is not a structural field`);
+    }
+    return node;
+  };
+  const structuralType = (id: string): LawAnonymousValueTypeNode => {
+    const node = nodes.get(id);
+    if (node?.kind !== "structural" || node.structuralKind !== "value-type") {
+      throw new Error(`result Protobuf codegen: '${id}' is not a structural value type`);
+    }
+    return node;
+  };
+  const required = (raw: string, member: string, decoded: string, path: string): string =>
+    `() { if (!${raw}.${dartHas(member)}) throw FormatException(${dartString(`${path} is absent`)}); return ${decoded}; }()`;
+  const emitRef = (ref: LawValueTypeRef, raw: string, path: string): string => {
+    const node = nodes.get(ref.id);
+    if (node?.kind === "structural" && node.structuralKind === "value-type") {
+      return emitStructural(node, raw, path);
+    }
+    if (node?.kind === "type") return emitDeclared(node, raw, path);
+    throw new Error(`result Protobuf codegen: '${path}' has no declared value type`);
+  };
+  const emitDeclared = (node: LawTypeNode, raw: string, path: string): string => {
+    if (node.form === "geometry") {
+      if (node.geometry === undefined) throw new Error(`result Protobuf codegen: '${path}' has no geometry kind`);
+      const coordinates = dartGeometryCoordinates(node.geometry, raw);
+      return `${node.entity.label}(coordinates: ${coordinates})`;
+    }
+    if (node.form === "sum") {
+      const arms = node.variants.map((ref) => {
+        const variant = nodes.get(ref.id);
+        if (variant?.kind !== "structural" || variant.structuralKind !== "value-variant" || variant.label === undefined) {
+          throw new Error(`result Protobuf codegen: '${path}' has an invalid declared sum arm '${ref.id}'`);
+        }
+        const target = nodes.get(variant.value.id);
+        const member = protoBindingMember(composedWireIdentity(paths, variant.entity));
+        const selected = `${raw}.${member}`;
+        const decoded = target?.kind === "type"
+          ? `${unionArmClassName(node.entity.label, variant.label)}(${emitDeclared(target, selected, `${path}.${variant.label}.value`)})`
+          : target?.kind === "structural" && target.structuralKind === "value-type"
+            ? emitRecordArm(target, selected, `${path}.${variant.label}`, unionArmClassName(node.entity.label, variant.label))
+            : (() => { throw new Error(`result Protobuf codegen: '${path}.${variant.label}' has no value type`); })();
+        return `if (${raw}.${dartHas(member)}) return ${decoded};`;
+      });
+      return `() { ${arms.join(" ")} throw FormatException(${dartString(`${path} selects no nominal union arm`)}); }()`;
+    }
+    const members = node.fields.flatMap((ref) => {
+      const field = nodes.get(ref.id);
+      if (field?.kind !== "field") {
+        throw new Error(`result Protobuf codegen: '${ref.id}' is not a field`);
+      }
+      const member = protoBindingMember(composedWireIdentity(paths, field.entity));
+      const selected = `${raw}.${member}`;
+      const decoded = emitRef(field.value, selected, `${path}.${field.entity.label}`);
+      if (field.required) {
+        return [`${dartMemberName(field.entity.label)}: ${required(raw, member, decoded, `${path}.${field.entity.label}`)}`];
+      }
+      return [`${dartMemberName(field.entity.label)}: ${raw}.${dartHas(member)} ? ${decoded} : null`];
+    });
+    return `${node.entity.label}(${members.join(", ")})`;
+  };
+  const emitRecordArm = (
+    node: LawAnonymousValueTypeNode,
+    raw: string,
+    path: string,
+    className: string,
+  ): string => {
+    if (node.expression.kind !== "record") {
+      throw new Error(`result Protobuf codegen: '${path}' is not a record arm`);
+    }
+    const members = node.expression.fields.map(structuralField).flatMap((field) => {
+      const value = nodes.get(field.value.id);
+      if (
+        value?.kind === "structural" &&
+        value.structuralKind === "value-type" &&
+        value.expression.kind === "literal" &&
+        field.name === "type"
+      ) return [];
+      const member = protoBindingMember(composedWireIdentity(paths, field.entity));
+      const decoded = emitRef(field.value, `${raw}.${member}`, `${path}.${field.name}`);
+      return [field.required
+        ? `${dartMemberName(field.name)}: ${required(raw, member, decoded, `${path}.${field.name}`)}`
+        : `${dartMemberName(field.name)}: ${raw}.${dartHas(member)} ? ${decoded} : null`];
+    });
+    return `${className}(${members.join(", ")})`;
+  };
+  const emitStructural = (node: LawAnonymousValueTypeNode, raw: string, path: string): string => {
+    const semantic = node.expression.semantic;
+    if (semantic?.kind === "sha256-digest") return `Sha256Digest(${raw})`;
+    if (semantic?.kind === "git-object-id") return `GitObjectId(${raw})`;
+    if (semantic?.kind === "branded-id") return `${semantic.name}(${raw})`;
+    if (semantic?.kind === "id-reference") {
+      const target = semantic.targetKind === "contract"
+        ? contractTypeName(semantic.target)
+        : semantic.target;
+      return `NmsInternalNomosRefs.create<${target}>(workspace: workspace, type: ${dartString(semantic.target)}, id: ${raw})`;
+    }
+    if (semantic?.kind === "unit") {
+      const value = node.expression.kind === "integer" ? `${raw}.toDouble()` : raw;
+      return `${semantic.name}(${value})`;
+    }
+    if (semantic?.kind === "address-reference") {
+      if (node.expression.kind !== "record") {
+        throw new Error(`result Protobuf codegen: address reference '${path}' is not a record`);
+      }
+      const members = new Map(
+        node.expression.fields.map(structuralField).map((field) => [field.name, field]),
+      );
+      const addressPart = (name: "workspace" | "type" | "id"): string => {
+        const field = members.get(name);
+        if (field === undefined) {
+          throw new Error(`result Protobuf codegen: address reference '${path}' has no '${name}' field`);
+        }
+        const member = protoBindingMember(composedWireIdentity(paths, field.entity));
+        const decoded = emitStructural(structuralType(field.value.id), `${raw}.${member}`, `${path}.${name}`);
+        return required(raw, member, decoded, `${path}.${name}`);
+      };
+      return `(workspace: ${addressPart("workspace")}, type: ${addressPart("type")}, id: ${addressPart("id")})`;
+    }
+    if (semantic?.kind === "versioned-reference") {
+      if (node.expression.kind !== "record") {
+        throw new Error(`result Protobuf codegen: versioned reference '${path}' is not a record`);
+      }
+      const members = new Map(
+        node.expression.fields.map(structuralField).map((field) => [field.name, field]),
+      );
+      const referencePart = (name: "pinned" | "series"): string => {
+        const field = members.get(name);
+        if (field === undefined) {
+          throw new Error(`result Protobuf codegen: versioned reference '${path}' has no '${name}' field`);
+        }
+        const member = protoBindingMember(composedWireIdentity(paths, field.entity));
+        const decoded = emitStructural(structuralType(field.value.id), `${raw}.${member}`, `${path}.${name}`);
+        return required(raw, member, decoded, `${path}.${name}`);
+      };
+      return `(pinned: ${referencePart("pinned")}, series: ${referencePart("series")})`;
+    }
+    const geometry = structuralGeometryKind(nodes, node);
+    if (geometry !== undefined) {
+      const semantic = node.expression.kind === "record"
+        ? node.expression.semantic
+        : undefined;
+      if (semantic?.kind !== "value-object") {
+        throw new Error(`result Protobuf codegen: geometry '${path}' has no public Dart value type`);
+      }
+      return `${semantic.name}(coordinates: ${dartGeometryCoordinates(geometry, raw)})`;
+    }
+    switch (node.expression.kind) {
+      case "default": return emitRef(node.expression.value, raw, path);
+      case "recursive": throw new Error(`result Protobuf codegen: '${path}' contains recursive values`);
+      case "string": return raw;
+      case "enum": return node.expression.name === undefined
+        ? raw
+        : `${node.expression.name}.fromWire(${raw})`;
+      case "integer": return dartInteger(raw, path);
+      case "number": return raw;
+      case "boolean": return raw;
+      case "null": return "null";
+      case "literal": return JSON.stringify(node.expression.value);
+      case "nullable": return dartNullable(raw, "null", emitRef(node.expression.value, `${raw}.value`, path), path);
+      case "record": {
+        const semantic = node.expression.semantic;
+        if (semantic?.kind !== "value-object") {
+          throw new Error(`result Protobuf codegen: anonymous record '${path}' has no public Dart value type`);
+        }
+        const members = node.expression.fields.map(structuralField).flatMap((field) => {
+          const value = nodes.get(field.value.id);
+          if (
+            value?.kind === "structural" &&
+            value.structuralKind === "value-type" &&
+            value.expression.kind === "literal" &&
+            field.name === "type"
+          ) return [];
+          const member = protoBindingMember(composedWireIdentity(paths, field.entity));
+          const decoded = emitRef(field.value, `${raw}.${member}`, `${path}.${field.name}`);
+          return [field.required
+            ? `${dartMemberName(field.name)}: ${required(raw, member, decoded, `${path}.${field.name}`)}`
+            : `${dartMemberName(field.name)}: ${raw}.${dartHas(member)} ? ${decoded} : null`];
+        });
+        return `${semantic.name}(${members.join(", ")})`;
+      }
+      case "list": return `${raw}.items.map((value) => ${emitRef(node.expression.element, "value", `${path}[]`)}).toList(growable: false)`;
+      case "map": return `{for (final entry in ${raw}.entries) entry.key: ${emitRef(node.expression.value, "entry.value", `${path}.*`)}}`;
+      case "sum": {
+        const semantic = node.expression.semantic;
+        if (semantic?.kind !== "value-object") {
+          throw new Error(`result Protobuf codegen: structural sum '${path}' is not nominal`);
+        }
+        const arms = node.expression.variants.map((ref) => {
+          const variant = nodes.get(ref.id);
+          if (variant?.kind !== "structural" || variant.structuralKind !== "value-variant") {
+            throw new Error(`result Protobuf codegen: '${path}' has a non-variant arm`);
+          }
+          const value = structuralType(variant.value.id);
+          const discriminator = value.expression.kind === "record"
+            ? value.expression.fields.map(structuralField).flatMap((field) => {
+                const type = structuralType(field.value.id);
+                return field.name === "type" && type.expression.kind === "literal" && typeof type.expression.value === "string"
+                  ? [type.expression.value]
+                  : [];
+              })[0]
+            : undefined;
+          if (discriminator === undefined) {
+            throw new Error(`result Protobuf codegen: '${path}' union arm has no discriminator`);
+          }
+          const member = protoBindingMember(composedWireIdentity(paths, variant.entity));
+          return { member, value, discriminator };
+        });
+        const body = arms.map((arm) =>
+          `if (${raw}.${dartHas(arm.member)}) return ${emitRecordArm(arm.value, `${raw}.${arm.member}`, `${path}.${arm.discriminator}`, unionArmClassName(semantic.name, arm.discriminator))};`,
+        );
+        return `() { ${body.join(" ")} throw FormatException(${dartString(`${path} selects no nominal union arm`)}); }()`;
+      }
+      case "unknown": throw new Error(`result Protobuf codegen: '${path}' is unstructured`);
+    }
+  };
+
+  const readFields = new Map<string, LawReadNode>();
+  for (const node of graph.nodes) {
+    if (node.kind === "read" && node.of.id === aggregateNode.entity.id) {
+      readFields.set(node.entity.label, node);
+    }
+  }
+  const decodedField = (field: DartQueryResultAggregate["baseFields"][number]): string => {
+    const lawField = aggregateNode.fields
+      .map((ref) => nodes.get(ref.id))
+      .find((node) => node?.kind === "field" && node.entity.label === field.name);
+    if (lawField?.kind !== "field") {
+      throw new Error(`result Protobuf codegen: '${aggregate.model}.${field.name}' has no law field`);
+    }
+    const member = protoBindingMember(composedWireIdentity(paths, lawField.entity));
+    const raw = `row.${member}`;
+    const valueTypeNode = nodes.get(lawField.value.id);
+    const spec = field.spec;
+    const valueRaw = spec.surfaced === true
+      ? `${raw}.resolved`
+      : spec.nullAdmits === true
+        ? `${raw}.value`
+        : raw;
+    const structural = emitRef(lawField.value, valueRaw, `${aggregate.model}.${field.name}`);
+    const present = (() => {
+      if (spec.nomosRefTarget !== undefined) {
+        return `() { final value = ${structural}; return NmsInternalNomosRefs.create<${spec.nomosRefTarget}>(workspace: value.workspace, type: value.type, id: value.id); }()`;
+      }
+      if (spec.versionedRefTarget !== undefined) {
+        return `() { final value = ${structural}; return NmsInternalVersionedNomosRefs.create<${spec.versionedRefTarget}, ${spec.versionedRefSeries}>(pinned: NmsInternalNomosRefs.create<${spec.versionedRefTarget}>(workspace: value.pinned.workspace, type: value.pinned.type, id: value.pinned.id), series: NmsInternalNomosRefs.create<${spec.versionedRefSeries}>(workspace: value.series.workspace, type: value.series.type, id: value.series.id), currentField: ${dartString(spec.versionedRefCurrentField!)}); }()`;
+      }
+      if (spec.valueClass !== undefined) {
+        return `NmsInternalNomosRefs.create<${spec.valueClass}>(workspace: workspace, type: ${dartString(spec.valueAggregateType!)}, id: ${structural})`;
+      }
+      if (spec.foreignRefTarget !== undefined) {
+        const workspaceField = aggregateNode.fields
+          .map((ref) => nodes.get(ref.id))
+          .find((node) => node?.kind === "field" && node.entity.label === field.foreignWorkspaceName);
+        if (workspaceField?.kind !== "field") throw new Error(`result Protobuf codegen: foreign ref '${field.name}' has no workspace field`);
+        const workspaceMember = protoBindingMember(composedWireIdentity(paths, workspaceField.entity));
+        return `NmsInternalForeignRefs.create<${spec.foreignRefTarget}>(id: ${structural}, workspace: row.${workspaceMember}, type: ${dartString(spec.foreignRefAggregateType!)})`;
+      }
+      if (spec.refIdClass !== undefined) {
+        return `NmsInternalNomosRefs.create<${spec.refIdClass}>(workspace: workspace, type: ${dartString(spec.refAggregateType!)}, id: ${structural})`;
+      }
+      // Semantic scalar wrapping belongs to the law graph. Applying the public
+      // field spec as well would decode the same Protobuf string twice (for
+      // example Sha256Digest(Sha256Digest(raw))). Aggregate enums created before
+      // named structural vocabulary remain unnamed in the graph, so only that
+      // legacy-free scalar case needs the public enum name supplied here.
+      if (spec.kind === "enum" && !(
+        valueTypeNode?.kind === "structural" &&
+        valueTypeNode.structuralKind === "value-type" &&
+        valueTypeNode.expression.kind === "enum" &&
+        valueTypeNode.expression.name !== undefined
+      )) return `${spec.dartType}.fromWire(${structural})`;
+      if (spec.kind === "set") return `${structural}.toSet()`;
+      return structural;
+    })();
+    if (spec.surfaced === true) {
+      const valueType = spec.dartType.replace(/\?$/, "");
+      const observed = "observation";
+      const observedValue = emitRef(
+        lawField.value,
+        `${observed}.value`,
+        `${aggregate.model}.${field.name}.pending.value`,
+      );
+      const surfaced = `() { ` +
+        `if (${raw}.hasResolved()) return SurfacedResolved<${valueType}>(${present}); ` +
+        `if (${raw}.hasPending()) return SurfacedPending<${valueType}>(${raw}.pending.observations.map((${observed}) { ` +
+        `if (!${observed}.hasValue()) throw FormatException(${dartString(`${aggregate.model}.${field.name} pending observation has no value`)}); ` +
+        `if (!${observed}.hasPhysical() || !${observed}.hasLogical() || !${observed}.hasReplica()) throw FormatException(${dartString(`${aggregate.model}.${field.name} pending observation has no complete clock`)}); ` +
+        `return SurfacedObservation<${valueType}>(value: ${observedValue}, occurredAt: Hlc(physical: ${observed}.physical.toInt(), logical: ${observed}.logical.toInt(), replica: int.parse(${observed}.replica)), author: ${observed}.hasAuthor() ? ${observed}.author : null); ` +
+        `}).toList(growable: false)); ` +
+        `throw FormatException(${dartString(`${aggregate.model}.${field.name} selects no surfaced result`)}); }()`;
+      return field.required
+        ? required("row", member, surfaced, `${aggregate.model}.${field.name}`)
+        : `row.${dartHas(member)} ? ${surfaced} : null`;
+    }
+    if (spec.nullAdmits === true) {
+      const slotType = spec.dartType.replace(/\?$/, "");
+      const decoded = required(raw, "value", present, `${aggregate.model}.${field.name}`);
+      return `!row.${dartHas(member)} ? const NomosSlot<${slotType}>.omitted() : ${dartNullable(raw, `const NomosSlot<${slotType}>.explicitNull()`, `NomosSlot<${slotType}>.of(${decoded})`, `${aggregate.model}.${field.name}`)}`;
+    }
+    if (spec.kind === "set") return `row.${dartHas(member)} ? ${present} : const <String>{}`;
+    if (spec.kind === "map") return `row.${dartHas(member)} ? ${present} : const {}`;
+    return field.required
+      ? required("row", member, present, `${aggregate.model}.${field.name}`)
+      : `row.${dartHas(member)} ? ${present} : null`;
+  };
+  const decodedComputed = (field: DartQueryResultAggregate["computedFields"][number]): string => {
+    const read = readFields.get(field.name);
+    const readContract = read === undefined ? undefined : nodes.get(read.contract.id);
+    if (read === undefined || readContract?.kind !== "read-contract" || readContract.returns.kind !== "scalar") {
+      throw new Error(`result Protobuf codegen: '${aggregate.model}.${field.name}' has no scalar read`);
+    }
+    const member = protoBindingMember(composedWireIdentity(paths, read.entity));
+    const raw = `row.${member}`;
+    const value = emitRef(readContract.returns.value, raw, `${aggregate.model}.${field.name}`);
+    const decoded = field.enumType === undefined ? value : `${field.enumType}.fromWire(${value})`;
+    return field.required
+      ? required("row", member, decoded, `${aggregate.model}.${field.name}`)
+      : `row.${dartHas(member)} ? ${decoded} : null`;
+  };
+
+  const resultMessage = protoMessageName(
+    "QueryResult",
+    operationMessageIdentity(graph, query.entity.sid),
+  );
+  const rowIdSid = `${aggregateNode.entity.sid}:result:id`;
+  const rowsSid = `${query.entity.sid}:result:rows`;
+  const cursorSid = `${query.entity.sid}:result:cursor`;
+  const doneSid = `${query.entity.sid}:result:done`;
+  const rowsFunction = `_nmsDecodeQuery_${symbol(graph.domain.entity.label)}_${symbol(query.entity.label)}Rows`;
+  const pageFunction = `_nmsDecodeQuery_${symbol(graph.domain.entity.label)}_${symbol(query.entity.label)}Page`;
+  const decodeRows = `_nmsDecodeRows_${symbol(graph.domain.entity.label)}_${symbol(query.entity.label)}`;
+  const typeUrl = `type.nomos.dev/nomos.operation.v1.QueryResult_${query.entity.sid}`;
+  const rowId = protoBindingMember(rowIdSid);
+  const rows = protoBindingMember(rowsSid);
+  const cursor = protoBindingMember(cursorSid);
+  const done = protoBindingMember(doneSid);
+  const provenanceMember = protoBindingMember(provenanceRowIdentity(aggregateNode.entity.sid));
+  const provenanceEntries = aggregate.attributedFields.map(name => {
+    const field = aggregateNode.fields.map(ref => nodes.get(ref.id))
+      .find(node => node?.kind === "field" && node.entity.label === name);
+    if (field?.kind !== "field" || field.mergeDrivers[0]?.kind !== "Attributed") {
+      throw new Error(`result Protobuf codegen: '${aggregate.model}.${name}' has no attributed law field`);
+    }
+    const member = protoBindingMember(provenanceFieldIdentity(composedWireIdentity(paths, field.entity)));
+    const raw = `row.${provenanceMember}.${member}`;
+    const author = protoBindingMember(provenanceAuthorIdentity);
+    const contested = protoBindingMember(provenanceContestedIdentity);
+    const path = `${aggregate.model}.${name} provenance`;
+    return `if (row.${provenanceMember}.${dartHas(member)}) ${dartString(name)}: FieldProvenance(` +
+      `author: ${required(raw, author, dartNullable(`${raw}.${author}`, "null", `${raw}.${author}.value`, `${path}.author`), `${path}.author`)}, ` +
+      `wasContested: ${required(raw, contested, `${raw}.${contested}`, `${path}.wasContested`)}),`;
+  });
+  return {
+    rowsFunction,
+    pageFunction,
+    typeUrl,
+    source: [
+      `List<${aggregate.model}> ${decodeRows}(NmsGeneratedResult result, String workspace) {`,
+      `  if (result.protobufType != ${dartString(typeUrl)}) throw const FormatException('Query result type does not match generated realm contract');`,
+      `  final message = _nmsop.${resultMessage}.fromBuffer(result.protobufPayload);`,
+      ...(query.readKind === "ordered" ? [
+        `  if (message.${rows}.length > ${query.limit}) throw const FormatException('Ordered result exceeds its declared limit');`,
+        `  if (message.${dartHas(cursor)} || message.${dartHas(done)}) throw const FormatException('Ordered result cannot carry page metadata');`,
+      ] : []),
+      `  return message.${rows}.map((row) {`,
+      `    if (!row.${dartHas(rowId)}) throw const FormatException('Query row has no stable identity');`,
+      `    return NmsInternalRecordOrigins.remember(${aggregate.model}(`,
+      `      ref: NmsInternalNomosRefs.create<${aggregate.refType}>(workspace: workspace, type: ${dartString(aggregate.runtimeType)}, id: row.${rowId}),`,
+      ...aggregate.baseFields.map((field) => `      ${field.spec.name}: ${decodedField(field)},`),
+      ...aggregate.computedFields.map((field) => `      ${dartMemberName(field.name)}: ${decodedComputed(field)},`),
+      ...(provenanceEntries.length > 0 ? [
+        `      \$provenance: row.${dartHas(provenanceMember)} ? { ${provenanceEntries.join(" ")} } : const {},`,
+      ] : []),
+      `    ), workspace: workspace, type: ${dartString(aggregate.runtimeType)}, id: row.${rowId});`,
+      `  }).toList(growable: false);`,
+      `}`,
+      `List<${aggregate.model}> ${rowsFunction}(NmsGeneratedResult result, String workspace) => ${decodeRows}(result, workspace);`,
+      `NomosPage<${aggregate.model}> ${pageFunction}(NmsGeneratedResult result, String workspace) {`,
+      `  if (result.protobufType != ${dartString(typeUrl)}) throw const FormatException('Query result type does not match generated realm contract');`,
+      `  final message = _nmsop.${resultMessage}.fromBuffer(result.protobufPayload);`,
+      `  return NomosPage(rows: ${decodeRows}(result, workspace), cursor: message.${dartHas(cursor)} ? message.${cursor} : null, done: message.${dartHas(done)} && message.${done});`,
+      `}`,
+      ``,
+    ],
+  };
+}
+
+/** Generate one query-specific decoder over protoc-gen-es bindings. The
+ * application sees the same Row<T> and nested nominal values as before; no
+ * USDA parser, generic map, or asserted transport object sits on this path. */
+export function emitTsQueryResultProtoDecoder(
+  graph: LawGraph,
+  paths: ReadonlyMap<string, string>,
+  query: LawRowReadNode,
+  aggregate: TsResultAggregate,
+  emitAggregateDecoder = true,
+): TsQueryResultDecoder {
+  const nodes = new Map<string, LawGraph["nodes"][number]>(
+    graph.nodes.map((node) => [node.entity.id, node]),
+  );
+  const contract = nodes.get(query.contract.id);
+  if (contract?.kind !== "read-contract" || contract.returns.kind !== "rows") {
+    throw new Error(`result Protobuf codegen: '${query.entity.label}' has no row contract`);
+  }
+  const aggregateNode = nodes.get(contract.returns.aggregate.id);
+  if (aggregateNode?.kind !== "aggregate") {
+    throw new Error(`result Protobuf codegen: '${query.entity.label}' returns no aggregate`);
+  }
+  let local = 0;
+  const fresh = (prefix: string): string => `_${prefix}${local++}`;
+  const structuralField = (ref: LawStructuralRef<"value-field">): LawAnonymousValueFieldNode => {
+    const node = nodes.get(ref.id);
+    if (node?.kind !== "structural" || node.structuralKind !== "value-field") {
+      throw new Error(`result Protobuf codegen: '${ref.id}' is not a structural field`);
+    }
+    return node;
+  };
+  const structuralType = (id: string): LawAnonymousValueTypeNode => {
+    const node = nodes.get(id);
+    if (node?.kind !== "structural" || node.structuralKind !== "value-type") {
+      throw new Error(`result Protobuf codegen: '${id}' is not a structural value type`);
+    }
+    return node;
+  };
+  const emitRef = (ref: LawValueTypeRef, raw: string, path: string): string => {
+    const node = nodes.get(ref.id);
+    if (node?.kind === "structural" && node.structuralKind === "value-type") {
+      return emitStructural(node, raw, path);
+    }
+    if (node?.kind === "type") return emitDeclared(node, raw, path);
+    throw new Error(`result Protobuf codegen: '${path}' has no declared value type`);
+  };
+  const emitDeclared = (node: LawTypeNode, raw: string, path: string): string => {
+    if (node.form === "geometry") {
+      if (node.geometry === undefined) throw new Error(`result Protobuf codegen: '${path}' has no geometry kind`);
+      const coordinates = tsGeometryCoordinates(node.geometry, raw);
+      return `({ type: ${JSON.stringify(node.geometry)}, coordinates: ${coordinates} })`;
+    }
+    if (node.form === "sum") {
+      const selected = fresh("sum");
+      const cases = node.variants.map((ref) => {
+        const variant = nodes.get(ref.id);
+        if (variant?.kind !== "structural" || variant.structuralKind !== "value-variant" || variant.label === undefined) {
+          throw new Error(`result Protobuf codegen: '${path}' has an invalid declared sum arm '${ref.id}'`);
+        }
+        const target = nodes.get(variant.value.id);
+        const member = protoBindingMember(composedWireIdentity(paths, variant.entity));
+        const decoded = target?.kind === "type"
+          ? `{ type: ${JSON.stringify(variant.label)}, value: ${emitDeclared(target, `${selected}.choice.value!`, `${path}.${variant.label}.value`)} }`
+          : target?.kind === "structural" && target.structuralKind === "value-type"
+            ? `({ type: ${JSON.stringify(variant.label)}, ...${emitStructural(target, `${selected}.choice.value!`, `${path}.${variant.label}`)} })`
+            : (() => { throw new Error(`result Protobuf codegen: '${path}.${variant.label}' has no value type`); })();
+        return `case ${JSON.stringify(member)}: return ${decoded};`;
+      });
+      return `((${selected}) => { switch (${selected}.choice.case) { ${cases.join(" ")} default: throw new TypeError(${JSON.stringify(path)} + " selects no nominal union arm"); } })(${raw})`;
+    }
+    const members = node.fields.map((ref) => {
+      const field = nodes.get(ref.id);
+      if (field?.kind !== "field") throw new Error(`result Protobuf codegen: '${ref.id}' is not a field`);
+      const sid = composedWireIdentity(paths, field.entity);
+      const selected = `${raw}.${protoBindingMember(sid)}`;
+      const fieldPath = `${path}.${field.entity.label}`;
+      if (field.required) {
+        const decoded = emitRef(
+          field.value,
+          `_nmsResultRequired(${selected}, ${JSON.stringify(fieldPath)})`,
+          fieldPath,
+        );
+        return `${JSON.stringify(field.entity.label)}: ${decoded}`;
+      }
+      const captured = fresh("field");
+      const decoded = emitRef(field.value, captured, fieldPath);
+      return `...(((${captured}) => ${captured} === undefined ? {} : { ${JSON.stringify(field.entity.label)}: ${decoded} })(${selected}))`;
+    });
+    return `({ ${members.join(", ")} })`;
+  };
+  const emitStructural = (node: LawAnonymousValueTypeNode, raw: string, path: string): string => {
+    const geometry = structuralGeometryKind(nodes, node);
+    if (geometry !== undefined) {
+      return `({ type: ${JSON.stringify(geometry)}, coordinates: ${tsGeometryCoordinates(geometry, raw)} })`;
+    }
+    switch (node.expression.kind) {
+      case "default": return emitRef(node.expression.value, raw, path);
+      case "recursive": throw new Error(`result Protobuf codegen: '${path}' contains recursive values`);
+      case "string": return `_nmsVoString(${raw}, ${JSON.stringify(path)})`;
+      case "enum": return `_nmsVoEnum(${raw}, ${JSON.stringify(node.expression.values)}, ${JSON.stringify(path)})`;
+      case "integer": return `_nmsResultInteger(${raw}, ${JSON.stringify(path)})`;
+      case "number": return `_nmsVoNumber(${raw}, ${JSON.stringify(path)}, false)`;
+      case "boolean": return `_nmsVoBoolean(${raw}, ${JSON.stringify(path)})`;
+      case "null": return `null`;
+      case "literal": return JSON.stringify(node.expression.value);
+      case "nullable": return tsNullable(raw, emitRef(node.expression.value, "nullable.value", path), path);
+      case "record": {
+        const members = node.expression.fields.map(structuralField).map((field) => {
+          const sid = composedWireIdentity(paths, field.entity);
+          const selected = `${raw}.${protoBindingMember(sid)}`;
+          const fieldPath = `${path}.${field.name}`;
+          if (field.required) {
+            const decoded = emitRef(
+              field.value,
+              `_nmsResultRequired(${selected}, ${JSON.stringify(fieldPath)})`,
+              fieldPath,
+            );
+            return `${JSON.stringify(field.name)}: ${decoded}`;
+          }
+          const captured = fresh("field");
+          const decoded = emitRef(
+            field.value,
+            captured,
+            fieldPath,
+          );
+          return `...(((${captured}) => ${captured} === undefined ? {} : { ${JSON.stringify(field.name)}: ${decoded} })(${selected}))`;
+        });
+        return `({ ${members.join(", ")} })`;
+      }
+      case "list": {
+        const item = fresh("item");
+        return `${raw}.items.map((${item}) => ${emitRef(node.expression.element, item, `${path}[]`)})`;
+      }
+      case "map": {
+        const entry = fresh("entry");
+        // Protobuf message presence makes an entry value optional in the
+        // generated binding even though Nomos map law requires every key to
+        // carry a value. The kernel-authored result guarantees presence; keep
+        // that invariant explicit at this exact generated boundary rather
+        // than allowing `T | undefined` to infect every nested decoder.
+        return `Object.fromEntries(${raw}.entries.map((${entry}) => [${entry}.key, ${emitRef(node.expression.value, `${entry}.value!`, `${path}.*`)}]))`;
+      }
+      case "sum": {
+        const selected = fresh("sum");
+        const cases = node.expression.variants.map((ref) => {
+          const variant = nodes.get(ref.id);
+          if (variant?.kind !== "structural" || variant.structuralKind !== "value-variant") {
+            throw new Error(`result Protobuf codegen: '${path}' has a non-variant arm`);
+          }
+          const value = nodes.get(variant.value.id);
+          if (value?.kind !== "structural" || value.structuralKind !== "value-type") {
+            throw new Error(`result Protobuf codegen: '${path}' variant has no value`);
+          }
+          const field = protoBindingMember(composedWireIdentity(paths, variant.entity));
+          return `case ${JSON.stringify(field)}: return ${emitStructural(value, `${selected}.choice.value!`, path)};`;
+        });
+        return `(( ${selected} ) => { switch (${selected}.choice.case) { ${cases.join(" ")} default: throw new TypeError(${JSON.stringify(path)} + " selects no nominal union arm"); } })(${raw})`;
+      }
+      case "unknown": throw new Error(`result Protobuf codegen: '${path}' is unstructured`);
+    }
+  };
+
+  const readFields = new Map<string, LawReadNode>();
+  for (const node of graph.nodes) {
+    if (node.kind === "read" && node.of.id === aggregateNode.entity.id) {
+      readFields.set(node.entity.label, node);
+    }
+  }
+  const members = emitAggregateDecoder ? aggregate.fields.map(({ name, field, projectionSchema, required }) => {
+    const lawField = aggregateNode.fields
+      .map((ref) => nodes.get(ref.id))
+      .find((node) => node?.kind === "field" && node.entity.label === name);
+    const read = readFields.get(name);
+    const sid = lawField?.kind === "field"
+      ? composedWireIdentity(paths, lawField.entity)
+      : read === undefined
+        ? undefined
+        : composedWireIdentity(paths, read.entity);
+    if (sid === undefined) throw new Error(`result Protobuf codegen: '${aggregate.typeName}.${name}' has no law identity`);
+    const raw = `row.${protoBindingMember(sid)}`;
+    const valueRef = lawField?.kind === "field"
+      ? lawField.value
+      : (() => {
+          const readContract = read === undefined ? undefined : nodes.get(read.contract.id);
+          if (readContract?.kind !== "read-contract" || readContract.returns.kind !== "scalar") {
+            throw new Error(`result Protobuf codegen: '${aggregate.typeName}.${name}' has no scalar contract`);
+          }
+          return readContract.returns.value;
+        })();
+    const fieldPath = `${aggregate.typeName}.${name}`;
+    const selected = required
+      ? `_nmsResultRequired(${raw}, ${JSON.stringify(fieldPath)})`
+      : `${raw}!`;
+    const surfaced = lawField?.kind === "field" && lawField.mergeDrivers[0]?.kind === "Surfaced";
+    const surfacedSelection = surfaced ? fresh("selection") : undefined;
+    const selectedValue = surfaced ? `${surfacedSelection}.value!` : selected;
+    const structural = lawField?.kind === "field" && lawField.nullable
+      ? tsNullable(selected, emitRef(valueRef, "nullable.value", fieldPath), fieldPath)
+      : emitRef(valueRef, selectedValue, fieldPath);
+    const foreignWorkspace = field?.foreignRef === undefined
+      ? undefined
+      : (() => {
+          const workspaceField = aggregateNode.fields
+            .map((ref) => nodes.get(ref.id))
+            .find((node) =>
+              node?.kind === "field" &&
+              node.entity.label === field.foreignRef!.workspaceField
+            );
+          if (workspaceField?.kind !== "field") {
+            throw new Error(
+              `result Protobuf codegen: foreign ref '${aggregate.typeName}.${name}' has no declared workspace field '${field.foreignRef.workspaceField}'`,
+            );
+          }
+          const member = protoBindingMember(composedWireIdentity(paths, workspaceField.entity));
+          const selected = `row.${member}`;
+          return `(() => { const value = ${selected}; if (value === undefined) throw new TypeError(${JSON.stringify(`${aggregate.typeName}.${field.foreignRef.workspaceField} is absent`)}); return value; })()`;
+        })();
+    const decodedInner = field !== undefined
+      ? authoredFieldValue(field, structural, "holon.workspace", "holon", foreignWorkspace)
+      : projectionSchema !== undefined
+        ? structural
+        : (() => { throw new Error(`result Protobuf codegen: '${aggregate.typeName}.${name}' has no public schema`); })();
+    const decoded = surfaced
+      ? (() => {
+          const observation = fresh("observation");
+          const selection = surfacedSelection!;
+          const observationValue = emitRef(
+            valueRef,
+            `_nmsResultRequired(${observation}.value, ${JSON.stringify(`${fieldPath}.pending.value`)})`,
+            `${fieldPath}.pending.value`,
+          );
+          const typedObservationValue = field === undefined
+            ? observationValue
+            : authoredFieldValue(field, observationValue, "holon.workspace", "holon", foreignWorkspace);
+          return `(() => { ` +
+            `const ${selection} = ${selected}.selected; ` +
+            `switch (${selection}.case) { ` +
+            `case "resolved": return ${decodedInner}; ` +
+            `case "pending": return { __surfaced: { status: "pending", pending: ${selection}.value.observations.map((${observation}) => ({ ` +
+            `value: ${typedObservationValue}, occurredAt: { ` +
+            `physical: Number(_nmsResultRequired(${observation}.physical, ${JSON.stringify(`${fieldPath}.pending.occurredAt.physical`)})), ` +
+            `logical: _nmsResultRequired(${observation}.logical, ${JSON.stringify(`${fieldPath}.pending.occurredAt.logical`)}), ` +
+            `replica: _nmsResultRequired(${observation}.replica, ${JSON.stringify(`${fieldPath}.pending.occurredAt.replica`)}) }, ` +
+            `...(${observation}.author === undefined ? {} : { author: ${observation}.author }) })) } }; ` +
+            `default: throw new TypeError(${JSON.stringify(fieldPath)} + " selects no surfaced result"); } })()`;
+        })()
+      : decodedInner;
+    return required
+      ? `${JSON.stringify(name)}: ${decoded}`
+      : `...(${raw} === undefined ? {} : { ${JSON.stringify(name)}: ${decoded} })`;
+  }) : [];
+  const resultMessage = protoMessageName(
+    "QueryResult",
+    operationMessageIdentity(graph, query.entity.sid),
+  );
+  const rowIdSid = `${aggregateNode.entity.sid}:result:id`;
+  const rowsSid = `${query.entity.sid}:result:rows`;
+  const cursorSid = `${query.entity.sid}:result:cursor`;
+  const doneSid = `${query.entity.sid}:result:done`;
+  if (emitAggregateDecoder) {
+    const attributed = aggregateNode.fields.map(ref => nodes.get(ref.id)).filter(
+      (node): node is Extract<LawGraph["nodes"][number], { kind: "field" }> =>
+        node?.kind === "field" && node.mergeDrivers[0]?.kind === "Attributed",
+    );
+    if (attributed.length > 0) {
+      const raw = `row.${protoBindingMember(provenanceRowIdentity(aggregateNode.entity.sid))}`;
+      const entries = attributed.map(field => {
+        const entry = `${raw}.${protoBindingMember(provenanceFieldIdentity(composedWireIdentity(paths, field.entity)))}`;
+        const author = `${entry}.${protoBindingMember(provenanceAuthorIdentity)}`;
+        const contested = `${entry}.${protoBindingMember(provenanceContestedIdentity)}`;
+        const path = `${aggregate.typeName}.${field.entity.label} provenance`;
+        return `...(${entry} === undefined ? {} : { ${JSON.stringify(field.entity.label)}: { ` +
+          `author: ${tsNullable(`_nmsResultRequired(${author}, ${JSON.stringify(`${path}.author`)})`, "nullable.value", `${path}.author`)}, ` +
+          `wasContested: _nmsResultRequired(${contested}, ${JSON.stringify(`${path}.wasContested`)}) } })`;
+      });
+      members.push(`...(${raw} === undefined ? {} : { __prov: { ${entries.join(", ")} } })`);
+    }
+  }
+  const rowMessage = protoMessageName(
+    "Read",
+    operationMessageIdentity(graph, aggregateNode.entity.sid),
+  );
+  const rowFunction = `_nmsDecodeRow_${symbol(graph.domain.entity.label)}_${symbol(aggregate.typeName)}`;
+  const rowsFunction = `_nmsDecodeQuery_${symbol(graph.domain.entity.label)}_${symbol(query.entity.label)}Rows`;
+  const pageFunction = `_nmsDecodeQuery_${symbol(graph.domain.entity.label)}_${symbol(query.entity.label)}Page`;
+  const decodeRows = `_nmsDecodeRows_${symbol(graph.domain.entity.label)}_${symbol(query.entity.label)}`;
+  const typeUrl = `type.nomos.dev/nomos.operation.v1.QueryResult_${query.entity.sid}`;
+  return {
+    rowsFunction,
+    pageFunction,
+    typeUrl,
+    source: [
+      ...(emitAggregateDecoder ? [
+        `const ${rowFunction} = (row: _nmsop.${rowMessage}, holon: NomosHolon): Row<${aggregate.typeName}> => {`,
+        `  const id = row.${protoBindingMember(rowIdSid)}; if (id === undefined) throw new TypeError("Query row has no stable identity");`,
+        `  return { data: { ${members.join(", ")} } satisfies ${aggregate.typeName}, ref: _nmsRef<${aggregate.typeName}>(holon.workspace, ${JSON.stringify(aggregate.typeName)}, id), type: ${JSON.stringify(aggregate.typeName)} };`,
+        `};`,
+        ``,
+      ] : []),
+      `const ${decodeRows} = (result: NmsGeneratedResult, holon: NomosHolon): Row<${aggregate.typeName}>[] => {`,
+      `  if (result.protobufType !== ${JSON.stringify(typeUrl)}) throw new TypeError("Query result type does not match generated realm contract");`,
+      `  const message = fromBinary(_nmsop.${resultMessage}Schema, result.protobufPayload);`,
+      ...(query.readKind === "ordered" ? [
+        `  if (message.${protoBindingMember(rowsSid)}.length > ${query.limit}) throw new TypeError("Ordered result exceeds its declared limit");`,
+        `  if (message.${protoBindingMember(cursorSid)} !== undefined || message.${protoBindingMember(doneSid)} !== undefined) throw new TypeError("Ordered result cannot carry page metadata");`,
+      ] : []),
+      `  return message.${protoBindingMember(rowsSid)}.map((row) => ${rowFunction}(row, holon));`,
+      `};`,
+      `const ${rowsFunction} = (result: NmsGeneratedResult, holon: NomosHolon): Row<${aggregate.typeName}>[] => ${decodeRows}(result, holon);`,
+      `const ${pageFunction} = (result: NmsGeneratedResult, holon: NomosHolon): { rows: Row<${aggregate.typeName}>[]; cursor: string | null; done: boolean } => {`,
+      `  if (result.protobufType !== ${JSON.stringify(typeUrl)}) throw new TypeError("Query result type does not match generated realm contract");`,
+      `  const message = fromBinary(_nmsop.${resultMessage}Schema, result.protobufPayload);`,
+      `  return { rows: ${decodeRows}(result, holon), cursor: message.${protoBindingMember(cursorSid)} ?? null, done: message.${protoBindingMember(doneSid)} ?? false };`,
+      `};`,
+      ``,
+    ],
+  };
+}