@blamejs/blamejs-shop 0.5.12 → 0.5.13

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

@@ -371,8 +371,235 @@ async function testBackupPostureRefusesPlaintext() {
     refused2 && /posture-requires-encryption/.test(refused2.code || refused2.message));
 }
 
+var STRONG_PASSPHRASE = "aLongCorrectHorseBatteryStaple9876!Phrase";   // ~227 bits estimated
+
+async function testWrapInputValidation() {
+  var pair = b.crypto.generateEncryptionKeyPair();
+
+  // Non-Buffer / non-Uint8Array bytes → bad-input.
+  var badInput = null;
+  try { b.archive.wrap("not a buffer", { recipient: pair }); } catch (e) { badInput = e; }
+  check("archive.wrap: non-Buffer bytes refused with bad-input",
+    badInput && /bad-input/.test(badInput.code || badInput.message));
+
+  // Zero-length bytes → empty-input (nothing to seal).
+  var emptyErr = null;
+  try { b.archive.wrap(Buffer.alloc(0), { recipient: pair }); } catch (e) { emptyErr = e; }
+  check("archive.wrap: empty bytes refused with empty-input",
+    emptyErr && /empty-input/.test(emptyErr.code || emptyErr.message));
+
+  // A recipient string that is not "tenant" → bad-recipient.
+  var badStrErr = null;
+  try { b.archive.wrap(Buffer.from("x"), { recipient: "nonsense" }); } catch (e) { badStrErr = e; }
+  check("archive.wrap: unrecognised recipient string refused with bad-recipient",
+    badStrErr && /bad-recipient/.test(badStrErr.code || badStrErr.message));
+
+  // An empty recipient object (no publicKey / peerCert*) → bad-recipient.
+  var emptyObjErr = null;
+  try { b.archive.wrap(Buffer.from("x"), { recipient: {} }); } catch (e) { emptyObjErr = e; }
+  check("archive.wrap: empty recipient object refused with bad-recipient",
+    emptyObjErr && /bad-recipient/.test(emptyObjErr.code || emptyObjErr.message));
+
+  // Partial peer-cert recipient (only one of the two halves) → bad-recipient.
+  var partialCertErr = null;
+  try {
+    b.archive.wrap(Buffer.from("x"), { recipient: { peerCertDer: Buffer.from("cert") } });
+  } catch (e) { partialCertErr = e; }
+  check("archive.wrap: peer-cert recipient missing peerKemPubkey refused",
+    partialCertErr && /bad-recipient/.test(partialCertErr.code || partialCertErr.message));
+
+  var partialCertErr2 = null;
+  try {
+    b.archive.wrap(Buffer.from("x"), { recipient: { peerKemPubkey: "kem" } });
+  } catch (e) { partialCertErr2 = e; }
+  check("archive.wrap: peer-cert recipient missing peerCertDer refused",
+    partialCertErr2 && /bad-recipient/.test(partialCertErr2.code || partialCertErr2.message));
+
+  // Uint8Array (non-Buffer) input round-trips through the static-key path.
+  var u8 = new Uint8Array(Buffer.from("uint8 archive bytes ".repeat(10)));
+  var sealedU8 = b.archive.wrap(u8, { recipient: pair });
+  var recoveredU8 = b.archive.unwrap(sealedU8, { recipient: pair });
+  check("archive.wrap: Uint8Array input round-trips losslessly",
+    recoveredU8.equals(Buffer.from(u8)));
+}
+
+async function testUnwrapInputValidation() {
+  var pair = b.crypto.generateEncryptionKeyPair();
+
+  // Non-Buffer sealed input → bad-input.
+  var badInput = null;
+  try { b.archive.unwrap("not a buffer", { recipient: pair }); } catch (e) { badInput = e; }
+  check("archive.unwrap: non-Buffer sealed refused with bad-input",
+    badInput && /bad-input/.test(badInput.code || badInput.message));
+
+  // Input shorter than the 6-byte header → bad-magic (not a crypto error).
+  var shortErr = null;
+  try { b.archive.unwrap(Buffer.from("BAW"), { recipient: pair }); } catch (e) { shortErr = e; }
+  check("archive.unwrap: sub-header-length input refused with bad-magic",
+    shortErr && /bad-magic/.test(shortErr.code || shortErr.message));
+
+  // A well-formed BAWRP envelope with an unknown version byte → bad-version.
+  var sealed = b.archive.wrap(Buffer.from("archive bytes"), { recipient: pair });
+  var tampered = Buffer.from(sealed);
+  tampered[5] = 0x09;   // neither 0x01 (recipient) nor 0x02 (tenant)
+  var badVerErr = null;
+  try { b.archive.unwrap(tampered, { recipient: pair }); } catch (e) { badVerErr = e; }
+  check("archive.unwrap: unknown version byte refused with bad-version",
+    badVerErr && /bad-version/.test(badVerErr.code || badVerErr.message));
+
+  // A recipient (v0x01) envelope unwrapped with no recipient → no-recipient.
+  var noRecipErr = null;
+  try { b.archive.unwrap(sealed, {}); } catch (e) { noRecipErr = e; }
+  check("archive.unwrap: recipient envelope without opts.recipient refused with no-recipient",
+    noRecipErr && /no-recipient/.test(noRecipErr.code || noRecipErr.message));
+
+  // A recipient (v0x01) envelope with a non-object recipient → no-recipient.
+  var strRecipErr = null;
+  try { b.archive.unwrap(sealed, { recipient: "tenant" }); } catch (e) { strRecipErr = e; }
+  check("archive.unwrap: recipient envelope with string recipient refused with no-recipient",
+    strRecipErr && /no-recipient/.test(strRecipErr.code || strRecipErr.message));
+}
+
+async function testPassphraseInputValidation() {
+  // wrapWithPassphrase: non-Buffer bytes → bad-input.
+  var badInput = null;
+  try {
+    await b.archive.wrapWithPassphrase("not a buffer", { passphrase: STRONG_PASSPHRASE });
+  } catch (e) { badInput = e; }
+  check("archive.wrapWithPassphrase: non-Buffer bytes refused with bad-input",
+    badInput && /bad-input/.test(badInput.code || badInput.message));
+
+  // wrapWithPassphrase: empty bytes → empty-input.
+  var emptyErr = null;
+  try {
+    await b.archive.wrapWithPassphrase(Buffer.alloc(0), { passphrase: STRONG_PASSPHRASE });
+  } catch (e) { emptyErr = e; }
+  check("archive.wrapWithPassphrase: empty bytes refused with empty-input",
+    emptyErr && /empty-input/.test(emptyErr.code || emptyErr.message));
+
+  // wrapWithPassphrase: missing / wrong-typed passphrase → no-passphrase.
+  var noPassErr = null;
+  try {
+    await b.archive.wrapWithPassphrase(Buffer.from("x"), { passphrase: 12345 });
+  } catch (e) { noPassErr = e; }
+  check("archive.wrapWithPassphrase: numeric passphrase refused with no-passphrase",
+    noPassErr && /no-passphrase/.test(noPassErr.code || noPassErr.message));
+
+  // wrapWithPassphrase: negative minEntropyBits → bad-arg (finite-and->=0 gate).
+  var negEntropyErr = null;
+  try {
+    await b.archive.wrapWithPassphrase(Buffer.from("x"), {
+      passphrase:     STRONG_PASSPHRASE,
+      minEntropyBits: -5,
+    });
+  } catch (e) { negEntropyErr = e; }
+  check("archive.wrapWithPassphrase: negative minEntropyBits refused with bad-arg",
+    negEntropyErr && /bad-arg/.test(negEntropyErr.code || negEntropyErr.message));
+
+  // unwrapWithPassphrase: non-Buffer sealed → bad-input.
+  var uBadInput = null;
+  try {
+    await b.archive.unwrapWithPassphrase("not a buffer", { passphrase: STRONG_PASSPHRASE });
+  } catch (e) { uBadInput = e; }
+  check("archive.unwrapWithPassphrase: non-Buffer sealed refused with bad-input",
+    uBadInput && /bad-input/.test(uBadInput.code || uBadInput.message));
+
+  // unwrapWithPassphrase: sub-header-length input → bad-magic.
+  var uShortErr = null;
+  try {
+    await b.archive.unwrapWithPassphrase(Buffer.from("BAWP"), { passphrase: STRONG_PASSPHRASE });
+  } catch (e) { uShortErr = e; }
+  check("archive.unwrapWithPassphrase: sub-header input refused with bad-magic",
+    uShortErr && /bad-magic/.test(uShortErr.code || uShortErr.message));
+
+  // unwrapWithPassphrase: BAWPP with an unknown version byte → bad-version.
+  var realSealed = await b.archive.wrapWithPassphrase(Buffer.from("PHI bytes"), {
+    passphrase: STRONG_PASSPHRASE,
+  });
+  var verTampered = Buffer.from(realSealed);
+  verTampered[5] = 0x09;
+  var uBadVerErr = null;
+  try {
+    await b.archive.unwrapWithPassphrase(verTampered, { passphrase: STRONG_PASSPHRASE });
+  } catch (e) { uBadVerErr = e; }
+  check("archive.unwrapWithPassphrase: unknown version byte refused with bad-version",
+    uBadVerErr && /bad-version/.test(uBadVerErr.code || uBadVerErr.message));
+
+  // unwrapWithPassphrase: valid magic/version but no passphrase → no-passphrase.
+  var uNoPassErr = null;
+  try {
+    await b.archive.unwrapWithPassphrase(realSealed, {});
+  } catch (e) { uNoPassErr = e; }
+  check("archive.unwrapWithPassphrase: missing passphrase refused with no-passphrase",
+    uNoPassErr && /no-passphrase/.test(uNoPassErr.code || uNoPassErr.message));
+
+  // unwrapWithPassphrase: header claims a salt longer than the remaining
+  // bytes → truncated-envelope (adversarial length field).
+  var truncated = Buffer.concat([
+    Buffer.from("BAWPP", "ascii"),
+    Buffer.from([0x01, 0xff]),        // version 0x01, saltLen 255
+    Buffer.from("too-short-for-255"),
+  ]);
+  var truncErr = null;
+  try {
+    await b.archive.unwrapWithPassphrase(truncated, { passphrase: STRONG_PASSPHRASE });
+  } catch (e) { truncErr = e; }
+  check("archive.unwrapWithPassphrase: oversized saltLen refused with truncated-envelope",
+    truncErr && /truncated-envelope/.test(truncErr.code || truncErr.message));
+}
+
+async function testRewrapTenantMoreRefusals() {
+  // Sub-header-length blob → bad-magic (no vault needed for this branch).
+  var shortErr = null;
+  try {
+    b.archive.rewrapTenant({ blob: Buffer.from("BA"), oldRootJson: "x", newRootJson: "y", tenantId: "alpha" });
+  } catch (e) { shortErr = e; }
+  check("rewrapTenant: sub-header blob refused with bad-magic",
+    shortErr && /bad-magic/.test(shortErr.code || shortErr.message));
+
+  var tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-aw-rewrap-more-"));
+  try {
+    await helpers.setupVaultOnly(tmpDir);
+    var root = b.vault.getKeysJson();
+    var sealed = b.archive.wrap(Buffer.from("tenant bytes"), { recipient: "tenant", tenantId: "alpha" });
+
+    // Missing newRootJson (old root present, blob opens) → bad-root on the
+    // re-key leg.
+    var noNewRootErr = null;
+    try {
+      b.archive.rewrapTenant({ blob: sealed, oldRootJson: root, tenantId: "alpha" });
+    } catch (e) { noNewRootErr = e; }
+    check("rewrapTenant: missing newRootJson refused with bad-root",
+      noNewRootErr && /bad-root/.test(noNewRootErr.code || noNewRootErr.message));
+  } finally {
+    helpers.teardownVaultOnly(tmpDir);
+  }
+}
+
+async function testUnwrapTenantMissingId() {
+  var tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-aw-unwrap-noid-"));
+  try {
+    await helpers.setupVaultOnly(tmpDir);
+    var sealed = b.archive.wrap(Buffer.from("tenant bytes"), { recipient: "tenant", tenantId: "alpha" });
+    // A tenant (v0x02) envelope unwrapped with recipient "tenant" but no
+    // tenantId → no-tenant-id from the unwrap dispatch path (distinct from
+    // the wrap-side no-tenant-id already covered).
+    var noIdErr = null;
+    try { b.archive.unwrap(sealed, { recipient: "tenant" }); } catch (e) { noIdErr = e; }
+    check("archive.unwrap tenant: missing tenantId on unwrap refused with no-tenant-id",
+      noIdErr && /no-tenant-id/.test(noIdErr.code || noIdErr.message));
+  } finally {
+    helpers.teardownVaultOnly(tmpDir);
+  }
+}
+
 async function run() {
   await testWrapUnwrapRoundTrip();
+  await testWrapInputValidation();
+  await testUnwrapInputValidation();
+  await testPassphraseInputValidation();
+  await testRewrapTenantMoreRefusals();
+  await testUnwrapTenantMissingId();
   await testWrapRefusesBadMagic();
   await testWrapRefusesWrongKey();
   await testWrapRefusesPartialStaticRecipient();

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

@@ -232,6 +232,21 @@ function run() {
   var rawShort = b.argParser.parseRaw(["-v"]);
   check("parseRaw: -v shortcut",      rawShort.flags.v === true);
 
+  // ---- parseRaw booleanNames: a declared flag never swallows a value ----
+  var rawBn = b.argParser.parseRaw(["--version", "up", "--db", "x"], { booleanNames: ["version"] });
+  check("parseRaw booleanNames: bare --version stays boolean, next token is positional",
+        rawBn.flags.version === true && rawBn.pos.length === 1 && rawBn.pos[0] === "up" && rawBn.flags.db === "x");
+  var rawBnMid = b.argParser.parseRaw(["migrate", "--version", "up"], { booleanNames: ["version"] });
+  check("parseRaw booleanNames: token after a mid-argv --version stays a positional in order",
+        rawBnMid.flags.version === true && rawBnMid.pos.length === 2 &&
+        rawBnMid.pos[0] === "migrate" && rawBnMid.pos[1] === "up");
+  var rawBnEq = b.argParser.parseRaw(["--version=x"], { booleanNames: ["version"] });
+  check("parseRaw booleanNames: inline --version=x still records the explicit value",
+        rawBnEq.flags.version === "x");
+  var rawBnOther = b.argParser.parseRaw(["--arg", "-v"], { booleanNames: ["version"] });
+  check("parseRaw booleanNames: a NON-declared flag still consumes its value",
+        rawBnOther.flags.arg === "-v");
+
   var rawProtoThrew = _threw(function () { b.argParser.parseRaw(["--__proto__", "x"]); });
   check("parseRaw: __proto__ rejected",
         !!rawProtoThrew && rawProtoThrew.isArgParserError);

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

@@ -10,6 +10,7 @@
 
 var helpers = require("../helpers");
 var check   = helpers.check;
+var b       = helpers.b;
 var asn1    = require("../../lib/asn1-der");
 
 function testReadNodeShortFormLength() {
@@ -133,12 +134,84 @@ function testHighTagNumberNoOverflow() {
         threw && threw.code === "asn1/tag-too-large");
 }
 
+function testNonMinimalLongFormLengthRejected() {
+  // X.690 §10.1: DER requires the MINIMUM number of length octets. A short-
+  // formable length (< 128) encoded in long form is non-minimal BER, not DER.
+  // 0x30 0x81 0x03 0x02 0x01 0x05 encodes length 3 in a 2-octet long form
+  // where the single short-form octet 0x03 is required. The parser rejects
+  // every other BER-ism (indefinite length, non-minimal OID subidentifiers,
+  // non-minimal high-tag-number tags), so it must reject this one too.
+  var buf = Buffer.from([0x30, 0x81, 0x03, 0x02, 0x01, 0x05]);
+  var threw = null;
+  try { asn1.readNode(buf); } catch (e) { threw = e; }
+  check("readNode: non-minimal long-form length (0x81 0x03) is refused",
+        threw && threw.code === "asn1/length-non-minimal");
+}
+
+function testLeadingZeroLengthOctetRejected() {
+  // 0x82 0x00 0x7f encodes length 127 with a leading-zero length octet — a
+  // strict-DER parser refuses the redundant octet (short form 0x7f is
+  // required). Aliases a value to two distinct wire encodings otherwise.
+  var body = Buffer.alloc(127, 0xaa);
+  var buf = Buffer.concat([Buffer.from([0x04, 0x82, 0x00, 0x7f]), body]);
+  var threw = null;
+  try { asn1.readNode(buf); } catch (e) { threw = e; }
+  check("readNode: leading-zero length octet (0x82 0x00 0x7f) is refused",
+        threw && threw.code === "asn1/length-non-minimal");
+}
+
+function testMinimalLongFormLengthAccepted() {
+  // Control: a genuinely long value (300 bytes) needs the 3-octet long form
+  // 0x82 0x01 0x2c, which IS minimal — the strictness check must NOT reject
+  // it. Guards against a fix that over-rejects legitimate long-form DER.
+  var body = Buffer.alloc(300, 0xbb);
+  var octet = asn1.writeOctetString(body);        // encoder emits 04 82 01 2c ...
+  var node = asn1.readNode(octet);
+  check("readNode: minimal long-form length (0x82 0x01 0x2c) is accepted",
+        node.length === 300 && Buffer.compare(asn1.readOctetString(node), body) === 0);
+  // Boundary: length 128 is the first value that REQUIRES long form (short
+  // form maxes at 127); 0x81 0x80 is minimal and must be accepted.
+  var body128 = Buffer.alloc(128, 0xcc);
+  var octet128 = asn1.writeOctetString(body128);  // 04 81 80 ...
+  check("readNode: minimal long-form at the 128-byte boundary is accepted",
+        asn1.readNode(octet128).length === 128);
+  // Boundary: length 127 is the last short-form value; must round-trip.
+  var body127 = Buffer.alloc(127, 0xdd);
+  check("readNode: short-form length 127 is accepted",
+        asn1.readNode(asn1.writeOctetString(body127)).length === 127);
+}
+
+function testCmsDecodeRefusesNonMinimalLength() {
+  // Consumer path: b.cms.decode routes the top-level ContentInfo through
+  // readNode. A non-minimal outer SEQUENCE length must be refused as
+  // cms/bad-asn1 rather than silently parsed — otherwise a BER/DER parser-
+  // differential encoding of an attacker-supplied CMS is accepted.
+  var inner = Buffer.concat([
+    asn1.writeOid("1.2.840.113549.1.7.1"),
+    asn1.writeContextExplicit(0, asn1.writeNull()),
+  ]);
+  // Canonical short-form outer length would be one octet; force long form.
+  var nonMinimal = Buffer.concat([Buffer.from([0x30, 0x81, inner.length]), inner]);
+  var threw = null;
+  try { b.cms.decode(nonMinimal); } catch (e) { threw = e; }
+  check("b.cms.decode: non-minimal ContentInfo length is refused (cms/bad-asn1)",
+        threw && threw.code === "cms/bad-asn1");
+  // Control: the DER-minimal encoding of the same ContentInfo still decodes.
+  var canonical = asn1.writeNode(0x30, inner);
+  check("b.cms.decode: the DER-minimal ContentInfo still decodes",
+        b.cms.decode(canonical).contentType === "1.2.840.113549.1.7.1");
+}
+
 async function run() {
   testReadNodeShortFormLength();
   testReadOid();
   testOidFirstSubidMultibyte();
   testOidNonMinimalRejected();
   testHighTagNumberNoOverflow();
+  testNonMinimalLongFormLengthRejected();
+  testLeadingZeroLengthOctetRejected();
+  testMinimalLongFormLengthAccepted();
+  testCmsDecodeRefusesNonMinimalLength();
   testReadSequence();
   testReadOctetString();
   testReadBitString();

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

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
+"use strict";
+/**
+ * Layer 0 — b.atomicFile.cleanOrphans boot-time orphan sweep.
+ *
+ * A crashed atomic write leaves a sibling temp file named
+ * `<filepath>.tmp-<token>`. cleanOrphans globs those by prefix and prunes
+ * the ones older than `olderThanMs` (default 5 minutes), leaving fresh
+ * in-flight temps and every unrelated file untouched. This drives the real
+ * consumer path: real orphan temp files planted in a scratch dir, aged past
+ * the threshold via mtime backdating, then swept.
+ */
+
+var helpers      = require("../helpers");
+var check        = helpers.check;
+var b            = helpers.b;
+var backdateFile = helpers.backdateFile;
+var os           = require("node:os");
+var path         = require("node:path");
+var fs           = require("node:fs");
+
+function _plant(fp, token, body) {
+  var p = fp + ".tmp-" + token;
+  fs.writeFileSync(p, body || token);
+  return p;
+}
+
+function testCleanOrphansDefault() {
+  var dir = fs.mkdtempSync(path.join(os.tmpdir(), "bjs-orphan-def-"));
+  var fp  = path.join(dir, "vault.key.sealed");
+  try {
+    // Files that MUST survive: the real sealed file + an unrelated sibling.
+    fs.writeFileSync(fp, "real-sealed-contents");
+    var unrelated = path.join(dir, "other.txt");
+    fs.writeFileSync(unrelated, "leave-me");
+
+    // Stale orphan, aged an hour into the past (well past the 5-min default).
+    var stale = _plant(fp, "staleaaaa");
+    backdateFile(stale);
+    // Fresh in-flight temp (mtime ~now) — MUST survive the default sweep.
+    var fresh = _plant(fp, "freshbbbb");
+
+    // Default olderThanMs is documented as 300000 (5 minutes).
+    var removed = b.atomicFile.cleanOrphans(fp);
+    check("atomicFile.cleanOrphans: default removes the stale orphan", removed === 1);
+    check("atomicFile.cleanOrphans: stale orphan unlinked", !fs.existsSync(stale));
+    check("atomicFile.cleanOrphans: fresh temp survives default", fs.existsSync(fresh));
+    check("atomicFile.cleanOrphans: real sealed file untouched", fs.existsSync(fp));
+    check("atomicFile.cleanOrphans: unrelated sibling untouched", fs.existsSync(unrelated));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+function testCleanOrphansExplicitThreshold() {
+  var dir = fs.mkdtempSync(path.join(os.tmpdir(), "bjs-orphan-thr-"));
+  var fp  = path.join(dir, "db.enc");
+  try {
+    var stale1 = _plant(fp, "aaaa");
+    var stale2 = _plant(fp, "bbbb");
+    backdateFile(stale1);
+    backdateFile(stale2);
+    var fresh = _plant(fp, "cccc");
+
+    var removed = b.atomicFile.cleanOrphans(fp, { olderThanMs: 300000 });
+    check("atomicFile.cleanOrphans: explicit threshold removes both stale", removed === 2);
+    check("atomicFile.cleanOrphans: stale1 gone", !fs.existsSync(stale1));
+    check("atomicFile.cleanOrphans: stale2 gone", !fs.existsSync(stale2));
+    check("atomicFile.cleanOrphans: fresh temp survives", fs.existsSync(fresh));
+
+    // Age is the sole driver: once the surviving temp is itself aged past
+    // the threshold, the next sweep prunes it too. (Backdating avoids the
+    // fs-mtime-granularity knife-edge of a just-created file at age 0.)
+    backdateFile(fresh);
+    var removedAged = b.atomicFile.cleanOrphans(fp, { olderThanMs: 300000 });
+    check("atomicFile.cleanOrphans: newly-aged temp now pruned", removedAged === 1);
+    check("atomicFile.cleanOrphans: aged temp gone", !fs.existsSync(fresh));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+function testCleanOrphansNoOrphans() {
+  var dir = fs.mkdtempSync(path.join(os.tmpdir(), "bjs-orphan-none-"));
+  var fp  = path.join(dir, "audit-sign.key.sealed");
+  try {
+    fs.writeFileSync(fp, "sealed");
+    // A same-directory temp for a DIFFERENT basename must not be swept —
+    // the prefix match is anchored to this filepath's basename.
+    var otherTemp = path.join(dir, "vault.key.sealed.tmp-zzzz");
+    fs.writeFileSync(otherTemp, "not-mine");
+    backdateFile(otherTemp);
+
+    var removed = b.atomicFile.cleanOrphans(fp, { olderThanMs: 300000 });
+    check("atomicFile.cleanOrphans: no matching orphans → 0", removed === 0);
+    check("atomicFile.cleanOrphans: foreign-basename temp untouched", fs.existsSync(otherTemp));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+function run() {
+  testCleanOrphansDefault();
+  testCleanOrphansExplicitThreshold();
+  testCleanOrphansNoOrphans();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run();
+  console.log("OK — " + helpers.getChecks() + " checks passed");
+}

package/lib/vendor/blamejs/test/layer-0-primitives/audit-sign-anchor.test.js

@@ -81,6 +81,139 @@ async function run() {
     var threw = false;
     try { as.anchor({ counter: 1 }); } catch (e) { threw = e.code === "ANCHOR_BAD_TIPHASH"; }
     check("anchor throws a typed error on a malformed tip", threw);
+
+    // ---- Signed-bytes canonicalization: the record delimiter must not be a
+    // field value. anchorPayload joins format / counter / tipHash / prevTipHash
+    // / createdAt with "\n". If a string field carries a "\n", content can
+    // migrate across a field boundary WITHOUT changing the signed bytes, so ONE
+    // signature is valid for several different { tipHash, prevTipHash } splits:
+    // a signature minted for one split verifies for a boundary-shifted twin,
+    // defeating the "prevTipHash is bound into the signature" linkage guarantee.
+    // RED before the fix (both twins verified true); fail-closed after.
+    var fmt = a1.format;
+    var kCounter = 5, kCreatedAt = 99;
+    var tipA = "X", prevA = "Y\nZ";        // split A
+    var tipB = "X\nY", prevB = "Z";        // split B -- identical signed bytes
+    var bytesA = Buffer.from(fmt + "\n" + kCounter + "\n" + tipA + "\n" + prevA + "\n" + kCreatedAt, "utf8");
+    var bytesB = Buffer.from(fmt + "\n" + kCounter + "\n" + tipB + "\n" + prevB + "\n" + kCreatedAt, "utf8");
+    check("two field-boundary splits produce identical signed bytes (the collision)",
+      bytesA.equals(bytesB));
+    var collisionSig = as.sign(bytesA).toString("hex");
+    var collisionBase = {
+      format: fmt, counter: kCounter, createdAt: kCreatedAt,
+      algorithm: as.getAlgorithm(), publicKeyFingerprint: as.getPublicKeyFingerprint(),
+      signature: collisionSig,
+    };
+    var anchorSplitA = Object.assign({}, collisionBase, { tipHash: tipA, prevTipHash: prevA });
+    var anchorSplitB = Object.assign({}, collisionBase, { tipHash: tipB, prevTipHash: prevB });
+    check("verifyAnchor fails closed on a delimiter-bearing prevTipHash (canonicalization)",
+      as.verifyAnchor(anchorSplitA).ok === false);
+    check("verifyAnchor fails closed on the boundary-shifted twin (same signature, different tipHash)",
+      as.verifyAnchor(anchorSplitB).ok === false);
+
+    // Sign-side: minting an ambiguous signature is refused up front, so the
+    // collision above can never be produced through the public API.
+    var threwTipNL = false;
+    try { as.anchor({ counter: 1, tipHash: "a\nb" }); }
+    catch (e) { threwTipNL = e.code === "ANCHOR_BAD_TIPHASH"; }
+    check("anchor refuses a tipHash carrying the record delimiter", threwTipNL);
+    var threwPrevNL = false;
+    try { as.anchor({ counter: 1, tipHash: "ok", prevTipHash: "a\nb" }); }
+    catch (e) { threwPrevNL = e.code === "ANCHOR_BAD_PREV"; }
+    check("anchor refuses a prevTipHash carrying the record delimiter", threwPrevNL);
+    var threwFmtNL = false;
+    try { as.anchor({ counter: 1, tipHash: "ok" }, { format: "my\nledger" }); }
+    catch (e) { threwFmtNL = e.code === "ANCHOR_BAD_FORMAT"; }
+    check("anchor refuses a format carrying the record delimiter", threwFmtNL);
+
+    // ---- verifyAnchor defensive-reader branches (never throw on adversarial
+    // content; return { ok:false }). ----
+    check("verifyAnchor rejects a non-object",
+      as.verifyAnchor(null).ok === false && as.verifyAnchor(42).ok === false);
+    check("verifyAnchor rejects an anchor missing signature / fingerprint",
+      as.verifyAnchor({ tipHash: "h1", counter: 1 }).ok === false);
+    check("verifyAnchor rejects a non-finite counter",
+      as.verifyAnchor(Object.assign({}, a1, { counter: Infinity })).ok === false);
+
+    // ---- verifyAnchorChain adversarial branches ----
+    check("verifyAnchorChain rejects a non-array",
+      as.verifyAnchorChain(null).ok === false && as.verifyAnchorChain("nope").ok === false);
+    check("verifyAnchorChain on an empty array is a vacuous pass",
+      as.verifyAnchorChain([]).ok === true && as.verifyAnchorChain([]).anchorsVerified === 0);
+    // Replay: the same anchor twice -> counter not strictly increasing.
+    var replay = as.verifyAnchorChain([a1, a2, a2]);
+    check("verifyAnchorChain rejects a replayed (duplicate) anchor",
+      replay.ok === false && replay.breakAt === 2);
+    // Fail-closed default: linkage is REQUIRED unless the caller opts out, so an
+    // operator who forgets prevTipHash does not silently get the weaker guarantee.
+    var unlinkedDefault = as.verifyAnchorChain([u1, u2]);
+    check("verifyAnchorChain requires linkage by default (unlinked non-genesis rejected)",
+      unlinkedDefault.ok === false && unlinkedDefault.breakAt === 1);
+
+    // ---- fingerprintOf / getPublicKeyByFingerprint ----
+    var threwFpEmpty = false;
+    try { as.fingerprintOf(""); } catch (e) { threwFpEmpty = e.code === "audit-sign/bad-public-key"; }
+    var threwFpType = false;
+    try { as.fingerprintOf(123); } catch (e) { threwFpType = e.code === "audit-sign/bad-public-key"; }
+    check("fingerprintOf throws a typed error on empty / non-string input",
+      threwFpEmpty && threwFpType);
+    check("fingerprintOf matches getPublicKeyFingerprint for the live key",
+      as.fingerprintOf(as.getPublicKey()) === as.getPublicKeyFingerprint());
+    check("getPublicKeyByFingerprint returns null for an unknown fingerprint",
+      as.getPublicKeyByFingerprint("00ff00ff") === null);
+
+    // ---- reSignAll: re-sign valid, SKIP tampered / empty, never abort ----
+    var reSignSeen = [];
+    var okPayload = Buffer.from("resign-ok", "utf8");
+    var okEntry = { id: 1, payload: okPayload, signature: as.sign(okPayload), oldPublicKeyPem: as.getPublicKey() };
+    var tamperedEntry = {
+      id: 2, payload: Buffer.from("resign-tampered", "utf8"),
+      signature: as.sign(Buffer.from("a-different-payload", "utf8")),   // sig over other bytes -> fails verify
+      oldPublicKeyPem: as.getPublicKey(),
+    };
+    async function* reSignEntries() { yield okEntry; yield tamperedEntry; yield { id: 3 }; }
+    var summary = await as.reSignAll(reSignEntries(), {
+      onProgress: function (e) { reSignSeen.push(e.id); },
+    });
+    check("reSignAll re-signs the valid entry and skips tampered + empty",
+      summary.reSigned === 1 && summary.skipped === 2 && summary.errors === 0);
+    check("reSignAll onProgress fires only for the re-signed entry",
+      reSignSeen.length === 1 && reSignSeen[0] === 1);
+
+    // ---- Key-rotation boundary ----
+    var beforeFp = as.getPublicKeyFingerprint();
+    var preRotAnchor = as.anchor({ counter: 200, tipHash: "rot-tip" });
+    check("anchor verifies before rotation", as.verifyAnchor(preRotAnchor).ok === true);
+    // Negative rotations first (no state change): ROTATE_NOOP + ROTATE_BAD_ALG.
+    var threwNoop = false;
+    try { await as.rotateSigningKey({ publicKeyPem: as.getPublicKey(), privateKeyPem: "unused-for-noop-check" }); }
+    catch (e) { threwNoop = e.code === "ROTATE_NOOP"; }
+    check("rotateSigningKey refuses a no-op rotation (identical fingerprint)", threwNoop);
+    var threwBadAlg = false;
+    try {
+      await as.rotateSigningKey({
+        publicKeyPem: "-----BEGIN PUBLIC KEY-----\nQUJD\n-----END PUBLIC KEY-----",
+        privateKeyPem: "unused", algorithm: "not-a-real-alg",
+      });
+    } catch (e) { threwBadAlg = e.code === "ROTATE_BAD_ALG"; }
+    check("rotateSigningKey refuses an unsupported algorithm", threwBadAlg);
+    check("failed rotations left the live key untouched", as.getPublicKeyFingerprint() === beforeFp);
+
+    // Real rotation: fresh key generated, old public key archived to the
+    // unsealed history so pre-rotation anchors still verify.
+    var rot = await as.rotateSigningKey();
+    check("rotation changed the live fingerprint",
+      rot.newFingerprint !== beforeFp && as.getPublicKeyFingerprint() === rot.newFingerprint);
+    check("pre-rotation anchor still verifies after rotation (history resolves the old key)",
+      as.verifyAnchor(preRotAnchor).ok === true);
+    check("getPublicKeyByFingerprint resolves the rotated-out key",
+      typeof as.getPublicKeyByFingerprint(beforeFp) === "string");
+    var postRotAnchor = as.anchor({ counter: 201, tipHash: "rot-tip-2", prevTipHash: "rot-tip" });
+    check("post-rotation anchor verifies under the new key",
+      as.verifyAnchor(postRotAnchor).ok === true &&
+      postRotAnchor.publicKeyFingerprint === rot.newFingerprint);
+    check("a chain spanning the rotation boundary verifies end-to-end",
+      as.verifyAnchorChain([preRotAnchor, postRotAnchor]).ok === true);
   } finally {
     try { b.auditSign._resetForTest(); } catch (_e) { /* best-effort */ }
     try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_e) { /* best-effort */ }
@@ -88,3 +221,11 @@ async function run() {
 }
 
 module.exports = { run: run };
+if (require.main === module) {
+  run().then(function () {
+    console.log("OK - audit-sign-anchor tests (" + helpers.getChecks() + " checks)");
+  }).catch(function (e) {
+    console.error(helpers.formatErr(e));
+    process.exitCode = 1;
+  });
+}