githolon 0.13.0 → 0.15.0

package/dist/cli.mjs

@@ -476,7 +476,14 @@ function call(ex, mode, fields, STDERR) {
   const reqPtr = ex.git_holon_alloc(req.length);
   try {
     new Uint8Array(ex.memory.buffer, reqPtr, req.length).set(req);
-    const { ptr, len } = unpack(ex.git_holon_call(reqPtr, req.length));
+    let packed;
+    try {
+      packed = ex.git_holon_call(reqPtr, req.length);
+    } catch (e) {
+      const tail = STDERR.length ? ` | stderr: ${STDERR.slice(-8).join(" / ")}` : "";
+      throw new Error(`${String(e && e.stack || e)}${tail}`);
+    }
+    const { ptr, len } = unpack(packed);
     try {
       const e = JSON.parse(dec2.decode(new Uint8Array(ex.memory.buffer, ptr, len).slice()));
       if (!e.ok) throw new Error((e.error || "holon error") + (STDERR.length ? ` | ${STDERR.slice(-4).join(" / ")}` : ""));
@@ -488,14 +495,9 @@ function call(ex, mode, fields, STDERR) {
     ex.git_holon_dealloc(reqPtr, req.length);
   }
 }
-function seedManifests(m, strings) {
-  m.set("domain_manifests.json", new File(enc2.encode(strings.read)));
-  m.set("identity-manifests.json", new File(enc2.encode(strings.identity)));
-}
-async function createEngine({ wasmModule, bootstrapPkg, nomosPkg, manifestStrings, replica, installedBy = "nomos-cloud" }) {
+async function createEngine({ wasmModule, bootstrapPkg, nomosPkg, replica, installedBy = "nomos-cloud" }) {
   const hashes = { bootstrap: await sha256hex(bootstrapPkg), nomos: await sha256hex(nomosPkg) };
   const root = /* @__PURE__ */ new Map();
-  seedManifests(root, manifestStrings);
   root.set("domain.package.usda", new File(enc2.encode(bootstrapPkg)));
   root.set("ws", new Directory(/* @__PURE__ */ new Map()));
   const preopen = new PreopenDirectory("/work", root);
@@ -516,55 +518,56 @@ async function createEngine({ wasmModule, bootstrapPkg, nomosPkg, manifestString
     hashes,
     bootstrapPkg,
     nomosPkg,
-    manifestStrings,
     installedBy,
     fs: makeGitFs(preopen, "/work", { File, Directory }),
     mounted: /* @__PURE__ */ new Map(),
     // ws -> { restored, remoteMain, restoreError }
-    mainIntents: /* @__PURE__ */ new Map(),
+    mainIntents: /* @__PURE__ */ new Map()
     // ws -> { head, ids:Set, oids:Set } (admission idempotence)
-    knownDomainsCache: null
   };
   return eng;
 }
-function setManifests(eng, strings) {
-  eng.manifestStrings = strings;
-  eng.knownDomainsCache = null;
-  eng.directiveRoutesCache = null;
-  eng.scopedReadsCache = null;
-  eng.placementDirectivesCache = null;
-  eng.tenantTypesCache = null;
-  eng.globalAggregatesCache = null;
-  const root = eng.preopen.dir.contents;
-  seedManifests(root, strings);
-  const wsRoot = root.get("ws");
-  for (const ws of eng.mounted.keys()) {
-    const wsDir = wsRoot.contents.get(ws);
-    if (wsDir) seedManifests(wsDir.contents, strings);
-  }
+function stageWorkspaceDir(eng, ws) {
+  const wsContents = /* @__PURE__ */ new Map();
+  eng.preopen.dir.contents.get("ws").contents.set(ws, new Directory(wsContents));
 }
 async function mountWorkspace(eng, ws, ledger) {
   if (eng.mounted.has(ws)) return eng.mounted.get(ws);
-  const wsContents = /* @__PURE__ */ new Map();
-  seedManifests(wsContents, eng.manifestStrings);
-  eng.preopen.dir.contents.get("ws").contents.set(ws, new Directory(wsContents));
+  stageWorkspaceDir(eng, ws);
   const gitdir = gitdirOf(ws);
-  let restored = false, remoteMain = null, restoreError = null;
+  let restored = false, remoteMain = null, restoreError = null, checkpoint = null;
   try {
     const info = await git.getRemoteInfo({ http, url: ledger.remote, headers: ledger.headers });
     remoteMain = info.refs && info.refs.heads && info.refs.heads.main || null;
     if (remoteMain) {
       await git.init({ fs: eng.fs, gitdir, bare: true, defaultBranch: "main" });
       await git.addRemote({ fs: eng.fs, gitdir, remote: "origin", url: ledger.remote, force: true });
-      await git.fetch({ fs: eng.fs, http, gitdir, remote: "origin", ref: "main", singleBranch: true, headers: ledger.headers });
+      const ckpt = await discoverCheckpointFromCustody(ledger).catch(() => null);
+      let shallowOk = false;
+      if (ckpt?.cursor && ckpt.frontier) {
+        const steps = [32, 96, 256, 1024];
+        for (let i = 0; i < steps.length; i++) {
+          const depth = steps[i], relative = i > 0;
+          await git.fetch({ fs: eng.fs, http, gitdir, remote: "origin", ref: "main", singleBranch: true, depth, relative, headers: ledger.headers });
+          if (await git.readCommit({ fs: eng.fs, gitdir, oid: ckpt.cursor }).then(() => true, () => false)) {
+            shallowOk = true;
+            break;
+          }
+        }
+      }
+      if (!shallowOk) await git.fetch({ fs: eng.fs, http, gitdir, remote: "origin", ref: "main", singleBranch: true, headers: ledger.headers });
       await git.writeRef({ fs: eng.fs, gitdir, ref: "refs/heads/main", value: remoteMain, force: true });
       await git.writeRef({ fs: eng.fs, gitdir, ref: "HEAD", value: "ref: refs/heads/main", force: true, symbolic: true });
+      if (shallowOk && ckpt?.blob) {
+        const r = importCheckpoint(eng, ws, ckpt.blob, ckpt.frontier);
+        checkpoint = { restored: !!(r && r.restored), frontierSeeded: !!(r && r.frontierSeeded), cursor: r && r.cursor ? r.cursor : ckpt.cursor, ref: ckpt.ref };
+      }
       restored = true;
     }
   } catch (e) {
     restoreError = String(e && e.stack || e).split("\n").slice(0, 5).join(" | ");
   }
-  const m = { restored, remoteMain, restoreError };
+  const m = { restored, remoteMain, restoreError, checkpoint };
   eng.mounted.set(ws, m);
   return m;
 }
@@ -591,6 +594,71 @@ function author(eng, ws, domain, directiveId, payload, controllerHash, opts = {}
   if (defer && res.ok) (eng.pendingProjection ??= /* @__PURE__ */ new Set()).add(ws);
   return res;
 }
+function importCheckpoint(eng, ws, blobB64, frontierB64) {
+  return JSON.parse(call(eng.ex, "checkpoint_import", { repoArg: repoArgOf(ws), workspace: ws, branch: BRANCH, blob: blobB64, ...frontierB64 ? { frontier: frontierB64 } : {} }, eng.STDERR));
+}
+async function streamAll(stream) {
+  const chunks = [];
+  const reader = stream.getReader();
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  let len = 0;
+  for (const c of chunks) len += c.length;
+  const out10 = new Uint8Array(len);
+  let at = 0;
+  for (const c of chunks) {
+    out10.set(c, at);
+    at += c.length;
+  }
+  return out10;
+}
+async function gunzip(bytes) {
+  const ds = new DecompressionStream("gzip");
+  return streamAll(new Response(bytes).body.pipeThrough(ds));
+}
+async function discoverCheckpointFromCustody(ledger) {
+  const freshHeaders = () => ({ ...ledger.headers || {} });
+  const refs = (await git.listServerRefs({ http, url: ledger.remote, headers: freshHeaders(), prefix: "refs/meta/checkpoint/", protocolVersion: 2 }) || []).filter((r) => r.ref && r.ref.startsWith("refs/meta/checkpoint/") && r.oid);
+  if (!refs.length) return null;
+  const root = /* @__PURE__ */ new Map();
+  root.set("ckpt", new Directory(/* @__PURE__ */ new Map()));
+  const preopen = new PreopenDirectory("/work", root);
+  const fs = makeGitFs(preopen, "/work", { File, Directory });
+  const gitdir = "/work/ckpt/nomos.git";
+  await git.init({ fs, gitdir, bare: true, defaultBranch: BRANCH });
+  await git.addRemote({ fs, gitdir, remote: "origin", url: ledger.remote, force: true });
+  const readFile = async (oid, filepath) => {
+    try {
+      return (await git.readBlob({ fs, gitdir, oid, filepath })).blob;
+    } catch {
+      return null;
+    }
+  };
+  for (let i = refs.length - 1; i >= 0 && i >= refs.length - 3; i--) {
+    const { ref, oid } = refs[i];
+    try {
+      await git.fetch({ fs, http, gitdir, remote: "origin", ref, singleBranch: true, depth: 1, headers: freshHeaders() });
+      const gz = await readFile(oid, "checkpoint");
+      if (!gz) continue;
+      let meta = {};
+      try {
+        const mb = await readFile(oid, "meta");
+        if (mb) meta = JSON.parse(dec2.decode(mb));
+      } catch {
+      }
+      const codec = meta.codec ?? "gzip";
+      const blob = dec2.decode(codec === "gzip" ? await gunzip(gz) : gz);
+      const fgz = await readFile(oid, "frontier");
+      const frontier = fgz ? dec2.decode(codec === "gzip" ? await gunzip(fgz) : fgz) : null;
+      return { ref, oid, cursor: meta.cursor || null, blob, frontier };
+    } catch {
+    }
+  }
+  return null;
+}
 function applyIntentBytes(eng, ws, bytes) {
   const name = `intent-in-${eng.seq++}.json`;
   writeWork(eng, name, bytes);
@@ -648,9 +716,8 @@ async function fetchRuntime(cloud) {
   const localWasm = process.env["NOMOS_LOCAL_WASM"];
   if (localWasm) {
     const bytes = readFileSync2(localWasm);
-    const manifests2 = await fetchJsonCached(`${cloud}/v1/runtime/manifests`, join4(cache, "manifests.json"));
     const packages2 = await fetchJsonCached(`${cloud}/v1/runtime/packages`, join4(cache, "packages.json"));
-    return { wasmBytes: bytes, manifests: manifests2, packages: packages2 };
+    return { wasmBytes: bytes, packages: packages2 };
   }
   try {
     const r = await fetch(`${cloud}/v1/runtime/holon.wasm`);
@@ -662,25 +729,8 @@ async function fetchRuntime(cloud) {
     if (!existsSync3(wasmCache)) throw e;
     wasmBytes = readFileSync2(wasmCache);
   }
-  const manifests = await fetchJsonCached(`${cloud}/v1/runtime/manifests`, join4(cache, "manifests.json"));
   const packages = await fetchJsonCached(`${cloud}/v1/runtime/packages`, join4(cache, "packages.json"));
-  return { wasmBytes, manifests, packages };
-}
-function mergeManifests(baked, overlay) {
-  const read = JSON.parse(baked.domainManifests);
-  const identity = JSON.parse(baked.identityManifests);
-  for (const [k, v] of Object.entries(overlay.identityManifests ?? {})) identity[k] = v;
-  const r = overlay.readManifest;
-  if (r !== void 0) {
-    for (const [t, schema] of Object.entries(r["aggregateFieldKinds"] ?? {})) read["aggregateFieldKinds"][t] = schema;
-    for (const key of ["queries", "counts", "sums", "mins", "maxes", "spatials", "deriveds", "combineds"]) {
-      for (const d of r[key] ?? []) {
-        const list = read[key] = read[key] ?? [];
-        if (!list.some((x) => JSON.stringify(x) === JSON.stringify(d))) list.push(d);
-      }
-    }
-  }
-  return { read: JSON.stringify(read), identity: JSON.stringify(identity) };
+  return { wasmBytes, packages };
 }
 function writeTreeToDisk(dir, diskPath) {
   mkdirSync3(diskPath, { recursive: true });
@@ -701,13 +751,11 @@ function readTreeFromDisk(diskPath) {
 }
 async function holonEngine(cloud, overlay, installedBy) {
   const runtime = await fetchRuntime(cloud);
-  const manifestStrings = overlay === void 0 ? { read: runtime.manifests.domainManifests, identity: runtime.manifests.identityManifests } : mergeManifests(runtime.manifests, overlay);
   const replica = BigInt(`0x${randomBytes(8).toString("hex")}`) & (1n << 63n) - 1n;
   const eng = await createEngine({
     wasmModule: await WebAssembly.compile(runtime.wasmBytes),
     bootstrapPkg: runtime.packages.bootstrap,
     nomosPkg: runtime.packages.nomos,
-    manifestStrings,
     replica,
     installedBy
   });
@@ -1475,12 +1523,9 @@ function readDeployBody(cwd, packageName) {
 async function installLaw(s, deployBody, installedBy) {
   const newHash = await sha256hex(deployBody.packageUsda);
   if (newHash === s.lawHash) return { ok: true };
-  const previous = { ...s.eng.manifestStrings };
   const t0 = performance.now();
-  setManifests(s.eng, mergeManifests(s.runtime.manifests, deployBody));
   const res = author(s.eng, WS, "nomos", "installDomain", installPayload(newHash, deployBody.packageUsda, installedBy), s.eng.hashes.nomos);
   if (res.ok === false) {
-    setManifests(s.eng, previous);
     return { ok: false, error: `law install refused: ${res.error ?? "unknown"} \u2014 the previous law (${s.lawHash.slice(0, 12)}\u2026) keeps serving; fix and save again` };
   }
   s.lawHash = newHash;
@@ -1758,7 +1803,7 @@ async function gitRemote(ws, name, opts) {
 var HELP = {
   compile: {
     usage: "githolon compile [config] [--layered]",
-    what: "Compile the package by ./nomos.package.mjs (the @githolon/dsl launcher): ONE deterministic\n.package.usda (sha256 = the law's content hash) + read/identity manifests + the deploy body +\nthe typed TS client + the generated proof \u2014 all into build/.",
+    what: "Compile the package by ./nomos.package.mjs (the @githolon/dsl launcher): ONE deterministic\n.package.usda (sha256 = the law's content hash) + the deploy body +\nthe typed TS client + the generated proof \u2014 all into build/.",
     flags: [
       ["[config]", "an alternate config file (default: nomos.package.mjs)"],
       ["--layered", "also emit the per-domain layered USD view"]
@@ -1792,7 +1837,7 @@ var HELP = {
       ["<ws|dir>", "a workspace name on the cloud, or a local holon directory (githolon ledger init)"],
       ["--step N", "non-interactive; print the running tallies every N intents"],
       ["--json", "one JSON line per step + the final verdict (pipe it)"],
-      ["--file <deploy.json>", "stage this deploy body's read manifests (default: the one in ./build)"]
+      ["--file <deploy.json>", "reserved for local package hints (default: the one in ./build)"]
     ],
     examples: ["githolon replay my-guestbook", "githolon replay ./my-holon --step 10", "githolon replay my-guestbook --json | jq .directive"]
   },
@@ -1965,7 +2010,7 @@ init_engine();
 init_engine();
 init_cloud();
 init_local_holon();
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import { join as join9 } from "node:path";
 import git3 from "isomorphic-git";
 var out7 = (s) => void process.stdout.write(s + "\n");
@@ -2055,15 +2100,9 @@ async function replay(target, opts) {
   const cloud = cloudBase(opts.cloud);
   const json = opts.json === true;
   const emit = (o) => out7(JSON.stringify(o));
-  let overlay;
-  try {
-    overlay = JSON.parse(readFileSync7(discoverDeployJson(process.cwd(), opts.file), "utf8"));
-  } catch {
-    overlay = void 0;
-  }
   let eng;
   try {
-    ({ eng } = await holonEngine(cloud, overlay, "githolon-replay"));
+    ({ eng } = await holonEngine(cloud, void 0, "githolon-replay"));
   } catch (e) {
     err7(`cannot boot the local holon: ${String(e.message ?? e)}
   the runtime rides ${cloud}/v1/runtime/* (cached in ~/.holon/runtime after one fetch)`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "githolon",
-  "version": "0.13.0",
+  "version": "0.15.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",
@@ -10,7 +10,7 @@
     "directory": "cli"
   },
   "bin": {
-    "githolon": "./dist/cli.mjs"
+    "githolon": "dist/cli.mjs"
   },
   "files": [
     "dist"
@@ -27,7 +27,7 @@
   },
   "dependencies": {
     "@bjorn3/browser_wasi_shim": "0.4.2",
-    "@githolon/dsl": "^0.13.0",
+    "@githolon/dsl": "^0.15.0",
     "isomorphic-git": "^1.38.4"
   },
   "devDependencies": {