@blamejs/blamejs-shop 0.0.113 → 0.0.115

package/lib/vendor/blamejs/test/layer-0-primitives/backup-bundle-info.test.js

@@ -0,0 +1,279 @@
+"use strict";
+/**
+ * Layer 0 — b.backup.bundleAdapterStorage#bundleInfo + listBundles
+ * format inference + v0.12.17 envelopeKind probe.
+ */
+
+var fs = require("node:fs");
+var path = require("node:path");
+var os = require("node:os");
+var b = require("../../index");
+var helpers = require("../helpers");
+var check = helpers.check;
+
+async function testBundleInfoTarGzRecipient() {
+  var pair = b.crypto.generateEncryptionKeyPair();
+  var src = fs.mkdtempSync(path.join(os.tmpdir(), "bi-src-r-"));
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "bi-dest-r-"));
+  try {
+    fs.writeFileSync(path.join(src, "phi.json"), "{\"id\":42}", { mode: 0o600 });
+    var storage = b.backup.bundleAdapterStorage({
+      adapter:        b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+      format:         "tar.gz",
+      cryptoStrategy: "recipient",
+      recipient:      pair,
+    });
+    var bid = "2026-05-23T23-00-00-000Z-deadbeef";
+    await storage.writeBundle(bid, src);
+    var info = await storage.bundleInfo(bid);
+    check("bundleInfo: format inferred from storage layout", info.format === "tar.gz");
+    check("bundleInfo: envelopeKind probed from payload magic",
+      info.envelopeKind === "recipient");
+    check("bundleInfo: sizeBytes carries payload length", info.sizeBytes > 0);
+  } finally {
+    try { fs.rmSync(src,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testBundleInfoTarPassphrase() {
+  var src = fs.mkdtempSync(path.join(os.tmpdir(), "bi-src-p-"));
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "bi-dest-p-"));
+  try {
+    fs.writeFileSync(path.join(src, "data.json"), "{\"v\":1}", { mode: 0o600 });
+    var storage = b.backup.bundleAdapterStorage({
+      adapter:        b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+      format:         "tar",
+      cryptoStrategy: "passphrase",
+      passphrase:     "aLongCorrectHorseBatteryStaple9876!Phrase",
+    });
+    var bid = "2026-05-23T23-15-00-000Z-cafef00d";
+    await storage.writeBundle(bid, src);
+    var info = await storage.bundleInfo(bid);
+    check("bundleInfo: tar format inferred", info.format === "tar");
+    check("bundleInfo: passphrase envelope detected",
+      info.envelopeKind === "passphrase");
+  } finally {
+    try { fs.rmSync(src,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testBundleInfoPlaintext() {
+  var src = fs.mkdtempSync(path.join(os.tmpdir(), "bi-src-n-"));
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "bi-dest-n-"));
+  try {
+    fs.writeFileSync(path.join(src, "data.json"), "{\"v\":1}", { mode: 0o600 });
+    var storage = b.backup.bundleAdapterStorage({
+      adapter: b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+      format:  "tar.gz",
+    });
+    var bid = "2026-05-23T23-30-00-000Z-ba5eba11";
+    await storage.writeBundle(bid, src);
+    var info = await storage.bundleInfo(bid);
+    check("bundleInfo: plaintext bundle yields envelopeKind \"none\"",
+      info.envelopeKind === "none");
+  } finally {
+    try { fs.rmSync(src,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testBundleInfoNotFound() {
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "bi-dest-nf-"));
+  try {
+    var storage = b.backup.bundleAdapterStorage({
+      adapter: b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+    });
+    var refused = null;
+    try {
+      await storage.bundleInfo("2026-05-23T23-45-00-000Z-feedface");
+    } catch (e) { refused = e; }
+    check("bundleInfo: nonexistent bundle refused with bundle-not-found",
+      refused && /bundle-not-found/.test(refused.code || refused.message));
+  } finally {
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testBundleInfoLargeBundleUsesPartialRead() {
+  // Codex P1 on v0.12.17 PR #168 — bundleInfo's envelope probe
+  // claimed 5 bytes but read the full payload. With a 1 MiB
+  // bundle + readPartial-capable adapter, the probe should consume
+  // at most 16 bytes; verify by mocking an adapter whose readFile
+  // throws "DO NOT CALL" but whose readPartial returns the magic.
+  var calls = { readFile: 0, readPartial: 0 };
+  var sealedHead = Buffer.concat([Buffer.from("BAWRP"), Buffer.alloc(11)]);   // 16 bytes
+  var mockAdapter = {
+    writeFile: async function () {},
+    readFile:  async function () { calls.readFile += 1; throw new Error("readFile MUST NOT be called for the probe"); },
+    listKeys:  async function () { return []; },
+    deleteKey: async function () {},
+    hasKey:    async function (key) { return /bundle\.tar\.gz$/.test(key); },
+    readPartial: async function (key, length) {
+      calls.readPartial += 1;
+      return sealedHead.slice(0, length);
+    },
+    statKey:   async function () { return { size: 1024 * 1024, mtimeMs: 0 }; },
+  };
+  var storage = b.backup.bundleAdapterStorage({ adapter: mockAdapter });
+  var info = await storage.bundleInfo("2026-05-23T23-00-00-000Z-bbbbbbbb");
+  check("bundleInfo: probe routes through readPartial when adapter exposes it",
+    calls.readPartial === 1 && calls.readFile === 0);
+  check("bundleInfo: envelopeKind correctly identified from partial read",
+    info.envelopeKind === "recipient");
+  check("bundleInfo: sizeBytes from statKey", info.sizeBytes === 1024 * 1024);
+}
+
+async function testListBundlesTarGzWinsOverTar() {
+  // Codex P2 on v0.12.17 PR #168 — when both bundle.tar and
+  // bundle.tar.gz exist for the same bundleId (e.g. operator
+  // migration in progress), listBundles must report tar.gz to
+  // align with readBundle's precedence. Verify by injecting both
+  // keys via a mock adapter.
+  var mockAdapter = {
+    writeFile: async function () {},
+    readFile:  async function () { return Buffer.alloc(0); },
+    listKeys:  async function () {
+      // Return keys in tar-first order; tar.gz should still win.
+      return [
+        "2026-05-23T22-00-00-000Z-aabbccdd/bundle.tar",
+        "2026-05-23T22-00-00-000Z-aabbccdd/bundle.tar.gz",
+      ];
+    },
+    deleteKey: async function () {},
+    hasKey:    async function () { return false; },
+  };
+  var storage = b.backup.bundleAdapterStorage({ adapter: mockAdapter });
+  var list = await storage.listBundles();
+  check("listBundles: tar.gz precedence applied when both formats exist",
+    list.length === 1 && list[0].format === "tar.gz");
+}
+
+async function testListBundlesWithStats() {
+  // v0.12.18 — listBundles({ withStats: true }) populates
+  // createdAt + size from statKey when the adapter exposes it.
+  var src = fs.mkdtempSync(path.join(os.tmpdir(), "lbws-src-"));
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "lbws-dest-"));
+  try {
+    fs.writeFileSync(path.join(src, "a"), "x", { mode: 0o600 });
+    var storage = b.backup.bundleAdapterStorage({
+      adapter: b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+      format:  "tar.gz",
+    });
+    var bid = "2026-05-24T00-00-00-000Z-99887766";
+    await storage.writeBundle(bid, src);
+    var noStats = await storage.listBundles();
+    check("listBundles: default call leaves size + createdAt null",
+      noStats[0].size === null && noStats[0].createdAt === null);
+    var withStats = await storage.listBundles({ withStats: true });
+    check("listBundles({ withStats: true }): size populated",
+      typeof withStats[0].size === "number" && withStats[0].size > 0);
+    check("listBundles({ withStats: true }): createdAt is ISO string",
+      typeof withStats[0].createdAt === "string" &&
+      /^\d{4}-\d{2}-\d{2}T/.test(withStats[0].createdAt));
+  } finally {
+    try { fs.rmSync(src,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testBundleInfoDirectoryCreatedAt() {
+  // Codex P2 on v0.12.18 PR #169 — directory-format bundles MUST
+  // populate createdAt from the manifest.json (parity with
+  // listBundles({ withStats })). Previously the stat lookup was
+  // gated inside `if (payloadKey !== null)` which skipped
+  // directory bundles entirely.
+  var src = fs.mkdtempSync(path.join(os.tmpdir(), "bidir-src-"));
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "bidir-dest-"));
+  try {
+    fs.writeFileSync(path.join(src, "a"), "x", { mode: 0o600 });
+    fs.writeFileSync(path.join(src, "manifest.json"), "{\"version\":1}", { mode: 0o600 });
+    var storage = b.backup.bundleAdapterStorage({
+      adapter: b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+      format:  "directory",
+    });
+    var bid = "2026-05-24T00-45-00-000Z-aaaa9999";
+    await storage.writeBundle(bid, src);
+    var info = await storage.bundleInfo(bid);
+    check("bundleInfo: directory-format bundle reports createdAt from manifest",
+      typeof info.createdAt === "string" && /^\d{4}-\d{2}-\d{2}T/.test(info.createdAt));
+    check("bundleInfo: directory-format bundle reports format \"directory\"",
+      info.format === "directory");
+    var list = await storage.listBundles({ withStats: true });
+    check("listBundles+withStats vs bundleInfo: createdAt parity for directory format",
+      list[0].createdAt === info.createdAt);
+  } finally {
+    try { fs.rmSync(src,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testBundleInfoCreatedAt() {
+  var src = fs.mkdtempSync(path.join(os.tmpdir(), "bica-src-"));
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "bica-dest-"));
+  try {
+    fs.writeFileSync(path.join(src, "a"), "x", { mode: 0o600 });
+    var storage = b.backup.bundleAdapterStorage({
+      adapter: b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+      format:  "tar",
+    });
+    var bid = "2026-05-24T00-30-00-000Z-aabbccdd";
+    await storage.writeBundle(bid, src);
+    var info = await storage.bundleInfo(bid);
+    check("bundleInfo: createdAt is ISO string from statKey.mtimeMs",
+      typeof info.createdAt === "string" && /^\d{4}-\d{2}-\d{2}T/.test(info.createdAt));
+  } finally {
+    try { fs.rmSync(src,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testListBundlesCarriesFormat() {
+  var src = fs.mkdtempSync(path.join(os.tmpdir(), "lb-src-"));
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "lb-dest-"));
+  try {
+    fs.writeFileSync(path.join(src, "data.json"), "{\"v\":1}", { mode: 0o600 });
+    var tarStorage = b.backup.bundleAdapterStorage({
+      adapter: b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+      format:  "tar",
+    });
+    await tarStorage.writeBundle("2026-05-23T23-50-00-000Z-a1b2c3d4", src);
+    var tarGzStorage = b.backup.bundleAdapterStorage({
+      adapter: b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+      format:  "tar.gz",
+    });
+    await tarGzStorage.writeBundle("2026-05-23T23-55-00-000Z-e5f6a7b8", src);
+    var list = await tarStorage.listBundles();
+    check("listBundles: returns 2 bundles", list.length === 2);
+    var byFormat = {};
+    for (var i = 0; i < list.length; i += 1) byFormat[list[i].format] = (byFormat[list[i].format] || 0) + 1;
+    check("listBundles: format inferred per bundle (tar + tar.gz)",
+      byFormat.tar === 1 && byFormat["tar.gz"] === 1);
+  } finally {
+    try { fs.rmSync(src,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function run() {
+  await testBundleInfoTarGzRecipient();
+  await testBundleInfoTarPassphrase();
+  await testBundleInfoPlaintext();
+  await testBundleInfoNotFound();
+  await testBundleInfoLargeBundleUsesPartialRead();
+  await testListBundlesTarGzWinsOverTar();
+  await testListBundlesCarriesFormat();
+  await testListBundlesWithStats();
+  await testBundleInfoCreatedAt();
+  await testBundleInfoDirectoryCreatedAt();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("[backup-bundle-info] OK — " + helpers.getChecks() + " checks passed"); },
+    function (e) { console.error("FAIL:", e && e.stack || e); process.exit(1); }
+  );
+}

package/lib/vendor/blamejs/test/layer-0-primitives/backup-object-store-adapter.test.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * Layer 0 — b.backup.bundleAdapterStorage.objectStoreAdapter +
+ * end-to-end round-trip via b.objectStore local backend +
+ * combined with v0.12.10 recipient + v0.12.11 passphrase wrap.
+ */
+
+var fs = require("node:fs");
+var path = require("node:path");
+var os = require("node:os");
+var b = require("../../index");
+var helpers = require("../helpers");
+var check = helpers.check;
+
+function _mkSrc(name, contents) {
+  var dir = fs.mkdtempSync(path.join(os.tmpdir(), "bjs-os-src-"));
+  fs.writeFileSync(path.join(dir, name), contents);
+  return dir;
+}
+
+async function testObjectStoreAdapterRoundTrip() {
+  var rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "bjs-os-root-"));
+  var src = _mkSrc("data.json", "{\"v\":1}");
+  var verify = path.join(os.tmpdir(), "bjs-os-verify-" + Date.now());
+  try {
+    var client = b.objectStore.buildBackend({ protocol: "local", rootDir: rootDir });
+    var storage = b.backup.bundleAdapterStorage({
+      adapter: b.backup.bundleAdapterStorage.objectStoreAdapter(client, { prefix: "test-prefix" }),
+      format:  "tar.gz",
+    });
+    var bundleId = "2026-05-23T22-00-00-000Z-aaaa1111";
+    await storage.writeBundle(bundleId, src);
+    check("objectStoreAdapter: hasBundle true after write",
+      await storage.hasBundle(bundleId));
+    await storage.readBundle(bundleId, verify);
+    check("objectStoreAdapter: bundle round-trips after fs-backed objectStore put + get",
+      fs.readFileSync(path.join(verify, "data.json"), "utf-8") === "{\"v\":1}");
+    var diskKey = path.join(rootDir, "test-prefix", bundleId, "bundle.tar.gz");
+    check("objectStoreAdapter: prefix applied — key lands under operator-specified root",
+      fs.existsSync(diskKey));
+  } finally {
+    try { fs.rmSync(rootDir, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(src,     { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(verify,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testObjectStoreAdapterWithRecipient() {
+  var rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "bjs-os-root-r-"));
+  var src = _mkSrc("phi.json", "{\"patient\":42}");
+  var verify = path.join(os.tmpdir(), "bjs-os-verify-r-" + Date.now());
+  try {
+    var pair = b.crypto.generateEncryptionKeyPair();
+    var client = b.objectStore.buildBackend({ protocol: "local", rootDir: rootDir });
+    var storage = b.backup.bundleAdapterStorage({
+      adapter:        b.backup.bundleAdapterStorage.objectStoreAdapter(client),
+      format:         "tar.gz",
+      cryptoStrategy: "recipient",
+      recipient:      pair,
+    });
+    var bundleId = "2026-05-23T22-15-00-000Z-aaaa2222";
+    await storage.writeBundle(bundleId, src);
+    var sealed = fs.readFileSync(path.join(rootDir, bundleId, "bundle.tar.gz"));
+    check("objectStoreAdapter + recipient: bundle carries BAWRP envelope magic on disk",
+      sealed.slice(0, 5).toString("ascii") === "BAWRP");
+    await storage.readBundle(bundleId, verify);
+    check("objectStoreAdapter + recipient: round-trips through unwrap + gunzip + untar",
+      fs.readFileSync(path.join(verify, "phi.json"), "utf-8") === "{\"patient\":42}");
+  } finally {
+    try { fs.rmSync(rootDir, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(src,     { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(verify,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testObjectStoreAdapterRefusesBadClient() {
+  var refused = null;
+  try {
+    b.backup.bundleAdapterStorage.objectStoreAdapter({});  // missing put/get/etc
+  } catch (e) { refused = e; }
+  check("objectStoreAdapter: missing methods refused upfront",
+    refused && /missing method/.test(refused.message || ""));
+  var refused2 = null;
+  try {
+    b.backup.bundleAdapterStorage.objectStoreAdapter(null);
+  } catch (e) { refused2 = e; }
+  check("objectStoreAdapter: null client refused upfront",
+    refused2 && /client is required/.test(refused2.message || ""));
+}
+
+async function testObjectStoreAdapterPagination() {
+  // Codex P1 on v0.12.13 PR #164 — listKeys must follow
+  // truncated / continuationToken pages. Mock a client that
+  // returns 3 pages then exhausts.
+  var pages = [
+    { items: [{ key: "p/a" }, { key: "p/b" }], truncated: true, continuationToken: "tok1" },
+    { items: [{ key: "p/c" }, { key: "p/d" }], truncated: true, continuationToken: "tok2" },
+    { items: [{ key: "p/e" }],                  truncated: false, continuationToken: null  },
+  ];
+  var calls = [];
+  var client = {
+    put:    async function () { return { size: 0 }; },
+    get:    async function () { return Buffer.alloc(0); },
+    head:   async function () { return { size: 0 }; },
+    delete: async function () { return true; },
+    list:   async function (prefix, opts) {
+      calls.push({ prefix: prefix, token: (opts && opts.continuationToken) || null });
+      return pages.shift();
+    },
+  };
+  var adapter = b.backup.bundleAdapterStorage.objectStoreAdapter(client, { prefix: "p" });
+  var keys = await adapter.listKeys("");
+  check("objectStoreAdapter.listKeys: walks all paginated pages",
+    keys.length === 5 && keys.join(",") === "a,b,c,d,e");
+  check("objectStoreAdapter.listKeys: forwarded continuationToken across calls",
+    calls.length === 3 && calls[1].token === "tok1" && calls[2].token === "tok2");
+}
+
+async function testObjectStoreAdapterPaginationRunaway() {
+  // A misbehaving backend that returns truncated:true forever
+  // must trip the safety cap rather than spin.
+  var client = {
+    put:    async function () { return { size: 0 }; },
+    get:    async function () { return Buffer.alloc(0); },
+    head:   async function () { return { size: 0 }; },
+    delete: async function () { return true; },
+    list:   async function () {
+      return { items: [{ key: "k" }], truncated: true, continuationToken: "ever" };
+    },
+  };
+  var adapter = b.backup.bundleAdapterStorage.objectStoreAdapter(client);
+  var refused = null;
+  try { await adapter.listKeys(""); } catch (e) { refused = e; }
+  check("objectStoreAdapter.listKeys: runaway pagination refused with typed error",
+    refused && /list-pagination-runaway/.test(refused.code || refused.message));
+}
+
+async function testObjectStoreAdapterPrefixTraversalRefused() {
+  var client = b.objectStore.buildBackend({
+    protocol: "local",
+    rootDir:  fs.mkdtempSync(path.join(os.tmpdir(), "bjs-os-trav-")),
+  });
+  var refused = null;
+  try {
+    b.backup.bundleAdapterStorage.objectStoreAdapter(client, { prefix: "../escape" });
+  } catch (e) { refused = e; }
+  check("objectStoreAdapter: prefix with traversal segment refused upfront",
+    refused && /traversal/.test(refused.message || ""));
+}
+
+async function run() {
+  await testObjectStoreAdapterRoundTrip();
+  await testObjectStoreAdapterWithRecipient();
+  await testObjectStoreAdapterRefusesBadClient();
+  await testObjectStoreAdapterPagination();
+  await testObjectStoreAdapterPaginationRunaway();
+  await testObjectStoreAdapterPrefixTraversalRefused();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("[backup-object-store-adapter] OK — " + helpers.getChecks() + " checks passed"); },
+    function (e) { console.error("FAIL:", e && e.stack || e); process.exit(1); }
+  );
+}

package/lib/vendor/blamejs/test/layer-0-primitives/backup-verify-bundle.test.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * Layer 0 — b.backup.bundleAdapterStorage#verifyBundle integrity
+ * check across plaintext + recipient + passphrase + directory.
+ */
+
+var fs = require("node:fs");
+var path = require("node:path");
+var os = require("node:os");
+var b = require("../../index");
+var helpers = require("../helpers");
+var check = helpers.check;
+
+function _mkSrcDir(name, contents) {
+  var dir = fs.mkdtempSync(path.join(os.tmpdir(), "vb-src-"));
+  fs.writeFileSync(path.join(dir, name), contents, { mode: 0o600 });
+  return dir;
+}
+
+async function testVerifyTarGzRecipientOk() {
+  var pair = b.crypto.generateEncryptionKeyPair();
+  var src = _mkSrcDir("a.json", "{\"x\":1}");
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "vb-dest-"));
+  try {
+    var storage = b.backup.bundleAdapterStorage({
+      adapter:        b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+      format:         "tar.gz",
+      cryptoStrategy: "recipient",
+      recipient:      pair,
+    });
+    var bid = "2026-05-24T01-00-00-000Z-aaaa1111";
+    await storage.writeBundle(bid, src);
+    var v = await storage.verifyBundle(bid);
+    check("verifyBundle: tar.gz + recipient bundle reports ok=true",
+      v.ok === true);
+    check("verifyBundle: format reported", v.format === "tar.gz");
+    check("verifyBundle: envelopeKind reported", v.envelopeKind === "recipient");
+    check("verifyBundle: entryCount populated", v.entryCount === 1);
+    check("verifyBundle: errors array empty", v.errors.length === 0);
+  } finally {
+    try { fs.rmSync(src,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testVerifyTarPassphraseOk() {
+  var src = _mkSrcDir("a.json", "{\"x\":1}");
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "vb-dest-p-"));
+  try {
+    var storage = b.backup.bundleAdapterStorage({
+      adapter:        b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+      format:         "tar",
+      cryptoStrategy: "passphrase",
+      passphrase:     "aLongCorrectHorseBatteryStaple9876!Phrase",
+    });
+    var bid = "2026-05-24T01-15-00-000Z-bbbb2222";
+    await storage.writeBundle(bid, src);
+    var v = await storage.verifyBundle(bid);
+    check("verifyBundle: tar + passphrase ok",
+      v.ok === true && v.envelopeKind === "passphrase" && v.entryCount === 1);
+  } finally {
+    try { fs.rmSync(src,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testVerifyPlaintextTarOk() {
+  var src = _mkSrcDir("a.json", "{\"x\":1}");
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "vb-dest-pt-"));
+  try {
+    var storage = b.backup.bundleAdapterStorage({
+      adapter: b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+      format:  "tar",
+    });
+    var bid = "2026-05-24T01-30-00-000Z-cccc3333";
+    await storage.writeBundle(bid, src);
+    var v = await storage.verifyBundle(bid);
+    check("verifyBundle: plaintext tar ok",
+      v.ok === true && v.envelopeKind === "none" && v.entryCount === 1);
+  } finally {
+    try { fs.rmSync(src,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testVerifyWrongPassphraseFails() {
+  var src = _mkSrcDir("a.json", "{\"x\":1}");
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "vb-dest-wp-"));
+  try {
+    var storage = b.backup.bundleAdapterStorage({
+      adapter:        b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+      format:         "tar",
+      cryptoStrategy: "passphrase",
+      passphrase:     "aLongCorrectHorseBatteryStaple9876!Phrase",
+    });
+    var bid = "2026-05-24T01-45-00-000Z-dddd4444";
+    await storage.writeBundle(bid, src);
+    var v = await storage.verifyBundle(bid, {
+      passphrase: "wrongPassphrase!CompletelyDifferent987654321",
+    });
+    check("verifyBundle: wrong passphrase reports ok=false with error",
+      v.ok === false && v.errors.length > 0);
+  } finally {
+    try { fs.rmSync(src,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testVerifyCorruptedTarFails() {
+  // Write a tar bundle, corrupt the tar header, verify reports failure.
+  var src = _mkSrcDir("a.json", "{\"x\":1}");
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "vb-dest-cor-"));
+  try {
+    var storage = b.backup.bundleAdapterStorage({
+      adapter: b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+      format:  "tar",
+    });
+    var bid = "2026-05-24T02-00-00-000Z-eeee5555";
+    await storage.writeBundle(bid, src);
+    var tarPath = path.join(dest, bid, "bundle.tar");
+    // Corrupt the first 257 bytes (header field) so ustar magic + chksum break.
+    var bytes = fs.readFileSync(tarPath);
+    bytes[257] = 0x42; bytes[258] = 0x42; bytes[259] = 0x42;
+    fs.writeFileSync(tarPath, bytes, { mode: 0o600 });
+    var v = await storage.verifyBundle(bid);
+    check("verifyBundle: corrupted tar reports ok=false with error",
+      v.ok === false && v.errors.length > 0);
+  } finally {
+    try { fs.rmSync(src,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testVerifyDirectoryOk() {
+  var src = fs.mkdtempSync(path.join(os.tmpdir(), "vb-dir-src-"));
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "vb-dir-dest-"));
+  try {
+    fs.writeFileSync(path.join(src, "manifest.json"), "{\"v\":1}", { mode: 0o600 });
+    fs.writeFileSync(path.join(src, "a"), "x", { mode: 0o600 });
+    var storage = b.backup.bundleAdapterStorage({
+      adapter: b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+      format:  "directory",
+    });
+    var bid = "2026-05-24T02-15-00-000Z-ffff6666";
+    await storage.writeBundle(bid, src);
+    var v = await storage.verifyBundle(bid);
+    check("verifyBundle: directory format reports ok=true (manifest existence is the verification)",
+      v.ok === true && v.format === "directory" && v.entryCount === null);
+  } finally {
+    try { fs.rmSync(src,  { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function testVerifyMissingBundleFails() {
+  var dest = fs.mkdtempSync(path.join(os.tmpdir(), "vb-dest-mb-"));
+  try {
+    var storage = b.backup.bundleAdapterStorage({
+      adapter: b.backup.bundleAdapterStorage.fsAdapter({ root: dest }),
+    });
+    var v = await storage.verifyBundle("2026-05-24T02-30-00-000Z-99999999");
+    check("verifyBundle: missing bundle reports ok=false with bundle-not-found",
+      v.ok === false && /bundle-not-found/.test(v.errors[0] || ""));
+  } finally {
+    try { fs.rmSync(dest, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+  }
+}
+
+async function run() {
+  await testVerifyTarGzRecipientOk();
+  await testVerifyTarPassphraseOk();
+  await testVerifyPlaintextTarOk();
+  await testVerifyWrongPassphraseFails();
+  await testVerifyCorruptedTarFails();
+  await testVerifyDirectoryOk();
+  await testVerifyMissingBundleFails();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("[backup-verify-bundle] OK — " + helpers.getChecks() + " checks passed"); },
+    function (e) { console.error("FAIL:", e && e.stack || e); process.exit(1); }
+  );
+}

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

@@ -5646,6 +5646,34 @@ var KNOWN_ANTIPATTERNS = [
     reason: "Codex P1 on v0.12.7 PR #158 — archive-read.extract used renameSync to atomically place each decompressed entry at its canonical destination + tracked written[].path for catch-block cleanup. When the destination directory was non-empty, the rename silently overwrote operator files; on extract abort, the cleanup deleted them. Fix: refuse upfront if destination path exists, force operators to use a fresh / empty subtree. Detector locks the shape: any extract code that tracks resolvedPath for catch-block cleanup MUST carry a `destination-exists` refusal in the same file.",
   },
 
+  {
+    // Codex P1 on v0.12.13 PR #164 — listKeys against a paginated
+    // object-store backend dropped every key past the first page
+    // because the call sent only one client.list() and ignored
+    // the `truncated` / `continuationToken` contract. Detector
+    // locks the shape: any lib/ call to `client.list(...)` paired
+    // with `truncated` consumption MUST also walk the
+    // continuationToken loop, OR the call site must carry an
+    // `allow:list-without-pagination` marker explaining why
+    // single-page is sufficient (typically: the caller already
+    // bounds the prefix or already passes a maxResults that's
+    // known to be larger than the universe).
+    id: "object-store-list-without-pagination",
+    primitive: "object-store list calls in lib/ MUST walk truncated / continuationToken pages — single-shot list silently truncates at the backend's page cap (1000 by default). The runtime symptom is silent data loss in listBundles / deleteBundle. Either follow the pagination loop or carry the `allow:list-without-pagination` marker with the bound reason.",
+    regex: /\bclient\.list\s*\(/,
+    requires: /continuationToken|truncated|allow:list-without-pagination/,
+    skipCommentLines: true,
+    allowlist: [
+      // backup/index.js IS the runtime pagination site (walks the
+      // loop with the runaway-cap defence). Allowlisted because
+      // the inline `client.list` calls there are inside the
+      // walker itself; the detector would false-positive on the
+      // call inside the do-while.
+      "lib/backup/index.js",
+    ],
+    reason: "Codex P1 on v0.12.13 PR #164 — objectStoreAdapter.listKeys called client.list once and never followed the truncated/continuationToken pagination contract. The fix walks the loop with a PAGINATION_CAP safety net. Detector locks the shape so a future caller of client.list can't silently drop pagination.",
+  },
+
   {
     // Codex P1A on v0.12.12 PR #163 — "on-request" placement
     // semantics collapsed into "always" when shouldEmit didn't