@githolon/testing 0.46.0 → 0.48.0

package/package.json

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

@@ -129,7 +129,8 @@ export async function createEngine({ wasmModule, bootstrapPkg, nomosPkg, replica
   root.set("ws", new Directory(new Map()));
   const preopen = new PreopenDirectory("/work", root);
   const STDERR = [];
-  const fds = [new OpenFile(new File([])), ConsoleStdout.lineBuffered(() => {}), ConsoleStdout.lineBuffered((l) => STDERR.push(l)), preopen];
+  const pushStderr = (l) => { if (STDERR.length >= 500) STDERR.splice(0, STDERR.length - 499); STDERR.push(l); };
+  const fds = [new OpenFile(new File([])), ConsoleStdout.lineBuffered(() => {}), ConsoleStdout.lineBuffered(pushStderr), preopen];
   const wasi = new WASI(["wasm_git_holon", "reactor"], [], fds, { debug: false });
   const inst = await WebAssembly.instantiate(wasmModule, { wasi_snapshot_preview1: wasi.wasiImport });
   const code = wasi.start(inst);
@@ -1003,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
@@ -1088,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`;
@@ -1145,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 } : {}) };
 }
 
 /**
@@ -1188,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 } : {}) };
 }
 
 /**
@@ -1346,6 +1352,16 @@ export function currentLaw(eng, ws) {
   return out.keyMap || {};
 }
 
+/** INSTALLED-LAW META-READ — kernel-folded control-plane state, not tenant projection. */
+export function installedLaw(eng, ws) {
+  return JSON.parse(call(eng.ex, "query", { repoArg: repoArgOf(ws), workspace: ws, queryBytes: b64Json({ op: "installedLaw" }), branch: BRANCH }, eng.STDERR));
+}
+
+/** INSTALLED PACKAGE META-READ — package bytes from folded policy/domain-installation state. */
+export function domainPackage(eng, ws, hash) {
+  return JSON.parse(call(eng.ex, "query", { repoArg: repoArgOf(ws), workspace: ws, queryBytes: b64Json({ op: "domainPackage", hash }), branch: BRANCH }, eng.STDERR));
+}
+
 /** THE CAPABILITY DECLARATION READ (Full-A — capability_marketplace.md §4): the holon
  * surfaces every CURRENTLY-INSTALLED domain's `nomosCapabilities` law key (the impure-
  * capability quartets sealed into the law). The deploy lane relays these as a "declared —
@@ -1474,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);