@githolon/dsl 0.108.6 → 0.110.0

package/src/law_source_map.ts

@@ -82,7 +82,10 @@ export class DomainSourceMap {
   private readonly texts = new Map<string, string | null>();
 
   /** `files` — the ORDERED module paths composing the domain (config order; first is the fallback anchor). */
-  constructor(private readonly files: readonly string[]) {}
+  private readonly files: readonly string[];
+  constructor(files: readonly string[]) {
+    this.files = files;
+  }
 
   private text(file: string): string | null {
     if (!this.texts.has(file)) {

package/src/law_units.ts

@@ -0,0 +1,498 @@
+// D21c — per-domain law units, authored by the compiler.
+//
+// D21 (architecture/identity_target_model.md): law is installed per domain and composed by the
+// kernel. The unit of law is one domain — its layer, its routes and the plans those routes name —
+// content-addressed. The compiler only AUTHORS units. It may preview a composition (the coverage
+// check below), but the composed stage and its projections are the kernel's to derive.
+//
+// Units are split from the package the compiler already emits, so today's package bytes and closure
+// identity do not move, and the split is the one the kernel's `DomainLawUnit::split`
+// (kernel/src/law_units.rs) makes from the same package, so both hash identically. The format is
+// specified in architecture/law_units_format.md.
+
+import { createHash } from "node:crypto";
+
+/** One authenticated file of a law closure, at its package logical path. */
+export interface LawUnitInputAsset {
+  readonly logicalPath: string;
+  readonly sha256: string;
+  readonly bytes: Uint8Array;
+}
+
+/** One route of the package route table: an execution selector naming one plan by hash. */
+export interface LawUnitRoute {
+  readonly selector: string;
+  readonly planSha256: string;
+}
+
+export type LawUnitKind = "domain" | "framework" | "composition";
+
+export interface LawUnitAsset {
+  readonly logicalPath: string;
+  readonly sha256: string;
+  readonly bytes: Uint8Array;
+}
+
+export interface LawUnit {
+  /** `framework`, `composition` or `domain:<d>` — kind-qualified, because a domain may itself be
+   * named like a reserved word or begin with `__`. */
+  readonly key: string;
+  readonly kind: LawUnitKind;
+  /** The domain, for a domain unit. */
+  readonly domain?: string;
+  /** sha256 over the unit's tagged, sorted inventory and route pairs (see `lawUnitHash`). */
+  readonly hash: string;
+  /** The unit's own routes, byte-ordered by selector. Typed pairs, not a file: the kernel's composer
+   * synthesizes the one `runtime/routes.usda` from the union of every installed unit's routes. */
+  readonly routes: readonly LawUnitRoute[];
+  /** Every file of the unit at its package logical path, byte-ordered. */
+  readonly assets: readonly LawUnitAsset[];
+  /** `unit.usda`: the unit's manifest (key, hash, inventory, routes). A carrier, never itself hashed. */
+  readonly manifest: Uint8Array;
+}
+
+export const FRAMEWORK_UNIT = "framework";
+export const COMPOSITION_UNIT = "composition";
+export const domainUnitKey = (domain: string): string => `domain:${domain}`;
+
+export const LAW_UNIT_HASH_TAG = "nomos-law-unit-v1";
+export const LAW_UNIT_FORMAT = "nomos.law-unit.v1";
+export const LAW_UNIT_MANIFEST = "unit.usda";
+
+/** Files of the package that the kernel synthesizes or derives from the installed units. */
+const DERIVED_LOGICAL_PATHS = new Set([
+  "root.usda",
+  "runtime/routes.usda",
+  "runtime/composed-law.usdc",
+  "runtime/read-projection.usda",
+  "runtime/read-projection.usdc",
+  "runtime/command-projection.usda",
+  "runtime/command-projection.usdc",
+]);
+
+/** Byte order on ASCII strings — the order Rust's `BTreeMap<String, _>` gives. */
+const byteOrder = (left: string, right: string): number =>
+  left < right ? -1 : left > right ? 1 : 0;
+
+const sha256Hex = (bytes: Uint8Array | string): string =>
+  createHash("sha256").update(bytes).digest("hex");
+
+const utf8 = (text: string): Uint8Array => new TextEncoder().encode(text);
+
+const DOMAIN_LAYER = /^domains\/([^/]+)\.usda$/;
+const PLAN_FILE = /^runtime\/plans\/([0-9a-f]{64})\.(mjs|usda)$/;
+const BASE_FILE = /^runtime\/bases\/([0-9a-f]{64})\.(mjs|usda)$/;
+
+export const isDerivedLawPath = (logicalPath: string): boolean =>
+  DERIVED_LOGICAL_PATHS.has(logicalPath);
+
+/** What a domain layer declares, for route ownership: its aggregates' `nomos:wireType` and
+ * `nomos:label` (prims `/Nomos/Domains/<d>/Aggregates/<a>`) and its invariants' `nomos:label`
+ * (prims `/Nomos/Domains/<d>/Invariants/<n>`) — the same prims the kernel's split reads. */
+export interface DomainDeclarations {
+  readonly aggregateWireTypes: ReadonlySet<string>;
+  readonly aggregateLabels: ReadonlySet<string>;
+  readonly invariantLabels: ReadonlySet<string>;
+}
+
+/** Scan a compiler-authored domain layer for the declarations route ownership reads. The layer is
+ * emitted one opinion per line with each prim's braces on their own lines; a line ending `= {`
+ * opens a dictionary value (closed by its own `}`), which is not a prim. */
+export function scanDomainDeclarations(usda: string): DomainDeclarations {
+  const aggregateWireTypes = new Set<string>();
+  const aggregateLabels = new Set<string>();
+  const invariantLabels = new Set<string>();
+  const frames: Array<string | null> = [];
+  let pendingPrim: string | null = null;
+  let body = false;
+  for (const raw of usda.split("\n")) {
+    const line = raw.trim();
+    const prim = /^(?:def|over|class)\b[^=]*?"([^"]+)"\s*(?:\(\s*)?$/.exec(line);
+    if (!body) {
+      // Skip the layer header `( ... )`: the body starts at the first prim.
+      if (prim === null) continue;
+      body = true;
+    }
+    if (prim !== null) {
+      pendingPrim = prim[1]!;
+      continue;
+    }
+    if (line === "{") {
+      frames.push(pendingPrim);
+      pendingPrim = null;
+      continue;
+    }
+    if (line === "}") {
+      frames.pop();
+      continue;
+    }
+    if (line.endsWith("= {")) {
+      frames.push(null);
+      continue;
+    }
+    const property = /\bnomos:(wireType|label) = ("(?:[^"\\]|\\.)*")$/.exec(line);
+    if (property === null) continue;
+    if (frames.includes(null)) continue;
+    const at = frames as string[];
+    if (at.length !== 5 || at[0] !== "Nomos" || at[1] !== "Domains") continue;
+    const value = JSON.parse(property[2]!) as string;
+    if (at[3] === "Aggregates") {
+      (property[1] === "wireType" ? aggregateWireTypes : aggregateLabels).add(value);
+    } else if (at[3] === "Invariants" && property[1] === "label") {
+      invariantLabels.add(value);
+    }
+  }
+  return { aggregateWireTypes, aggregateLabels, invariantLabels };
+}
+
+/** The unit key that owns a route. A domain's own plan and offers belong to it. A report on one
+ * subject belongs to the one domain that declares that subject: an aggregate (by `nomos:wireType`,
+ * else by `nomos:label`) for `aggregateInvariant` / `combine` / `derive`, an invariant (by
+ * `nomos:label`) for `workspaceInvariant` / `workspaceInvariantReads`. Everything else — `describe`,
+ * `report:report:*`, `report:invariant:*`, and any subject declared by no domain or by several —
+ * spans the composed set and belongs to the composition. */
+export function routeOwner(
+  selector: string,
+  declarations: ReadonlyMap<string, DomainDeclarations>
+): string {
+  // Exactly the kernel's `selector_domain`: everything after `plan:domain:`, or the text between
+  // `plan:offer:` and the next `:`.
+  const domainPlan = /^plan:domain:(.*)$/s.exec(selector);
+  if (domainPlan !== null) return domainUnitKey(domainPlan[1]!);
+  const offer = /^plan:offer:([^:]*):/.exec(selector);
+  if (offer !== null) return domainUnitKey(offer[1]!);
+  const declaring = (
+    pick: (d: DomainDeclarations) => ReadonlySet<string>,
+    subject: string
+  ): string[] =>
+    [...declarations].filter(([, d]) => pick(d).has(subject)).map(([domain]) => domain);
+  const aggregate = /^report:(?:aggregateInvariant|combine|derive):(.*)$/s.exec(selector);
+  if (aggregate !== null) {
+    const subject = aggregate[1]!;
+    let owners = declaring((d) => d.aggregateWireTypes, subject);
+    if (owners.length === 0) owners = declaring((d) => d.aggregateLabels, subject);
+    return owners.length === 1 ? domainUnitKey(owners[0]!) : COMPOSITION_UNIT;
+  }
+  const invariant = /^report:(?:workspaceInvariant|workspaceInvariantReads):(.*)$/s.exec(selector);
+  if (invariant !== null) {
+    const owners = declaring((d) => d.invariantLabels, invariant[1]!);
+    return owners.length === 1 ? domainUnitKey(owners[0]!) : COMPOSITION_UNIT;
+  }
+  return COMPOSITION_UNIT;
+}
+
+/** The directory a unit is written to: its key with `:` made path-portable, then its hash. */
+export const lawUnitDirectoryName = (unit: Pick<LawUnit, "key" | "hash">): string =>
+  `${unit.key.replace(":", "-")}-${unit.hash}`;
+
+/** The package's `runtime/routes.usda`: every route, one prim each, in selector collation order. Also
+ * rebuilt from the emitted law units by their coverage preview below, which proves the units
+ * carry exactly the package's routes. */
+export function packageRoutesLayerUsda(routes: readonly LawUnitRoute[]): string {
+  const routeOpinions: string[] = [
+    "#usda 1.0",
+    "(",
+    "    customLayerData = {",
+    '        string "nomos:format" = "nomos.law-layer.v3"',
+    '        string "nomos:logicalPath" = "runtime/routes"',
+    "    }",
+    ")",
+    "",
+    'def Scope "__NomosRuntime_7e9c"',
+    "{",
+    '    custom string nomos:kind = "runtime"',
+    '    custom string nomos:format = "nomos.openusd-plan-metadata.v3"',
+    "",
+    '    def Scope "Routes"',
+    "    {",
+  ];
+  [...routes]
+    .sort((left, right) => left.selector.localeCompare(right.selector))
+    .forEach((route, index) => {
+      routeOpinions.push(
+        `        def Scope "r${String(index).padStart(6, "0")}"`,
+        "        {",
+        `            custom string nomos:selector = ${JSON.stringify(
+          route.selector
+        )}`,
+        `            custom string nomos:plan = "${route.planSha256}"`,
+        "        }",
+        ""
+      );
+    });
+  if (routeOpinions[routeOpinions.length - 1] === "") routeOpinions.pop();
+  routeOpinions.push("    }", "}", "");
+  return routeOpinions.join("\n");
+}
+
+/** Unit identity — agreed with the kernel's `DomainLawUnit` (kernel/src/law_units.rs):
+ * sha256("nomos-law-unit-v1\0" key "\0" "assets\0" (logicalPath "\0" sha256 "\0")*
+ *        "routes\0" (selector "\0" planSha256 "\0")*), assets by logical path and routes by
+ * selector, each in byte order, digests lowercase hex. */
+export function lawUnitHash(
+  key: string,
+  inventory: readonly { readonly logicalPath: string; readonly sha256: string }[],
+  routes: readonly LawUnitRoute[]
+): string {
+  const hash = createHash("sha256");
+  hash.update(`${LAW_UNIT_HASH_TAG}\0`);
+  hash.update(key);
+  hash.update("\0");
+  hash.update("assets\0");
+  for (const asset of [...inventory].sort((l, r) => byteOrder(l.logicalPath, r.logicalPath))) {
+    hash.update(asset.logicalPath);
+    hash.update("\0");
+    hash.update(asset.sha256);
+    hash.update("\0");
+  }
+  hash.update("routes\0");
+  for (const route of [...routes].sort((l, r) => byteOrder(l.selector, r.selector))) {
+    hash.update(route.selector);
+    hash.update("\0");
+    hash.update(route.planSha256);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+
+function unitManifestUsda(unit: Omit<LawUnit, "manifest">): string {
+  return [
+    "#usda 1.0",
+    "(",
+    '    defaultPrim = "__NomosLawUnit_7e9c"',
+    "    customLayerData = {",
+    `        string "nomos:format" = "${LAW_UNIT_FORMAT}"`,
+    "    }",
+    ")",
+    "",
+    'def NomosLawUnit "__NomosLawUnit_7e9c"',
+    "{",
+    `    custom string nomos:unit = ${JSON.stringify(unit.key)}`,
+    `    custom token nomos:unitKind = "${unit.kind}"`,
+    ...(unit.domain === undefined
+      ? []
+      : [`    custom string nomos:domain = ${JSON.stringify(unit.domain)}`]),
+    `    custom string nomos:unitHash = "${unit.hash}"`,
+    "",
+    '    def Scope "Assets"',
+    "    {",
+    ...unit.assets.flatMap((asset) => [
+      `        def NomosLawAsset "a_${sha256Hex(asset.logicalPath)}"`,
+      "        {",
+      `            custom string nomos:logicalPath = ${JSON.stringify(asset.logicalPath)}`,
+      `            custom string nomos:sha256 = "${asset.sha256}"`,
+      "        }",
+    ]),
+    "    }",
+    "",
+    '    def Scope "Routes"',
+    "    {",
+    ...unit.routes.flatMap((route) => [
+      `        def NomosLawRoute "s_${sha256Hex(route.selector)}"`,
+      "        {",
+      `            custom string nomos:selector = ${JSON.stringify(route.selector)}`,
+      `            custom string nomos:plan = "${route.planSha256}"`,
+      "        }",
+    ]),
+    "    }",
+    "}",
+    "",
+  ].join("\n");
+}
+
+/** Split an emitted package into its law units: one per domain layer, the framework unit
+ * (`framework.usda`, byte-identical in every package) and the composition unit (`package.usda`, the
+ * package-specific runtime bases, and the routes that span domains). A plan travels in every unit
+ * whose routes name it: units are content-addressed, so a shared plan is one blob in git. */
+export function splitLawUnits(
+  closureAssets: readonly LawUnitInputAsset[],
+  routes: readonly LawUnitRoute[]
+): LawUnit[] {
+  const fail = (message: string): never => {
+    throw new Error(`law units: ${message}`);
+  };
+  const byPath = new Map<string, LawUnitInputAsset>();
+  for (const asset of closureAssets) {
+    if (byPath.has(asset.logicalPath)) fail(`duplicate package path '${asset.logicalPath}'`);
+    if (sha256Hex(asset.bytes) !== asset.sha256) {
+      fail(`'${asset.logicalPath}' bytes do not match its declared sha256`);
+    }
+    byPath.set(asset.logicalPath, asset);
+  }
+  interface Member {
+    kind: LawUnitKind;
+    domain?: string;
+    paths: Set<string>;
+    routes: LawUnitRoute[];
+  }
+  const members = new Map<string, Member>();
+  const unit = (key: string, kind: LawUnitKind, domain?: string): Member => {
+    let entry = members.get(key);
+    if (entry === undefined) {
+      entry = { kind, ...(domain === undefined ? {} : { domain }), paths: new Set(), routes: [] };
+      members.set(key, entry);
+    }
+    return entry;
+  };
+  unit(FRAMEWORK_UNIT, "framework");
+  unit(COMPOSITION_UNIT, "composition");
+  const declarations = new Map<string, DomainDeclarations>();
+  const planHashes = new Set<string>();
+  for (const [logicalPath, asset] of byPath) {
+    if (DERIVED_LOGICAL_PATHS.has(logicalPath)) continue;
+    const domain = DOMAIN_LAYER.exec(logicalPath);
+    if (domain !== null) {
+      const name = domain[1]!;
+      unit(domainUnitKey(name), "domain", name).paths.add(logicalPath);
+      declarations.set(name, scanDomainDeclarations(new TextDecoder().decode(asset.bytes)));
+      continue;
+    }
+    const plan = PLAN_FILE.exec(logicalPath);
+    if (plan !== null) {
+      planHashes.add(plan[1]!);
+      continue;
+    }
+    if (logicalPath === "framework.usda") {
+      unit(FRAMEWORK_UNIT, "framework").paths.add(logicalPath);
+      continue;
+    }
+    if (logicalPath === "package.usda" || BASE_FILE.test(logicalPath)) {
+      unit(COMPOSITION_UNIT, "composition").paths.add(logicalPath);
+      continue;
+    }
+    fail(`package file '${logicalPath}' is neither unit law nor a known derived projection`);
+  }
+  const seenSelectors = new Set<string>();
+  const referencedPlans = new Set<string>();
+  for (const route of routes) {
+    if (seenSelectors.has(route.selector)) fail(`selector '${route.selector}' is routed twice`);
+    seenSelectors.add(route.selector);
+    const owner = routeOwner(route.selector, declarations);
+    const entry = members.get(owner);
+    if (entry === undefined) {
+      return fail(`route '${route.selector}' names '${owner}', which has no domain layer`);
+    }
+    for (const extension of ["mjs", "usda"]) {
+      const planPath = `runtime/plans/${route.planSha256}.${extension}`;
+      if (!byPath.has(planPath)) fail(`route '${route.selector}' names missing '${planPath}'`);
+      entry.paths.add(planPath);
+    }
+    entry.routes.push(route);
+    referencedPlans.add(route.planSha256);
+  }
+  for (const plan of planHashes) {
+    if (!referencedPlans.has(plan)) fail(`plan '${plan}' is in the package but no route names it`);
+  }
+  return [...members]
+    .sort(([left], [right]) => byteOrder(left, right))
+    .map(([key, entry]) => {
+      const unitRoutes = [...entry.routes].sort((l, r) => byteOrder(l.selector, r.selector));
+      const assets: LawUnitAsset[] = [...entry.paths].sort(byteOrder).map((logicalPath) => {
+        const asset = byPath.get(logicalPath)!;
+        return { logicalPath, sha256: asset.sha256, bytes: asset.bytes };
+      });
+      const withoutManifest = {
+        key,
+        kind: entry.kind,
+        ...(entry.domain === undefined ? {} : { domain: entry.domain }),
+        hash: lawUnitHash(key, assets, unitRoutes),
+        routes: unitRoutes,
+        assets,
+      };
+      return { ...withoutManifest, manifest: utf8(unitManifestUsda(withoutManifest)) };
+    });
+}
+
+/** The compiler's composition PREVIEW: prove that the units cover exactly the package's non-derived
+ * law. Every domain layer, framework layer, base and plan of the package is in some unit and nothing
+ * else is; a path held by two units is a plan, byte-identical in both; every route is held by exactly
+ * one unit, its owner, and names a plan that unit carries; every plan a unit carries is named by one
+ * of its routes; and the union of unit routes rebuilds the package's own `runtime/routes.usda` byte
+ * for byte. Throws on the first discrepancy. A check only — never a shipped composition. */
+export function assertLawUnitsCoverPackage(
+  units: readonly LawUnit[],
+  closureAssets: readonly LawUnitInputAsset[],
+  routes: readonly LawUnitRoute[]
+): void {
+  const fail = (message: string): never => {
+    throw new Error(`law unit coverage: ${message}`);
+  };
+  const declarations = new Map<string, DomainDeclarations>();
+  for (const asset of closureAssets) {
+    const domain = DOMAIN_LAYER.exec(asset.logicalPath);
+    if (domain !== null) {
+      declarations.set(domain[1]!, scanDomainDeclarations(new TextDecoder().decode(asset.bytes)));
+    }
+  }
+  const keys = new Set<string>();
+  const union = new Map<string, string>();
+  const unionRoutes = new Map<string, string>();
+  for (const unit of units) {
+    if (keys.has(unit.key)) fail(`unit '${unit.key}' appears twice`);
+    keys.add(unit.key);
+    if (lawUnitHash(unit.key, unit.assets, unit.routes) !== unit.hash) {
+      fail(`unit '${unit.key}' hash does not match its inventory and routes`);
+    }
+    const own = new Map(unit.assets.map((asset) => [asset.logicalPath, asset] as const));
+    if (own.size !== unit.assets.length) fail(`unit '${unit.key}' lists a path twice`);
+    const namedPlans = new Set<string>();
+    for (const route of unit.routes) {
+      if (unionRoutes.has(route.selector)) fail(`selector '${route.selector}' is held by two units`);
+      if (routeOwner(route.selector, declarations) !== unit.key) {
+        fail(`unit '${unit.key}' holds route '${route.selector}', which it does not own`);
+      }
+      unionRoutes.set(route.selector, route.planSha256);
+      for (const extension of ["mjs", "usda"]) {
+        if (!own.has(`runtime/plans/${route.planSha256}.${extension}`)) {
+          fail(`unit '${unit.key}' route '${route.selector}' names a plan the unit does not carry`);
+        }
+      }
+      namedPlans.add(route.planSha256);
+    }
+    for (const asset of unit.assets) {
+      if (sha256Hex(asset.bytes) !== asset.sha256) {
+        fail(`unit '${unit.key}' '${asset.logicalPath}' bytes do not match`);
+      }
+      const plan = PLAN_FILE.exec(asset.logicalPath);
+      if (plan !== null && !namedPlans.has(plan[1]!)) {
+        fail(`unit '${unit.key}' carries plan '${plan[1]}' that none of its routes name`);
+      }
+      const prior = union.get(asset.logicalPath);
+      if (prior !== undefined && prior !== asset.sha256) fail(`'${asset.logicalPath}' differs between units`);
+      if (prior !== undefined && plan === null) {
+        fail(`'${asset.logicalPath}' is held by two units (only plans may be shared)`);
+      }
+      union.set(asset.logicalPath, asset.sha256);
+    }
+  }
+  const expected = new Map(
+    closureAssets
+      .filter((asset) => !DERIVED_LOGICAL_PATHS.has(asset.logicalPath))
+      .map((asset) => [asset.logicalPath, asset.sha256] as const)
+  );
+  for (const [logicalPath, sha256] of expected) {
+    const held = union.get(logicalPath);
+    if (held === undefined) fail(`package file '${logicalPath}' is in no unit`);
+    if (held !== sha256) fail(`package file '${logicalPath}' differs in its unit`);
+  }
+  for (const logicalPath of union.keys()) {
+    if (!expected.has(logicalPath)) fail(`unit file '${logicalPath}' is not package law`);
+  }
+  if (unionRoutes.size !== routes.length) {
+    fail(`units hold ${unionRoutes.size} routes; the package has ${routes.length}`);
+  }
+  for (const route of routes) {
+    if (unionRoutes.get(route.selector) !== route.planSha256) {
+      fail(`route '${route.selector}' is not held as the package routes it`);
+    }
+  }
+  const packageRoutes = closureAssets.find((asset) => asset.logicalPath === "runtime/routes.usda");
+  if (packageRoutes !== undefined) {
+    const rebuilt = packageRoutesLayerUsda(
+      [...unionRoutes].map(([selector, planSha256]) => ({ selector, planSha256 }))
+    );
+    if (sha256Hex(rebuilt) !== packageRoutes.sha256) {
+      fail("the units' routes do not rebuild the package's runtime/routes.usda");
+    }
+  }
+}

package/src/law_value_type.ts

@@ -1,6 +1,6 @@
 import type { z } from "zod";
 import { enumTypeNameOf } from "./enum_type.js";
-import { isGitObjectIdSchema, isSha256DigestSchema } from "./fields.js";
+import { isGitObjectIdSchema, isSha256DigestSchema, type GeometryKind } from "./fields.js";
 import { recipientMetaOf } from "./recipient.js";
 import {
   NOMOS_UNIT_BRAND,
@@ -45,7 +45,8 @@ export interface LawValueMember {
  */
 export type LawValueSemantic =
   | { readonly kind: "sha256-digest" | "git-object-id" }
-  | { readonly kind: "branded-id" | "unit" | "value-object"; readonly name: string }
+  | { readonly kind: "branded-id" | "unit"; readonly name: string }
+  | { readonly kind: "value-object"; readonly name: string; readonly geometry?: GeometryKind }
   | { readonly kind: "recipient"; readonly subject: "User" }
   | {
       readonly kind: "id-reference" | "address-reference";
@@ -234,7 +235,10 @@ function semanticOf(schema: z.ZodTypeAny): LawValueSemantic | undefined {
   const unit = (schema as unknown as Record<symbol, unknown>)[NOMOS_UNIT_BRAND];
   if (typeof unit === "string") return { kind: "unit", name: unit };
   const valueObject = voMetaOf(schema);
-  if (valueObject !== undefined) return { kind: "value-object", name: valueObject.name };
+  if (valueObject !== undefined) return {
+    kind: "value-object", name: valueObject.name,
+    ...(valueObject.geometry === undefined ? {} : { geometry: valueObject.geometry }),
+  };
   return undefined;
 }