githolon 0.48.1 → 0.50.0

package/dist/cli.mjs

@@ -1299,6 +1299,44 @@ var init_git_fs = __esm({
 });
 
 // vendor/engine/tree.mjs
+function flatten(dir, prefix, out12) {
+  for (const [name, inode] of dir.contents) {
+    const path = prefix ? prefix + "/" + name : name;
+    if (inode.contents instanceof Map) {
+      out12.push({ path, dir: true });
+      flatten(inode, path, out12);
+    } else {
+      out12.push({ path, dir: false, bytes: inode.data ?? new Uint8Array(0) });
+    }
+  }
+}
+function serializeTree(workTree) {
+  const entries = [];
+  flatten(workTree, "", entries);
+  const chunks = [];
+  const header = new Uint8Array(4);
+  new DataView(header.buffer).setUint32(0, entries.length, true);
+  chunks.push(header);
+  for (const e of entries) {
+    const pathBytes = enc.encode(e.path);
+    const body = e.dir ? new Uint8Array(0) : e.bytes ?? new Uint8Array(0);
+    const meta = new Uint8Array(9);
+    const dv = new DataView(meta.buffer);
+    dv.setUint8(0, e.dir ? 1 : 0);
+    dv.setUint32(1, pathBytes.length, true);
+    dv.setUint32(5, body.length, true);
+    chunks.push(meta, pathBytes, body);
+  }
+  let total = 0;
+  for (const c of chunks) total += c.length;
+  const out12 = new Uint8Array(total);
+  let off = 0;
+  for (const c of chunks) {
+    out12.set(c, off);
+    off += c.length;
+  }
+  return out12;
+}
 var enc, dec;
 var init_tree = __esm({
   "vendor/engine/tree.mjs"() {
@@ -2268,6 +2306,74 @@ var init_proof_offline = __esm({
   }
 });
 
+// src/harness.ts
+var harness_exports = {};
+__export(harness_exports, {
+  harnessInstall: () => harnessInstall
+});
+import { existsSync as existsSync9, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join10 } from "node:path";
+import { randomBytes as randomBytes3 } from "node:crypto";
+async function harnessInstall(opts) {
+  const { deploy: deployPaths, workspace, out: outPath } = opts;
+  if (deployPaths.length === 0) die("no --deploy JSON path(s) given");
+  const runtimeDir = opts.runtime || process.env["NOMOS_OFFLINE_RUNTIME"] || join10(configDir(), "runtime");
+  const wasmFile = join10(runtimeDir, "holon.wasm");
+  const pkgsFile = join10(runtimeDir, "packages.json");
+  if (!existsSync9(wasmFile) || !existsSync9(pkgsFile)) {
+    die(
+      `runtime cache missing at ${runtimeDir} (holon.wasm + packages.json). Warm it once with a \`githolon\` run (it fetches + caches the runtime), then re-run offline.`
+    );
+  }
+  const wasm = readFileSync11(wasmFile);
+  const pkgs = JSON.parse(readFileSync11(pkgsFile, "utf8"));
+  const replica = BigInt(`0x${randomBytes3(8).toString("hex")}`) & (1n << 63n) - 1n;
+  const eng = await createEngine({
+    wasmModule: await WebAssembly.compile(wasm),
+    bootstrapPkg: pkgs.bootstrap,
+    nomosPkg: pkgs.nomos,
+    replica,
+    installedBy: "nomos-test-harness"
+  });
+  await mountFresh(eng, workspace);
+  author(eng, workspace, "bootstrap", "installDomain", installPayload(eng.hashes.nomos, eng.nomosPkg, "nomos-test-harness"), "");
+  const lawHashes = [];
+  for (const p of deployPaths) {
+    if (!existsSync9(p)) die(`deploy JSON not found: ${p} \u2014 run \`npx githolon compile\` first`);
+    const deploy2 = JSON.parse(readFileSync11(p, "utf8"));
+    const usda = deploy2.packageUsda;
+    if (typeof usda !== "string" || !usda.startsWith("#usda")) die(`${p} has no #usda packageUsda`);
+    const lawHash = await sha256hex(usda);
+    author(eng, workspace, "nomos", "installDomain", installPayload(lawHash, usda, "nomos-test-harness"), eng.hashes.nomos);
+    lawHashes.push(lawHash);
+    process.stderr.write(`harness-install: installed ${p} (law ${lawHash.slice(0, 12)}\u2026)
+`);
+  }
+  const wsNode = eng.preopen.dir.contents.get("ws").contents.get(workspace);
+  if (!wsNode) die(`internal: workspace tree '${workspace}' not found after install`);
+  const treeBytes = serializeTree(wsNode);
+  writeFileSync6(outPath, treeBytes);
+  process.stderr.write(`harness-install: snapshot written (${treeBytes.length} bytes) \u2192 ${outPath}
+`);
+  process.stdout.write(JSON.stringify({ ok: true, snapshot: outPath, workspace, lawHashes }) + "\n");
+  return 0;
+}
+var die;
+var init_harness = __esm({
+  "src/harness.ts"() {
+    "use strict";
+    init_engine();
+    init_tree();
+    init_local_holon();
+    init_cloud();
+    die = (msg) => {
+      process.stderr.write(`harness-install: ${msg}
+`);
+      process.exit(1);
+    };
+  }
+});
+
 // src/scene_projector.ts
 import { createHash as createHash4 } from "node:crypto";
 function fnv1a32(s) {
@@ -2517,8 +2623,10 @@ function glyphSignature(structJson, name, partCount) {
   return { structureHash: h, facetCount, hue, hueBase, elongation, size, color: hslToRgb(hue, 0.62, 0.6) };
 }
 function packageLayers(packageUsda) {
+  const b = /nomos:usdJsonB64 = "([A-Za-z0-9+/=]+)"/.exec(packageUsda);
+  if (b) return JSON.parse(Buffer.from(b[1], "base64").toString("utf8")).layers;
   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");
+  if (!m) throw new Error("a chain-installed package carries no nomos:usdJson blob \u2014 not an openusd-ir package");
   return JSON.parse(Buffer.from(m[1], "hex").toString("utf8")).layers;
 }
 function lawInstallsFromChain(entries) {
@@ -3322,8 +3430,8 @@ 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 { existsSync as existsSync10, mkdirSync as mkdirSync4, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join11, resolve as resolve2 } from "node:path";
 import { createHash as createHash5 } from "node:crypto";
 import git3 from "isomorphic-git";
 async function walkChain2(eng, ws) {
@@ -3344,8 +3452,8 @@ 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)`);
+    const gitDir = existsSync10(join11(target, ".git")) ? join11(target, ".git") : target;
+    if (!existsSync10(join11(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 {
@@ -3404,7 +3512,7 @@ async function projectOnce(cloud, target, isDir, name) {
 }
 async function scene(target, opts) {
   const cloud = cloudBase(opts.cloud);
-  const isDir = existsSync9(target) || target.includes("/") || target.startsWith(".");
+  const isDir = existsSync10(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;
@@ -3424,13 +3532,13 @@ async function scene(target, opts) {
     err11(`the emitted stage violates the portable profile: ${violations.join("; ")}`);
     return 1;
   }
-  const outDir = resolve2(opts.out ?? join10("scene", name));
+  const outDir = resolve2(opts.out ?? join11("scene", name));
   mkdirSync4(outDir, { recursive: true });
-  const usdaPath = join10(outDir, `${name}.usda`);
-  const usdzPath = join10(outDir, `${name}.usdz`);
+  const usdaPath = join11(outDir, `${name}.usda`);
+  const usdzPath = join11(outDir, `${name}.usdz`);
   const usdaBytes = new TextEncoder().encode(first.usda);
-  writeFileSync6(usdaPath, usdaBytes);
-  writeFileSync6(usdzPath, usdzPack([[`${name}.usda`, usdaBytes]]));
+  writeFileSync7(usdaPath, usdaBytes);
+  writeFileSync7(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`);
@@ -3456,10 +3564,10 @@ var init_scene = __esm({
 });
 
 // src/cli.ts
-import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync12 } from "node:fs";
 import { spawnSync as spawnSync4 } from "node:child_process";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname5, join as join11, resolve as resolve3 } from "node:path";
+import { dirname as dirname5, join as join12, resolve as resolve3 } from "node:path";
 import { pathToFileURL as pathToFileURL4 } from "node:url";
 
 // src/generate.ts
@@ -3671,6 +3779,20 @@ function runCompile(args) {
   const r = spawnSync(process.execPath, [launcher, ...args], { stdio: "inherit", cwd: process.cwd() });
   return r.status ?? 1;
 }
+function resolveCheckLauncher(cwd) {
+  const launcher = resolveCompileLauncher(cwd);
+  return launcher === void 0 ? void 0 : join3(dirname(launcher), "check_package.mjs");
+}
+function runCheck(args) {
+  const launcher = resolveCheckLauncher(process.cwd());
+  if (launcher === void 0) {
+    process.stderr.write(`error: ${NO_DSL_REMEDY}
+`);
+    return 1;
+  }
+  const r = spawnSync(process.execPath, [launcher, ...args], { stdio: "inherit", cwd: process.cwd() });
+  return r.status ?? 1;
+}
 function compileAsync(cwd, args = []) {
   const launcher = resolveCompileLauncher(cwd);
   const t0 = performance.now();
@@ -4826,9 +4948,15 @@ The inner loop:
             --query <id> [--param k=v]                   keys from the chain, read private fields in cleartext
 
 Authoring:
+  githolon check    [config]                              run the author-time gate (static twins) on
+                                                       ./nomos.package.mjs \u2014 the unified report; exits
+                                                       non-zero on any REFUSE (compile runs it implicitly)
   githolon compile  [compiler args]                       compile the package by ./nomos.package.mjs
   githolon proof    [build/<name>.proof.mts]              run the proof GENERATED from your law, live
                                                        (every compile emits it; ALL GREEN or it names the jam)
+  githolon harness-install --deploy <deploy.json[,...]>  offline install for the headless TEST HARNESS:
+            --workspace <ws> --out <snapshot>            install tenant law IN-CHAIN (no cloud), write the
+                                                       restore snapshot, print { ok, snapshot, lawHashes }
   githolon generate <domain|aggregate|intent> <name> [options]
   githolon g        <domain|aggregate|intent> <name> [options]
 
@@ -5009,10 +5137,10 @@ async function runProof(args) {
   let proofPath;
   if (explicit !== void 0) {
     proofPath = resolve3(process.cwd(), explicit);
-    if (!existsSync10(proofPath)) return refuse(`proof not found: ${proofPath} \u2014 run \`githolon compile\` to (re)generate it`);
+    if (!existsSync11(proofPath)) return refuse(`proof not found: ${proofPath} \u2014 run \`githolon compile\` to (re)generate it`);
   } else {
-    const buildDir = join11(process.cwd(), "build");
-    if (!existsSync10(buildDir)) {
+    const buildDir = join12(process.cwd(), "build");
+    if (!existsSync11(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"));
@@ -5022,7 +5150,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 = join11(buildDir, proofs[0]);
+    proofPath = join12(buildDir, proofs[0]);
   }
   if (!live) {
     try {
@@ -5035,14 +5163,14 @@ async function runProof(args) {
   }
   const resolvePkgDir = (name, fromDir) => {
     try {
-      return dirname5(createRequire2(pathToFileURL4(join11(fromDir, "noop.js"))).resolve(`${name}/package.json`));
+      return dirname5(createRequire2(pathToFileURL4(join12(fromDir, "noop.js"))).resolve(`${name}/package.json`));
     } catch {
       return void 0;
     }
   };
   const dslDir = (() => {
     try {
-      return dirname5(createRequire2(pathToFileURL4(join11(process.cwd(), "noop.js"))).resolve("@githolon/dsl/package.json"));
+      return dirname5(createRequire2(pathToFileURL4(join12(process.cwd(), "noop.js"))).resolve("@githolon/dsl/package.json"));
     } catch {
       try {
         return dirname5(createRequire2(import.meta.url).resolve("@githolon/dsl/package.json"));
@@ -5055,9 +5183,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(join11(tsxDir, "package.json"), "utf8"));
+  const tsxPkg = JSON.parse(readFileSync12(join12(tsxDir, "package.json"), "utf8"));
   const tsxBinRel = typeof tsxPkg.bin === "string" ? tsxPkg.bin : tsxPkg.bin?.["tsx"];
-  const tsxCli = join11(tsxDir, tsxBinRel ?? "dist/cli.mjs");
+  const tsxCli = join12(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));
@@ -5165,9 +5293,33 @@ async function main(argv) {
   if (argv[0] === "compile") {
     return runCompile(argv.slice(1));
   }
+  if (argv[0] === "check") {
+    return runCheck(argv.slice(1));
+  }
   if (argv[0] === "proof") {
     return runProof(argv.slice(1));
   }
+  if (argv[0] === "harness-install") {
+    const rest = argv.slice(1);
+    const pull = (flag) => {
+      const at = rest.indexOf(flag);
+      return at >= 0 ? rest[at + 1] : void 0;
+    };
+    const deployArg = pull("--deploy");
+    const workspace = pull("--workspace") ?? "test-ws";
+    const out12 = pull("--out");
+    const runtime = pull("--runtime");
+    const deploy2 = (deployArg ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    if (deploy2.length === 0 || out12 === void 0) {
+      process.stderr.write(
+        `error: usage: githolon harness-install --deploy <deploy.json[,deploy.json...]> --workspace <ws> --out <snapshotPath> [--runtime <dir>]
+`
+      );
+      return 1;
+    }
+    const { harnessInstall: harnessInstall2 } = await Promise.resolve().then(() => (init_harness(), harness_exports));
+    return harnessInstall2({ deploy: deploy2, workspace, out: out12, ...runtime !== void 0 ? { runtime } : {} });
+  }
   if (argv[0] === "dev") {
     const rest = argv.slice(1);
     let cloud;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "githolon",
-  "version": "0.48.1",
+  "version": "0.50.0",
   "type": "module",
   "description": "githolon — the Nomos developer CLI: Rails-style generators for @githolon/dsl domains + the package compiler. Kernel-independent.",
   "license": "SEE LICENSE IN LICENSE.md",
@@ -29,8 +29,8 @@
   },
   "dependencies": {
     "@bjorn3/browser_wasi_shim": "0.4.2",
-    "@githolon/client": "^0.48.1",
-    "@githolon/dsl": "^0.48.1",
+    "@githolon/client": "^0.50.0",
+    "@githolon/dsl": "^0.50.0",
     "isomorphic-git": "^1.38.4"
   },
   "devDependencies": {