@githolon/testing 0.47.0 → 0.48.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@githolon/testing",
-  "version": "0.47.0",
+  "version": "0.48.1",
   "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

@@ -1004,6 +1004,9 @@ export async function admitIntentOffers(eng, ws, ledger, offers, { receiptFence
   // BORN: the G3 birth offer-effect's child heads any `.births()` offer in this batch produced (the kernel
   // surfaced them on the admit verdict). Accumulated across the batch and relayed out for the host to persist.
   const born = [];
+  // ...and their TYPED VERDICTS (born|deferred|failed|unwarranted-cert — typed_birth_outcomes.md §2),
+  // accumulated beside `born` (never in place of; no custody bytes, no pack treatment).
+  const birthOutcomes = [];
   const timings = { spans: [], intents: 0, sessions: 0 };
   // THE §5.2 SUMMARY CAPTURE on the OFFER LANE (offers are the only source of intents — this lane is the one
   // admit, routed workspaces included). A shard (selfLabel set) with scoped reads captures the per-batch
@@ -1089,6 +1092,7 @@ export async function admitIntentOffers(eng, ws, ledger, offers, { receiptFence
         rec.admitted.push({ oid, head: res.head });
         admittedTotal += 1;
         if (Array.isArray(res.born) && res.born.length) born.push(...res.born);
+        if (Array.isArray(res.birthOutcomes) && res.birthOutcomes.length) birthOutcomes.push(...res.birthOutcomes);
         if (cap) finishSummaryCapture(eng, ws, summaryCtx, cap, res.head, intentId);
       } else {
         const error = `${String(res.error || "").slice(0, 300)} — dead-lettered; fix the law (or the payload), then POST /v1/workspaces/${ws}/dead-letters/retry`;
@@ -1146,7 +1150,7 @@ export async function admitIntentOffers(eng, ws, ledger, offers, { receiptFence
   // 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 } : {}) };
+  return { sessions: [...sessions.values()].map((s) => ({ ...s, ...(s.skipped.length ? {} : { skipped: undefined }) })), main: head, deadLetters, timings, ...(summary ? { summary } : {}), ...(bornPacked.length ? { born: bornPacked } : {}), ...(birthOutcomes.length ? { birthOutcomes } : {}), ...(resultPackB64 ? { resultPackB64, resultBase: clientBase } : {}), ...(deferDurability && admittedTotal && head ? { deferred: true, head } : {}) };
 }
 
 /**
@@ -1189,7 +1193,8 @@ export async function authorOn(eng, ws, ledger, domain, directiveId, payload, la
   // 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 } : {}) };
+  // birthOutcomes carries NO custody bytes — pass through verbatim (no packBornChildren treatment).
+  return { ok: true, head: res.head, ...(bornPacked ? { born: bornPacked } : {}), ...(res.birthOutcomes ? { birthOutcomes: res.birthOutcomes } : {}) };
 }
 
 /**
@@ -1485,9 +1490,10 @@ export function author(eng, ws, domain, directiveId, payload, controllerHash, op
     writeWork(eng, `envelope-${seq}.json`, enc.encode(stringifyBig(envelope)));
     v = offerOnce();
   }
-  // KEEP `born`: the wasm offer ran the G3 birth offer-effect and surfaced the child heads; thread them
+  // KEEP `born` (+ `birthOutcomes`, the typed verdict vector beside it — typed_birth_outcomes.md §2):
+  // the wasm offer ran the G3 birth offer-effect and surfaced the child heads; thread them
   // through the normalized shape so the relay (container author case → worker out.born) sees them.
-  const res = v.outcome === "admitted" ? { ok: true, head: v.head, intentOut: v.intentOut, ...(v.born ? { born: v.born } : {}) }
+  const res = v.outcome === "admitted" ? { ok: true, head: v.head, intentOut: v.intentOut, ...(v.born ? { born: v.born } : {}), ...(v.birthOutcomes ? { birthOutcomes: v.birthOutcomes } : {}) }
     : v.outcome === "refused" ? { ok: false, error: v.verdict?.reason ?? v.error }
     : v; // defensive: a non-verdict shape passes through unchanged
   if (defer && res.ok) (eng.pendingProjection ??= new Set()).add(ws);
@@ -1986,16 +1992,21 @@ export function packDelta(eng, ws, base, head) {
 // pack of all reachable from main (fresh clone); `base` = the client's known head ⇒ the incremental delta.
 // The kernel resolves main itself. Returns `{ packB64, bytes }` (base64 so it rides the container JSON op).
 export function servePack(eng, ws, base = "") {
+  // `head`: the tip this pack reaches (resolved BEFORE packing, so it can only under-state, never
+  // over-state, what the pack contains) — the cache-coherence anchor for the worker's short-TTL pack
+  // cache: a cached pack is reusable ONLY while main still points at the head it was built from.
+  let head = null;
+  try { head = kgit.resolveRef(eng, gitdirOf(ws), BRANCH); } catch { /* diagnostics only */ }
   let r;
   try {
     r = JSON.parse(call(eng.ex, "pack_delta", { repoArg: repoArgOf(ws), workspace: ws, base, branch: BRANCH }, eng.STDERR));
   } catch (e) {
     // UP TO DATE: the client's `have` already IS main → nothing to send. A clean empty response, not an error.
-    if (/nothing to pack|head == base/.test(String(e))) return { packB64: "", bytes: 0, upToDate: true };
+    if (/nothing to pack|head == base/.test(String(e))) return { packB64: "", bytes: 0, upToDate: true, ...(head ? { head } : {}) };
     throw e;
   }
   if (!r || r.ok !== true || typeof r.packB64 !== "string") throw new Error("servePack: kernel produced no pack");
-  return { packB64: r.packB64, bytes: r.bytes };
+  return { packB64: r.packB64, bytes: r.bytes, ...(head ? { head } : {}) };
 }
 
 // ── G3 COLD-STORAGE: SURFACE THE BORN CHILD'S CUSTODY BYTES (the host-bailiff persist lane) ──────────────