@githolon/dsl 0.13.0 → 0.15.0

package/src/usd_layers.ts

@@ -143,6 +143,40 @@ function sortedSchema(schema: WireSchema): WireSchema {
   return out;
 }
 
+function domainLayerAttrLines(domain: string, layer: UsdLayer, indent: string): string[] {
+  return [
+    `${indent}custom string nomos:kind = "domain"`,
+    `${indent}custom string nomos:domain = ${usdaString(domain)}`,
+    ...(layer.nomosIdentityManifest !== undefined
+      ? [`${indent}custom string nomos:identityManifestHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosIdentityManifest)))}`]
+      : []),
+    ...(layer.nomosReadProjection !== undefined
+      ? [`${indent}custom string nomos:readProjectionHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosReadProjection)))}`]
+      : []),
+    ...(layer.nomosStableIds !== undefined
+      ? [`${indent}custom string nomos:stableIdsHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosStableIds)))}`]
+      : []),
+    ...(layer.nomosReadGate !== undefined
+      ? [`${indent}custom string nomos:readGateHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosReadGate)))}`]
+      : []),
+    ...(layer.nomosReadVisibility !== undefined
+      ? [`${indent}custom string nomos:readVisibilityHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosReadVisibility)))}`]
+      : []),
+    ...(layer.nomosEncryption !== undefined
+      ? [`${indent}custom string nomos:encryptionHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosEncryption)))}`]
+      : []),
+    ...(layer.nomosRelations !== undefined
+      ? [`${indent}custom string nomos:relationsHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosRelations)))}`]
+      : []),
+    ...(layer.nomosRelationGate !== undefined
+      ? [`${indent}custom string nomos:relationGateHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosRelationGate)))}`]
+      : []),
+    ...(layer.nomosAttestationGate !== undefined
+      ? [`${indent}custom string nomos:attestationGateHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosAttestationGate)))}`]
+      : []),
+  ];
+}
+
 // ── per-module layer emission ────────────────────────────────────────────────────────
 
 /** One authored module of a domain's ordered module list (weak → strong). */
@@ -349,31 +383,9 @@ export function usdaLayerText(
     `{`,
     `    def Scope ${usdaString(primName(domain))}`,
     `    {`,
-    `        custom string nomos:kind = "domain"`,
-    `        custom string nomos:domain = ${usdaString(domain)}`,
-    // STABLE IDS + the captured-read gate (#58): layer-level law keys, hex-carried
+    // Stable ids + holon-owned manifests: layer-level law keys, hex-carried
     // so the .usda round-trips byte-faithfully to the IR layer.
-    ...(layer.nomosStableIds !== undefined
-      ? [`        custom string nomos:stableIdsHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosStableIds)))}`]
-      : []),
-    ...(layer.nomosReadGate !== undefined
-      ? [`        custom string nomos:readGateHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosReadGate)))}`]
-      : []),
-    ...(layer.nomosReadVisibility !== undefined
-      ? [`        custom string nomos:readVisibilityHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosReadVisibility)))}`]
-      : []),
-    ...(layer.nomosEncryption !== undefined
-      ? [`        custom string nomos:encryptionHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosEncryption)))}`]
-      : []),
-    ...(layer.nomosRelations !== undefined
-      ? [`        custom string nomos:relationsHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosRelations)))}`]
-      : []),
-    ...(layer.nomosRelationGate !== undefined
-      ? [`        custom string nomos:relationGateHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosRelationGate)))}`]
-      : []),
-    ...(layer.nomosAttestationGate !== undefined
-      ? [`        custom string nomos:attestationGateHex = ${usdaString(hexUtf8(JSON.stringify(layer.nomosAttestationGate)))}`]
-      : []),
+    ...domainLayerAttrLines(domain, layer, "        "),
     ``,
     ...body,
     `    }`,
@@ -388,8 +400,30 @@ export function usdaLayerText(
  * list is STRONGEST-FIRST, so the list is emitted REVERSED. Same monoid, opposite
  * notation — the reversal IS the correspondence, recorded in the doc string.
  */
-export function layeredRootUsda(sublayerRelPathsWeakToStrong: readonly string[]): string {
+export function layeredRootUsda(
+  sublayerRelPathsWeakToStrong: readonly string[],
+  composed?: UsdDocument,
+): string {
   const strongestFirst = [...sublayerRelPathsWeakToStrong].reverse();
+  const composedDomainOpinions =
+    composed === undefined || composed.layers.length === 0
+      ? []
+      : [
+          ``,
+          `over "Nomos"`,
+          `{`,
+          ...composed.layers.flatMap((layer) => {
+            const domain = layer.path.slice(layer.path.lastIndexOf("/") + 1);
+            return [
+              `    over ${usdaString(primName(domain))}`,
+              `    {`,
+              ...domainLayerAttrLines(domain, layer, "        "),
+              `    }`,
+            ];
+          }),
+          `}`,
+          ``,
+        ];
   return [
     `#usda 1.0`,
     `(`,
@@ -406,6 +440,7 @@ export function layeredRootUsda(sublayerRelPathsWeakToStrong: readonly string[])
     ),
     `    ]`,
     `)`,
+    ...composedDomainOpinions,
     ``,
   ].join("\n");
 }
@@ -461,6 +496,97 @@ function foldById<T extends { readonly id: string }>(
   return [...byId.keys()].sort().map((id) => byId.get(id)!);
 }
 
+function foldByKey<T>(
+  lists: readonly (readonly T[] | undefined)[],
+  keyOf: (item: T) => string,
+): T[] | undefined {
+  const byKey = new Map<string, T>();
+  for (const list of lists) for (const item of list ?? []) byKey.set(keyOf(item), item);
+  if (byKey.size === 0) return undefined;
+  return [...byKey.keys()].sort().map((key) => byKey.get(key)!);
+}
+
+function foldRecord<T>(
+  records: readonly (Readonly<Record<string, T>> | undefined)[],
+): Record<string, T> | undefined {
+  const byKey = new Map<string, T>();
+  for (const record of records) {
+    if (record === undefined) continue;
+    for (const [key, value] of Object.entries(record)) byKey.set(key, value);
+  }
+  if (byKey.size === 0) return undefined;
+  const out: Record<string, T> = {};
+  for (const key of [...byKey.keys()].sort()) out[key] = byKey.get(key)!;
+  return out;
+}
+
+function foldIdentityManifest(
+  stack: readonly UsdLayer[],
+  stableIds: UsdLayer["nomosStableIds"],
+): UsdLayer["nomosIdentityManifest"] {
+  const manifests = stack
+    .map((l) => l.nomosIdentityManifest)
+    .filter((m): m is NonNullable<UsdLayer["nomosIdentityManifest"]> => m !== undefined);
+  if (manifests.length === 0) return undefined;
+  const domain = manifests[manifests.length - 1]!.domain;
+  const workspaceInvariants = foldById(manifests.map((m) => m.workspaceInvariants));
+  const queries = foldById(manifests.map((m) => m.queries));
+  const counts = foldById(manifests.map((m) => m.counts));
+  const spatials = foldById(manifests.map((m) => m.spatials));
+  const sums = foldById(manifests.map((m) => m.sums));
+  const deriveds = foldById(manifests.map((m) => m.deriveds));
+  const combineds = foldById(manifests.map((m) => m.combineds));
+  const mins = foldById(manifests.map((m) => m.mins));
+  const maxes = foldById(manifests.map((m) => m.maxes));
+  const orderedReads = foldById(manifests.map((m) => m.orderedReads));
+  const workspaceTypes = foldById(manifests.map((m) => m.workspaceTypes));
+  const homes = foldRecord(manifests.map((m) => m.homes));
+  const routes = foldByKey(manifests.map((m) => m.routes), (r) => r.directive);
+  return {
+    domain,
+    aggregates: foldById(manifests.map((m) => m.aggregates)) ?? [],
+    directives: foldById(manifests.map((m) => m.directives)) ?? [],
+    ...(stableIds !== undefined ? { stableIds } : {}),
+    ...(workspaceInvariants !== undefined ? { workspaceInvariants } : {}),
+    ...(queries !== undefined ? { queries } : {}),
+    ...(counts !== undefined ? { counts } : {}),
+    ...(spatials !== undefined ? { spatials } : {}),
+    ...(sums !== undefined ? { sums } : {}),
+    ...(deriveds !== undefined ? { deriveds } : {}),
+    ...(combineds !== undefined ? { combineds } : {}),
+    ...(mins !== undefined ? { mins } : {}),
+    ...(maxes !== undefined ? { maxes } : {}),
+    ...(orderedReads !== undefined ? { orderedReads } : {}),
+    ...(workspaceTypes !== undefined ? { workspaceTypes } : {}),
+    ...(homes !== undefined ? { homes } : {}),
+    ...(routes !== undefined ? { routes } : {}),
+  };
+}
+
+function foldReadProjection(stack: readonly UsdLayer[]): UsdLayer["nomosReadProjection"] {
+  const projections = stack
+    .map((l) => l.nomosReadProjection)
+    .filter((p): p is NonNullable<UsdLayer["nomosReadProjection"]> => p !== undefined);
+  if (projections.length === 0) return undefined;
+  const aggregateFieldKinds = foldRecord(projections.map((p) => p.aggregateFieldKinds)) ?? {};
+  const sums = foldById(projections.map((p) => p.sums));
+  const mins = foldById(projections.map((p) => p.mins));
+  const maxes = foldById(projections.map((p) => p.maxes));
+  const orderedReads = foldById(projections.map((p) => p.orderedReads));
+  return {
+    aggregateFieldKinds,
+    queries: foldById(projections.map((p) => p.queries)) ?? [],
+    counts: foldById(projections.map((p) => p.counts)) ?? [],
+    spatials: foldById(projections.map((p) => p.spatials)) ?? [],
+    deriveds: foldById(projections.map((p) => p.deriveds)) ?? [],
+    combineds: foldById(projections.map((p) => p.combineds)) ?? [],
+    ...(sums !== undefined ? { sums } : {}),
+    ...(mins !== undefined ? { mins } : {}),
+    ...(maxes !== undefined ? { maxes } : {}),
+    ...(orderedReads !== undefined ? { orderedReads } : {}),
+  };
+}
+
 /**
  * THE ORDERED OPINION-MAP FOLD: flatten module layers (weak → strong within each
  * stage path) into the effective single-layer-per-domain document. Strongest
@@ -509,6 +635,8 @@ export function flattenLayeredUsd(layers: readonly UsdLayer[]): UsdDocument {
         stableIds = { v: 1, domain: domainSid, aggregates };
       }
     }
+    const identityManifest = foldIdentityManifest(stack, stableIds);
+    const readProjection = foldReadProjection(stack);
     // The captured-read gate (#58): queries + per-directive read sets merged
     // later-wins, SORTED keys (matching the composed emission).
     let readGate: UsdLayer["nomosReadGate"];
@@ -606,6 +734,8 @@ export function flattenLayeredUsd(layers: readonly UsdLayer[]): UsdDocument {
     return {
       path,
       prims: [...prims.keys()].sort().map((p) => prims.get(p)!),
+      ...(identityManifest !== undefined ? { nomosIdentityManifest: identityManifest } : {}),
+      ...(readProjection !== undefined ? { nomosReadProjection: readProjection } : {}),
       ...(queries !== undefined ? { queries } : {}),
       ...(deriveds !== undefined ? { deriveds } : {}),
       ...(combineds !== undefined ? { combineds } : {}),
@@ -733,6 +863,8 @@ function attrStringArray(prim: ParsedPrim, name: string): string[] {
 export function parseUsdaDocument(text: string): UsdDocument {
   const prims = parseUsdaPrims(text);
   const domainByScope = new Map<string, string>();
+  const identityManifestByDomain = new Map<string, UsdLayer["nomosIdentityManifest"]>();
+  const readProjectionByDomain = new Map<string, UsdLayer["nomosReadProjection"]>();
   const stableIdsByDomain = new Map<string, UsdLayer["nomosStableIds"]>();
   const readGateByDomain = new Map<string, UsdLayer["nomosReadGate"]>();
   const readVisibilityByDomain = new Map<string, UsdLayer["nomosReadVisibility"]>();
@@ -744,7 +876,15 @@ export function parseUsdaDocument(text: string): UsdDocument {
     if (p.attrs.get("nomos:kind") === "domain") {
       const domain = attrString(p, "nomos:domain");
       domainByScope.set(p.path, domain);
-      // STABLE IDS + the captured-read gate (#58): the hex-carried layer-level keys.
+      // Holon-owned manifests + gates: the hex-carried layer-level law keys.
+      const idHex = p.attrs.get("nomos:identityManifestHex");
+      if (typeof idHex === "string") {
+        identityManifestByDomain.set(domain, JSON.parse(unhexUtf8(idHex)) as UsdLayer["nomosIdentityManifest"]);
+      }
+      const rpHex = p.attrs.get("nomos:readProjectionHex");
+      if (typeof rpHex === "string") {
+        readProjectionByDomain.set(domain, JSON.parse(unhexUtf8(rpHex)) as UsdLayer["nomosReadProjection"]);
+      }
       const sidHex = p.attrs.get("nomos:stableIdsHex");
       if (typeof sidHex === "string") {
         stableIdsByDomain.set(domain, JSON.parse(unhexUtf8(sidHex)) as UsdLayer["nomosStableIds"]);
@@ -865,6 +1005,8 @@ export function parseUsdaDocument(text: string): UsdDocument {
   const layers: UsdLayer[] = [...buckets.keys()]
     .map((domain) => {
       const b = buckets.get(domain)!;
+      const identity = identityManifestByDomain.get(domain);
+      const readProjection = readProjectionByDomain.get(domain);
       const sids = stableIdsByDomain.get(domain);
       const rg = readGateByDomain.get(domain);
       const rv = readVisibilityByDomain.get(domain);
@@ -875,6 +1017,8 @@ export function parseUsdaDocument(text: string): UsdDocument {
       return {
         path: `/Nomos/${domain}`,
         prims: [...b.prims].sort(byPath),
+        ...(identity !== undefined ? { nomosIdentityManifest: identity } : {}),
+        ...(readProjection !== undefined ? { nomosReadProjection: readProjection } : {}),
         ...(b.queries.length > 0 ? { queries: [...b.queries].sort(byId) } : {}),
         ...(b.deriveds.length > 0 ? { deriveds: [...b.deriveds].sort(byId) } : {}),
         ...(b.combineds.length > 0 ? { combineds: [...b.combineds].sort(byId) } : {}),

package/src/workspace_sharding.ts

@@ -10,7 +10,7 @@
  * invariants, slice 3 delta lane + least-loaded placement).
  *
  * `nomos-compile` APPENDS this module to a TAXONOMY-BEARING domain's module list —
- * both in the canonical manifests (the placement law is hash-bearing law) and in the
+ * both in the compiled package metadata (the placement law is hash-bearing law) and in the
  * generated engine entry (the plans ship in the lump). A taxonomy-FREE package never
  * imports it (subpath `@githolon/dsl/workspace-sharding`, never the runtime barrel —
  * the slice-1 hash-stability law: its bytes must not enter other tenants' lumps).
@@ -110,7 +110,7 @@ export interface ShardingRouteSpec {
 export interface ShardingLawSpec {
   readonly axes: readonly ShardingAxisSpec[];
   /**
-   * THE DERIVED ROUTES (slice 2's canonical-manifest `routes`, fed back into the law):
+   * THE DERIVED ROUTES (slice 2's package route facts, fed back into the law):
    * per routed directive, the homing invariant `nomosWrongHome:<directive>` is derived
    * so THE CHAIN GATE ITSELF refuses a wrong-home write (#41 — slice 3a; the edge
    * bailiff stays as defense-in-depth). OMITTED routes ⇒ no invariants (slice-2 shape).
@@ -317,7 +317,6 @@ export const NomosSummarySubtotal = aggregate("NomosSummarySubtotal", {
 export const NomosSummaryFrontier = aggregate("NomosSummaryFrontier", {
   shard: t.string().merge(Lww),
   frontier: t.string().merge(Lww), // the shard main oid the subtotals are true at
-  readManifestHash: t.string().merge(Lww),
   updatedAt: t.string().merge(Lww),
 });
 
@@ -530,7 +529,6 @@ export const nomosAmendSummaryFrontier = directive("nomosAmendSummaryFrontier")
     z.object({
       shard: z.string().regex(/^s\d+$/),
       frontier: z.string(),
-      readManifestHash: z.string(),
       updatedAt: z.string(),
     }),
   )
@@ -539,7 +537,6 @@ export const nomosAmendSummaryFrontier = directive("nomosAmendSummaryFrontier")
     return [
       withMarker(set(wm, "shard", p.shard), "ensures"),
       set(wm, "frontier", p.frontier),
-      set(wm, "readManifestHash", p.readManifestHash),
       set(wm, "updatedAt", p.updatedAt),
     ];
   });
@@ -656,7 +653,6 @@ export const nomosPropagateSummary = directive("nomosPropagateSummary")
       shard: z.string().regex(/^s\d+$/),
       fromOid: z.string(), // "" = the shard's first delta (a virgin coordinator record)
       toOid: z.string().min(1),
-      readManifestHash: z.string(),
       propagatedAt: z.string(),
       subtotals: z.array(summarySubtotalSchema).min(1).max(1024),
       events: z.array(summaryEventSchema).max(4096),
@@ -762,7 +758,6 @@ export const nomosPropagateSummary = directive("nomosPropagateSummary")
     ops.push(
       withMarker(set(wm, "shard", p.shard), "ensures"),
       set(wm, "frontier", p.toOid),
-      set(wm, "readManifestHash", p.readManifestHash),
       set(wm, "updatedAt", p.propagatedAt),
     );
     return ops;