@blamejs/blamejs-shop 0.5.12 → 0.5.13

package/lib/vendor/blamejs/test/layer-0-primitives/age-gate.test.js

@@ -84,6 +84,39 @@ function run() {
   withConsent(_mockReq({ user: { age: 12, parentalConsent: true } }), _mockRes(), function () { consentPassedCalls++; });
   check("ageGate passes when parentalConsent present", consentPassedCalls === 1);
 
+  // A getAge that computes a NON-FINITE number (NaN from parseInt on a
+  // malformed birth field / date math, or ±Infinity) must NOT be read as a
+  // confirmed adult. typeof NaN === "number" and `NaN < consentRequired`
+  // is false, so the classifier fell through to "above-threshold" — silently
+  // dropping every child-safety privacy default for a user whose age simply
+  // failed to compute (an attacker-influenced fail-open when the birth field
+  // is request-derived). A non-finite age is classified "unknown" (privacy
+  // headers applied), consistent with a null / non-number return.
+  var nanGate = b.middleware.ageGate({
+    audit: false,
+    getAge:          function () { return Number("not-a-birth-year"); },   // NaN
+    consentRequired: 18,
+  });
+  var nanRes = _mockRes();
+  var nanNext = 0;
+  nanGate(_mockReq({ url: "/kids", method: "POST" }), nanRes, function () { nanNext++; });
+  check("NaN age classified unknown, not above-threshold",
+    nanRes._captured.headers["X-Privacy-Posture"] === "unknown");
+  check("NaN age applies the no-store privacy default",
+    nanRes._captured.headers["Cache-Control"] === "private, no-store");
+  check("NaN age still flows downstream as unknown (privacy posture, no hard block)",
+    nanNext === 1 && nanRes._captured.status === 0);
+
+  var infGate = b.middleware.ageGate({
+    audit: false,
+    getAge:          function () { return Infinity; },
+    consentRequired: 18,
+  });
+  var infRes = _mockRes();
+  infGate(_mockReq({ url: "/kids", method: "POST" }), infRes, function () {});
+  check("Infinity age classified unknown (non-finite is not a valid age)",
+    infRes._captured.headers["X-Privacy-Posture"] === "unknown");
+
   var threwBadGetAge = false;
   try { b.middleware.ageGate({ audit: false, getAge: "nope" }); }
   catch (e) { threwBadGetAge = e.code === "age-gate/bad-get-age"; }

package/lib/vendor/blamejs/test/layer-0-primitives/agent-saga.test.js

@@ -271,9 +271,69 @@ async function run() {
   await testErrorCauseAttached();
   await testFailedCompStepNameCorrect();
   await testSagaStatePersistedAcrossRun();
+  await testResumeCompensatesPreCrashSteps();
+  await testResumeRefusesTerminalSaga();
   await testRefusesBadConfig();
 }
 
+async function testResumeCompensatesPreCrashSteps() {
+  // A saga that crashed after step 2, resumed, then FAILS at step 3 must
+  // compensate the FULL completed set — the pre-crash steps (s1, s2) included,
+  // in reverse order. Regression: _runFrom reset completedSteps=[] on resume,
+  // so a post-resume failure compensated only this run's steps, leaving the
+  // pre-crash work (e.g. a committed charge) uncompensated.
+  var compensated = [];
+  var stateStore = {
+    saveStep:        async function () {},
+    loadResumePoint: async function () { return { stepIndex: 2, state: { s1: "done", s2: "done" } }; },
+    markFailed:      async function () {},
+  };
+  var saga = b.agent.saga.create({
+    name:       "test.resume-compensate",
+    stateStore: stateStore,
+    steps: [
+      { name: "s1", run: async function () {}, compensate: async function () { compensated.push("s1"); } },
+      { name: "s2", run: async function () {}, compensate: async function () { compensated.push("s2"); } },
+      { name: "s3", run: async function () { throw new Error("s3 boom"); },
+        compensate: async function () { compensated.push("s3"); } },
+    ],
+  });
+  var threw = null;
+  try { await saga.resume("saga-X", {}, {}); } catch (e) { threw = e; }
+  check("resume-then-fail rejects with agent-saga/failed", threw && /agent-saga\/failed/.test(threw.code || ""));
+  check("resume compensates pre-crash s2 first (reverse order)", compensated[0] === "s2");
+  check("resume compensates pre-crash s1 second",               compensated[1] === "s1");
+  check("resume compensates BOTH pre-crash steps",              compensated.length === 2);
+  check("the failing s3 is not compensated",                    compensated.indexOf("s3") === -1);
+}
+
+async function testResumeRefusesTerminalSaga() {
+  // A saga that already reached a terminal state (failed-and-compensated, or
+  // completed) must not be resumed — replaying it would re-invoke the completed
+  // steps' compensators, which are not required to be idempotent (a double
+  // refund). A stateStore that marks the saga terminal (resumePoint.terminal)
+  // gets the resume refused rather than replayed.
+  var compensated = [];
+  var stateStore = {
+    saveStep:        async function () {},
+    loadResumePoint: async function () { return { stepIndex: 2, state: {}, terminal: true }; },
+    markFailed:      async function () {},
+  };
+  var saga = b.agent.saga.create({
+    name:       "test.terminal-resume",
+    stateStore: stateStore,
+    steps: [
+      { name: "s1", run: async function () {}, compensate: async function () { compensated.push("s1"); } },
+      { name: "s2", run: async function () {}, compensate: async function () { compensated.push("s2"); } },
+      { name: "s3", run: async function () {}, compensate: async function () { compensated.push("s3"); } },
+    ],
+  });
+  var threw = null;
+  try { await saga.resume("saga-terminal", {}, {}); } catch (e) { threw = e; }
+  check("resume of a terminal saga is refused", threw && /agent-saga\/not-resumable/.test(threw.code || ""));
+  check("a refused terminal resume runs no compensators", compensated.length === 0);
+}
+
 module.exports = { run: run };
 if (require.main === module) {
   run().then(function () { console.log("OK"); })

package/lib/vendor/blamejs/test/layer-0-primitives/agent-snapshot.test.js

@@ -478,6 +478,8 @@ async function runReseal() {
     await testResealSkipsPlaintextRows();
     await testResealRefusesNonVaultSealer();
     await testResealDescriptorMapsStore();
+    await testResealDescriptorBackendKey();
+    await testResealRekeyFailure();
   } finally {
     helpers.teardownVaultOnly(tmpDir);
   }
@@ -529,14 +531,523 @@ async function testAllowPlaintextRefusedUnderRegulatedPosture() {
     persisted && typeof persisted.snapshotId === "string");
 }
 
+// ---- Load-gate: wrapper-vs-body cross-checks + signature refusals -------
+
+async function testTenantMismatchRefused() {
+  // A hostile backend relabels a SEALED row's decorative wrapper tenantId.
+  // The seal's AAD binds table + snapshotId + schemaVersion but NOT
+  // tenantId, so the Poly1305 tag still verifies after the relabel — yet
+  // the wrapper tenantId is exactly what loadLatest({ tenantId }) filters
+  // on. Without a wrapper-vs-body cross-check, loadLatest({ tenantId:"b" })
+  // returns tenant-a's AUTHENTIC snapshot (cross-tenant restore). The load
+  // gate must refuse the relabel.
+  var backend = _fakeBackend();
+  var snapshot = _signedSnapshot({ backend: backend });
+  var s = await snapshot.takeSnapshot({ tenantId: "tenant-a" });
+  await snapshot.persist(s);
+  var raw = await backend.get(s.snapshotId);
+  await backend.put(s.snapshotId, Object.assign({}, raw, { tenantId: "tenant-b" }));
+  await expectRejection("loadLatest refuses relabelled cross-tenant wrapper",
+    snapshot.loadLatest({ tenantId: "tenant-b" }),
+    "agent-snapshot/tenant-id-mismatch");
+
+  // Control — an untouched tenant still round-trips.
+  var backend2 = _fakeBackend();
+  var snap2 = _signedSnapshot({ backend: backend2 });
+  var s2 = await snap2.takeSnapshot({ tenantId: "tenant-c" });
+  await snap2.persist(s2);
+  var ok = await snap2.loadLatest({ tenantId: "tenant-c" });
+  check("loadLatest returns matching-tenant snapshot",
+    ok && ok.snapshotId === s2.snapshotId && ok.tenantId === "tenant-c");
+}
+
+async function testTakenAtMismatchRefused() {
+  // Same class as the tenant relabel: loadLatest sorts candidates on the
+  // untrusted wrapper takenAt to pick "latest", but takenAt is not AAD-bound,
+  // so a hostile backend can relabel a returned row's age. takenAt is a signed
+  // body field, so the load gate cross-checks the wrapper against the body and
+  // refuses a divergence (audit-integrity / rollback defense).
+  var backend = _fakeBackend();
+  var snapshot = _signedSnapshot({ backend: backend });
+  var s = await snapshot.takeSnapshot({ tenantId: "tenant-a" });
+  await snapshot.persist(s);
+  var raw = await backend.get(s.snapshotId);
+  await backend.put(s.snapshotId, Object.assign({}, raw, { takenAt: (raw.takenAt || 0) + 1000000 }));
+  await expectRejection("loadById refuses a relabelled wrapper takenAt",
+    snapshot.loadById(s.snapshotId),
+    "agent-snapshot/taken-at-mismatch");
+
+  // Control — an untouched row still round-trips.
+  var backend2 = _fakeBackend();
+  var snap2 = _signedSnapshot({ backend: backend2 });
+  var s2 = await snap2.takeSnapshot({ tenantId: "tenant-c" });
+  await snap2.persist(s2);
+  var ok = await snap2.loadLatest({ tenantId: "tenant-c" });
+  check("loadLatest returns row with un-relabelled takenAt",
+    ok && ok.snapshotId === s2.snapshotId);
+}
+
+// A backend whose list() can be forged independently of get() — the deeper
+// threat model where list() and get() are separately tamperable.
+function _listForgingBackend() {
+  var map = new Map();
+  var forge = null;   // when set: { field, value } applied to list() entries only
+  return {
+    put:    function (k, v) { map.set(k, v); return Promise.resolve(); },
+    get:    function (k)    { return Promise.resolve(map.get(k) || null); },
+    delete: function (k)    { map.delete(k); return Promise.resolve(); },
+    list:   function () {
+      var out = [];
+      map.forEach(function (v) {
+        if (forge) { var c = Object.assign({}, v); c[forge.field] = forge.value; out.push(c); }
+        else out.push(v);
+      });
+      return Promise.resolve(out);
+    },
+    forgeList: function (field, value) { forge = { field: field, value: value }; },
+  };
+}
+
+async function testListOnlyTenantForgeryRefused() {
+  // Deeper than a get() wrapper relabel: list() and get() are independently
+  // tamperable. A backend that relabels tenant A's LIST entry as tenant B while
+  // leaving A's get() row honest passes the wrapper/body cross-check in
+  // _unwrapAndVerify (the honest row agrees with its own body), yet
+  // loadLatest({ tenantId:'tenant-b' }) selects it via the forged list filter
+  // and would return A's authentic snapshot for a tenant-B query. The requested
+  // tenantId must be bound to the loaded snapshot's authenticated tenantId.
+  var backend = _listForgingBackend();
+  var snapshot = _signedSnapshot({ backend: backend });
+  var s = await snapshot.takeSnapshot({ tenantId: "tenant-a" });
+  await snapshot.persist(s);
+  backend.forgeList("tenantId", "tenant-b");   // list() now claims tenant-b; get() stays tenant-a
+  await expectRejection("loadLatest refuses a list()-only tenant forgery (requested vs authenticated)",
+    snapshot.loadLatest({ tenantId: "tenant-b" }),
+    "agent-snapshot/tenant-id-mismatch");
+}
+
+async function testListOnlyTakenAtForgeryRefused() {
+  // list() sort metadata is likewise untrusted: a backend that inflates a row's
+  // list() takenAt to win the "latest" sort, while get() returns the honest
+  // (older) body, is caught by binding the selection sort key to the loaded
+  // snapshot's authenticated takenAt.
+  var backend = _listForgingBackend();
+  var snapshot = _signedSnapshot({ backend: backend });
+  var s = await snapshot.takeSnapshot({ tenantId: "tenant-a" });
+  await snapshot.persist(s);
+  backend.forgeList("takenAt", 99999999999999);   // list() claims a far-future age; get() stays honest
+  await expectRejection("loadLatest refuses a list()-only takenAt sort-key forgery",
+    snapshot.loadLatest({ tenantId: "tenant-a" }),
+    "agent-snapshot/taken-at-mismatch");
+}
+
+async function testTenantMismatchTamperDirections() {
+  // Both directions of a wrapper/body tenant divergence are refused: a
+  // hostile backend that ADDS a tenant to a no-tenant body, and one that
+  // STRIPS the tenant from a tenant body.
+  var backend = _fakeBackend();
+  var snapshot = _signedSnapshot({ backend: backend });
+
+  var s0 = await snapshot.takeSnapshot({});
+  await snapshot.persist(s0);
+  var raw0 = await backend.get(s0.snapshotId);
+  await backend.put(s0.snapshotId, Object.assign({}, raw0, { tenantId: "ghost" }));
+  await expectRejection("wrapper adds a tenant to a no-tenant body → refused",
+    snapshot.loadById(s0.snapshotId), "agent-snapshot/tenant-id-mismatch");
+
+  var s1 = await snapshot.takeSnapshot({ tenantId: "real" });
+  await snapshot.persist(s1);
+  var raw1 = await backend.get(s1.snapshotId);
+  await backend.put(s1.snapshotId, Object.assign({}, raw1, { tenantId: null }));
+  await expectRejection("wrapper strips the tenant from a tenant body → refused",
+    snapshot.loadById(s1.snapshotId), "agent-snapshot/tenant-id-mismatch");
+}
+
+async function testTopologySameCountRemap() {
+  // Same consumer COUNT but a different topic SET is a real topology
+  // change — a count-only comparison would miss it and defeat
+  // refuseOnTopologyChange. [a,b] -> [a,c].
+  var snapHealth = { agents: [], elections: [], consumers: [{ topic: "a" }, { topic: "b" }], streams: 0, draining: false, overall: "ok" };
+  var restoreHealth = { agents: [], elections: [], consumers: [{ topic: "a" }, { topic: "c" }], streams: 0, draining: false, overall: "ok" };
+  var s1 = _signedSnapshot({ orchestrator: _fakeOrch(snapHealth) });
+  var snap = await s1.takeSnapshot({ sagas: [{ id: "x" }] });
+  var r = await _signedSnapshot({ orchestrator: _fakeOrch(restoreHealth) }).restore(snap, {});
+  check("same-count topic remap detected as topology change", r.topologyChanged === true);
+  await expectRejection("same-count remap honored by refuseOnTopologyChange",
+    _signedSnapshot({ orchestrator: _fakeOrch(restoreHealth) })
+      .restore(snap, { refuseOnTopologyChange: true }),
+    "agent-snapshot/topology-changed");
+}
+
+async function testSnapshotIdMismatchRefused() {
+  // A hostile backend returns a different snapshot's body for the
+  // requested id. The wrapper/body snapshotId cross-check refuses it
+  // before any signature is even consulted.
+  var backend = _fakeBackend();
+  var writer = _signedSnapshot({ backend: backend });
+  var s = await writer.takeSnapshot({});
+  await writer.persist(s);
+  await backend.put("different-key", s);
+  await expectRejection("loadById refuses wrapper/body snapshotId mismatch",
+    writer.loadById("different-key"), "agent-snapshot/snapshot-id-mismatch");
+}
+
+async function testPlaintextForgedSignatureRefused() {
+  // Plaintext-downgrade + forgery: an attacker writes a bare (unsealed)
+  // envelope with a tampered signed field, so the stored signature no
+  // longer covers the bytes. Load must refuse with bad-signature.
+  var backend = _fakeBackend();
+  var writer = _signedSnapshot({ backend: backend });
+  var s = await writer.takeSnapshot({});
+  await writer.persist(s);
+  var forged = Object.assign({}, s, { takenAt: s.takenAt + 1 });
+  await backend.put(forged.snapshotId, forged);
+  await expectRejection("loadById refuses forged plaintext (bad signature)",
+    writer.loadById(forged.snapshotId), "agent-snapshot/bad-signature");
+}
+
+async function testVerifyThrowsRefused() {
+  // A verifier that THROWS (e.g. malformed key material) must fail closed
+  // to bad-signature, never accept the snapshot.
+  var base = _fakeSigner();
+  var throwingVerify = {
+    sign:         base.sign,
+    verify:       function () { throw new Error("verify boom"); },
+    getPublicKey: function () { return null; },
+  };
+  var backend = _fakeBackend();
+  var snapshot = b.agent.snapshot.create({
+    orchestrator: _fakeOrch(), backend: backend, signer: throwingVerify, sealer: _fakeSealer(),
+  });
+  var s = await snapshot.takeSnapshot({});
+  await snapshot.persist(s);
+  await expectRejection("load refuses when verify throws",
+    snapshot.loadById(s.snapshotId), "agent-snapshot/bad-signature");
+}
+
+async function testSealedLoadWithoutSealerRefused() {
+  // An allowPlaintext-mode loader (no sealer wired, vault not initialized)
+  // encountering a SEALED row must refuse — it cannot silently skip the
+  // seal and treat the ciphertext as plaintext.
+  var backend = _fakeBackend();
+  var writer = _signedSnapshot({ backend: backend });
+  var s = await writer.takeSnapshot({});
+  await writer.persist(s);
+  var loader = b.agent.snapshot.create({
+    orchestrator: _fakeOrch(), backend: backend, signer: _fakeSigner(), allowPlaintext: true,
+  });
+  await expectRejection("sealed row + no sealer on load refuses",
+    loader.loadById(s.snapshotId), "agent-snapshot/sealer-not-wired");
+}
+
+async function testPersistSealerNotWiredRefused() {
+  // Signer wired, no sealer, vault not initialized, allowPlaintext not set
+  // — persist must refuse rather than write cleartext (secure-by-default).
+  var snapshot = b.agent.snapshot.create({
+    orchestrator: _fakeOrch(), backend: _fakeBackend(), signer: _fakeSigner(),
+  });
+  var s = await snapshot.takeSnapshot({});
+  await expectRejection("persist without sealer refuses (sealer-not-wired)",
+    snapshot.persist(s), "agent-snapshot/sealer-not-wired");
+}
+
+// ---- Size caps + defensive take-snapshot shape -------------------------
+
+async function testTakeSnapshotOversizeRefused() {
+  var tiny = b.agent.snapshot.create({
+    orchestrator: _fakeOrch(), backend: _fakeBackend(),
+    signer: _fakeSigner(), sealer: _fakeSealer(),
+    policy: { maxSnapshotBytes: 10, drainTimeoutMs: 1000, snapshotIntervalMs: 2000 },
+  });
+  await expectRejection("takeSnapshot oversize refuses",
+    tiny.takeSnapshot({}), "agent-snapshot/oversize");
+}
+
+async function testPersistOversizeRefused() {
+  // takeSnapshot on a generous facade, persist on a tiny-cap facade: the
+  // signed envelope exceeds the persist-time cap.
+  var big = _signedSnapshot();
+  var s = await big.takeSnapshot({});
+  var tiny = b.agent.snapshot.create({
+    orchestrator: _fakeOrch(), backend: _fakeBackend(),
+    signer: _fakeSigner(), sealer: _fakeSealer(),
+    policy: { maxSnapshotBytes: 10 },
+  });
+  await expectRejection("persist oversize refuses",
+    tiny.persist(s), "agent-snapshot/oversize");
+}
+
+async function testTakeSnapshotHealthNonArray() {
+  // health() that omits the agents/elections/consumers arrays coerces to
+  // empty arrays rather than throwing. takeSnapshot() with no opts also
+  // exercises the snapshotOpts default.
+  var snapshot = _signedSnapshot({ orchestrator: _fakeOrch({ overall: "ok" }) });
+  var s = await snapshot.takeSnapshot();
+  check("health non-array → empty agents",
+    Array.isArray(s.orchestratorState.agents) && s.orchestratorState.agents.length === 0);
+  check("health non-array → empty elections", s.orchestratorState.elections.length === 0);
+  check("health non-array → empty consumers", s.orchestratorState.consumers.length === 0);
+}
+
+// ---- Restore-handler dispatch edges ------------------------------------
+
+async function testRestoreNoHandlersAcknowledgedDrop() {
+  // In-flight items, no handlers, requireHandlers NOT set → the drop is
+  // acknowledged: restore returns a zero-count result (no throw), the
+  // audited skip is the operator's grep signal.
+  var snapshot = _signedSnapshot();
+  var snap = await snapshot.takeSnapshot({ sagas: [{ id: "s1" }] });
+  var r = await snapshot.restore(snap);
+  check("restore acknowledged-drop echoes snapshotId", r.snapshotId === snap.snapshotId);
+  check("restore acknowledged-drop counts zero", r.restored.sagas === 0);
+}
+
+async function testRestoreHandlerThrows() {
+  var handlers = { sagas: function () { throw new Error("handler boom"); } };
+  var snapshot = _signedSnapshot({ restoreHandlers: handlers });
+  var snap = await snapshot.takeSnapshot({ sagas: [{ id: "s1" }] });
+  await expectRejection("restore handler throw surfaces as restore-handler-failed",
+    snapshot.restore(snap, {}), "agent-snapshot/restore-handler-failed");
+}
+
+async function testRestoreVoidHandlerAndNullPayload() {
+  // Void (return-undefined) handlers: array payloads count their length,
+  // object payloads count 1; a null payload segment is a 0-count no-op.
+  var handlers = {
+    sagas:            function () { /* void, array payload */ },
+    idempotencyCache: function () { /* void, object payload */ },
+    streams:          function () { /* payload forced null below */ },
+  };
+  var snapshot = _signedSnapshot({ restoreHandlers: handlers });
+  var snap = await snapshot.takeSnapshot({
+    sagas: [{ id: "s1" }, { id: "s2" }], idempotencyCache: { hot: 1 },
+  });
+  snap.inFlight.streams = null;
+  var r = await snapshot.restore(snap, {});
+  check("void array-handler returns payload length", r.restored.sagas === 2);
+  check("void object-handler returns 1", r.restored.idempotencyCache === 1);
+  check("null-payload handler returns 0", r.restored.streams === 0);
+}
+
+// ---- Load/list/gc filtering + defensive backends -----------------------
+
+async function testLoadLatestTenantFilter() {
+  var snapshot = _signedSnapshot();
+  var sa = await snapshot.takeSnapshot({ tenantId: "t-alpha" });
+  await snapshot.persist(sa);
+  var missByTenant = await snapshot.loadLatest({ tenantId: "t-nope" });
+  check("loadLatest tenant filter: no match → null", missByTenant === null);
+  var hit = await snapshot.loadLatest({ tenantId: "t-alpha" });
+  check("loadLatest tenant filter: match returns snap",
+    hit && hit.snapshotId === sa.snapshotId);
+}
+
+async function testListFilters() {
+  var snapshot = _signedSnapshot();
+  var sa = await snapshot.takeSnapshot({ tenantId: "l-alpha" });
+  await snapshot.persist(sa);
+  var only = await snapshot.list({ tenantId: "l-alpha", sinceMs: 1 });
+  check("list tenant+since filter keeps match",
+    only.length === 1 && only[0].tenantId === "l-alpha");
+  var none = await snapshot.list({ tenantId: "l-beta" });
+  check("list tenant filter excludes non-match", none.length === 0);
+  var future = await snapshot.list({ sinceMs: Date.now() + 100000 });
+  check("list sinceMs filter excludes older", future.length === 0);
+  var all = await snapshot.list();
+  check("list() no opts returns entries", all.length === 1);
+}
+
+async function testGcNoDeleteBackend() {
+  var noDel = {
+    put:  function () { return Promise.resolve(); },
+    get:  function () { return Promise.resolve(null); },
+    list: function () { return Promise.resolve([]); },
+  };
+  var snapshot = _signedSnapshot({ backend: noDel });
+  var r = await snapshot.gc();
+  check("gc without backend.delete → purged 0", r.purged === 0);
+}
+
+async function testGcDeleteThrows() {
+  var map = new Map();
+  var throwingDel = {
+    put:    function (k, v) { map.set(k, v); return Promise.resolve(); },
+    get:    function (k)    { return Promise.resolve(map.get(k) || null); },
+    list:   function ()     { var o = []; map.forEach(function (v) { o.push(v); }); return Promise.resolve(o); },
+    delete: function ()     { return Promise.reject(new Error("delete boom")); },
+  };
+  var snapshot = _signedSnapshot({ backend: throwingDel });
+  var s = await snapshot.takeSnapshot({});
+  await snapshot.persist(s);
+  await helpers.waitUntil(function () { return Date.now() > s.takenAt; },
+    { label: "agent-snapshot.gc: clock past takenAt before delete-throw gc" });
+  var r = await snapshot.gc({ olderThanMs: 0 });
+  check("gc swallows delete rejection, purged 0", r.purged === 0);
+}
+
+// ---- create() + reseal() input-shape edges -----------------------------
+
+async function testCreateNoArgs() {
+  var threw = null;
+  try { b.agent.snapshot.create(); } catch (e) { threw = e; }
+  check("create() no args → bad-orchestrator",
+    threw && (threw.code || "").indexOf("agent-snapshot/bad-orchestrator") !== -1);
+}
+
+async function testResealBackendListNonArray() {
+  var backend = {
+    put:  function () { return Promise.resolve(); },
+    get:  function () { return Promise.resolve(null); },
+    list: function () { return Promise.resolve(null); },
+  };
+  var r = await b.agent.snapshot.reseal({ backend: backend, oldRootJson: "x", newRootJson: "y" });
+  check("reseal list non-array → resealed 0",
+    r.resealed === 0 && r.table === "agent.snapshot");
+}
+
+async function testResealSkipsBadEntries() {
+  var backend = {
+    put:  function () { return Promise.resolve(); },
+    get:  function (k) { return Promise.resolve(k === "present-null" ? null : null); },
+    list: function () {
+      return Promise.resolve([{}, { snapshotId: "" }, { snapshotId: "present-null" }]);
+    },
+  };
+  var r = await b.agent.snapshot.reseal({ backend: backend, oldRootJson: "x", newRootJson: "y" });
+  check("reseal skips no/empty snapshotId + missing raw", r.resealed === 0);
+}
+
+async function testResealNoArgsAndDescriptorNoArgs() {
+  await expectRejection("reseal() no args → bad-backend",
+    b.agent.snapshot.reseal(), "agent-snapshot/bad-backend");
+  await expectRejection("AAD_ROTATION.reseal() no args → bad-backend",
+    b.agent.snapshot.AAD_ROTATION.reseal(), "agent-snapshot/bad-backend");
+}
+
+async function testLoadByIdBadId() {
+  var snapshot = _signedSnapshot();
+  await expectRejection("loadById empty id refuses",
+    snapshot.loadById(""), "agent-snapshot/bad-snapshot-id");
+  await expectRejection("loadById non-string id refuses",
+    snapshot.loadById(null), "agent-snapshot/bad-snapshot-id");
+}
+
+async function testListAndLoadLatestBackendNonArray() {
+  var backend = {
+    put:  function () { return Promise.resolve(); },
+    get:  function () { return Promise.resolve(null); },
+    list: function () { return Promise.resolve(null); },
+  };
+  var snapshot = _signedSnapshot({ backend: backend });
+  var l = await snapshot.list({});
+  check("list non-array backend → []", Array.isArray(l) && l.length === 0);
+  var latest = await snapshot.loadLatest({});
+  check("loadLatest non-array backend → null", latest === null);
+}
+
+async function testGcDefaultOlderThan() {
+  var backend = _fakeBackend();
+  var snapshot = _signedSnapshot({ backend: backend });
+  var s = await snapshot.takeSnapshot({});
+  await snapshot.persist(s);
+  await helpers.waitUntil(function () { return Date.now() > s.takenAt; },
+    { label: "agent-snapshot.gc: clock past takenAt for default-olderThan gc" });
+  var r = await snapshot.gc({});
+  check("gc default olderThanMs purges old entry",
+    r.purged === 1 && backend._size() === 0);
+}
+
+async function testRealAuditSignerRoundTrip() {
+  // No opts.signer → _resolveSigner falls back to the framework's real
+  // b.auditSign, exercising the signer wrapper (sign / verify /
+  // getPublicKey) and persist's getPublicKey-bound sigPubKey path.
+  var dir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-snapshot-auditsign-"));
+  b.auditSign._resetForTest();
+  await b.auditSign.init({ dataDir: dir, mode: "plaintext", algorithm: "ml-dsa-65" });
+  try {
+    var backend = _fakeBackend();
+    var snapshot = b.agent.snapshot.create({
+      orchestrator: _fakeOrch(), backend: backend, sealer: _fakeSealer(),
+    });
+    var s = await snapshot.takeSnapshot({});
+    await snapshot.persist(s);
+    check("real auditSign: sig populated",
+      typeof s.sig === "string" && s.sig.length > 0);
+    check("real auditSign: sigPubKey bound off getPublicKey",
+      typeof s.sigPubKey === "string" && s.sigPubKey.length > 0);
+    var loaded = await snapshot.loadById(s.snapshotId);
+    check("real auditSign: verified round-trip",
+      loaded && loaded.snapshotId === s.snapshotId);
+  } finally {
+    b.auditSign._resetForTest();
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_e) { /* best-effort */ }
+  }
+}
+
+// ---- reseal rekey-failure + descriptor backend-key (vault-backed) ------
+
+async function testResealRekeyFailure() {
+  var backend = _fakeBackend();
+  var snapshot = _vaultBackedSnapshot(backend);
+  var snap = await snapshot.takeSnapshot({});
+  await snapshot.persist(snap);
+  var raw = await backend.get(snap.snapshotId);
+  var prefix = b.agent.snapshot.SEALED_PREFIX;
+  var inner = raw.sealed.slice(prefix.length);
+  // Corrupt the inner vault.aad ciphertext (keep the prefix so it still
+  // looks vault-sealed) so resealRoot's unseal fails. Stamp an explicit
+  // wrapper schemaVersion so the != null AAD reconstruction branch runs.
+  var corrupted = inner.slice(0, inner.length - 6) + "AAAAAA";
+  await backend.put(snap.snapshotId,
+    Object.assign({}, raw, { sealed: prefix + corrupted, schemaVersion: 1 }));
+  var oldRootJson = b.vault.getKeysJson();
+  var newRootJson = JSON.stringify(
+    Object.assign(JSON.parse(oldRootJson), { _rotationTestRoot: "v6" }));
+  await expectRejection("reseal refuses a row it cannot re-key",
+    b.agent.snapshot.reseal({
+      backend: backend, oldRootJson: oldRootJson, newRootJson: newRootJson,
+    }),
+    "agent-snapshot/reseal-failed");
+}
+
+async function testResealDescriptorBackendKey() {
+  // AAD_ROTATION.reseal maps `backend` when the pipeline passes no `store`.
+  var backend = _fakeBackend();
+  var snapshot = _vaultBackedSnapshot(backend);
+  await snapshot.persist(await snapshot.takeSnapshot({}));
+  var oldRootJson = b.vault.getKeysJson();
+  var newRootJson = JSON.stringify(
+    Object.assign(JSON.parse(oldRootJson), { _rotationTestRoot: "v7" }));
+  var result = await b.agent.snapshot.AAD_ROTATION.reseal({
+    backend: backend, oldRootJson: oldRootJson, newRootJson: newRootJson,
+  });
+  check("AAD_ROTATION.reseal via backend key re-keyed", result.resealed === 1);
+}
+
 async function run() {
   testSurface();
   await testCreateRequiresOrchestrator();
   await testCreateRequiresBackend();
+  await testCreateNoArgs();
   await testSignerNotWiredRefused();
+  await testPersistSealerNotWiredRefused();
   await testTakeAndPersist();
+  await testTakeSnapshotHealthNonArray();
+  await testTakeSnapshotOversizeRefused();
+  await testPersistOversizeRefused();
   await testLoadLatest();
+  await testLoadLatestTenantFilter();
   await testLoadById();
+  await testSnapshotIdMismatchRefused();
+  await testTenantMismatchRefused();
+  await testTakenAtMismatchRefused();
+  await testListOnlyTenantForgeryRefused();
+  await testListOnlyTakenAtForgeryRefused();
+  await testTenantMismatchTamperDirections();
+  await testTopologySameCountRemap();
+  await testPlaintextForgedSignatureRefused();
+  await testVerifyThrowsRefused();
+  await testSealedLoadWithoutSealerRefused();
   await testTamperedEnvelopeRefused();
   await testUnsignedEnvelopeRefused();
   await testAllowPlaintextRefusedUnderRegulatedPosture();
@@ -544,9 +1055,22 @@ async function run() {
   await testRefuseOnTopologyChange();
   await testSchemaVersionMismatch();
   await testList();
+  await testListFilters();
   await testGc();
+  await testGcNoDeleteBackend();
+  await testGcDeleteThrows();
   await testRestoreHandlersInvoked();
   await testRestoreRequireHandlersRefuses();
+  await testRestoreNoHandlersAcknowledgedDrop();
+  await testRestoreHandlerThrows();
+  await testRestoreVoidHandlerAndNullPayload();
+  await testLoadByIdBadId();
+  await testListAndLoadLatestBackendNonArray();
+  await testGcDefaultOlderThan();
+  await testResealBackendListNonArray();
+  await testResealSkipsBadEntries();
+  await testResealNoArgsAndDescriptorNoArgs();
+  await testRealAuditSignerRoundTrip();
   await runReseal();
 }