@githolon/testing 0.19.0 → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@githolon/testing",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "type": "module",
   "description": "@githolon/testing — law TDD for Nomos domains: boot the REAL engine plane in-process (the exact machinery every cloud DO, heavy container and web client runs), dispatch directives, assert rows, assert TYPED REFUSALS, fork for what-ifs — fully offline inside vitest.",
   "license": "SEE LICENSE IN LICENSE.md",

package/vendor/engine/engine.mjs

@@ -1137,7 +1137,11 @@ export async function admitIntentOffers(eng, ws, ledger, offers, { refuseDomains
     } catch { /* fall back to the client's own GET /pack */ }
   }
   log("admit-intent-offers", { ws, sessions: sessions.size, admitted: admittedTotal, rejected: [...sessions.values()].reduce((n, s) => n + s.rejected.length, 0), resultPack: resultPackB64 ? "inline" : "none" });
-  return { sessions: [...sessions.values()].map((s) => ({ ...s, ...(s.skipped.length ? {} : { skipped: undefined }) })), main: head, deadLetters, timings, ...(summary ? { summary } : {}), ...(born.length ? { born } : {}), ...(resultPackB64 ? { resultPackB64, resultBase: clientBase } : {}), ...(deferDurability && admittedTotal && head ? { deferred: true, head } : {}) };
+  // G3 COLD-STORAGE: a `.births()` offer in this batch produced child custody in this engine's FS (the sibling
+  // repos). Pack each born child's full chain BEFORE returning so the bytes ride out for the worker to persist
+  // to the child's own Artifacts repo (the host names nothing — it shuttles kernel-produced bytes keyed by ws).
+  const bornPacked = born.length ? packBornChildren(eng, born) : born;
+  return { sessions: [...sessions.values()].map((s) => ({ ...s, ...(s.skipped.length ? {} : { skipped: undefined }) })), main: head, deadLetters, timings, ...(summary ? { summary } : {}), ...(bornPacked.length ? { born: bornPacked } : {}), ...(resultPackB64 ? { resultPackB64, resultBase: clientBase } : {}), ...(deferDurability && admittedTotal && head ? { deferred: true, head } : {}) };
 }
 
 /**
@@ -1175,9 +1179,12 @@ export async function authorOn(eng, ws, ledger, domain, directiveId, payload, la
   }
   if (res && res.ok === false) return { ok: false, error: String(res.error || "the law refused this intent").slice(0, 500) };
   await commitAndPush(eng, ws, ledger);
-  // KEEP `born`: a `.births()` directive authored here ran the G3 birth offer-effect; surface the child
-  // heads so the container author case → worker out.born relays them (the host persists the child custody).
-  return { ok: true, head: res.head, ...(res.born ? { born: res.born } : {}) };
+  // G3 COLD-STORAGE: a `.births()` directive authored here ran the kernel birth offer-effect, which wrote each
+  // child's custody to a sibling repo in this engine's FS. Pack each born child's full chain so the container
+  // author case → worker relays the bytes and the worker persists them to the child's OWN Artifacts repo. The
+  // PARENT's main was already pushed above; the child custody is a SEPARATE store the host must ship.
+  const bornPacked = Array.isArray(res.born) && res.born.length ? packBornChildren(eng, res.born) : res.born;
+  return { ok: true, head: res.head, ...(bornPacked ? { born: bornPacked } : {}) };
 }
 
 /**
@@ -1899,6 +1906,63 @@ export function servePack(eng, ws, base = "") {
   if (!r || r.ok !== true || typeof r.packB64 !== "string") throw new Error("servePack: kernel produced no pack");
   return { packB64: r.packB64, bytes: r.bytes };
 }
+
+// ── G3 COLD-STORAGE: SURFACE THE BORN CHILD'S CUSTODY BYTES (the host-bailiff persist lane) ──────────────
+// The kernel's birth offer-effect (`run_birth_effect`) wrote each born child's whole genesis→head custody to
+// a SIBLING repo IN THIS ENGINE'S FS — `sibling_repo_arg(parent_repo_arg, child)` == `/work/ws/<child>` ==
+// `repoArgOf(child)` (the kernel names no DO/container topology; it writes a path the host already keys by ws
+// name). That custody lives ONLY in the engine FS until the HOST ships it to the child's OWN custody store.
+// So pack each born child's FULL chain (base="" ⇒ genesis→head) straight from its sibling repo and carry the
+// bytes OUT on the born entry; the worker (which holds the Artifacts binding) creates the child repo + pushes
+// the pack to refs/heads/main. Host-pure: the adapter NAMES no domain, DECIDES nothing — it shuttles the
+// kernel-produced child custody keyed by the kernel-returned `{workspace, head}`. A child whose pack can't be
+// produced keeps its entry WITHOUT packB64 (+ logs) so the worker SURFACES the failure (the physical birth is
+// never silently dropped). Returns the born array with packB64 added where it could be packed.
+export function packBornChildren(eng, born) {
+  if (!Array.isArray(born) || !born.length) return born;
+  return born.map((b) => {
+    const child = b && typeof b.workspace === "string" ? b.workspace : null;
+    const head = b && typeof b.head === "string" ? b.head : null;
+    if (!child || !/^[0-9a-f]{40}$/i.test(head || "")) {
+      log("born-pack-skipped", { workspace: child, head, reason: "malformed born entry" });
+      return b;
+    }
+    try {
+      // base="" ⇒ the FULL pack of everything reachable from the child's head (genesis→head). The kernel
+      // resolves the child's main itself from the sibling repo at repoArgOf(child).
+      const pack = packDelta(eng, child, "", head);
+      if (!pack || !pack.length) {
+        log("born-pack-empty", { workspace: child, head });
+        return b;
+      }
+      return { ...b, packB64: b64Bytes(pack), packBytes: pack.length };
+    } catch (e) {
+      log("born-pack-failed", { workspace: child, head, error: String(e).slice(0, 200) });
+      return b;
+    }
+  });
+}
+
+// ── INGEST A CUSTODY PACK AS A WORKSPACE'S OWN STORE (the host-side twin of the worker's pushPack persist) ──
+// Stage a FRESH bare repo for `ws` in THIS engine's FS, ingest the kernel-built `packBytes` (apply_pack — the
+// inbound twin of pack_delta; objects land PACKED), then point refs/heads/main + HEAD at `head`. This is what
+// a peer/edge does on receiving a workspace's pack over the wire: it holds ONLY the pack, no parent FS. The
+// cross-workspace birth proof uses it to mount a born child from an INDEPENDENT custody store (not the parent
+// engine FS) — proving the host-bailiff persist is what makes the child servable on its own. `packBytes` is a
+// Uint8Array (the bytes packBornChildren / the worker's b64-decoded packB64 carry).
+export async function ingestPackAsCustody(eng, ws, packBytes, head) {
+  if (!packBytes || !packBytes.length) throw new Error(`ingestPackAsCustody: empty pack for '${ws}'`);
+  if (!/^[0-9a-f]{40}$/i.test(head || "")) throw new Error(`ingestPackAsCustody: bad head '${head}' for '${ws}'`);
+  unmount(eng, ws);
+  stageWorkspaceDir(eng, ws);
+  const gitdir = gitdirOf(ws);
+  await custodySkeleton(eng, gitdir);
+  applyPackInto(eng, ws, packBytes);            // kernel apply_pack — ingests the genesis→head objects
+  kgit.writeRef(eng, gitdir, "refs/heads/main", head);
+  kgit.writeRef(eng, gitdir, "HEAD", "ref: refs/heads/main");
+  eng.mounted.set(ws, { restored: true, remoteMain: head, restoreError: null });
+  return { ok: true, head: kgit.resolveRef(eng, gitdir, "refs/heads/main") };
+}
 export const nomosActive = (eng, ws) => qById(eng, ws, `domain-installation:${eng.hashes.nomos}`).length > 0;
 // E2E crypto linkage probe (the encryption arc): run the wrap→unwrap + field seal→open
 // INSIDE the deployable wasm. Pure — no workspace, no chain. Returns {wrapHandoff, fieldAead}.