@githolon/dsl 0.119.34 → 0.119.35

package/dart/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.70.33
+
+- Restage the bundled runtime with hosted REST parity fixes: foreign references serialise as plain references (CAP-1107), and payload shape errors name the field path and the expected shape (CAP-1108).
+
 ## 0.70.32
 
 - Restage the bundled runtime with the projection fix that keeps a founding record's owner contract, so reading it on an upgraded Home no longer reports `evolutionRequired` (CAP-1012).

package/dart/lib/src/runner/node-entry.mjs

@@ -26258,7 +26258,7 @@ function delayUntilDue(follow, nowUnixMillis) {
 
 // ../src/runtime/runtime_identity.ts
 init_define_NOMOS_KERNEL_RELEASE();
-var PEER_RUNTIME_IDENTITY = "0.119.34" ? `@githolon/runtime@${"0.119.34"}` : "@githolon/runtime@unbundled";
+var PEER_RUNTIME_IDENTITY = "0.119.35" ? `@githolon/runtime@${"0.119.35"}` : "@githolon/runtime@unbundled";
 
 // ../src/runtime/replica_follow_desk.ts
 init_define_NOMOS_KERNEL_RELEASE();

package/dart/pubspec.yaml

@@ -7,7 +7,7 @@ repository: https://github.com/Captain-App/nomos2
 description: >-
   Nomos 2 Dart client — generated domain values, intent payloads and application
   lifecycle types over the typed Nomos kernel protocol and USDA custody model.
-version: 0.70.32
+version: 0.70.33
 
 environment:
   sdk: ^3.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@githolon/dsl",
-  "version": "0.119.34",
+  "version": "0.119.35",
   "type": "module",
   "sideEffects": false,
   "description": "Nomos 2 domain-authoring DSL: aggregates + directives in TS, executed and encoded to the Rust kernel's wire shapes.",
@@ -82,7 +82,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@githolon/runtime": "0.119.34",
+    "@githolon/runtime": "0.119.35",
     "@bufbuild/protobuf": "2.13.0",
     "@bufbuild/protoc-gen-es": "2.13.0",
     "esbuild": "0.24.2",

package/src/codegen_call_proto.ts

@@ -827,12 +827,39 @@ export const TS_CALL_PROTO_PRELUDE = [
   `  routingCandidates.push(value);`,
   `  return value;`,
   `};`,
-  `const _nmsProtoInt = (value: number): bigint => {`,
-  `  if (!Number.isSafeInteger(value)) throw new TypeError("Nomos integers must be safe integers");`,
+  // Shape checks name the payload field path and its expected shape: hosted REST and other
+  // untyped callers reach this encoder with raw JSON, where a wrong shape must say which field.
+  `const _nmsShapeOf = (value: unknown): string => {`,
+  `  if (value === undefined) return "nothing (the field is missing)";`,
+  `  if (value === null) return "null";`,
+  `  if (Array.isArray(value)) return "a list";`,
+  `  if (typeof value === "object") { const keys = Object.keys(value); return "an object { " + keys.slice(0, 6).join(", ") + (keys.length > 6 ? ", …" : "") + " }"; }`,
+  `  if (typeof value === "string") return "a string";`,
+  `  if (typeof value === "number") return "the number " + String(value);`,
+  `  return typeof value;`,
+  `};`,
+  `const _nmsShapeError = (path: string, expected: string, value: unknown): never => {`,
+  `  throw new TypeError(path + ": expected " + expected + ", got " + _nmsShapeOf(value));`,
+  `};`,
+  `const _nmsCheck = <T>(value: T, kind: "string" | "number" | "boolean" | "record" | "list", path: string, expected: string): T => {`,
+  `  const valid = kind === "record" ? typeof value === "object" && value !== null && !Array.isArray(value)`,
+  `    : kind === "list" ? Array.isArray(value) : typeof value === kind;`,
+  `  return valid ? value : _nmsShapeError(path, expected, value);`,
+  `};`,
+  `const _nmsCheckOneOf = <T>(value: T, allowed: readonly unknown[], path: string, expected: string): T =>`,
+  `  allowed.includes(value) ? value : _nmsShapeError(path, expected, value);`,
+  `const _nmsProtoInt = (value: number, path?: string): bigint => {`,
+  `  if (!Number.isSafeInteger(value)) {`,
+  `    if (path !== undefined) _nmsShapeError(path, "a safe integer", value);`,
+  `    throw new TypeError("Nomos integers must be safe integers");`,
+  `  }`,
   `  return BigInt(value);`,
   `};`,
-  `const _nmsProtoNumber = (value: number): number => {`,
-  `  if (!Number.isFinite(value)) throw new TypeError("Nomos numbers must be finite");`,
+  `const _nmsProtoNumber = (value: number, path?: string): number => {`,
+  `  if (!Number.isFinite(value)) {`,
+  `    if (path !== undefined) _nmsShapeError(path, "a finite number", value);`,
+  `    throw new TypeError("Nomos numbers must be finite");`,
+  `  }`,
   `  return value;`,
   `};`,
   ``,
@@ -909,6 +936,41 @@ export function emitTsCallProtoEncoder(
   let local = 0;
   const fresh = (prefix: string): string => `_${prefix}${local++}`;
 
+  /** The field path a shape error names, e.g. `catalogue/createListing facts.rows[].site`. */
+  const pathOf = (where: string): string => JSON.stringify(`${domain}/${spec.publicDirective} facts.${where}`);
+  /** The expected JSON shape a shape error names; nested records list their field names only. */
+  const describe = (typeId: string, depth = 0): string => {
+    const node = typeNode(spec.nodes, typeId);
+    const semantic = node.expression.semantic;
+    if (semantic?.kind === "id-reference" || semantic?.kind === "address-reference")
+      return `a NomosRef { workspace, type, id }${semantic.target ? ` to ${semantic.target}` : ""}`;
+    const geometry = structuralGeometryKind(spec.nodes, node);
+    if (geometry !== undefined) return `a GeoJSON ${geometry}`;
+    const expression = node.expression;
+    switch (expression.kind) {
+      case "default": return describe(expression.value.id, depth);
+      case "nullable": return `${describe(expression.value.id, depth)} or null`;
+      case "string": return "a string";
+      case "enum": return `one of ${expression.values.map((value) => JSON.stringify(value)).join(" | ")}`;
+      case "integer": return "an integer";
+      case "number": return "a number";
+      case "boolean": return "true or false";
+      case "null": return "null";
+      case "literal": return JSON.stringify(expression.value);
+      case "record": {
+        const names = expression.fields.map((ref) => fieldNode(spec.nodes, ref))
+          .map((item) => `${item.name}${item.required ? "" : "?"}`);
+        return `an object { ${names.join(", ")} }`;
+      }
+      case "list": return depth > 1 ? "a list" : `a list of ${describe(expression.element.id, depth + 1)}`;
+      case "map": return depth > 1 ? "an object map" : `an object map of ${describe(expression.value.id, depth + 1)}`;
+      case "sum": return `one of ${nominalSumArms(spec.nodes, node, `${domain}/${directive} union`)
+        .map((arm) => `{ type: ${JSON.stringify(arm.discriminator)}, … }`).join(" | ")}`;
+      default: return "a value";
+    }
+  };
+  const expected = (typeId: string): string => JSON.stringify(describe(typeId));
+
   /** Build a MessageInitShape expression for protoc-gen-es. Nested records,
    * lists, maps and unions stay typed objects until the maintained Protobuf
    * runtime serializes the one top-level generated message. */
@@ -932,6 +994,9 @@ export function emitTsCallProtoEncoder(
       const position = fresh("position");
       return `(() => { const ${selected} = ${value}; const ${coordinates}: number[] = []; const ${positions}: number[] = []; for (const ${position} of ${selected}.coordinates) { ${coordinates}.push(...${position}); ${positions}.push(${coordinates}.length); } return { coordinates: ${coordinates}, positionEnds: ${positions} }; })()`;
     }
+    // Reference semantics lowered `value` through their own field-naming helpers above.
+    const checked = (kind: "string" | "number" | "boolean" | "record" | "list"): string =>
+      value !== raw ? value : `_nmsCheck(${value}, ${JSON.stringify(kind)}, ${pathOf(where)}, ${expected(typeId)})`;
     switch (node.expression.kind) {
       case "default": return emitValue(value, node.expression.value.id, where);
       case "recursive": throw new Error(`call Protobuf codegen: '${domain}/${directive}' contains recursive values`);
@@ -940,11 +1005,12 @@ export function emitTsCallProtoEncoder(
         return `(() => { const ${selected} = ${value}; return ${selected} === null ? { selected: { case: "isNull" as const, value: true } } : { selected: { case: "value" as const, value: ${emitValue(selected, node.expression.value.id, where)} } }; })()`;
       }
       case "string":
+        return `_nmsProtoString(${checked("string")}, _nmsRoutingCandidates)`;
       case "enum":
-        return `_nmsProtoString(${value}, _nmsRoutingCandidates)`;
-      case "integer": return `_nmsProtoInt(${value})`;
-      case "number": return `_nmsProtoNumber(${value})`;
-      case "boolean": return value;
+        return `_nmsProtoString(_nmsCheckOneOf(${value}, ${JSON.stringify(node.expression.values)}, ${pathOf(where)}, ${expected(typeId)}), _nmsRoutingCandidates)`;
+      case "integer": return `_nmsProtoInt(${checked("number")}, ${pathOf(where)})`;
+      case "number": return `_nmsProtoNumber(${checked("number")}, ${pathOf(where)})`;
+      case "boolean": return checked("boolean");
       case "null": return `{}`;
       case "literal": {
         const literal = JSON.stringify(node.expression.value);
@@ -967,7 +1033,7 @@ export function emitTsCallProtoEncoder(
           const encoded = emitValue(child.required ? childRaw : `(${childRaw})!`, child.value.id, `${where}.${child.name}`);
           return `${fieldName}: ${child.required ? encoded : `${childRaw} === undefined ? undefined : ${encoded}`}`;
         });
-        return `(() => { const ${selected} = (${value})!; return { ${properties.join(", ")} }; })()`;
+        return `(() => { const ${selected} = ${checked("record")}!; return { ${properties.join(", ")} }; })()`;
       }
       case "list": {
         const item = fresh("item");
@@ -975,13 +1041,13 @@ export function emitTsCallProtoEncoder(
         // a generated message initializer (`{ items: ... }`), an unwrapped
         // arrow body is parsed as a statement block and silently becomes
         // `void[]` instead of the declared nested value.
-        return `{ items: ${value}.map((${item}) => (${emitValue(item, node.expression.element.id, `${where}[]`)})) }`;
+        return `{ items: ${checked("list")}.map((${item}) => (${emitValue(item, node.expression.element.id, `${where}[]`)})) }`;
       }
       case "map": {
         const entries = fresh("entries");
         const key = fresh("key");
         const item = fresh("item");
-        return `(() => { const ${entries} = Object.entries(${value}).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0); return { entries: ${entries}.map(([${key}, ${item}]) => ({ key: _nmsProtoString(${key}, _nmsRoutingCandidates), value: ${emitValue(item, node.expression.value.id, `${where}.*`)} })) }; })()`;
+        return `(() => { const ${entries} = Object.entries(${checked("record")}).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0); return { entries: ${entries}.map(([${key}, ${item}]) => ({ key: _nmsProtoString(${key}, _nmsRoutingCandidates), value: ${emitValue(item, node.expression.value.id, `${where}.*`)} })) }; })()`;
       }
       case "sum": {
         const arms = nominalSumArms(spec.nodes, node, `${domain}/${directive} ${where}`);
@@ -991,7 +1057,7 @@ export function emitTsCallProtoEncoder(
           const fieldName = protoFieldName(composedWireIdentity(paths, arm.variant.entity));
           cases.push(`case ${JSON.stringify(arm.discriminator)}: return { choice: { case: ${JSON.stringify(fieldName)} as const, value: ${emitValue(selected, arm.value.entity.id, `${where}.${arm.discriminator}`)} } };`);
         }
-        return `(() => { const ${selected} = ${value}; switch (${selected}.type) { ${cases.join(" ")} default: throw new TypeError("Unknown nominal union arm: " + String((${selected} as unknown as { readonly type?: unknown }).type)); } })()`;
+        return `(() => { const ${selected} = ${checked("record")}; switch (${selected}.type) { ${cases.join(" ")} default: return _nmsShapeError(${pathOf(where)}, ${expected(typeId)}, ${selected}); } })()`;
       }
       case "unknown": throw new Error(`call Protobuf codegen: '${domain}/${directive}' contains an unstructured value at ${where}`);
     }

package/src/compile_package_main.ts

@@ -2593,8 +2593,8 @@ const NOMOS_TYPES_DEP = "^0.16.0";
 // 0.48.x: session-bound clients (XClient.bind/NomosClientInterface/DomainClientSessionMismatch/
 //         DomainNotInstalledForSession, engine.follow, pendingConflicts lanes) — the generated client
 //         REQUIRES this surface. 0.48.1 fixes NomosSession.watchPendingConflicts delegation.
-const NOMOS_CLIENT_DEP = "^0.70.32";
-const NOMOS_FLUTTER_DEP = "^0.69.24";
+const NOMOS_CLIENT_DEP = "^0.70.33";
+const NOMOS_FLUTTER_DEP = "^0.69.25";
 // DRIFT TRIPWIRE: pubspec_pins.test.ts asserts these equal the CURRENT versions in the Dart and Flutter
 // package pubspecs — a release without this bump fails the suite, so tenants never
 // land back in dependency_overrides (the exact co2 report this closes, third occurrence).

package/src/reception_artifact.ts

@@ -8,6 +8,42 @@ import {
 } from "./reception_artifact_contract.js";
 export * from "./reception_artifact_contract.js";
 
+/** The generated module's one JSON boundary, shared by the closure and per-unit Receptions. A
+ * foreign reference (`t.foreignRef`) carries resolver functions for in-process navigation; across
+ * hosted JSON it is its plain locator, the same `{workspace,type,id,address}` shape as any other
+ * reference, so hosted REST answers the values the app reads. Anything else carrying a function still
+ * refuses. Changing these lines changes served modules: bump both generator identities. */
+export const RECEPTION_RESULT_SERIALISER: readonly string[] = [
+  `const FOREIGN_REFERENCE_MEMBERS = "exists,id,ref,resolve,resolveResult,type,watch,workspace";`,
+  `function foreignReference(descriptors) {`,
+  `  if (Object.keys(descriptors).sort().join(",") !== FOREIGN_REFERENCE_MEMBERS) return undefined;`,
+  `  const value = key => descriptors[key].value;`,
+  `  if (["exists", "resolve", "resolveResult", "watch"].some(key => typeof value(key) !== "function")) return undefined;`,
+  `  if (["workspace", "type", "id"].some(key => typeof value(key) !== "string")) return undefined;`,
+  `  const ref = value("ref"); if (!ref || typeof ref !== "object" || Object.getPrototypeOf(ref) !== Object.prototype) return undefined;`,
+  `  const own = Object.getOwnPropertyDescriptors(ref); if (Object.keys(own).sort().join(",") !== "address,id,type,workspace" || Object.values(own).some(descriptor => descriptor.get || descriptor.set)) return undefined;`,
+  `  return ["workspace", "type", "id"].every(key => own[key].value === value(key)) ? ref : undefined;`,
+  `}`,
+  `function serialiseResult(value, depth = 0, seen = new Set()) {`,
+  `  const unavailable = () => { const error = new Error("Generated result cannot cross the hosted JSON contract"); error.code = "nomos.reception.result.unavailable"; throw error; };`,
+  `  if (depth > 64) return unavailable();`,
+  `  if (value === undefined) return { $nomos: "absent" };`,
+  `  if (value === null || typeof value === "string" || typeof value === "boolean") return value;`,
+  `  if (typeof value === "number") { if (!Number.isFinite(value)) return unavailable(); return value; }`,
+  `  if (typeof value === "bigint") return { $nomos: "integer", decimal: value.toString() };`,
+  `  if (value instanceof Uint8Array) { let binary = ""; for (const byte of value) binary += String.fromCharCode(byte); return { $nomos: "bytes", base64: btoa(binary) }; }`,
+  `  if (value instanceof Date) { if (!Number.isFinite(value.getTime())) return unavailable(); return { $nomos: "timestamp", iso: value.toISOString() }; }`,
+  `  if (typeof value !== "object" || seen.has(value)) return unavailable();`,
+  `  seen.add(value); try {`,
+  `    if (Array.isArray(value)) return value.map(item => serialiseResult(item, depth + 1, seen));`,
+  `    const prototype = Object.getPrototypeOf(value); if (prototype !== Object.prototype && prototype !== null) return unavailable();`,
+  `    const descriptors = Object.getOwnPropertyDescriptors(value); if (Object.values(descriptors).some(descriptor => descriptor.get || descriptor.set)) return unavailable();`,
+  `    const reference = foreignReference(descriptors); if (reference !== undefined) return serialiseResult(reference, depth + 1, seen);`,
+  `    const output = {}; for (const [key, descriptor] of Object.entries(descriptors)) Object.defineProperty(output, key, { value: serialiseResult(descriptor.value, depth + 1, seen), enumerable: true }); return output;`,
+  `  } finally { seen.delete(value); }`,
+  `}`,
+];
+
 export async function generateReceptionArtifact(input: ReceptionGenerationInput): Promise<ClosureReceptionArtifact> {
   const templates = await validateReceptionGenerationInput(input);
   const artifactId = await artifactIdentity(input.closure, input.generator, input.runtimeContract);
@@ -17,22 +53,7 @@ export async function generateReceptionArtifact(input: ReceptionGenerationInput)
     ...templates.map((template, index) => `const factory${index} = (() => { ${template.factorySource.replaceAll(JSON.stringify(RECEPTION_CLOSURE_TOKEN), JSON.stringify(input.closure))} return __NOMOS_RECEPTION_FACET__.${template.factory}; })();`),
     `const domains = Object.freeze(Object.assign(Object.create(null), { ${templates.map((template, index) => `${JSON.stringify(template.domain)}: factory${index}`).join(", ")} }));`,
     `const description = ${JSON.stringify({ artifactId, closure: input.closure, generator: input.generator, runtimeContract: input.runtimeContract, domains: inventory })};`,
-    `function serialiseResult(value, depth = 0, seen = new Set()) {`,
-    `  const unavailable = () => { const error = new Error("Generated result cannot cross the hosted JSON contract"); error.code = "nomos.reception.result.unavailable"; throw error; };`,
-    `  if (depth > 64) return unavailable();`,
-    `  if (value === undefined) return { $nomos: "absent" };`,
-    `  if (value === null || typeof value === "string" || typeof value === "boolean") return value;`,
-    `  if (typeof value === "number") { if (!Number.isFinite(value)) return unavailable(); return value; }`,
-    `  if (typeof value === "bigint") return { $nomos: "integer", decimal: value.toString() };`,
-    `  if (value instanceof Uint8Array) { let binary = ""; for (const byte of value) binary += String.fromCharCode(byte); return { $nomos: "bytes", base64: btoa(binary) }; }`,
-    `  if (value instanceof Date) { if (!Number.isFinite(value.getTime())) return unavailable(); return { $nomos: "timestamp", iso: value.toISOString() }; }`,
-    `  if (typeof value !== "object" || seen.has(value)) return unavailable();`,
-    `  seen.add(value); try {`,
-    `    if (Array.isArray(value)) return value.map(item => serialiseResult(item, depth + 1, seen));`,
-    `    const prototype = Object.getPrototypeOf(value); if (prototype !== Object.prototype && prototype !== null) return unavailable();`,
-    `    const output = {}; for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) { if (descriptor.get || descriptor.set) return unavailable(); Object.defineProperty(output, key, { value: serialiseResult(descriptor.value, depth + 1, seen), enumerable: true }); } return output;`,
-    `  } finally { seen.delete(value); }`,
-    `}`,
+    ...RECEPTION_RESULT_SERIALISER,
     `export default class Reception extends WorkerEntrypoint {`,
     `  describe() { return description; }`,
     `  async invoke(call, office) {`,

package/src/reception_artifact_contract.ts

@@ -1,7 +1,7 @@
 /** Derived Reception identity is independent of admitted law and request authority. */
 import { usdaString, usdaUnquote } from "./usda_text.js";
 
-export const RECEPTION_GENERATOR = "nomos-typescript-reception-v1";
+export const RECEPTION_GENERATOR = "nomos-typescript-reception-v2";
 export const RECEPTION_RUNTIME_CONTRACT = "nomos-peer-office-reception-v1";
 export const RECEPTION_TEMPLATE_FORMAT = "nomos.reception-template.v1";
 export const RECEPTION_COMPRESSED_TEMPLATE_FORMAT = "nomos.reception-template.v2";

package/src/reception_unit_artifact.ts

@@ -2,6 +2,7 @@
  * Unit associations must be authenticated upstream. A cached module receives closure context
  * only through a fresh host-verified binding; the Office still judges the requested operation. */
 import { RECEPTION_CLOSURE_TOKEN, RECEPTION_SOURCE_BYTES_LIMIT } from "./reception_artifact_contract.js";
+import { RECEPTION_RESULT_SERIALISER } from "./reception_artifact.js";
 import {
   assertUnitReceptionRecord, snapshotUnitReceptionValue, canonicalReceptionOperations, closureReceptionOperations, closureReceptionManifestIdentity,
   receptionSha256, unitReceptionArtifactIdentity, unitReceptionUnavailable, validateUnitReceptionIdentity,
@@ -40,22 +41,7 @@ export async function generateUnitReceptionArtifact(input: UnitReceptionInput):
     `description.operations = Object.freeze(description.operations.map(operation => Object.freeze(operation))); Object.freeze(description);`,
     `const operations = Object.freeze(Object.fromEntries(description.operations.map(operation => [operation.member, Object.freeze(operation)])));`,
     `function bindFactory(__nomosBoundClosure) { ${template.factorySource.replaceAll(literal, "__nomosBoundClosure")} return __NOMOS_RECEPTION_FACET__.${template.factory}; }`,
-    `function serialiseResult(value, depth = 0, seen = new Set()) {`,
-    `  const unavailable = () => { const error = new Error("Generated result cannot cross the hosted JSON contract"); error.code = "nomos.reception.result.unavailable"; throw error; };`,
-    `  if (depth > 64) return unavailable();`,
-    `  if (value === undefined) return { $nomos: "absent" };`,
-    `  if (value === null || typeof value === "string" || typeof value === "boolean") return value;`,
-    `  if (typeof value === "number") { if (!Number.isFinite(value)) return unavailable(); return value; }`,
-    `  if (typeof value === "bigint") return { $nomos: "integer", decimal: value.toString() };`,
-    `  if (value instanceof Uint8Array) { let binary = ""; for (const byte of value) binary += String.fromCharCode(byte); return { $nomos: "bytes", base64: btoa(binary) }; }`,
-    `  if (value instanceof Date) { if (!Number.isFinite(value.getTime())) return unavailable(); return { $nomos: "timestamp", iso: value.toISOString() }; }`,
-    `  if (typeof value !== "object" || seen.has(value)) return unavailable();`,
-    `  seen.add(value); try {`,
-    `    if (Array.isArray(value)) return value.map(item => serialiseResult(item, depth + 1, seen));`,
-    `    const prototype = Object.getPrototypeOf(value); if (prototype !== Object.prototype && prototype !== null) return unavailable();`,
-    `    const output = {}; for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) { if (descriptor.get || descriptor.set) return unavailable(); Object.defineProperty(output, key, { value: serialiseResult(descriptor.value, depth + 1, seen), enumerable: true }); } return output;`,
-    `  } finally { seen.delete(value); }`,
-    `}`,
+    ...RECEPTION_RESULT_SERIALISER,
     `export default class UnitReception extends WorkerEntrypoint {`,
     `  describe() { return description; }`,
     `  async invoke(call, office, binding) {`,

package/src/reception_unit_artifact_contract.ts

@@ -2,7 +2,7 @@
  * the caller must obtain this exact unit/template association from installed law. */
 import { receptionSha256, RECEPTION_RUNTIME_CONTRACT, type ReceptionOperation, type ReceptionTemplate } from "./reception_artifact_contract.js";
 export { receptionSha256, RECEPTION_RUNTIME_CONTRACT };
-export const RECEPTION_UNIT_GENERATOR = "nomos-typescript-unit-reception-v1";
+export const RECEPTION_UNIT_GENERATOR = "nomos-typescript-unit-reception-v2";
 export const UNIT_RECEPTION_ARTIFACT_FORMAT = "nomos.reception-unit-artifact.v1";
 export const CLOSURE_RECEPTION_MANIFEST_FORMAT = "nomos.reception-closure-manifest.v1";
 export const UNIT_RECEPTION_SOURCE_LIMIT = 16 * 1024 * 1024;