@githolon/testing 0.3.0

package/vendor/engine/git-fs.mjs

@@ -0,0 +1,93 @@
+// AUTO-SYNCED from cloud/holon-host/src/git-fs.mjs by testing/build.mjs — DO NOT EDIT HERE.
+// An isomorphic-git fs adapter over a @bjorn3/browser_wasi_shim PreopenDirectory tree.
+//
+// This is what lets the DO push/fetch the EXACT same in-memory git repo that the holon's gix
+// writes (loose objects under /work/workspaces/<ws>/nomos.git) — no copy, no second store. The
+// holon commits via gix; isomorphic-git reads those loose objects off this same tree and pushes
+// them to the Artifacts remote (and writes fetched objects back for the holon to read).
+//
+// isomorphic-git uses the Node-style fs.promises surface and is sensitive to error `.code`
+// (ENOENT/EEXIST/ENOTDIR/EISDIR), so we set those exactly.
+
+function fsErr(code, p) { const e = new Error(`${code}: ${p}`); e.code = code; return e; }
+
+// Build an fs ({promises:{...}}) rooted at `mount` (e.g. "/work") over `preopen.dir`.
+export function makeGitFs(preopen, mount, { File, Directory }) {
+  const root = preopen.dir; // Directory: { contents: Map }
+  const isDir = (n) => n && n.contents instanceof Map;
+
+  function parts(p) {
+    if (p === mount) return [];
+    if (!p.startsWith(mount + "/")) throw fsErr("ENOENT", p);
+    const rel = p.slice(mount.length + 1).replace(/\/+$/, "");
+    return rel === "" ? [] : rel.split("/");
+  }
+  function resolve(ps) {
+    let cur = root;
+    for (const part of ps) {
+      if (!isDir(cur)) return null;
+      const next = cur.contents.get(part);
+      if (next === undefined) return null;
+      cur = next;
+    }
+    return cur;
+  }
+  const parent = (ps) => resolve(ps.slice(0, -1));
+  const leaf = (ps) => ps[ps.length - 1];
+
+  const promises = {
+    async readFile(p, opts) {
+      const n = resolve(parts(p));
+      if (n === null) throw fsErr("ENOENT", p);
+      if (isDir(n)) throw fsErr("EISDIR", p);
+      const data = n.data ?? new Uint8Array(0);
+      const encoding = typeof opts === "string" ? opts : opts && opts.encoding;
+      return encoding ? new TextDecoder().decode(data) : new Uint8Array(data);
+    },
+    async writeFile(p, data) {
+      const ps = parts(p);
+      const par = parent(ps);
+      if (!isDir(par)) throw fsErr("ENOENT", p);
+      const bytes = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+      par.contents.set(leaf(ps), new File(bytes));
+    },
+    async unlink(p) {
+      const ps = parts(p), par = parent(ps);
+      if (!isDir(par) || !par.contents.delete(leaf(ps))) throw fsErr("ENOENT", p);
+    },
+    async readdir(p) {
+      const n = resolve(parts(p));
+      if (n === null) throw fsErr("ENOENT", p);
+      if (!isDir(n)) throw fsErr("ENOTDIR", p);
+      return [...n.contents.keys()];
+    },
+    async mkdir(p) {
+      const ps = parts(p), par = parent(ps);
+      if (!isDir(par)) throw fsErr("ENOENT", p);
+      if (par.contents.has(leaf(ps))) throw fsErr("EEXIST", p);
+      par.contents.set(leaf(ps), new Directory(new Map()));
+    },
+    async rmdir(p) {
+      const ps = parts(p), par = parent(ps);
+      if (!isDir(par)) throw fsErr("ENOENT", p);
+      par.contents.delete(leaf(ps));
+    },
+    async stat(p) { return promises.lstat(p); },
+    async lstat(p) {
+      const n = resolve(parts(p));
+      if (n === null) throw fsErr("ENOENT", p);
+      const dir = isDir(n);
+      return {
+        type: dir ? "dir" : "file",
+        mode: dir ? 0o040000 : 0o100644,
+        size: dir ? 0 : (n.data ? n.data.length : 0),
+        ino: 0, mtimeMs: 0, ctimeMs: 0, uid: 1, gid: 1, dev: 1,
+        isFile: () => !dir, isDirectory: () => dir, isSymbolicLink: () => false,
+      };
+    },
+    async readlink(p) { throw fsErr("EINVAL", p); },
+    async symlink() { throw fsErr("EPERM", "symlink unsupported"); },
+    async chmod() {},
+  };
+  return { promises };
+}

package/vendor/engine/tree.mjs

@@ -0,0 +1,73 @@
+// AUTO-SYNCED from cloud/holon-host/src/tree.mjs by testing/build.mjs — DO NOT EDIT HERE.
+// /work tree ⇄ flat manifest bytes — the decoupled twin of opfs_tree.mjs (serialize/deserialize
+// only, no OPFS I/O). On the edge the manifest bytes round-trip through R2 instead of an OPFS
+// SyncAccessHandle. Byte format is identical to opfs_tree.mjs so a snapshot is portable between
+// the browser holon and the edge holon:
+//   [u32 count] then per entry: [u8 isDir][u32 pathLen][path][u32 byteLen][bytes]
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+
+function flatten(dir, prefix, out) {
+  for (const [name, inode] of dir.contents) {
+    const path = prefix ? prefix + "/" + name : name;
+    if (inode.contents instanceof Map) {
+      out.push({ path, dir: true });
+      flatten(inode, path, out);
+    } else {
+      out.push({ path, dir: false, bytes: inode.data ?? new Uint8Array(0) });
+    }
+  }
+}
+
+export 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 out = new Uint8Array(total);
+  let off = 0;
+  for (const c of chunks) { out.set(c, off); off += c.length; }
+  return out;
+}
+
+export function deserializeTree(bytes, { File, Directory }) {
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let off = 0;
+  const count = dv.getUint32(off, true); off += 4;
+  const root = new Directory(new Map());
+  for (let i = 0; i < count; i++) {
+    const isDir = dv.getUint8(off); off += 1;
+    const pathLen = dv.getUint32(off, true); off += 4;
+    const byteLen = dv.getUint32(off, true); off += 4;
+    const path = dec.decode(bytes.subarray(off, off + pathLen)); off += pathLen;
+    const body = bytes.subarray(off, off + byteLen); off += byteLen;
+    const parts = path.split("/");
+    let cur = root;
+    for (let p = 0; p < parts.length - 1; p++) {
+      let next = cur.contents.get(parts[p]);
+      if (!next) { next = new Directory(new Map()); cur.contents.set(parts[p], next); }
+      cur = next;
+    }
+    const leaf = parts[parts.length - 1];
+    if (isDir) {
+      if (!cur.contents.get(leaf)) cur.contents.set(leaf, new Directory(new Map()));
+    } else {
+      cur.contents.set(leaf, new File(body.slice()));
+    }
+  }
+  return root.contents;
+}