@githolon/dsl 0.5.1 → 0.7.0

package/src/usd_layers.ts

@@ -99,12 +99,14 @@ export function usdaStringArray(items: readonly string[]): string {
 
 /**
  * A `WireDriver` as a READABLE usda token: unit drivers are their bare serde
- * string (`"Lww"`, `"AddWins"`, …); `MapOf` nests as `MapOf(<inner>)`. Readable on
- * purpose — the usdcat/usdview tree is the visual proof, so the merge law of every
- * field must be legible in it (hex would bury the point).
+ * string (`"Lww"`, `"AddWins"`, `"LwwCausal"`, …); `MapOf` nests as `MapOf(<inner>)`;
+ * the EXPLICIT TIME-AUTHORITY `LwwBy` carries its principal as `LwwBy(<principal>)`.
+ * Readable on purpose — the usdcat/usdview tree is the visual proof, so the merge law
+ * (and the time-authority) of every field must be legible in it (hex would bury the point).
  */
 export function driverToken(driver: WireDriver): string {
   if (typeof driver === "string") return driver;
+  if ("LwwBy" in driver) return `LwwBy(${driver.LwwBy})`;
   return `MapOf(${driverToken(driver.MapOf)})`;
 }
 
@@ -113,6 +115,15 @@ export function parseDriverToken(token: string): WireDriver {
   if (token.startsWith("MapOf(") && token.endsWith(")")) {
     return { MapOf: parseDriverToken(token.slice("MapOf(".length, -1)) };
   }
+  // `LwwBy(<principal>)` — the principal is an opaque non-empty string (uids carry
+  // hyphens, so it is NOT the bare-identifier shape the unit-driver branch validates).
+  if (token.startsWith("LwwBy(") && token.endsWith(")")) {
+    const principal = token.slice("LwwBy(".length, -1);
+    if (principal.length === 0) {
+      throw new Error(`usd-layers: LwwBy driver token names no time-authority principal`);
+    }
+    return { LwwBy: principal };
+  }
   if (!/^[A-Za-z][A-Za-z0-9]*$/.test(token)) {
     throw new Error(`usd-layers: malformed driver token '${token}'`);
   }
@@ -348,6 +359,12 @@ export function usdaLayerText(
     ...(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)))}`]
+      : []),
     ``,
     ...body,
     `    }`,
@@ -502,6 +519,36 @@ export function flattenLayeredUsd(layers: readonly UsdLayer[]): UsdDocument {
         readGate = { v: 1, queries: queriesRec, directives: directivesRec };
       }
     }
+    // The read-visibility gate (slice 5.1): per-aggregate required-read caps merged
+    // later-wins, SORTED keys (matching the composed emission). Omit-when-empty.
+    let readVisibility: UsdLayer["nomosReadVisibility"];
+    {
+      const a = new Map<string, { requires: string }>();
+      for (const l of stack) {
+        if (l.nomosReadVisibility === undefined) continue;
+        for (const [type, spec] of Object.entries(l.nomosReadVisibility.aggregates)) a.set(type, spec);
+      }
+      if (a.size > 0) {
+        const aggregatesRec: Record<string, { requires: string }> = {};
+        for (const k of [...a.keys()].sort()) aggregatesRec[k] = a.get(k)!;
+        readVisibility = { v: 1, aggregates: aggregatesRec };
+      }
+    }
+    // The encryption gate (slice 2): per-aggregate encrypted-field sets merged later-wins,
+    // SORTED keys (matching the composed emission). Omit-when-empty.
+    let encryption: UsdLayer["nomosEncryption"];
+    {
+      const a = new Map<string, { scope: string; fields: string[]; delegatable: false }>();
+      for (const l of stack) {
+        if (l.nomosEncryption === undefined) continue;
+        for (const [type, spec] of Object.entries(l.nomosEncryption.aggregates)) a.set(type, spec);
+      }
+      if (a.size > 0) {
+        const aggregatesRec: Record<string, { scope: string; fields: string[]; delegatable: false }> = {};
+        for (const k of [...a.keys()].sort()) aggregatesRec[k] = a.get(k)!;
+        encryption = { v: 1, aggregates: aggregatesRec };
+      }
+    }
     return {
       path,
       prims: [...prims.keys()].sort().map((p) => prims.get(p)!),
@@ -510,6 +557,8 @@ export function flattenLayeredUsd(layers: readonly UsdLayer[]): UsdDocument {
       ...(combineds !== undefined ? { combineds } : {}),
       ...(stableIds !== undefined ? { nomosStableIds: stableIds } : {}),
       ...(readGate !== undefined ? { nomosReadGate: readGate } : {}),
+      ...(readVisibility !== undefined ? { nomosReadVisibility: readVisibility } : {}),
+      ...(encryption !== undefined ? { nomosEncryption: encryption } : {}),
     };
   });
 
@@ -629,6 +678,8 @@ export function parseUsdaDocument(text: string): UsdDocument {
   const domainByScope = new Map<string, string>();
   const stableIdsByDomain = new Map<string, UsdLayer["nomosStableIds"]>();
   const readGateByDomain = new Map<string, UsdLayer["nomosReadGate"]>();
+  const readVisibilityByDomain = new Map<string, UsdLayer["nomosReadVisibility"]>();
+  const encryptionByDomain = new Map<string, UsdLayer["nomosEncryption"]>();
   for (const p of prims) {
     if (p.attrs.get("nomos:kind") === "domain") {
       const domain = attrString(p, "nomos:domain");
@@ -642,6 +693,16 @@ export function parseUsdaDocument(text: string): UsdDocument {
       if (typeof rgHex === "string") {
         readGateByDomain.set(domain, JSON.parse(unhexUtf8(rgHex)) as UsdLayer["nomosReadGate"]);
       }
+      // THE READ-VISIBILITY GATE (slice 5.1): the hex-carried per-aggregate cap map.
+      const rvHex = p.attrs.get("nomos:readVisibilityHex");
+      if (typeof rvHex === "string") {
+        readVisibilityByDomain.set(domain, JSON.parse(unhexUtf8(rvHex)) as UsdLayer["nomosReadVisibility"]);
+      }
+      // THE ENCRYPTION GATE (slice 2): the hex-carried per-aggregate encrypted-field map.
+      const encHex = p.attrs.get("nomos:encryptionHex");
+      if (typeof encHex === "string") {
+        encryptionByDomain.set(domain, JSON.parse(unhexUtf8(encHex)) as UsdLayer["nomosEncryption"]);
+      }
     }
   }
 
@@ -731,6 +792,8 @@ export function parseUsdaDocument(text: string): UsdDocument {
       const b = buckets.get(domain)!;
       const sids = stableIdsByDomain.get(domain);
       const rg = readGateByDomain.get(domain);
+      const rv = readVisibilityByDomain.get(domain);
+      const enc = encryptionByDomain.get(domain);
       return {
         path: `/Nomos/${domain}`,
         prims: [...b.prims].sort(byPath),
@@ -739,6 +802,8 @@ export function parseUsdaDocument(text: string): UsdDocument {
         ...(b.combineds.length > 0 ? { combineds: [...b.combineds].sort(byId) } : {}),
         ...(sids !== undefined ? { nomosStableIds: sids } : {}),
         ...(rg !== undefined ? { nomosReadGate: rg } : {}),
+        ...(rv !== undefined ? { nomosReadVisibility: rv } : {}),
+        ...(enc !== undefined ? { nomosEncryption: enc } : {}),
       };
     })
     .sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));

package/src/wire.ts

@@ -130,19 +130,23 @@ export interface WireRead {
 
 /**
  * `Driver` — the kernel's externally-tagged serde encoding (`nomos2/kernel/src/lib.rs`).
- * Unit variants → bare strings; `MapOf` → `{ MapOf: <inner> }`. This mirrors the kernel
- * variants the DSL `encodeDriver` emits: the four originals plus the structural CRDT unit
- * drivers `RemoveWins` / `Counter` / `LastPosition` (each a real `merge_field` arm).
+ * Unit variants → bare strings; `MapOf` → `{ MapOf: <inner> }`; the newtype `LwwBy(String)`
+ * → `{ LwwBy: <principal> }`. This mirrors the kernel variants the DSL `encodeDriver` emits:
+ * the four originals, the structural CRDT unit drivers `RemoveWins` / `Counter` /
+ * `LastPosition`, and the EXPLICIT TIME-AUTHORITY drivers `LwwCausal` (causal-only LWW) /
+ * `LwwBy` (principal-as-time-authority LWW) — each a real `merge_field` arm.
  * (`NumericMax`/`NumericMin`/`ImmutableAfterCreate`/`OrderedList` are kernel variants no
  * DSL driver encodes to yet — added here only as the DSL gains a constant for them.)
  */
 export type WireDriver =
   | "Lww"
+  | "LwwCausal"
   | "AddWins"
   | "Conflict"
   | "RemoveWins"
   | "Counter"
   | "LastPosition"
+  | { LwwBy: string }
   | { MapOf: WireDriver };
 
 /** `Schema = BTreeMap<FieldId, Driver>` — a plain object, field -> Driver. */