githolon 0.12.0 → 0.14.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(" / ")}` : ""));
@@ -543,28 +550,48 @@ function setManifests(eng, strings) {
     if (wsDir) seedManifests(wsDir.contents, strings);
   }
 }
-async function mountWorkspace(eng, ws, ledger) {
-  if (eng.mounted.has(ws)) return eng.mounted.get(ws);
+function stageWorkspaceDir(eng, ws) {
   const wsContents = /* @__PURE__ */ new Map();
   seedManifests(wsContents, eng.manifestStrings);
   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);
+  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 +618,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "githolon",
-  "version": "0.12.0",
+  "version": "0.14.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",
@@ -27,7 +27,7 @@
   },
   "dependencies": {
     "@bjorn3/browser_wasi_shim": "0.4.2",
-    "@githolon/dsl": "^0.12.0",
+    "@githolon/dsl": "^0.14.0",
     "isomorphic-git": "^1.38.4"
   },
   "devDependencies": {