@blamejs/blamejs-shop 0.4.69 → 0.4.70

package/lib/vendor/blamejs/test/layer-0-primitives/restore-blob-remap.test.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * b.restore — blob-remap / signature-enforcement integrity (CWE-347).
+ *
+ * The documented attack: an attacker with write access to a bundle in storage
+ * copies one valid blob over another manifest entry (reusing its
+ * salt/checksum/size), strips manifest.signature, and restore.run() applies
+ * it with NO integrity error — writing one file's plaintext into another's
+ * slot (e.g. db.enc's bytes into db.key.enc). Two defenses:
+ *   1. each blob is sealed with its relativePath as AEAD associated data, so a
+ *      remapped blob fails the Poly1305 tag on restore (manifest.aadBound);
+ *   2. restore.create accepts a requireSignature policy (threaded into
+ *      extract) operators opt into to mandate a verified signer.
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+var fs      = helpers.fs;
+var os      = helpers.os;
+var path    = helpers.path;
+
+function _seed() {
+  var root = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-remap-"));
+  var dataDir = path.join(root, "data");
+  fs.mkdirSync(dataDir);
+  fs.writeFileSync(path.join(dataDir, "db.enc"), "ORIG-DB-CONTENT");
+  fs.writeFileSync(path.join(dataDir, "db.key.enc"), "SEALED-DEK");
+  return { root: root, dataDir: dataDir, storageRoot: path.join(root, "store") };
+}
+
+async function run() {
+  var pp = Buffer.from("operator-passphrase-not-secret");
+
+  // --- Build a bundle. ---
+  var fx = _seed();
+  try {
+    function storage() { return b.backup.diskStorage({ root: fx.storageRoot }); }
+    var r = await b.backup.create({
+      dataDir: fx.dataDir, storage: storage(), passphrase: pp,
+      files: [
+        { relativePath: "db.enc",     kind: "raw", required: true },
+        { relativePath: "db.key.enc", kind: "raw", required: true },
+      ],
+      vaultKeyJson: '{"vault":"orig"}', audit: false,
+    }).run();
+    var bdir = path.join(fx.storageRoot, r.bundleId);
+    var manifest = JSON.parse(fs.readFileSync(path.join(bdir, "manifest.json"), "utf8"));
+    check("backup: new bundle is marked aadBound", manifest.aadBound === true);
+
+    // --- Clean round-trip still restores (no regression). ---
+    fs.writeFileSync(path.join(fx.dataDir, "db.enc"), "MUTATED");
+    var rr = await b.restore.create({
+      dataDir: fx.dataDir, storage: storage(), passphrase: pp,
+      rollbackRoot: path.join(fx.root, "rb"), audit: false,
+    }).run({ bundleId: r.bundleId });
+    check("restore: clean round-trip succeeds", rr.fileCount === 2);
+    check("restore: db.enc restored to bundle bytes",
+          fs.readFileSync(path.join(fx.dataDir, "db.enc")).toString() === "ORIG-DB-CONTENT");
+
+    // --- Blob-remap attack: point db.key.enc's entry at db.enc's blob
+    // (reuse its salt/checksum/size), strip the signature, restore. ---
+    var dbEnc = manifest.files.filter(function (f) { return f.relativePath === "db.enc"; })[0];
+    var dbKey = manifest.files.filter(function (f) { return f.relativePath === "db.key.enc"; })[0];
+    dbKey.encryptedPath = dbEnc.encryptedPath;
+    dbKey.salt          = dbEnc.salt;
+    dbKey.checksum      = dbEnc.checksum;
+    dbKey.size          = dbEnc.size;
+    dbKey.encryptedSize = dbEnc.encryptedSize;
+    delete manifest.signature;
+    fs.writeFileSync(path.join(bdir, "manifest.json"), JSON.stringify(manifest));
+
+    var threw = null;
+    try {
+      await b.restore.create({
+        dataDir: fx.dataDir, storage: storage(), passphrase: pp,
+        rollbackRoot: path.join(fx.root, "rb2"), audit: false,
+      }).run({ bundleId: r.bundleId });
+    } catch (e) { threw = e; }
+    check("restore: blob-remap attack is REFUSED (AEAD path-binding)",
+          threw && /^restore\/(decrypt-failed|extract-failed)$/.test(threw.code || ""));
+  } finally {
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+
+  // --- requireSignature policy: an unsigned bundle is refused when the
+  // operator mandates a signature (HIPAA/PCI), and restores when not. ---
+  var fx2 = _seed();
+  try {
+    function storage2() { return b.backup.diskStorage({ root: fx2.storageRoot }); }
+    var r2 = await b.backup.create({
+      dataDir: fx2.dataDir, storage: storage2(), passphrase: pp,
+      files: [{ relativePath: "db.enc", kind: "raw", required: true }],
+      vaultKeyJson: '{"vault":"orig"}', audit: false,
+    }).run();
+    var m2 = JSON.parse(fs.readFileSync(path.join(fx2.storageRoot, r2.bundleId, "manifest.json"), "utf8"));
+    check("backup: best-effort bundle is unsigned (no audit-sign)", !m2.signature);
+
+    var threwReq = null;
+    try {
+      await b.restore.create({
+        dataDir: fx2.dataDir, storage: storage2(), passphrase: pp,
+        rollbackRoot: path.join(fx2.root, "rb"), audit: false, requireSignature: true,
+      }).run({ bundleId: r2.bundleId });
+    } catch (e) { threwReq = e; }
+    check("restore: requireSignature:true refuses an unsigned bundle",
+          threwReq && threwReq.code === "restore/missing-signature");
+
+    // Default (requireSignature not set) restores the unsigned best-effort
+    // bundle — the framework's documented CLI/standalone case.
+    var okRun = await b.restore.create({
+      dataDir: fx2.dataDir, storage: storage2(), passphrase: pp,
+      rollbackRoot: path.join(fx2.root, "rb3"), audit: false,
+    }).run({ bundleId: r2.bundleId });
+    check("restore: default restores an unsigned best-effort bundle", okRun.fileCount === 1);
+  } finally {
+    fs.rmSync(fx2.root, { recursive: true, force: true });
+  }
+
+  console.log("OK — restore blob-remap + signature policy (" + helpers.getChecks() + " checks)");
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(function () { process.exit(0); })
+       .catch(function (err) { process.exitCode = 1; throw err; });
+}

package/lib/vendor/blamejs/test/layer-0-primitives/retention-sweep-termination.test.js

@@ -0,0 +1,104 @@
+"use strict";
+// B8a: the retention sweep loop must TERMINATE even when a full batch of rows is
+// not removed from the candidate set by its action. The loop paged LIMIT-from-
+// the-top and exited only when `rows.length < batchSize`, so any full batch that
+// mutated nothing was re-selected forever:
+//   - dryRun (preview) mutates NOTHING → every table with > batchSize past-TTL
+//     rows looped infinitely (a preview that never returns — a DoS);
+//   - a full batch all on legal-hold (skipped) → re-selected forever;
+//   - (same for "warn"-stage and errored rows).
+// The fix adds keyset pagination (ORDER BY _id, _id > cursor) so the loop always
+// advances past rows it has already seen, regardless of whether they were
+// actioned.
+//
+// RED on the buggy tree: run() never returns (the harness times out).
+// GREEN after the fix: each scenario terminates and scans every row exactly once.
+
+var fs = require("fs");
+var path = require("path");
+var os = require("os");
+var helpers  = require("../helpers");
+var dbHelper = require("../helpers/db");
+var b     = helpers.b;
+var check = helpers.check;
+
+var N = 5;            // rows past TTL
+var BATCH = 2;        // < N so the loop must iterate (and, when buggy, re-select)
+
+function _seedRows(table, withHold) {
+  var cols = "\"_id\" TEXT PRIMARY KEY, \"createdAt\" INTEGER, \"payload\" TEXT, \"__erasedAt\" INTEGER" +
+    (withHold ? ", \"onHold\" INTEGER" : "");
+  b.db.prepare("CREATE TABLE \"" + table + "\" (" + cols + ")").run();
+  var longAgo = Date.now() - b.constants.TIME.days(400);
+  for (var i = 0; i < N; i++) {
+    if (withHold) {
+      b.db.prepare("INSERT INTO \"" + table + "\" (\"_id\", \"createdAt\", \"payload\", \"__erasedAt\", \"onHold\") " +
+        "VALUES (?, ?, ?, NULL, 1)").run("r-" + i, longAgo, "p-" + i);
+    } else {
+      b.db.prepare("INSERT INTO \"" + table + "\" (\"_id\", \"createdAt\", \"payload\", \"__erasedAt\") " +
+        "VALUES (?, ?, ?, NULL)").run("r-" + i, longAgo, "p-" + i);
+    }
+  }
+}
+
+async function run() {
+  var tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-retention-term-"));
+  await dbHelper.setupTestDb(tmpDir);
+  try {
+    // ---- dryRun: mutates nothing → must still terminate, scanning each row once ----
+    b.cryptoField.registerTable("retention_dry", { sealedFields: ["payload"], rowIdField: "_id" });
+    _seedRows("retention_dry", false);
+    var ret1 = b.retention.create({ db: b.db, audit: false });
+    ret1.declare({
+      name: "dry-ttl", table: "retention_dry", ageField: "createdAt",
+      ttlMs: b.constants.TIME.days(90), action: "erase", batchSize: BATCH,
+    });
+    var preview = await ret1.run("dry-ttl", { dryRun: true });
+    check("dryRun sweep TERMINATES (did not infinite-loop)", !!preview);
+    check("dryRun scans each row exactly once (no re-selection)", preview.scanned === N);
+    check("dryRun would-process every past-TTL row", preview.processed === N);
+    // Nothing was actually erased (preview).
+    var stillThere = b.db.prepare("SELECT COUNT(*) AS n FROM \"retention_dry\" WHERE \"payload\" IS NOT NULL").get();
+    check("dryRun left every row intact", stillThere.n === N);
+
+    // ---- all-legal-hold: every candidate skipped → must still terminate ----
+    b.cryptoField.registerTable("retention_held", { sealedFields: ["payload"], rowIdField: "_id" });
+    _seedRows("retention_held", true);
+    var ret2 = b.retention.create({ db: b.db, audit: false });
+    ret2.declare({
+      name: "held-ttl", table: "retention_held", ageField: "createdAt",
+      ttlMs: b.constants.TIME.days(90), action: "erase", batchSize: BATCH,
+      legalHoldField: "onHold",
+    });
+    var heldSweep = await ret2.run("held-ttl", { dryRun: false });
+    check("all-legal-hold sweep TERMINATES (did not infinite-loop)", !!heldSweep);
+    check("all-legal-hold scans each row exactly once", heldSweep.scanned === N);
+    check("all-legal-hold honors the hold on every row", heldSweep.legalHoldsHonored === N);
+    check("all-legal-hold processed none (all skipped)", heldSweep.processed === 0);
+    var heldIntact = b.db.prepare("SELECT COUNT(*) AS n FROM \"retention_held\" WHERE \"payload\" IS NOT NULL").get();
+    check("all-legal-hold left every held row intact", heldIntact.n === N);
+
+    // ---- real erase still works + terminates (no over/under-scan) ----
+    b.cryptoField.registerTable("retention_real", { sealedFields: ["payload"], rowIdField: "_id" });
+    _seedRows("retention_real", false);
+    var ret3 = b.retention.create({ db: b.db, audit: false });
+    ret3.declare({
+      name: "real-ttl", table: "retention_real", ageField: "createdAt",
+      ttlMs: b.constants.TIME.days(90), action: "erase", batchSize: BATCH,
+    });
+    var realSweep = await ret3.run("real-ttl", { dryRun: false });
+    check("real erase sweep terminates + scans each row once", realSweep.scanned === N);
+    check("real erase processed every past-TTL row", realSweep.processed === N);
+    var erased = b.db.prepare("SELECT COUNT(*) AS n FROM \"retention_real\" WHERE \"payload\" IS NULL").get();
+    check("real erase NULLed every sealed payload", erased.n === N);
+  } finally {
+    await dbHelper.teardownTestDb(tmpDir);
+  }
+  console.log("OK — retention sweep termination (" + helpers.getChecks() + " checks)");
+}
+
+module.exports = { run: run };
+if (require.main === module) {
+  run().then(function () { process.exit(0); })
+       .catch(function (err) { process.exitCode = 1; throw err; });
+}

package/lib/vendor/blamejs/test/layer-0-primitives/router-body-validation.test.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * b.router — request-body schema validation must run even when no body was
+ * parsed. A route declaring `spec.body` is asserting the body is part of the
+ * contract; skipping the check when `req.body === undefined` (no body sent /
+ * bodyParser absent / empty POST) silently admits a request that omits a
+ * required body straight to the handler. Mirrors the always-run params/query
+ * checks.
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+var s       = b.safeSchema;
+
+function _req(method, url) {
+  return { method: method, url: url, headers: { host: "localhost" } };
+}
+
+function _res() {
+  var res = {
+    statusCode:    0,
+    headersSent:   false,
+    writableEnded: false,
+    _body:         "",
+    writeHead: function (status, headers) {
+      res.statusCode = status;
+      res._headers = headers || {};
+      res.headersSent = true;
+    },
+    end: function (chunk) {
+      if (chunk !== undefined) res._body += chunk;
+      res.writableEnded = true;
+    },
+  };
+  return res;
+}
+
+async function testMissingRequiredBodyRejected() {
+  var r = b.router.create();
+  var handlerRan = false;
+  r.post("/items", { body: s.object({ name: s.string() }) }, function (req, res) {
+    handlerRan = true;
+    res.writeHead(200); res.end("created");
+  });
+
+  // No body was parsed onto the request (req.body === undefined).
+  var res = _res();
+  await r.handle(_req("POST", "/items"), res);
+  check("missing required body → 400", res.statusCode === 400);
+  check("missing required body → handler did not run", handlerRan === false);
+  check("missing required body → validation error names the body location",
+    /"where":"body"/.test(res._body));
+}
+
+async function testValidBodyAccepted() {
+  var r = b.router.create();
+  var seen = null;
+  r.post("/items", { body: s.object({ name: s.string() }) }, function (req, res) {
+    seen = req.body;
+    res.writeHead(200); res.end("created");
+  });
+
+  var req = _req("POST", "/items");
+  req.body = { name: "widget" };
+  var res = _res();
+  await r.handle(req, res);
+  check("valid body → 200", res.statusCode === 200);
+  check("valid body → handler sees parsed body", seen && seen.name === "widget");
+}
+
+async function testOptionalBodyAbsentAccepted() {
+  // An explicitly-optional body schema must still pass when no body is sent —
+  // the fix validates, it does not require a body unconditionally.
+  var r = b.router.create();
+  var handlerRan = false;
+  r.post("/items", { body: s.object({ name: s.string() }).optional() }, function (req, res) {
+    handlerRan = true;
+    res.writeHead(200); res.end("ok");
+  });
+
+  var res = _res();
+  await r.handle(_req("POST", "/items"), res);
+  check("optional body absent → 200", res.statusCode === 200 && handlerRan === true);
+}
+
+async function run() {
+  await testMissingRequiredBodyRejected();
+  await testValidBodyAccepted();
+  await testOptionalBodyAbsentAccepted();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(function () { console.log("OK router-body-validation — " + helpers.getChecks() + " checks"); })
+       .catch(function (e) { console.error("FAIL:", e && e.stack || e); process.exit(1); });
+}

package/lib/vendor/blamejs/test/layer-0-primitives/safe-json-stringify-for-script.test.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * b.safeJson.stringifyForScript — JSON safe to embed verbatim inside an
+ * inline <script>. Raw JSON.stringify leaves <, >, & literal, so a value
+ * containing "</script>" closes the surrounding element (XSS); the
+ * U+2028 / U+2029 separators are also illegal unescaped in a script on
+ * older parsers. This escapes all of them to \uXXXX — the parsed value is
+ * byte-identical.
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+function run() {
+  // </script> in a value is neutralised but round-trips.
+  var payload = { url: "/a</script><script>alert(1)</script>", amp: "a&b", lt: "x<y>z" };
+  var out = b.safeJson.stringifyForScript(payload);
+  check("no raw </script> survives", out.indexOf("</script>") === -1);
+  check("< is escaped to \\u003c", out.indexOf("\\u003c") !== -1 && out.indexOf("<") === -1);
+  check("> is escaped to \\u003e", out.indexOf(">") === -1);
+  check("& is escaped to \\u0026", out.indexOf("&") === -1);
+  check("round-trips to the identical value", JSON.parse(out).url === payload.url &&
+        JSON.parse(out).amp === "a&b" && JSON.parse(out).lt === "x<y>z");
+
+  // U+2028 / U+2029 (built via code point so this source stays ASCII).
+  var sep = { s: "a" + String.fromCharCode(0x2028) + "b" + String.fromCharCode(0x2029) + "c" };
+  var outSep = b.safeJson.stringifyForScript(sep);
+  check("U+2028 escaped to \\u2028", outSep.indexOf("\\u2028") !== -1 &&
+        outSep.indexOf(String.fromCharCode(0x2028)) === -1);
+  check("U+2029 escaped to \\u2029", outSep.indexOf("\\u2029") !== -1 &&
+        outSep.indexOf(String.fromCharCode(0x2029)) === -1);
+  check("separators round-trip to the identical value",
+        JSON.parse(outSep).s === sep.s);
+
+  console.log("OK — safeJson.stringifyForScript (" + helpers.getChecks() + " checks)");
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  try { run(); } catch (e) { console.error(e); process.exit(1); }
+}

package/lib/vendor/blamejs/test/layer-0-primitives/saml-subjectconfirmation-notonorafter.test.js

@@ -85,11 +85,12 @@ function _buildSignedResponse(idp, parts) {
     parts.nameId + "</saml:NameID>" +
     subjectConfirmation +
     "</saml:Subject>" +
-    "<saml:Conditions NotBefore=\"" + _isoFromNow(-5 * 60 * 1000) +                             // allow:raw-time-literal — 5m skew window
-    "\" NotOnOrAfter=\"" + _isoFromNow(5 * 60 * 1000) + "\">" +                                 // allow:raw-time-literal — 5m skew window
-    "<saml:AudienceRestriction><saml:Audience>" + SP_ENTITY_ID +
-    "</saml:Audience></saml:AudienceRestriction>" +
-    "</saml:Conditions>" +
+    (parts.conditions !== undefined ? parts.conditions :
+      "<saml:Conditions NotBefore=\"" + _isoFromNow(-5 * 60 * 1000) +                            // allow:raw-time-literal — 5m skew window
+      "\" NotOnOrAfter=\"" + _isoFromNow(5 * 60 * 1000) + "\">" +                                // allow:raw-time-literal — 5m skew window
+      "<saml:AudienceRestriction><saml:Audience>" + SP_ENTITY_ID +
+      "</saml:Audience></saml:AudienceRestriction>" +
+      "</saml:Conditions>") +
     "<saml:AuthnStatement SessionIndex=\"_sess-1\" AuthnInstant=\"" + issueInstant + "\">" +
     "<saml:AuthnContext><saml:AuthnContextClassRef>" +
     "urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport" +
@@ -273,11 +274,53 @@ async function testHolderOfKeyNotOnOrAfterRefused() {
     _verifyThrows(sp, b64bad, vopts) === "auth-saml/no-valid-confirmation");
 }
 
+// #B0 — a signed assertion with NO AudienceRestriction is not bound to THIS
+// SP. Accepting it is audience-confusion: an IdP-signed assertion minted for
+// another SP is replayed here. Must fail closed (default on).
+async function testMissingAudienceRestrictionRefused() {
+  var idp = await _mintRsaCert("idp.example");
+  var sp  = _newSp(idp);
+  var inResponseTo = "_req-noaud";
+  var b64 = _buildSignedResponse(idp, {
+    tag:    "no-aud",
+    method: "urn:oasis:names:tc:SAML:2.0:cm:bearer",
+    nameId: "u@example.com",
+    scd:    _bearerScd(" NotOnOrAfter=\"" + _isoFromNow(5 * 60 * 1000) + "\"", inResponseTo),    // allow:raw-time-literal — 5m future
+    conditions: "<saml:Conditions NotBefore=\"" + _isoFromNow(-5 * 60 * 1000) +                  // allow:raw-time-literal — 5m skew
+      "\" NotOnOrAfter=\"" + _isoFromNow(5 * 60 * 1000) + "\"></saml:Conditions>",               // allow:raw-time-literal — NO AudienceRestriction
+  });
+  check("signed assertion without AudienceRestriction refused (audience-confusion)",
+    _verifyThrows(sp, b64, { expectedInResponseTo: inResponseTo }) === "auth-saml/no-audience-restriction");
+}
+
+// #B0 — a present-but-unparseable Conditions NotBefore/NotOnOrAfter must fail
+// CLOSED (the Bearer SCD path already does; the Conditions path skipped it via
+// an isFinite() short-circuit, so an unparseable validity window was ignored).
+async function testUnparseableConditionsTimestampRefused() {
+  var idp = await _mintRsaCert("idp.example");
+  var sp  = _newSp(idp);
+  var inResponseTo = "_req-badts";
+  var b64 = _buildSignedResponse(idp, {
+    tag:    "bad-ts",
+    method: "urn:oasis:names:tc:SAML:2.0:cm:bearer",
+    nameId: "u@example.com",
+    scd:    _bearerScd(" NotOnOrAfter=\"" + _isoFromNow(5 * 60 * 1000) + "\"", inResponseTo),    // allow:raw-time-literal — 5m future
+    conditions: "<saml:Conditions NotBefore=\"" + _isoFromNow(-5 * 60 * 1000) +                  // allow:raw-time-literal — valid NotBefore
+      "\" NotOnOrAfter=\"not-a-date\">" +
+      "<saml:AudienceRestriction><saml:Audience>" + SP_ENTITY_ID +
+      "</saml:Audience></saml:AudienceRestriction></saml:Conditions>",
+  });
+  check("unparseable Conditions NotOnOrAfter refused (fail-closed)",
+    _verifyThrows(sp, b64, { expectedInResponseTo: inResponseTo }) === "auth-saml/conditions-bad-timestamp");
+}
+
 async function run() {
   await testBearerValidNotOnOrAfterAccepted();
   await testBearerMissingNotOnOrAfterRefused();
   await testBearerUnparseableNotOnOrAfterRefused();
   await testHolderOfKeyNotOnOrAfterRefused();
+  await testMissingAudienceRestrictionRefused();
+  await testUnparseableConditionsTimestampRefused();
 }
 
 if (require.main === module) {

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

@@ -21,6 +21,7 @@
 var helpers = require("../helpers");
 var b       = helpers.b;
 var check   = helpers.check;
+var C       = require("../../lib/constants");
 
 async function testHappyPath() {
   var r = await b.sandbox.run({
@@ -171,6 +172,27 @@ async function testProcessUnreachable() {
   }
 }
 
+async function testWebAssemblyStripped() {
+  // WebAssembly linear memory is off the V8 heap, so the maxBytes-derived
+  // heap cap can't bound `new WebAssembly.Memory(...).grow(N)`. WebAssembly
+  // must be stripped from the worker global so the grow-and-touch source
+  // cannot commit unbounded off-heap RAM (CWE-770). Stripped → the source
+  // ReferenceErrors and the call refuses, rather than resolving after
+  // committing ~GiB under a 4 MiB cap.
+  try {
+    await b.sandbox.run({
+      source: "var m = new WebAssembly.Memory({ initial: 1 }); m.grow(30000); " +
+              "var v = new Uint8Array(m.buffer); for (var i = 0; i < v.length; i += 4096) v[i] = 1; " +
+              "return v.length;",
+      maxBytes: C.BYTES.mib(4),
+      timeoutMs: 9000,
+    });
+    check("WebAssembly grow should be refused (stripped)", false);
+  } catch (e) {
+    check("WebAssembly unreachable in sandbox", e && e.code === "sandbox/runtime-error");
+  }
+}
+
 async function testNoNetworkAccess() {
   // require absent means http unreachable; confirm path.
   try {
@@ -233,6 +255,7 @@ async function run() {
   await testBadInput();
   await testContainment();
   await testProcessUnreachable();
+  await testWebAssemblyStripped();
   await testNoNetworkAccess();
   await testKnownSafeBuiltins();
 }

package/lib/vendor/blamejs/test/layer-0-primitives/sd-jwt-vc.test.js

@@ -318,6 +318,58 @@ async function testPresentWithKeyBinding() {
         result.holderKey && result.holderKey.kty === "EC");
 }
 
+async function testKbRequiresReplayBinding() {
+  // A KB-JWT presentation verified WITHOUT opts.audience/opts.nonce must fail
+  // closed — otherwise the aud/nonce compares silently skip and the
+  // presentation is replayable + acceptable at any verifier.
+  var issuer = _newKeyPair();
+  var holder = _newKeyPair();
+  var sd = sdJwtVc.issue({
+    issuer: "https://issuer", vct: "x", claims: { x: 1 },
+    issuerKey: issuer.privateKey, holderKey: _jwk(holder.publicKey),
+  });
+  var pres = sdJwtVc.present({
+    sdJwt: sd.token, audience: "https://verifier", nonce: "n-1",
+    holderKey: holder.privateKey, algorithm: "ES256",
+  });
+  // No nonce + no audience supplied to verify → must throw.
+  var threwNone = null;
+  try {
+    await sdJwtVc.verify(pres.presentation, {
+      issuerKeyResolver: async function () { return issuer.publicKey; },
+      requireKeyBinding: true,
+    });
+  } catch (e) { threwNone = e; }
+  check("verify: KB-JWT without audience+nonce fails closed",
+        threwNone && threwNone.code === "auth-sd-jwt-vc/missing-replay-binding");
+  // audience but no nonce → still throws (replay defense needs the fresh nonce).
+  var threwNoNonce = null;
+  try {
+    await sdJwtVc.verify(pres.presentation, {
+      issuerKeyResolver: async function () { return issuer.publicKey; },
+      audience: "https://verifier", requireKeyBinding: true,
+    });
+  } catch (e) { threwNoNonce = e; }
+  check("verify: KB-JWT with audience but no nonce fails closed",
+        threwNoNonce && threwNoNonce.code === "auth-sd-jwt-vc/missing-replay-binding");
+}
+
+async function testRequireExpOpt() {
+  // requireExp + expectedIssuer are accepted opts (previously expectedIssuer
+  // was consumed but absent from the allowlist → "unknown option"). A normal
+  // token (issue() always writes a numeric exp) still verifies under requireExp.
+  var issuer = _newKeyPair();
+  var sd = sdJwtVc.issue({
+    issuer: "https://issuer", vct: "x", claims: { x: 1 }, issuerKey: issuer.privateKey,
+  });
+  var ok = await sdJwtVc.verify(sd.token, {
+    issuerKeyResolver: async function () { return issuer.publicKey; },
+    requireExp: true, expectedIssuer: "https://issuer",
+  });
+  check("verify: requireExp + expectedIssuer accepted; exp-present token verifies",
+        ok.valid === true);
+}
+
 async function testKbWrongAudience() {
   var issuer = _newKeyPair();
   var holder = _newKeyPair();
@@ -776,6 +828,8 @@ function testExports() {
   await testVerifyDisclosureMismatch();
   await testPresentSubsetThenVerify();
   await testPresentWithKeyBinding();
+  await testKbRequiresReplayBinding();
+  await testRequireExpOpt();
   await testKbWrongAudience();
   await testKbWrongNonce();
   await testRequireKeyBindingMissing();

package/lib/vendor/blamejs/test/layer-0-primitives/session-extensions.test.js

@@ -181,6 +181,29 @@ async function testPluggableStore() {
   }
 }
 
+async function testDestroyAllForUserPluggableNoDb() {
+  // #340: a pluggable-store consumer who never ran b.db.init() must get a
+  // clear, actionable error from destroyAllForUser — not the opaque
+  // db/not-initialized that bubbled out of the stateless valid-from bump
+  // (which writes to the framework db, not the pluggable session store).
+  var tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ses-nodb-"));
+  try {
+    await helpers.setupVaultOnly(tmpDir);   // vault up; b.db deliberately NOT initialized
+    b.session.useStore({
+      execute:    function () { return Promise.resolve({ rowCount: 1 }); },
+      executeOne: function () { return Promise.resolve(null); },
+    });
+    var err = null;
+    try { await b.session.destroyAllForUser("u-1"); }
+    catch (e) { err = e; }
+    check("destroyAllForUser (pluggable store, no b.db) → clear error, not db/not-initialized",
+      err !== null && err.code !== "db/not-initialized" && /b\.db\.init\(\)/.test(err.message || ""));
+  } finally {
+    b.session.useStore(null);
+    helpers.teardownVaultOnly(tmpDir);
+  }
+}
+
 async function testPluggableStoreValidation() {
   var threw = false;
   try { b.session.useStore({ execute: function () {} }); }
@@ -381,6 +404,7 @@ async function run() {
   await testClientIpPrefixV6();
   await testClientIpPrefixV4MappedV6();
   await testPluggableStore();
+  await testDestroyAllForUserPluggableNoDb();
   await testPluggableStoreValidation();
   await testUpdateDataReplaceAndMerge();
   await testUpdateDataPreservesFingerprint();

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

@@ -44,10 +44,11 @@ async function _server() {
   };
 }
 
-function _get(port, urlPath) {
+function _get(port, urlPath, headers) {
   return new Promise(function (resolve, reject) {
     var req = http.request({
       hostname: "127.0.0.1", port: port, path: urlPath, method: "GET",
+      headers: headers || undefined,
     }, function (res) {
       var chunks = [];
       res.on("data", function (c) { chunks.push(c); });
@@ -484,7 +485,47 @@ async function testDirectoryIndexServed() {
   }
 }
 
+// RFC 7232 §3.3/§6: If-None-Match takes precedence over If-Modified-Since,
+// and If-Match takes precedence over If-Unmodified-Since. When the strong
+// entity-tag precondition is present, the recipient MUST ignore the
+// date-based one — otherwise a changed resource is falsely reported 304, or
+// an unchanged resource falsely 412'd.
+async function testConditionalEntityTagPrecedence() {
+  var ctx = await _server();
+  _writeFile(ctx.dir, "doc.txt", "hello conditional");
+  var srv = await ctx.start({ contentSafety: null });
+  try {
+    var base = await _get(srv.port, "/doc.txt");
+    check("conditional: baseline serves 200 with ETag",
+          base.statusCode === 200 && typeof base.headers.etag === "string");
+    var future = new Date(Date.now() + 86400000).toUTCString();
+    var past   = new Date(Date.now() - 86400000).toUTCString();
+
+    // If-None-Match present + non-matching → resource changed; the
+    // If-Modified-Since (future → would 304) must be ignored, serve 200.
+    var r1 = await _get(srv.port, "/doc.txt", {
+      "If-None-Match":     '"stale-does-not-match"',
+      "If-Modified-Since": future,
+    });
+    check("If-None-Match (stale) overrides If-Modified-Since → 200, not 304",
+          r1.statusCode === 200);
+
+    // If-Match: * (matches) + If-Unmodified-Since (past → would 412) must
+    // be ignored because If-Match is present and satisfied, serve 200.
+    var r2 = await _get(srv.port, "/doc.txt", {
+      "If-Match":            "*",
+      "If-Unmodified-Since": past,
+    });
+    check("If-Match (*) overrides If-Unmodified-Since → 200, not 412",
+          r2.statusCode === 200);
+  } finally {
+    srv.close();
+    ctx.cleanup();
+  }
+}
+
 async function run() {
+  await testConditionalEntityTagPrecedence();
   await testForceAttachmentDefaultOff();
   await testForceAttachmentOnHtml();
   await testForceAttachmentOnJs();