githolon 0.33.0 → 0.34.1

package/dist/cli.mjs

@@ -924,20 +924,45 @@ async function wsRetire(ws, opts) {
   const cloud = cloudBase(opts.cloud);
   const { signAndPostGovernance: signAndPostGovernance2, resolveGovernancePrincipal: resolveGovernancePrincipal2 } = await Promise.resolve().then(() => (init_governance(), governance_exports));
   const parent = opts.parent ?? "root";
+  let record;
+  try {
+    const q = await fetch(`${cloud}/v2/workspaces/${parent}/workspaceByName?name=${encodeURIComponent(ws)}`);
+    const qd = await q.json().catch(() => void 0);
+    const rows = qd?.ok === true ? qd.rows ?? [] : [];
+    record = rows.find((r) => r.data?.status !== "retired" && r.data?.status !== "reclaimed") ?? rows[0];
+  } catch {
+  }
+  const recordId = record?.id;
+  if (recordId === void 0) {
+    err3(
+      `retire '${ws}': no CloudWorkspace record named '${ws}' in ${parent}'s registry \u2014 nothing lawful to retire.
+  (a workspace born via the OPEN lane \u2014 bare POST /v2/workspaces/${ws} \u2014 has no registry row;
+   registered births ride \`githolon ws create ${ws} --via ${parent}\`. An unregistered leak needs a custodian sweep.)`
+    );
+    return 1;
+  }
   let v;
   try {
     const principal = resolveGovernancePrincipal2(opts);
-    const payload = { workspaceId: ws, retiredBy: principal, retiredAt: Date.now() };
-    v = await signAndPostGovernance2(parent, "retireOwnWorkspace", payload, opts);
-    if (!v.ok && v.status === 422) {
-      v = await signAndPostGovernance2(parent, "retireWorkspace", payload, opts);
-    }
+    const payload = { workspaceId: recordId, retiredBy: principal, retiredAt: Date.now() };
+    const bare = (s) => s.startsWith("user:") ? s.slice(5) : s;
+    const creator = record?.data?.createdBy ?? record?.data?.principal ?? "";
+    const own = creator !== "" && bare(creator) === bare(principal);
+    v = await signAndPostGovernance2(parent, own ? "retireOwnWorkspace" : "retireWorkspace", payload, opts);
   } catch (e) {
     err3(e.message);
     return 1;
   }
   if (!v.ok) {
     err3(`retire '${ws}' refused (${v.status}): ${typeof v.body === "string" ? v.body : JSON.stringify(v.body)}`);
+    if (JSON.stringify(v.body ?? "").includes("retire-own-only")) {
+      err3(
+        `note: you appear to BE '${ws}'s creator \u2014 the parent's deployed governance law may predate the
+  0.34.1 retireOwnWorkspace creator-normalization fix (the 'user:' subject prefix vs the bare uid).
+  A governance re-deploy to ${parent} fixes the self-service lane; meanwhile an ADMIN can retire it:
+  githolon ws retire ${ws} --as <admin-uid>`
+      );
+    }
     return 1;
   }
   out3(`\u2713 workspace ${ws} retired via signed governance offer to ${parent} on ${cloud}`);
@@ -1143,7 +1168,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 +1178,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 +1201,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 +1221,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 +1270,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 +1429,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 +2137,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
@@ -2827,7 +4039,7 @@ var HELP = {
   },
   proof: {
     usage: "githolon proof [build/<name>.proof.mts] [--domain <key>] [--live] [--keep]",
-    what: "Run the proof GENERATED from your law. DEFAULT: the OFFLINE legs on a LOCAL holon \u2014 the\nsame engine plane the cloud edge runs; no cloud workspace is touched (develop/play/understand\nhere, deploy with confidence after). --domain <key> proves a SPECIFIC domain of a multi-domain\npackage (offline; the default is the first). --live runs the full cloud loop (throwaway\nworkspace \u2192 deploy \u2192 offline write \u2192 admission \u2192 cloud reads \u2192 convergence), RETIRED on every\nexit; --keep keeps it and prints the secret once. ALL GREEN or it names the jam. The offline\nlegs also rerun on every save in `githolon dev`.",
+    what: "Run the proof GENERATED from your law. DEFAULT: the OFFLINE legs on a LOCAL holon \u2014 the\nsame engine plane the cloud edge runs; no cloud workspace is touched (develop/play/understand\nhere, deploy with confidence after). --domain <key> proves a SPECIFIC domain of a multi-domain\npackage (offline; the default is the first). --live runs the full cloud loop (throwaway\nworkspace \u2192 deploy \u2192 offline write \u2192 admission \u2192 cloud reads \u2192 convergence). The throwaway is\ncreated REGISTERED (a signed createWorkspace at root \u2014 your principal needs creation authority\nthere) and RETIRED on every exit via the lawful retireOwnWorkspace; --keep keeps it. ALL GREEN or it names the jam. The offline\nlegs also rerun on every save in `githolon dev`.",
     examples: ["githolon proof", "githolon proof --domain co2_platform", "githolon proof --live", "githolon proof --live --keep"]
   },
   dev: {
@@ -2856,6 +4068,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 +4353,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 +4685,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 +4764,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 +4791,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 +4817,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 +4828,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 +4841,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 +4874,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 +4888,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 +4901,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,22 +4921,67 @@ 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");
-  console.log("githolon proof --live \u2014 the full cloud loop (throwaway workspace, retired on exit" + (keep ? "; --keep: kept, secret printed once" : "") + ")");
+  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" : "") + ")");
+  const { wsCreate: wsCreate2, wsRetire: wsRetire2 } = await Promise.resolve().then(() => (init_cloud(), cloud_exports));
+  const { resolveGovernancePrincipal: resolveGovernancePrincipal2 } = await Promise.resolve().then(() => (init_governance(), governance_exports));
+  const { login: login2, activePrincipal: activePrincipal2 } = await Promise.resolve().then(() => (init_cloud(), cloud_exports));
+  let principal = process.env.NOMOS_PRINCIPAL;
+  try {
+    principal ??= resolveGovernancePrincipal2({});
+  } catch {
+    const lr = await login2({ agent: true });
+    principal = lr === 0 ? activePrincipal2() : void 0;
+  }
+  if (principal === void 0) {
+    return refuse("proof --live needs a principal \u2014 githolon login --agent (self-onboarding) failed; try it directly or pass NOMOS_PRINCIPAL");
+  }
+  const proofSlug = proofPath.split("/").pop().replace(/\.proof\.mts$/, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+  const ws = process.env.NOMOS_WS ?? `${proofSlug}-proof-${Math.random().toString(36).slice(2, 8)}`;
+  if (process.env.NOMOS_WS === void 0) {
+    const cr = await wsCreate2(ws, { via: "root", principal });
+    if (cr !== 0) {
+      return refuse(
+        `proof --live: registered create refused at root \u2014 principal ${principal} lacks creation authority, and the open birth lane would leak an unretirable workspace.
+  remedies:
+    \u2022 ask an operator: githolon grant creation ${principal}   (then rerun)
+    \u2022 or pre-create a REGISTERED workspace yourself and hand it over: NOMOS_WS=<ws> githolon proof --live
+    \u2022 or develop offline (no cloud workspace at all): githolon proof`
+      );
+    }
+  }
   const r = spawnSync4(process.execPath, [tsxCli, proofPath], {
     stdio: "inherit",
     cwd: process.cwd(),
-    env: { ...process.env, ...keep ? { PROOF_KEEP: "1" } : {} }
+    env: {
+      ...process.env,
+      NOMOS_WS: ws,
+      NOMOS_PRINCIPAL: principal,
+      NOMOS_PROOF_MANAGED: "1",
+      // the proof skips its own (dead) cleanup lane; the CLI retires below
+      ...keep ? { PROOF_KEEP: "1" } : {}
+    }
   });
-  return r.status ?? 1;
+  const proofStatus = r.status ?? 1;
+  if (keep) {
+    console.log(`workspace ${ws} KEPT (--keep) \u2014 retire it when done: githolon ws retire ${ws}`);
+    return proofStatus;
+  }
+  const rr = await wsRetire2(ws, { principal }).catch(() => 1);
+  if (rr !== 0) {
+    console.error(`\u26A0 THROWAWAY WORKSPACE NOT RETIRED: ${ws}`);
+    console.error(`\u26A0 retire it manually: githolon ws retire ${ws}`);
+    console.error(`\u26A0 (if it has no root registry row it was born unregistered and needs a custodian sweep)`);
+  }
+  return proofStatus;
 }
 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 +5096,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 +5174,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 +5187,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 +5209,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 +5296,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 +5313,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 +5332,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 +5352,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;
   }