githolon 0.32.0 → 0.34.0

package/dist/cli.mjs

@@ -1143,7 +1143,7 @@ function makeGitFs(preopen, mount, { File: File3, Directory: Directory3 }) {
     const rel = p.slice(mount.length + 1).replace(/\/+$/, "");
     return rel === "" ? [] : rel.split("/");
   }
-  function resolve3(ps) {
+  function resolve4(ps) {
     let cur = root;
     for (const part of ps) {
       if (!isDir(cur)) return null;
@@ -1153,11 +1153,11 @@ function makeGitFs(preopen, mount, { File: File3, Directory: Directory3 }) {
     }
     return cur;
   }
-  const parent = (ps) => resolve3(ps.slice(0, -1));
+  const parent = (ps) => resolve4(ps.slice(0, -1));
   const leaf = (ps) => ps[ps.length - 1];
   const promises = {
     async readFile(p, opts) {
-      const n = resolve3(parts(p));
+      const n = resolve4(parts(p));
       if (n === null) throw fsErr("ENOENT", p);
       if (isDir(n)) throw fsErr("EISDIR", p);
       const data = n.data ?? new Uint8Array(0);
@@ -1176,7 +1176,7 @@ function makeGitFs(preopen, mount, { File: File3, Directory: Directory3 }) {
       if (!isDir(par) || !par.contents.delete(leaf(ps))) throw fsErr("ENOENT", p);
     },
     async readdir(p) {
-      const n = resolve3(parts(p));
+      const n = resolve4(parts(p));
       if (n === null) throw fsErr("ENOENT", p);
       if (!isDir(n)) throw fsErr("ENOTDIR", p);
       return [...n.contents.keys()];
@@ -1196,7 +1196,7 @@ function makeGitFs(preopen, mount, { File: File3, Directory: Directory3 }) {
       return promises.lstat(p);
     },
     async lstat(p) {
-      const n = resolve3(parts(p));
+      const n = resolve4(parts(p));
       if (n === null) throw fsErr("ENOENT", p);
       const dir = isDir(n);
       return {
@@ -1245,13 +1245,13 @@ var init_tree = __esm({
 function concatBytes(chunks) {
   let n = 0;
   for (const c of chunks) n += c.length;
-  const out11 = new Uint8Array(n);
+  const out12 = new Uint8Array(n);
   let o = 0;
   for (const c of chunks) {
-    out11.set(c, o);
+    out12.set(c, o);
     o += c.length;
   }
-  return out11;
+  return out12;
 }
 function pkt(payload) {
   const body = typeof payload === "string" ? enc2.encode(payload) : payload;
@@ -1404,13 +1404,13 @@ async function sha256hex(t) {
 function osEntropyBuffer(n) {
   const bytes = new Uint8Array(n * 8);
   for (let o = 0; o < bytes.length; o += 65536) crypto.getRandomValues(bytes.subarray(o, Math.min(o + 65536, bytes.length)));
-  const out11 = new Array(n), T = 2 ** 53;
+  const out12 = new Array(n), T = 2 ** 53;
   for (let i = 0; i < n; i++) {
     let z = 0n;
     for (let b = 7; b >= 0; b--) z = z << 8n | BigInt(bytes[i * 8 + b]);
-    out11[i] = Number(z >> 11n) / T;
+    out12[i] = Number(z >> 11n) / T;
   }
-  return out11;
+  return out12;
 }
 function stringifyBig(o) {
   return JSON.stringify(o, (_k, v) => typeof v === "bigint" ? `@@B:${v}@@` : v).replace(/"@@B:(\d+)@@"/g, "$1");
@@ -2112,11 +2112,1198 @@ var init_proof_offline = __esm({
   }
 });
 
+// src/scene_projector.ts
+import { createHash as createHash4 } from "node:crypto";
+function fnv1a32(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function hslToRgb(h, s, l) {
+  const hue = (h % 1 + 1) % 1;
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  const chan = (t0) => {
+    let t = (t0 % 1 + 1) % 1;
+    if (t < 1 / 6) return p + (q - p) * 6 * t;
+    if (t < 1 / 2) return q;
+    if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+    return p;
+  };
+  const r32 = (v) => Math.round(v * 1e3) / 1e3;
+  return [r32(chan(hue + 1 / 3)), r32(chan(hue)), r32(chan(hue - 1 / 3))];
+}
+function icosphere(subdiv) {
+  const t = (1 + Math.sqrt(5)) / 2;
+  let points = [
+    [-1, t, 0],
+    [1, t, 0],
+    [-1, -t, 0],
+    [1, -t, 0],
+    [0, -1, t],
+    [0, 1, t],
+    [0, -1, -t],
+    [0, 1, -t],
+    [t, 0, -1],
+    [t, 0, 1],
+    [-t, 0, -1],
+    [-t, 0, 1]
+  ].map(norm);
+  let faces = [
+    [0, 11, 5],
+    [0, 5, 1],
+    [0, 1, 7],
+    [0, 7, 10],
+    [0, 10, 11],
+    [1, 5, 9],
+    [5, 11, 4],
+    [11, 10, 2],
+    [10, 7, 6],
+    [7, 1, 8],
+    [3, 9, 4],
+    [3, 4, 2],
+    [3, 2, 6],
+    [3, 6, 8],
+    [3, 8, 9],
+    [4, 9, 5],
+    [2, 4, 11],
+    [6, 2, 10],
+    [8, 6, 7],
+    [9, 8, 1]
+  ];
+  for (let s = 0; s < subdiv; s++) {
+    const midCache = /* @__PURE__ */ new Map();
+    const mid = (a, b) => {
+      const key = a < b ? `${a}_${b}` : `${b}_${a}`;
+      const hit = midCache.get(key);
+      if (hit !== void 0) return hit;
+      const idx = points.length;
+      points = [...points, norm(mul(add(points[a], points[b]), 0.5))];
+      midCache.set(key, idx);
+      return idx;
+    };
+    const next = [];
+    for (const [a, b, c] of faces) {
+      const ab = mid(a, b), bc = mid(b, c), ca = mid(c, a);
+      next.push([a, ab, ca], [b, bc, ab], [c, ca, bc], [ab, bc, ca]);
+    }
+    faces = next;
+  }
+  return { points, indices: faces.flat() };
+}
+function boxMesh() {
+  const p = [];
+  for (const z of [-0.5, 0.5]) for (const y of [-0.5, 0.5]) for (const x of [-0.5, 0.5]) p.push([x, y, z]);
+  const quads = [
+    [0, 2, 3, 1],
+    // -z
+    [4, 5, 7, 6],
+    // +z
+    [0, 1, 5, 4],
+    // -y
+    [2, 6, 7, 3],
+    // +y
+    [0, 4, 6, 2],
+    // -x
+    [1, 3, 7, 5]
+    // +x
+  ];
+  const indices = [];
+  for (const [a, b, c, d] of quads) indices.push(a, b, c, a, c, d);
+  return { points: p, indices };
+}
+function prism(n) {
+  const points = [];
+  for (const y of [-0.5, 0.5]) {
+    for (let i = 0; i < n; i++) {
+      const a = 2 * Math.PI * i / n;
+      points.push([Math.cos(a), y, Math.sin(a)]);
+    }
+  }
+  const indices = [];
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n;
+    indices.push(i, j, n + j, i, n + j, n + i);
+  }
+  const bottomCenter = points.length;
+  points.push([0, -0.5, 0]);
+  const topCenter = points.length;
+  points.push([0, 0.5, 0]);
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n;
+    indices.push(bottomCenter, j, i);
+    indices.push(topCenter, n + i, n + j);
+  }
+  return { points, indices };
+}
+function facetedPolyhedron(sides, elongation = 1) {
+  const n = Math.max(3, Math.floor(sides));
+  const points = [[0, elongation, 0], [0, -elongation, 0]];
+  for (let i = 0; i < n; i++) {
+    const a = 2 * Math.PI * i / n;
+    points.push([Math.cos(a), 0, Math.sin(a)]);
+  }
+  const indices = [];
+  for (let i = 0; i < n; i++) {
+    const a = 2 + i, b = 2 + (i + 1) % n;
+    indices.push(0, b, a);
+    indices.push(1, a, b);
+  }
+  return { points, indices };
+}
+function pinLeaf() {
+  const n = 10;
+  const ringY = 1;
+  const ringR = 0.34;
+  const points = [[0, 0, 0]];
+  for (let i = 0; i < n; i++) {
+    const a = 2 * Math.PI * i / n;
+    points.push([Math.cos(a) * ringR, ringY, Math.sin(a) * ringR]);
+  }
+  const ringCenter = points.length;
+  points.push([0, ringY, 0]);
+  const indices = [];
+  for (let i = 0; i < n; i++) {
+    const a = 1 + i, b = 1 + (i + 1) % n;
+    indices.push(0, b, a);
+    indices.push(ringCenter, a, b);
+  }
+  const head = icosphere(1);
+  const headR = 0.42, headY = 1.28;
+  const base = points.length;
+  for (const p of head.points) points.push([p[0] * headR, p[1] * headR + headY, p[2] * headR]);
+  for (const i of head.indices) indices.push(base + i);
+  return { points, indices };
+}
+function segmentStrip(a, b, width) {
+  const d = sub(b, a);
+  const dn = norm(d);
+  const ref = Math.abs(dn[1]) < 0.9 ? [0, 1, 0] : [1, 0, 0];
+  const u = norm(cross(dn, ref));
+  const v = norm(cross(dn, u));
+  const hu = mul(u, width / 2);
+  const hv = mul(v, width / 2);
+  const corners = (p) => [
+    add(add(p, hu), hv),
+    add(sub(p, hu), hv),
+    sub(sub(p, hu), hv),
+    sub(add(p, hu), hv)
+  ];
+  const points = [...corners(a), ...corners(b)];
+  const quads = [
+    [0, 1, 2, 3],
+    // a cap
+    [4, 7, 6, 5],
+    // b cap
+    [0, 4, 5, 1],
+    [1, 5, 6, 2],
+    [2, 6, 7, 3],
+    [3, 7, 4, 0]
+  ];
+  const indices = [];
+  for (const [x, y, z, w] of quads) indices.push(x, y, z, x, z, w);
+  return { points, indices };
+}
+function sortDeep(v) {
+  if (Array.isArray(v)) return v.map(sortDeep);
+  if (v !== null && typeof v === "object") {
+    return Object.fromEntries(
+      Object.keys(v).sort().map((k) => [k, sortDeep(v[k])])
+    );
+  }
+  return v;
+}
+function canonicalStructure(level, def, voIndex) {
+  if (level === "aggregate") {
+    const schema = def ?? {};
+    const kinds = Object.values(schema).map((driver) => JSON.stringify(sortDeep(driver))).sort();
+    return JSON.stringify({ level: "aggregate", fields: kinds });
+  }
+  if (level === "directive") {
+    const d = def ?? {};
+    return JSON.stringify({
+      level: "directive",
+      marker: d.marker ?? "",
+      reads: (d.reads ?? []).length,
+      requires: (d.requires ?? []).length
+    });
+  }
+  const vo = def;
+  if (vo.geometry !== void 0 && vo.fields === void 0) {
+    return JSON.stringify({ level: "valueObject", geometry: vo.geometry });
+  }
+  const fields = Object.values(vo.fields ?? {}).map((f) => {
+    const child = f.ref !== void 0 ? voIndex?.get(f.ref) : void 0;
+    const childHash = child !== void 0 ? sha256Hex(canonicalStructure("valueObject", child, voIndex)) : void 0;
+    return JSON.stringify(
+      sortDeep({
+        type: f.type ?? "",
+        ...f.optional === true ? { optional: true } : {},
+        ...f.array === true ? { array: true } : {},
+        ...f.geometry !== void 0 ? { geometry: f.geometry } : {},
+        ...childHash !== void 0 ? { child: childHash } : {}
+      })
+    );
+  }).sort();
+  return JSON.stringify({ level: "valueObject", fields });
+}
+function glyphSignature(structJson, name, partCount) {
+  const h = sha256Hex(structJson);
+  const hueBase = parseInt(h.slice(0, 8), 16) / 4294967296;
+  const tint = fnv1a32(name) % 1e3 / 1e3 * 0.08;
+  const hue = (hueBase + tint) % 1;
+  const facetCount = 4 + parseInt(h.slice(8, 10), 16) % 5;
+  const elongation = Math.round((0.8 + parseInt(h.slice(10, 12), 16) / 255 * 0.5) * 1e3) / 1e3;
+  const size = Math.round((1 + Math.log2(1 + Math.max(0, partCount)) * 0.18) * 1e3) / 1e3;
+  return { structureHash: h, facetCount, hue, hueBase, elongation, size, color: hslToRgb(hue, 0.62, 0.6) };
+}
+function packageLayers(packageUsda) {
+  const m = /nomos:usdJsonHex = "([0-9a-f]+)"/.exec(packageUsda);
+  if (!m) throw new Error("a chain-installed package carries no nomos:usdJsonHex \u2014 not an openusd-ir package");
+  return JSON.parse(Buffer.from(m[1], "hex").toString("utf8")).layers;
+}
+function lawInstallsFromChain(entries) {
+  const installs = [];
+  for (let t = 0; t < entries.length; t++) {
+    const p = JSON.parse(entries[t].intent).payload;
+    if (p?.directiveId !== "installDomain" || typeof p.payload?.packageUsda !== "string") continue;
+    installs.push({
+      frame: t,
+      domainHash: typeof p.payload.domainHash === "string" ? p.payload.domainHash : "",
+      layers: packageLayers(p.payload.packageUsda)
+    });
+  }
+  return installs;
+}
+function intentKind(directiveId) {
+  if (directiveId === "installDomain") return "install";
+  if (/order/i.test(directiveId)) return "order";
+  if (/receipt/i.test(directiveId)) return "receipt";
+  return "offer";
+}
+function nodePosition(domain, kind, name) {
+  const angle = seededAngle(`domain:${domain}`) - Math.PI / 2;
+  const boughRadius = 2;
+  const center = [Math.cos(angle) * boughRadius, 0.35 + Math.sin(angle) * boughRadius * 0.55, 2.2];
+  const outward0 = [center[0], center[1] - 0.35, 0];
+  const outward = norm(outward0[0] * outward0[0] + outward0[1] * outward0[1] < 0.01 ? [1, 0.2, 0] : outward0);
+  const lateral = [-outward[1], outward[0], 0];
+  const place = (id2, forward, radius, lift) => {
+    const spreadAngle = seededAngle(id2, Math.PI * 1.5) - Math.PI * 0.75;
+    const off = add(
+      add(mul(outward, radius * (0.55 + 0.45 * Math.abs(Math.cos(spreadAngle)))), mul(lateral, Math.sin(spreadAngle) * radius)),
+      [0, lift, forward]
+    );
+    return round3(add(center, off));
+  };
+  const id = `${kind}:${domain}:${name}`;
+  if (kind === "aggregate") return place(id, 1.15, 0.95, 0.15);
+  if (kind === "directive") return place(id, 2.3, 1.35, 0.35);
+  if (kind === "relationType") return place(id, 0.7, 1.15, -0.75);
+  if (kind === "geoField") return place(id, 1.6, 1.05, -0.35);
+  return place(id, 0.7, 0.8, -1.15);
+}
+function buildSceneGraph(installs) {
+  const nodes = [];
+  const edges = [];
+  const layersByPath = /* @__PURE__ */ new Map();
+  for (const inst of installs) {
+    for (const layer of inst.layers) {
+      const list = layersByPath.get(layer.path) ?? [];
+      list.push({ frame: inst.frame, layer });
+      layersByPath.set(layer.path, list);
+    }
+  }
+  for (const path of [...layersByPath.keys()].sort()) {
+    const gens = layersByPath.get(path);
+    const domain = path.split("/").pop() ?? path;
+    for (let g = 0; g < gens.length; g++) {
+      const { frame, layer } = gens[g];
+      const wither = g + 1 < gens.length ? gens[g + 1].frame : void 0;
+      if (wither === frame) continue;
+      const suffix = `f${frame}`;
+      const voIndex = new Map(
+        (layer.nomosValueObjects?.valueObjects ?? []).map((vo) => [vo.name, vo])
+      );
+      const nodeIds = /* @__PURE__ */ new Map();
+      const pushNode = (kind, name, glyph, scale) => {
+        const id = `${kind}:${domain}:${name}`;
+        nodeIds.set(`${kind}:${name}`, id);
+        nodes.push({
+          id,
+          primName: `${kind}_${sanitize(domain)}_${sanitize(name)}_${suffix}`,
+          domain,
+          name,
+          kind,
+          glyph,
+          pos: nodePosition(domain, kind, name),
+          scale,
+          born: frame,
+          wither
+        });
+      };
+      const aggs = layer.prims.filter((p) => p.kind === "aggregate").sort((a, b) => (a.type ?? "") < (b.type ?? "") ? -1 : 1);
+      for (const p of aggs) {
+        const name = bareTypeLabel(p.type ?? p.path.split("/").pop() ?? "?");
+        const struct = canonicalStructure("aggregate", p.schema ?? {});
+        const glyph = glyphSignature(struct, name, Object.keys(p.schema ?? {}).length);
+        pushNode("aggregate", name, glyph, 0.24 * glyph.size);
+      }
+      const dirs = layer.prims.filter((p) => p.kind === "directive").sort((a, b) => a.path < b.path ? -1 : 1);
+      for (const p of dirs) {
+        const name = p.path.split("/").pop() ?? "?";
+        const struct = canonicalStructure("directive", p);
+        const glyph = glyphSignature(struct, name, (p.requires ?? []).length + (p.reads ?? []).length + 1);
+        pushNode("directive", name, glyph, 0.16 * glyph.size);
+      }
+      for (const rt of Object.keys(layer.nomosRelations?.types ?? {}).sort()) {
+        const struct = JSON.stringify({ level: "relationType" });
+        pushNode("relationType", rt, glyphSignature(struct, rt, 1), 0.1);
+      }
+      for (const vo of (layer.nomosValueObjects?.valueObjects ?? []).slice().sort((a, b) => a.name < b.name ? -1 : 1)) {
+        const struct = canonicalStructure("valueObject", vo, voIndex);
+        const glyph = glyphSignature(struct, vo.name, Object.keys(vo.fields ?? {}).length || 1);
+        pushNode("valueObject", vo.name, glyph, 0.12 * glyph.size);
+      }
+      for (const u of (layer.nomosValueObjects?.usages ?? []).filter((u2) => voIndex.get(u2.vo)?.geometry !== void 0).slice().sort((a, b) => a.aggregate !== b.aggregate ? a.aggregate < b.aggregate ? -1 : 1 : a.field < b.field ? -1 : 1)) {
+        const struct = JSON.stringify({ level: "geoField", geometry: voIndex.get(u.vo).geometry });
+        const glyph = glyphSignature(struct, `${u.aggregate}.${u.field}`, 1);
+        pushNode("geoField", `${u.aggregate}.${u.field}`, glyph, 0.1);
+      }
+      const aggNames = aggs.map((p) => bareTypeLabel(p.type ?? ""));
+      const pushEdge = (kind, from, to, label) => {
+        const fromId = nodeIds.get(from);
+        const toId = nodeIds.get(to);
+        if (fromId === void 0 || toId === void 0) return;
+        edges.push({ id: `${kind}:${domain}:${label}:${suffix}`, kind, from: fromId, to: toId, label, born: frame, wither });
+      };
+      for (const p of aggs) {
+        const pName = bareTypeLabel(p.type ?? "");
+        const fieldKinds = layer.nomosReadProjection?.aggregateFieldKinds?.[p.type ?? ""] ?? layer.nomosReadProjection?.aggregateFieldKinds?.[pName] ?? p.schema ?? {};
+        for (const f of Object.keys(fieldKinds).sort()) {
+          if (!/Id$/.test(f) || f.length < 3) continue;
+          const stem = f[0].toUpperCase() + f.slice(1, -2);
+          const targets = aggNames.filter((t2) => t2 !== pName && (t2 === stem || t2.endsWith(stem))).sort((x, y) => x.length - y.length || (x < y ? -1 : 1));
+          if (targets.length === 0) continue;
+          pushEdge("nameRef", `aggregate:${pName}`, `aggregate:${targets[0]}`, `${pName}.${f}`);
+        }
+      }
+      for (const p of dirs) {
+        const name = p.path.split("/").pop() ?? "?";
+        if (typeof p.target === "string" && p.target.length > 0) {
+          const target = bareTypeLabel(p.target);
+          pushEdge("targets", `directive:${name}`, `aggregate:${target}`, `${name}\u2192${target}`);
+        }
+      }
+      const gate = layer.nomosRelationGate?.requires ?? {};
+      for (const dirId of Object.keys(gate).sort()) {
+        const req = gate[dirId];
+        const relType = String(req.object ?? "").split(":")[0] ?? "";
+        pushEdge("relationGate", `relationType:${relType}`, `directive:${dirId}`, `${dirId}\xB7${String(req.relation ?? "")}`);
+      }
+    }
+  }
+  const typeIndex = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.kind !== "aggregate") continue;
+    const list = typeIndex.get(n.name) ?? [];
+    if (!list.includes(n.id)) list.push(n.id);
+    typeIndex.set(n.name, list);
+  }
+  for (const [k, v] of typeIndex) typeIndex.set(k, v.sort());
+  return { nodes, edges, typeIndex };
+}
+function bareTypeLabel(t) {
+  const i = t.lastIndexOf(".");
+  return i > 0 && i < t.length - 1 ? t.slice(i + 1) : t;
+}
+function geoFieldsOfInstalls(installs) {
+  const out12 = /* @__PURE__ */ new Map();
+  const add2 = (type, field) => {
+    const set = out12.get(type) ?? /* @__PURE__ */ new Set();
+    set.add(field);
+    out12.set(type, set);
+  };
+  for (const inst of installs) {
+    for (const layer of inst.layers) {
+      const voIndex = new Map((layer.nomosValueObjects?.valueObjects ?? []).map((vo) => [vo.name, vo]));
+      const qualified = layer.nomosReadProjectionNamespace?.types ?? [];
+      const delim = layer.nomosReadProjectionNamespace?.delimiter ?? ".";
+      for (const u of layer.nomosValueObjects?.usages ?? []) {
+        if (voIndex.get(u.vo)?.geometry !== "Point") continue;
+        add2(u.aggregate, u.field);
+        for (const q of qualified) {
+          if (q.endsWith(`${delim}${u.aggregate}`)) add2(q, u.field);
+        }
+      }
+    }
+  }
+  return out12;
+}
+function pointOfOpValue(setOp) {
+  let v = setOp["Json"];
+  if (typeof v === "string") {
+    try {
+      v = JSON.parse(v);
+    } catch {
+      return void 0;
+    }
+  }
+  if (v === void 0 && typeof setOp["Str"] === "string") {
+    try {
+      v = JSON.parse(setOp["Str"]);
+    } catch {
+      return void 0;
+    }
+  }
+  const g = v;
+  if (g === void 0 || g === null || g.type !== "Point" || !Array.isArray(g.coordinates)) return void 0;
+  const [lng, lat] = g.coordinates;
+  if (typeof lng !== "number" || typeof lat !== "number" || !Number.isFinite(lng) || !Number.isFinite(lat)) return void 0;
+  return [lng, lat];
+}
+function framesFromChain(entries, upTo, geoFields) {
+  const typeOf2 = /* @__PURE__ */ new Map();
+  const frames = [];
+  const firstPoint = /* @__PURE__ */ new Map();
+  const allBorn = [];
+  for (let t = 0; t < Math.min(entries.length, upTo); t++) {
+    const doc = JSON.parse(entries[t].intent);
+    const touched = [];
+    const born = [];
+    for (const ev of doc.events ?? []) {
+      const aggId = ev.aggregate;
+      if (typeof aggId !== "string") continue;
+      const declaredRaw = (ev.ops ?? []).find((o) => o.field === "__type")?.op?.Set?.Str;
+      const declared = declaredRaw === void 0 ? void 0 : bareTypeLabel(declaredRaw);
+      if (declared !== void 0 && !typeOf2.has(aggId)) {
+        typeOf2.set(aggId, declared);
+        const b = { type: declared, id: aggId };
+        born.push(b);
+        allBorn.push(b);
+      }
+      const type = declared ?? typeOf2.get(aggId);
+      if (type !== void 0) touched.push(type);
+      const fields = type !== void 0 ? geoFields?.get(type) : void 0;
+      if (fields !== void 0 && !firstPoint.has(aggId)) {
+        for (const o of ev.ops ?? []) {
+          if (typeof o.field !== "string" || !fields.has(o.field) || o.op?.Set === void 0) continue;
+          const pt = pointOfOpValue(o.op.Set);
+          if (pt !== void 0) {
+            firstPoint.set(aggId, pt);
+            break;
+          }
+        }
+      }
+    }
+    frames.push({
+      t,
+      intentId: doc.id ?? "",
+      directive: `${doc.payload?.domain ?? "?"}/${doc.payload?.directiveId ?? "?"}`,
+      kind: intentKind(doc.payload?.directiveId ?? ""),
+      touched: [...new Set(touched)].sort(),
+      born
+    });
+  }
+  for (const b of allBorn) {
+    const pt = firstPoint.get(b.id);
+    if (pt !== void 0) b.point = pt;
+  }
+  return frames;
+}
+function trunkPosition(k) {
+  return round3([Math.sin(k * 0.45) * 0.38, -0.012 * k, -0.55 - 1.15 * k]);
+}
+function materialFor(mats, color, opacity, emissiveK) {
+  const key = `${vec(color)}|${num(opacity)}|${num(emissiveK)}`;
+  const hit = mats.names.get(key);
+  if (hit !== void 0) return hit;
+  const name = `mat_${String(mats.names.size).padStart(3, "0")}`;
+  mats.names.set(key, name);
+  const emissive = [r3(color[0] * emissiveK), r3(color[1] * emissiveK), r3(color[2] * emissiveK)];
+  mats.defs.push(
+    `    def Material "${name}"`,
+    `    {`,
+    `        token outputs:surface.connect = </Materials/${name}/PreviewSurface.outputs:surface>`,
+    `        def Shader "PreviewSurface"`,
+    `        {`,
+    `            uniform token info:id = "UsdPreviewSurface"`,
+    `            color3f inputs:diffuseColor = ${vec(color)}`,
+    `            color3f inputs:emissiveColor = ${vec(emissive)}`,
+    `            float inputs:opacity = ${num(opacity)}`,
+    `            float inputs:roughness = 0.4`,
+    `            token outputs:surface`,
+    `        }`,
+    `    }`
+  );
+  return name;
+}
+function meshPrim(o, indent) {
+  const I = indent, I2 = indent + "    ", I3 = indent + "        ";
+  const pts = o.mesh.points.map((p) => vec(mul(p, o.meshScale)));
+  const counts = new Array(o.mesh.indices.length / 3).fill(3).join(", ");
+  const lines = [
+    `${I}def Xform ${usdaString(o.primName)} (`,
+    `${I2}prepend apiSchemas = ["MaterialBindingAPI"]`,
+    `${I})`,
+    `${I}{`,
+    `${I2}rel material:binding = </Materials/${o.material}>`
+  ];
+  for (const [k, v] of o.attrs ?? []) lines.push(`${I2}custom string ${k} = ${usdaString(v)}`);
+  const ops = [];
+  if (o.translate !== void 0) {
+    const t = o.translate;
+    lines.push(
+      `${I2}matrix4d xformOp:transform = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (${num(t[0])}, ${num(t[1])}, ${num(t[2])}, 1) )`
+    );
+    ops.push('"xformOp:transform"');
+  }
+  if (o.translateSamples !== void 0 && o.translateSamples.length > 0) {
+    lines.push(`${I2}double3 xformOp:translate = ${vec(o.translateSamples[0][1])}`);
+    lines.push(`${I2}double3 xformOp:translate.timeSamples = {`);
+    for (const [t, p] of o.translateSamples) lines.push(`${I3}${t}: ${vec(p)},`);
+    lines.push(`${I2}}`);
+    ops.push('"xformOp:translate"');
+  }
+  if (o.scaleSamples !== void 0 && o.scaleSamples.length > 0) {
+    lines.push(`${I2}float3 xformOp:scale = (1, 1, 1)`);
+    lines.push(`${I2}float3 xformOp:scale.timeSamples = {`);
+    for (const [t, s] of o.scaleSamples) lines.push(`${I3}${t}: (${num(s)}, ${num(s)}, ${num(s)}),`);
+    lines.push(`${I2}}`);
+    ops.push('"xformOp:scale"');
+  }
+  if (ops.length > 0) lines.push(`${I2}uniform token[] xformOpOrder = [${ops.join(", ")}]`);
+  if (o.visibilitySamples !== void 0 && o.visibilitySamples.length > 0) {
+    lines.push(`${I2}token visibility.timeSamples = {`);
+    for (const [t, v] of o.visibilitySamples) lines.push(`${I3}${t}: ${usdaString(v)},`);
+    lines.push(`${I2}}`);
+  }
+  lines.push(
+    `${I2}def Mesh "geo"`,
+    `${I2}{`,
+    `${I3}float3[] extent = ${extentOf(o.mesh.points, o.meshScale)}`,
+    `${I3}int[] faceVertexCounts = [${counts}]`,
+    `${I3}int[] faceVertexIndices = [${o.mesh.indices.join(", ")}]`,
+    `${I3}point3f[] points = [${pts.join(", ")}]`,
+    `${I3}uniform token subdivisionScheme = "none"`,
+    `${I2}}`,
+    `${I}}`
+  );
+  return lines;
+}
+function insetOffset(lng, lat) {
+  return round3([lng / 360 * INSET_W, 0.05, -(lat / 180) * INSET_D]);
+}
+function emitSceneUsda(o) {
+  const endT = o.frames.length - 1 + (o.refusal !== void 0 ? 1 : 0);
+  const mats = { names: /* @__PURE__ */ new Map(), defs: [] };
+  const body = [];
+  const nodeById = new Map(o.graph.nodes.map((n) => [n.id, n]));
+  const pulses = /* @__PURE__ */ new Map();
+  for (const f of o.frames) {
+    const domainHint = f.directive.split("/")[0] ?? "";
+    for (const type of f.touched) {
+      const candidates = (o.graph.typeIndex.get(type) ?? []).filter((id2) => {
+        const n = nodeById.get(id2);
+        return n.born <= f.t && (n.wither === void 0 || n.wither > f.t);
+      });
+      const id = candidates.find((c) => nodeById.get(c).domain === domainHint) ?? candidates[0];
+      if (id === void 0) continue;
+      const track = pulses.get(id) ?? /* @__PURE__ */ new Map();
+      if (track.size === 0 && f.t > 0) track.set(0, 1);
+      track.set(f.t, 1.45);
+      if (!track.has(f.t + 1) || track.get(f.t + 1) === 1) track.set(f.t + 1, 1);
+      pulses.set(id, track);
+    }
+  }
+  body.push(`    def Scope "Law"`, `    {`);
+  const sortedNodes = [...o.graph.nodes].sort((a, b) => a.primName < b.primName ? -1 : 1);
+  for (const n of sortedNodes) {
+    const mesh = n.kind === "aggregate" ? GEO_ICOSPHERE_FINE : n.kind === "directive" ? GEO_HEX : n.kind === "valueObject" ? facetedPolyhedron(n.glyph.facetCount, n.glyph.elongation) : n.kind === "geoField" ? GEO_PIN : GEO_ICOSPHERE;
+    const vis = [];
+    if (n.born > 0) vis.push([0, "invisible"], [n.born, "inherited"]);
+    if (n.wither !== void 0) {
+      if (vis.length === 0) vis.push([0, "inherited"]);
+      vis.push([Math.min(endT, n.wither + 1), "invisible"]);
+    }
+    const scaleSamples = [];
+    const track = pulses.get(n.id);
+    if (track !== void 0) for (const t of [...track.keys()].sort((a, b) => a - b)) scaleSamples.push([t, track.get(t)]);
+    if (n.wither !== void 0) {
+      if (scaleSamples.length === 0 && n.wither > 0) scaleSamples.push([0, 1]);
+      scaleSamples.push([n.wither, 0.05]);
+    }
+    body.push(
+      ...meshPrim(
+        {
+          primName: n.primName,
+          mesh,
+          meshScale: n.scale,
+          translate: n.pos,
+          material: materialFor(mats, n.glyph.color, 1, 0.25),
+          ...vis.length > 0 ? { visibilitySamples: vis } : {},
+          ...scaleSamples.length > 0 ? { scaleSamples } : {},
+          attrs: [
+            ["nomos:law:domain", n.domain],
+            ["nomos:law:kind", n.kind],
+            ["nomos:law:name", n.name],
+            ["nomos:law:structureHash", n.glyph.structureHash]
+          ]
+        },
+        "        "
+      )
+    );
+  }
+  body.push(`    }`);
+  body.push(`    def Scope "Edges"`, `    {`);
+  const sortedEdges = [...o.graph.edges].sort((a, b) => a.id < b.id ? -1 : 1);
+  sortedEdges.forEach((e, i) => {
+    const a = nodeById.get(e.from);
+    const b = nodeById.get(e.to);
+    const vis = [];
+    if (e.born > 0) vis.push([0, "invisible"], [e.born, "inherited"]);
+    if (e.wither !== void 0) {
+      if (vis.length === 0) vis.push([0, "inherited"]);
+      vis.push([e.wither, "invisible"]);
+    }
+    body.push(
+      ...meshPrim(
+        {
+          primName: `e${String(i).padStart(3, "0")}_${sanitize(e.label).slice(0, 40)}`,
+          mesh: segmentStrip(a.pos, b.pos, 0.02),
+          meshScale: 1,
+          material: materialFor(mats, EDGE_COLORS[e.kind], 0.8, 0.1),
+          ...vis.length > 0 ? { visibilitySamples: vis } : {},
+          attrs: [
+            ["nomos:edge:kind", e.kind],
+            ["nomos:edge:label", e.label]
+          ]
+        },
+        "        "
+      )
+    );
+  });
+  body.push(`    }`);
+  body.push(`    def Scope "Chain"`, `    {`);
+  const N = o.frames.length + (o.refusal !== void 0 ? 1 : 0);
+  for (const f of o.frames) {
+    const stepsBehindHead = N - 1 - f.t;
+    body.push(
+      ...meshPrim(
+        {
+          primName: `link_${String(f.t).padStart(4, "0")}`,
+          mesh: GEO_ICOSPHERE,
+          meshScale: 0.12,
+          translate: trunkPosition(stepsBehindHead),
+          material: materialFor(mats, KIND_COLORS[f.kind], 1, 0.5),
+          ...f.t > 0 ? { visibilitySamples: [[0, "invisible"], [f.t, "inherited"]] } : {},
+          attrs: [
+            ["nomos:chain:intent", f.intentId],
+            ["nomos:chain:directive", f.directive],
+            ["nomos:chain:kind", f.kind],
+            ["nomos:chain:verdict", "admitted"]
+          ]
+        },
+        "        "
+      )
+    );
+  }
+  if (o.refusal !== void 0) {
+    body.push(
+      ...meshPrim(
+        {
+          primName: `link_refused`,
+          mesh: GEO_ICOSPHERE,
+          meshScale: 0.16,
+          translate: trunkPosition(0),
+          material: materialFor(mats, REFUSED_COLOR, 1, 0.8),
+          visibilitySamples: [[0, "invisible"], [endT, "inherited"]],
+          attrs: [
+            ["nomos:chain:intent", o.refusal.intentId],
+            ["nomos:chain:directive", o.refusal.directive],
+            ["nomos:chain:verdict", `refused: ${o.refusal.reason}`]
+          ]
+        },
+        "        "
+      )
+    );
+  }
+  if (N > 1) {
+    body.push(
+      ...meshPrim(
+        {
+          primName: "rail",
+          mesh: segmentStrip(add(trunkPosition(0), [0, -0.1, 0]), add(trunkPosition(N - 1), [0, -0.1, 0]), 0.03),
+          meshScale: 1,
+          material: materialFor(mats, [0.267, 0.325, 0.416], 0.7, 0),
+          attrs: [["nomos:chain:role", "rail"]]
+        },
+        "        "
+      )
+    );
+  }
+  const cursorSamples = [];
+  for (let t = 0; t <= endT; t++) cursorSamples.push([t, add(trunkPosition(N - 1 - Math.min(t, N - 1)), [0, 0.3, 0])]);
+  body.push(
+    ...meshPrim(
+      {
+        primName: "cursor",
+        mesh: GEO_ICOSPHERE,
+        meshScale: 0.09,
+        material: materialFor(mats, o.refusal !== void 0 ? REFUSED_COLOR : CURSOR_COLOR, 1, 1),
+        translateSamples: cursorSamples,
+        attrs: [["nomos:chain:role", "cursor"]]
+      },
+      "        "
+    )
+  );
+  body.push(`    }`);
+  body.push(`    def Scope "Instances"`, `    {`);
+  const perNodeCount = /* @__PURE__ */ new Map();
+  const insetBorn = /* @__PURE__ */ new Map();
+  const budLines = [];
+  for (const f of o.frames) {
+    const domainHint = f.directive.split("/")[0] ?? "";
+    for (const inst of f.born) {
+      const candidates = (o.graph.typeIndex.get(inst.type) ?? []).filter((id) => {
+        const n = nodeById.get(id);
+        return n.born <= f.t && (n.wither === void 0 || n.wither > f.t);
+      });
+      const anchorId = candidates.find((c) => nodeById.get(c).domain === domainHint) ?? candidates[0];
+      if (anchorId === void 0) continue;
+      const anchor = nodeById.get(anchorId);
+      const k = perNodeCount.get(anchorId) ?? 0;
+      perNodeCount.set(anchorId, k + 1);
+      let translate;
+      if (inst.point !== void 0) {
+        const [lng, lat] = inst.point;
+        translate = round3(add(add(anchor.pos, INSET_DROP), insetOffset(lng, lat)));
+        if (!insetBorn.has(anchorId) || insetBorn.get(anchorId) > f.t) insetBorn.set(anchorId, f.t);
+      } else {
+        const ang = k * 2.399963229728653;
+        const r = 0.45 + 0.06 * Math.floor(k / 9);
+        const jz = 0.25 + (fnv1a32(inst.id) & 255) / 255 * 0.1;
+        translate = round3(add(anchor.pos, [Math.cos(ang) * r, Math.sin(ang) * r * 0.7, jz]));
+      }
+      budLines.push(
+        ...meshPrim(
+          {
+            primName: `inst_${String(f.t).padStart(4, "0")}_${String(k).padStart(2, "0")}_${sanitize(inst.id).slice(0, 32)}`,
+            mesh: GEO_ICOSPHERE,
+            meshScale: 0.05,
+            translate,
+            material: materialFor(mats, INSTANCE_COLOR, 1, 0.6),
+            ...f.t > 0 ? { visibilitySamples: [[0, "invisible"], [f.t, "inherited"]] } : {},
+            attrs: [
+              ["nomos:id", inst.id],
+              ["nomos:type", inst.type],
+              ...inst.point !== void 0 ? [["nomos:geo:point", `${num(inst.point[0])},${num(inst.point[1])}`]] : []
+            ]
+          },
+          "        "
+        )
+      );
+    }
+  }
+  for (const anchorId of [...insetBorn.keys()].sort()) {
+    const anchor = nodeById.get(anchorId);
+    const bornAt = insetBorn.get(anchorId);
+    budLines.push(
+      ...meshPrim(
+        {
+          primName: `inset_${anchor.primName}`,
+          mesh: INSET_FRAME,
+          meshScale: 1,
+          translate: round3(add(anchor.pos, INSET_DROP)),
+          material: materialFor(mats, [0.353, 0.42, 0.494], 0.55, 0),
+          ...bornAt > 0 ? { visibilitySamples: [[0, "invisible"], [bornAt, "inherited"]] } : {},
+          attrs: [
+            ["nomos:inset:aggregate", anchor.name],
+            ["nomos:inset:projection", "equirectangular lng/lat"]
+          ]
+        },
+        "        "
+      )
+    );
+  }
+  body.push(...budLines, `    }`);
+  const header = [
+    `#usda 1.0`,
+    `(`,
+    `    doc = "Nomos ledger scene (portable profile): the chain-carried law canopy, the validated replay as timeSamples. timeCode is the chain index."`,
+    `    customLayerData = {`,
+    `        string "nomos:format" = "nomos.usd-portable-scene.v1"`,
+    `        string "nomos:scene" = ${usdaString(o.name)}`,
+    `        string "nomos:packages" = ${usdaString(o.packageHashes.join(","))}`,
+    `        string "nomos:verifyChain" = ${usdaString(o.verdictLine)}`,
+    `        string "nomos:timeCode" = "chain index (intent position on main)"`,
+    `    }`,
+    `    defaultPrim = "Scene"`,
+    `    startTimeCode = 0`,
+    `    endTimeCode = ${endT}`,
+    `    timeCodesPerSecond = 1`,
+    `    framesPerSecond = 1`,
+    `    metersPerUnit = 1`,
+    `    upAxis = "Y"`,
+    `)`,
+    ``,
+    `def Scope "Materials"`,
+    `{`,
+    ...mats.defs,
+    `}`,
+    ``,
+    `def Xform "Scene"`,
+    `{`
+  ];
+  return [...header, ...body, `}`, ``].join("\n");
+}
+function lintPortableProfile(usda) {
+  const violations = [];
+  const defRe = /^\s*def\s+(\w+)\s+"/gm;
+  let m;
+  const ALLOWED_DEFS = /* @__PURE__ */ new Set(["Xform", "Scope", "Mesh", "Material", "Shader"]);
+  while ((m = defRe.exec(usda)) !== null) {
+    if (!ALLOWED_DEFS.has(m[1])) violations.push(`forbidden prim schema: def ${m[1]}`);
+  }
+  if (/\bsubLayers\b/.test(usda)) violations.push("subLayers in a flattened stage");
+  if (/\bprepend references\b|\bpayload\b/.test(usda)) violations.push("references/payloads in a flattened stage");
+  const tsRe = /([\w:]+)\.timeSamples/g;
+  const ALLOWED_TS = /* @__PURE__ */ new Set(["xformOp:translate", "xformOp:scale", "visibility"]);
+  while ((m = tsRe.exec(usda)) !== null) {
+    const attr = m[1].split(" ").pop();
+    if (!ALLOWED_TS.has(attr)) violations.push(`forbidden timeSamples on ${attr}`);
+  }
+  const opRe = /xformOp:(\w+)/g;
+  const ALLOWED_OPS = /* @__PURE__ */ new Set(["transform", "translate", "scale"]);
+  while ((m = opRe.exec(usda)) !== null) {
+    if (!ALLOWED_OPS.has(m[1])) violations.push(`forbidden xformOp:${m[1]}`);
+  }
+  return [...new Set(violations)];
+}
+function crc32(bytes) {
+  let c = 4294967295;
+  for (let i = 0; i < bytes.length; i++) c = CRC_TABLE[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function usdzPack(entries) {
+  const chunks = [];
+  const central = [];
+  let offset = 0;
+  const w16 = (v) => [v & 255, v >>> 8 & 255];
+  const w32 = (v) => [v & 255, v >>> 8 & 255, v >>> 16 & 255, v >>> 24 & 255];
+  for (const [name, data] of entries) {
+    const nameBytes = new TextEncoder().encode(name);
+    const crc = crc32(data);
+    const headerLen = 30 + nameBytes.length;
+    const mis = (offset + headerLen) % 64;
+    let extraLen = 0;
+    if (mis !== 0) {
+      extraLen = 64 - mis;
+      if (extraLen < 4) extraLen += 64;
+    }
+    const pad = extraLen === 0 ? 0 : extraLen - 4;
+    const local = new Uint8Array([
+      ...w32(67324752),
+      ...w16(20),
+      // version needed
+      ...w16(0),
+      // flags
+      ...w16(0),
+      // method: stored
+      ...w16(0),
+      // dos time (fixed)
+      ...w16(33),
+      // dos date: 1980-01-01
+      ...w32(crc),
+      ...w32(data.length),
+      ...w32(data.length),
+      ...w16(nameBytes.length),
+      ...w16(extraLen),
+      ...nameBytes,
+      ...extraLen > 0 ? [...w16(6534), ...w16(pad), ...new Array(pad).fill(0)] : []
+    ]);
+    chunks.push(local, data);
+    central.push(
+      new Uint8Array([
+        ...w32(33639248),
+        ...w16(20),
+        ...w16(20),
+        ...w16(0),
+        ...w16(0),
+        ...w16(0),
+        ...w16(33),
+        ...w32(crc),
+        ...w32(data.length),
+        ...w32(data.length),
+        ...w16(nameBytes.length),
+        ...w16(0),
+        // no extra in central
+        ...w16(0),
+        // comment
+        ...w16(0),
+        // disk
+        ...w16(0),
+        // internal attrs
+        ...w32(0),
+        // external attrs
+        ...w32(offset),
+        ...nameBytes
+      ])
+    );
+    offset += local.length + data.length;
+  }
+  const centralStart = offset;
+  let centralLen = 0;
+  for (const c of central) centralLen += c.length;
+  const eocd = new Uint8Array([
+    ...w32(101010256),
+    ...w16(0),
+    ...w16(0),
+    ...w16(entries.length),
+    ...w16(entries.length),
+    ...w32(centralLen),
+    ...w32(centralStart),
+    ...w16(0)
+  ]);
+  const total = offset + centralLen + eocd.length;
+  const outBytes = new Uint8Array(total);
+  let at = 0;
+  for (const c of [...chunks, ...central, eocd]) {
+    outBytes.set(c, at);
+    at += c.length;
+  }
+  return outBytes;
+}
+var sha256Hex, add, sub, mul, norm, cross, seededAngle, r3, round3, sanitize, KIND_COLORS, REFUSED_COLOR, EDGE_COLORS, INSTANCE_COLOR, CURSOR_COLOR, num, vec, usdaString, extentOf, GEO_ICOSPHERE, GEO_ICOSPHERE_FINE, GEO_BOX, GEO_HEX, GEO_PIN, INSET_W, INSET_D, INSET_DROP, INSET_FRAME, CRC_TABLE;
+var init_scene_projector = __esm({
+  "src/scene_projector.ts"() {
+    "use strict";
+    sha256Hex = (s) => createHash4("sha256").update(s).digest("hex");
+    add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+    sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+    mul = (a, k) => [a[0] * k, a[1] * k, a[2] * k];
+    norm = (a) => {
+      const l = Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]) || 1;
+      return [a[0] / l, a[1] / l, a[2] / l];
+    };
+    cross = (a, b) => [
+      a[1] * b[2] - a[2] * b[1],
+      a[2] * b[0] - a[0] * b[2],
+      a[0] * b[1] - a[1] * b[0]
+    ];
+    seededAngle = (id, spread = Math.PI * 2) => fnv1a32(id) % 3600 / 3600 * spread;
+    r3 = (v) => {
+      const x = Math.round(v * 1e3) / 1e3;
+      return Object.is(x, -0) ? 0 : x;
+    };
+    round3 = (p) => [r3(p[0]), r3(p[1]), r3(p[2])];
+    sanitize = (s) => s.replace(/[^A-Za-z0-9_]/g, "_");
+    KIND_COLORS = {
+      install: [0.953, 0.714, 0.302],
+      // amber
+      order: [0.431, 0.659, 1],
+      // blue
+      receipt: [0.773, 0.549, 1],
+      // violet
+      offer: [0.604, 0.655, 0.71]
+      // neutral
+    };
+    REFUSED_COLOR = [1, 0.373, 0.337];
+    EDGE_COLORS = {
+      nameRef: [0.45, 0.47, 0.5],
+      relationGate: [0.63, 0.26, 0.96],
+      targets: [1, 0.42, 0.42]
+    };
+    INSTANCE_COLOR = [0.22, 0.85, 0.51];
+    CURSOR_COLOR = [0.24, 0.72, 0.35];
+    num = (n) => {
+      if (!Number.isFinite(n)) throw new Error("non-finite number in a usda literal");
+      const v = Math.round(n * 1e3) / 1e3;
+      return String(Object.is(v, -0) ? 0 : v);
+    };
+    vec = (p) => `(${p.map(num).join(", ")})`;
+    usdaString = (s) => JSON.stringify(s);
+    extentOf = (points, scale) => {
+      let min = [Infinity, Infinity, Infinity];
+      let max = [-Infinity, -Infinity, -Infinity];
+      for (const p of points) {
+        for (let i = 0; i < 3; i++) {
+          if (p[i] * scale < min[i]) min[i] = p[i] * scale;
+          if (p[i] * scale > max[i]) max[i] = p[i] * scale;
+        }
+      }
+      return `[${vec(round3(min))}, ${vec(round3(max))}]`;
+    };
+    GEO_ICOSPHERE = icosphere(1);
+    GEO_ICOSPHERE_FINE = icosphere(2);
+    GEO_BOX = boxMesh();
+    GEO_HEX = prism(6);
+    GEO_PIN = pinLeaf();
+    INSET_W = 1.6;
+    INSET_D = 0.8;
+    INSET_DROP = [0, -0.85, 0];
+    INSET_FRAME = {
+      points: GEO_BOX.points.map((p) => [p[0] * INSET_W, p[1] * 0.02, p[2] * INSET_D]),
+      indices: GEO_BOX.indices
+    };
+    CRC_TABLE = (() => {
+      const t = new Uint32Array(256);
+      for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+        t[n] = c >>> 0;
+      }
+      return t;
+    })();
+  }
+});
+
+// src/scene.ts
+var scene_exports = {};
+__export(scene_exports, {
+  scene: () => scene
+});
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join10, resolve as resolve2 } from "node:path";
+import { createHash as createHash5 } from "node:crypto";
+import git3 from "isomorphic-git";
+async function walkChain2(eng, ws) {
+  const gitdir = gitdirOf(ws);
+  const dec4 = new TextDecoder();
+  const entries = [];
+  for (const c of await git3.log({ fs: eng.fs, gitdir, ref: "main" })) {
+    try {
+      const { blob } = await git3.readBlob({ fs: eng.fs, gitdir, oid: c.oid, filepath: "intent.json" });
+      entries.push({ oid: c.oid, intent: dec4.decode(blob) });
+    } catch {
+    }
+  }
+  entries.reverse();
+  return entries;
+}
+async function projectOnce(cloud, target, isDir, name) {
+  const { eng } = await holonEngine(cloud, void 0, "githolon-scene");
+  const SOURCE3 = "source";
+  if (isDir) {
+    const gitDir = existsSync9(join10(target, ".git")) ? join10(target, ".git") : target;
+    if (!existsSync9(join10(gitDir, "HEAD"))) throw new Error(`${target} is not a git repo (no HEAD)`);
+    await mountFresh(eng, SOURCE3);
+    eng.preopen.dir.contents.get("ws").contents.get(SOURCE3).contents.set("nomos.git", readTreeFromDisk(gitDir));
+  } else {
+    const m = await mountWorkspace(eng, SOURCE3, { remote: `${cloud}/v2/workspaces/${target}/git`, headers: {} });
+    if (m.restored !== true) {
+      throw new Error(
+        `workspace '${target}' has no refs/heads/main on ${cloud} \u2014 nothing to project` + (m.restoreError ? ` (${String(m.restoreError).split(" | ")[0]})` : "")
+      );
+    }
+  }
+  const entries = await walkChain2(eng, SOURCE3);
+  if (entries.length === 0) throw new Error(`the chain on '${target}' carries no intents \u2014 nothing to project`);
+  const verdict = verifyChainLocal(eng, SOURCE3);
+  let verdictLine;
+  let upTo;
+  let refusal;
+  if (verdict["valid"] === true) {
+    verdictLine = `GREEN (${verdict["plansRerun"]} plans re-run)`;
+    upTo = entries.length;
+  } else {
+    const at = Number.isInteger(verdict["atIndex"]) ? verdict["atIndex"] : 0;
+    upTo = Math.max(0, at);
+    const bad = JSON.parse(entries[Math.min(at, entries.length - 1)].intent);
+    refusal = {
+      index: at,
+      reason: `${String(verdict["check"] ?? "replay")}: ${String(verdict["error"] ?? "invalid").slice(0, 200)}`,
+      directive: `${bad.payload?.domain ?? "?"}/${bad.payload?.directiveId ?? "?"}`,
+      intentId: bad.id ?? ""
+    };
+    verdictLine = `REFUSED at index ${at} \u2014 ${refusal.reason}`;
+  }
+  if (upTo === 0 && refusal === void 0) throw new Error(`${name}: nothing to emit`);
+  const consideredEntries = entries.slice(0, Math.max(upTo, 1));
+  const installs = lawInstallsFromChain(consideredEntries);
+  if (installs.length === 0) throw new Error("the chain installs no openusd-ir packages \u2014 nothing to draw");
+  const graph = buildSceneGraph(installs);
+  const frames = framesFromChain(entries, upTo, geoFieldsOfInstalls(installs));
+  const usda = emitSceneUsda({
+    name,
+    graph,
+    frames,
+    verdictLine,
+    packageHashes: installs.map((i) => i.domainHash),
+    refusal
+  });
+  return {
+    usda,
+    stats: {
+      frames: frames.length,
+      nodes: graph.nodes.length,
+      edges: graph.edges.length,
+      endT: frames.length - 1 + (refusal !== void 0 ? 1 : 0),
+      verdictLine
+    }
+  };
+}
+async function scene(target, opts) {
+  const cloud = cloudBase(opts.cloud);
+  const isDir = existsSync9(target) || target.includes("/") || target.startsWith(".");
+  const name = isDir ? (resolve2(target).split("/").filter(Boolean).pop() ?? "scene").replace(/\.git$/, "") : target;
+  out11(`scene \u2014 ${name} (${isDir ? resolve2(target) : `${cloud} :: ${target}`})`);
+  let first, second;
+  try {
+    first = await projectOnce(cloud, target, isDir, name);
+    second = await projectOnce(cloud, target, isDir, name);
+  } catch (e) {
+    err11(String(e.message ?? e));
+    return 1;
+  }
+  if (first.usda !== second.usda) {
+    err11(`two replays of the SAME chain emitted DIFFERENT bytes \u2014 the projector is nondeterministic (refusing to write)`);
+    return 1;
+  }
+  const violations = lintPortableProfile(first.usda);
+  if (violations.length > 0) {
+    err11(`the emitted stage violates the portable profile: ${violations.join("; ")}`);
+    return 1;
+  }
+  const outDir = resolve2(opts.out ?? join10("scene", name));
+  mkdirSync4(outDir, { recursive: true });
+  const usdaPath = join10(outDir, `${name}.usda`);
+  const usdzPath = join10(outDir, `${name}.usdz`);
+  const usdaBytes = new TextEncoder().encode(first.usda);
+  writeFileSync6(usdaPath, usdaBytes);
+  writeFileSync6(usdzPath, usdzPack([[`${name}.usda`, usdaBytes]]));
+  const s = first.stats;
+  out11(`  verify_chain ${s.verdictLine}`);
+  out11(`  law canopy   ${s.nodes} node(s), ${s.edges} edge(s) \u2014 from the chain's own installed packages`);
+  out11(`  chain tier   ${s.frames} frame(s), timeCodes 0..${s.endT} (timeCode = chain index)`);
+  out11(`  determinism  two fresh replays \u2192 BYTE-IDENTICAL  sha256 ${sha256(first.usda).slice(0, 16)}\u2026`);
+  out11(`  profile      portable (Mesh-only, UsdPreviewSurface, translate/scale/visibility timeSamples)`);
+  out11(`  \u2192 ${usdaPath} (${usdaBytes.length} bytes)`);
+  out11(`  \u2192 ${usdzPath}`);
+  return s.verdictLine.startsWith("GREEN") ? 0 : 2;
+}
+var out11, err11, sha256;
+var init_scene = __esm({
+  "src/scene.ts"() {
+    "use strict";
+    init_engine();
+    init_cloud();
+    init_local_holon();
+    init_scene_projector();
+    out11 = (s) => void process.stdout.write(s + "\n");
+    err11 = (s) => void process.stderr.write("error: " + s + "\n");
+    sha256 = (s) => createHash5("sha256").update(s).digest("hex");
+  }
+});
+
 // src/cli.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync11 } from "node:fs";
 import { spawnSync as spawnSync4 } from "node:child_process";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname5, join as join10, resolve as resolve2 } from "node:path";
+import { dirname as dirname5, join as join11, resolve as resolve3 } from "node:path";
 import { pathToFileURL as pathToFileURL4 } from "node:url";
 
 // src/generate.ts
@@ -2856,6 +4043,16 @@ var HELP = {
     ],
     examples: ["githolon replay my-guestbook", "githolon replay ./my-holon --step 10", "githolon replay my-guestbook --json | jq .directive"]
   },
+  scene: {
+    usage: "githolon scene <ws|dir> [--out <dir>] [--cloud <url>]",
+    what: "The ledger as a PORTABLE USD SCENE \u2014 the thin, canonical chain\u2192USD projector. Clones the chain\n(cloud workspace or local holon directory), GATES it on the wasm verify_chain (full emission only\non GREEN; a refusal emits up to the failing index with the red cursor verdict), and projects the\nCHAIN-CARRIED law (the packages' USD-IR \u2014 never TS source) + the validated replay into ONE\nflattened stage: UsdGeomMesh-only glyphs (icosphere aggregates, hex-prism directives, faceted\nvalue-object molecules, the kind-colored commit-link trunk), UsdPreviewSurface materials, and\ntranslate/scale/visibility timeSamples \u2014 timeCode = chain index. Deterministic: the scene is\nemitted twice through fresh engines and byte-compared. Writes <name>.usda + <name>.usdz (a stored\n64-byte-aligned zip \u2014 loads in three.js, usdview, Blender, QuickLook).\nExit codes: 0 green \xB7 2 emitted-with-refusal \xB7 1 error.",
+    flags: [
+      ["<ws|dir>", "a workspace name on the cloud, or a local ledger clone / holon directory"],
+      ["--out <dir>", "the output directory (default: ./scene/<name>)"],
+      ["--cloud <url>", "target cloud (default: $NOMOS_CLOUD or the public cloud)"]
+    ],
+    examples: ["githolon scene my-guestbook", "githolon scene ./co2-clone --out build/scene", "githolon scene co2-platform"]
+  },
   status: {
     usage: "githolon status [<ws>] [--target <name>] [--file <deploy.json>]",
     what: "IS WHAT I BUILT WHAT IS DEPLOYED? Compares the local law hash (build/*.deploy.json) against\nthe workspace's installed law and names the remedy when they differ.\nExit codes: 0 in sync \xB7 2 drift \xB7 1 error.",
@@ -3131,9 +4328,9 @@ function capJsonStrings(v, max = 2048) {
   if (typeof v === "string") return v.length > max ? `${v.slice(0, max)}\u2026(${v.length} chars)` : v;
   if (Array.isArray(v)) return v.map((x) => capJsonStrings(x, max));
   if (typeof v === "object" && v !== null) {
-    const out11 = {};
-    for (const [k, x] of Object.entries(v)) out11[k] = capJsonStrings(x, max);
-    return out11;
+    const out12 = {};
+    for (const [k, x] of Object.entries(v)) out12[k] = capJsonStrings(x, max);
+    return out12;
   }
   return v;
 }
@@ -3463,6 +4660,9 @@ The inner loop:
   githolon status [<ws>]                                  local law hash vs the DEPLOYED law, remedy named
   githolon replay <ws|dir>                                the ledger as film: step the chain intent-by-
                                                        intent; finale = the verify_chain verdict
+  githolon scene <ws|dir> [--out <dir>]                   the ledger as a PORTABLE USD scene: verify_chain-
+                                                       gated chain\u2192USD projection (.usda + .usdz, loads
+                                                       in three.js/usdview/QuickLook; timeCode = index)
   githolon decrypt <ws> --as <p> --secret <b64>          clone + decrypt as a principal: unwrap their scope
             --query <id> [--param k=v]                   keys from the chain, read private fields in cleartext
 
@@ -3539,7 +4739,7 @@ Options:
 function cloudArgs(rest) {
   const pos = [];
   const opts = {};
-  const VALUE_FLAGS = ["--cloud", "--principal", "--as", "--file", "--target", "--parent", "--via", "--max", "--label", "--secret", "--payload", "--payload-file", "--save", "--format", "--with"];
+  const VALUE_FLAGS = ["--cloud", "--principal", "--as", "--file", "--target", "--parent", "--via", "--max", "--label", "--secret", "--payload", "--payload-file", "--save", "--format", "--with", "--out"];
   const BOOL_FLAGS = ["--sha256", "--stamp", "--yes", "--clear", "--keep-beside", "--retire-replaced", "--explain-current-interface"];
   for (let i = 0; i < rest.length; i++) {
     const a = rest[i];
@@ -3566,6 +4766,7 @@ function cloudArgs(rest) {
       else if (a === "--save") opts.save = v;
       else if (a === "--format") opts.format = v;
       else if (a === "--with") opts.with = v;
+      else if (a === "--out") opts.out = v;
       else if (a === "--max") {
         const n = Number(v);
         if (!Number.isInteger(n) || n <= 0) return { pos, opts, bad: `--max requires a positive integer` };
@@ -3591,9 +4792,9 @@ ${USAGE}`);
   if (bad !== void 0) return usageFail(bad);
   const boundWs = async (explicit, hint) => resolveWorkspace(explicit, process.cwd(), opts.target, hint);
   if (command === "ws") {
-    const [sub2, name] = pos;
-    if (sub2 === "create" && name !== void 0) return wsCreate(name, opts);
-    if (sub2 === "status") {
+    const [sub3, name] = pos;
+    if (sub3 === "create" && name !== void 0) return wsCreate(name, opts);
+    if (sub3 === "status") {
       try {
         return await wsStatus(await boundWs(name, `githolon ws status <name>`), opts);
       } catch (e) {
@@ -3602,8 +4803,8 @@ ${USAGE}`);
         return 1;
       }
     }
-    if (sub2 === "retire" && name !== void 0) return wsRetire(name, opts);
-    if (sub2 === "reclaim" && name !== void 0) return wsReclaim(name, opts);
+    if (sub3 === "retire" && name !== void 0) return wsRetire(name, opts);
+    if (sub3 === "reclaim" && name !== void 0) return wsReclaim(name, opts);
     return usageFail("expected: githolon ws <create|status|retire|reclaim> <name>");
   }
   if (command === "deploy") {
@@ -3615,9 +4816,9 @@ ${USAGE}`);
       return 1;
     }
   }
-  const [sub, ws, secret] = pos;
-  if (sub === "set" && ws !== void 0 && secret !== void 0) return secretSet(ws, secret, opts);
-  if (sub === "rotate" && ws !== void 0) return secretRotate(ws, opts);
+  const [sub2, ws, secret] = pos;
+  if (sub2 === "set" && ws !== void 0 && secret !== void 0) return secretSet(ws, secret, opts);
+  if (sub2 === "rotate" && ws !== void 0) return secretRotate(ws, opts);
   return usageFail("expected: githolon secret <set <ws> <secret> | rotate <ws>>");
 }
 function isKind(s) {
@@ -3648,11 +4849,11 @@ async function runProof(args) {
   const explicit = args.find((a, i) => !a.startsWith("--") && i !== domainValueIdx);
   let proofPath;
   if (explicit !== void 0) {
-    proofPath = resolve2(process.cwd(), explicit);
-    if (!existsSync9(proofPath)) return refuse(`proof not found: ${proofPath} \u2014 run \`githolon compile\` to (re)generate it`);
+    proofPath = resolve3(process.cwd(), explicit);
+    if (!existsSync10(proofPath)) return refuse(`proof not found: ${proofPath} \u2014 run \`githolon compile\` to (re)generate it`);
   } else {
-    const buildDir = join10(process.cwd(), "build");
-    if (!existsSync9(buildDir)) {
+    const buildDir = join11(process.cwd(), "build");
+    if (!existsSync10(buildDir)) {
       return refuse("no build/ directory here \u2014 run `githolon compile` first (every compile generates build/<name>.proof.mts from your law)");
     }
     const proofs = readdirSync4(buildDir).filter((f) => f.endsWith(".proof.mts"));
@@ -3662,7 +4863,7 @@ async function runProof(args) {
     if (proofs.length > 1) {
       return refuse(`found ${proofs.length} proofs (${proofs.join(", ")}) \u2014 name one: githolon proof build/<name>.proof.mts`);
     }
-    proofPath = join10(buildDir, proofs[0]);
+    proofPath = join11(buildDir, proofs[0]);
   }
   if (!live) {
     try {
@@ -3675,14 +4876,14 @@ async function runProof(args) {
   }
   const resolvePkgDir = (name, fromDir) => {
     try {
-      return dirname5(createRequire2(pathToFileURL4(join10(fromDir, "noop.js"))).resolve(`${name}/package.json`));
+      return dirname5(createRequire2(pathToFileURL4(join11(fromDir, "noop.js"))).resolve(`${name}/package.json`));
     } catch {
       return void 0;
     }
   };
   const dslDir = (() => {
     try {
-      return dirname5(createRequire2(pathToFileURL4(join10(process.cwd(), "noop.js"))).resolve("@githolon/dsl/package.json"));
+      return dirname5(createRequire2(pathToFileURL4(join11(process.cwd(), "noop.js"))).resolve("@githolon/dsl/package.json"));
     } catch {
       try {
         return dirname5(createRequire2(import.meta.url).resolve("@githolon/dsl/package.json"));
@@ -3695,9 +4896,9 @@ async function runProof(args) {
   if (tsxDir === void 0) {
     return refuse("tsx not found \u2014 add @githolon/dsl to your project's dependencies (tsx rides along) and npm install");
   }
-  const tsxPkg = JSON.parse(readFileSync11(join10(tsxDir, "package.json"), "utf8"));
+  const tsxPkg = JSON.parse(readFileSync11(join11(tsxDir, "package.json"), "utf8"));
   const tsxBinRel = typeof tsxPkg.bin === "string" ? tsxPkg.bin : tsxPkg.bin?.["tsx"];
-  const tsxCli = join10(tsxDir, tsxBinRel ?? "dist/cli.mjs");
+  const tsxCli = join11(tsxDir, tsxBinRel ?? "dist/cli.mjs");
   console.log("githolon proof --live \u2014 the full cloud loop (throwaway workspace, retired on exit" + (keep ? "; --keep: kept, secret printed once" : "") + ")");
   const r = spawnSync4(process.execPath, [tsxCli, proofPath], {
     stdio: "inherit",
@@ -3710,7 +4911,7 @@ function parseArgs(argv) {
   const [command, ...rest] = argv;
   if (command !== "generate" && command !== "g") {
     throw new Error(
-      `Unknown command '${command ?? "(none)"}'. Expected dev | compile | proof | replay | status | generate | ws | deploy | domains | secret.`
+      `Unknown command '${command ?? "(none)"}'. Expected dev | compile | proof | replay | scene | status | generate | ws | deploy | domains | secret.`
     );
   }
   let outDir = DEFAULT_OUT;
@@ -3825,6 +5026,24 @@ ${commandHelp("replay")}`);
     }
     return replay(target, { ...opts, ...step !== void 0 ? { step } : {}, ...json ? { json: true } : {} });
   }
+  if (argv[0] === "scene") {
+    const { scene: scene2 } = await Promise.resolve().then(() => (init_scene(), scene_exports));
+    const { pos, opts, bad } = cloudArgs(argv.slice(1));
+    if (bad !== void 0) {
+      process.stderr.write(`error: ${bad}
+
+${commandHelp("scene")}`);
+      return 1;
+    }
+    const target = pos[0];
+    if (target === void 0) {
+      process.stderr.write(`error: expected: githolon scene <ws|dir>
+
+${commandHelp("scene")}`);
+      return 1;
+    }
+    return scene2(target, opts);
+  }
   if (argv[0] === "decrypt") {
     const rest = argv.slice(1);
     const pull = (flag) => {
@@ -3885,10 +5104,10 @@ ${commandHelp("status")}`);
 ${commandHelp("domains") ?? USAGE}`);
       return 1;
     }
-    const [sub, ...tail] = pos;
+    const [sub2, ...tail] = pos;
     const boundWs = async (explicit, hint) => resolveWorkspace(explicit, process.cwd(), opts.target, hint);
     try {
-      if (sub === "retire") {
+      if (sub2 === "retire") {
         const [ws, target] = tail;
         if (ws === void 0 || target === void 0) {
           process.stderr.write(`error: expected: githolon domains retire <ws> <domainHashOrKey> [--with <hashOrKey>]
@@ -3898,7 +5117,7 @@ ${commandHelp("domains") ?? USAGE}`);
         }
         return await domainsRetire2(await boundWs(ws, "githolon domains retire <ws> <hashOrKey>"), target, opts);
       }
-      if (sub === "status") {
+      if (sub2 === "status") {
         return await domainsStatus2(await boundWs(tail[0], "githolon domains status <ws>"), opts);
       }
     } catch (e) {
@@ -3920,11 +5139,11 @@ ${commandHelp("domains") ?? USAGE}`);
 ${USAGE}`);
       return 1;
     }
-    const [sub] = pos;
-    if (sub === "enroll") return keyEnroll2(opts);
-    if (sub === "show") return keyShow2(opts);
-    if (sub === "import") return keyImport2(opts);
-    if (sub === "export") return keyExport2(opts);
+    const [sub2] = pos;
+    if (sub2 === "enroll") return keyEnroll2(opts);
+    if (sub2 === "show") return keyShow2(opts);
+    if (sub2 === "import") return keyImport2(opts);
+    if (sub2 === "export") return keyExport2(opts);
     process.stderr.write(`error: expected: githolon key <enroll|show|import|export> [--principal <uid>]
 
 ${USAGE}`);
@@ -4007,9 +5226,9 @@ ${USAGE}`);
 ${USAGE}`);
       return 1;
     }
-    const [sub, dir] = pos;
-    if (sub === "init" && dir !== void 0) return ledgerInit(dir, opts);
-    if (sub === "verify" && dir !== void 0) return ledgerVerify(dir, opts);
+    const [sub2, dir] = pos;
+    if (sub2 === "init" && dir !== void 0) return ledgerInit(dir, opts);
+    if (sub2 === "verify" && dir !== void 0) return ledgerVerify(dir, opts);
     process.stderr.write(`error: expected: githolon ledger <init|verify> <dir>
 
 ${USAGE}`);
@@ -4024,9 +5243,9 @@ ${USAGE}`);
 ${USAGE}`);
       return 1;
     }
-    const [sub, ws, remoteName] = pos;
-    if (sub === "setup") return gitSetup(opts);
-    if (sub === "remote") {
+    const [sub2, ws, remoteName] = pos;
+    if (sub2 === "setup") return gitSetup(opts);
+    if (sub2 === "remote") {
       try {
         return await gitRemote(await resolveWorkspace(ws, process.cwd(), opts.target, "githolon git remote <ws>"), remoteName ?? "nomos", opts);
       } catch (e) {
@@ -4043,8 +5262,8 @@ ${USAGE}`);
   let parsed;
   try {
     parsed = parseArgs(argv);
-  } catch (err11) {
-    process.stderr.write(`error: ${err11.message}
+  } catch (err12) {
+    process.stderr.write(`error: ${err12.message}
 
 ${USAGE}`);
     return 1;
@@ -4063,8 +5282,8 @@ ${USAGE}`);
     process.stdout.write(`created ${path}
 `);
     return 0;
-  } catch (err11) {
-    process.stderr.write(`error: ${err11.message}
+  } catch (err12) {
+    process.stderr.write(`error: ${err12.message}
 `);
     return 1;
   }