@blamejs/blamejs-shop 0.4.68 → 0.4.70

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

@@ -145,6 +145,45 @@ async function testMiddlewareScopeDenied() {
         body && body.error && body.error.code === -32001);
 }
 
+async function testMiddlewareScopeNonStringThrows() {
+  // A non-string scope VALUE (operator typo, e.g. an array) must be refused at
+  // construction — else the runtime `typeof requiredScope === "string"` gate
+  // silently skips, a fail-open authorization bypass on a gated skill.
+  var threw = null;
+  try {
+    b.a2a.middleware.tasks({ scopes: { transfer: ["a2a:transfer"] }, handler: function () {} });
+  } catch (e) { threw = e; }
+  check("middleware: non-string scope value rejected at construction",
+        threw && threw.code === "a2a-tasks/bad-mw-opts");
+}
+
+async function testMiddlewareRejectsHostileSkill() {
+  // The untrusted-peer ingress must validate task.skill (the client send path
+  // does); an oversized / metacharacter-laden skill must never reach the handler.
+  var handlerRan = false;
+  var mw = b.a2a.middleware.tasks({ handler: function () { handlerRan = true; return null; } });
+  var hostile = "A".repeat(5000);
+  var req = _mockReq("POST", "application/json",
+    Buffer.from(JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tasks/send", params: { task: { skill: hostile } } })),
+    []);
+  var res = _mockRes();
+  var body = await _runMwAndDecode(mw, req, res);
+  check("middleware: oversized skill rejected (-32602), handler not run",
+        body && body.error && body.error.code === -32602 && handlerRan === false);
+}
+
+async function testMiddlewareRejectsHostileTaskId() {
+  var handlerRan = false;
+  var mw = b.a2a.middleware.tasks({ handler: function () { handlerRan = true; return null; } });
+  var req = _mockReq("POST", "application/json",
+    Buffer.from(JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tasks/get", params: { taskId: "../../etc/passwd" } })),
+    []);
+  var res = _mockRes();
+  var body = await _runMwAndDecode(mw, req, res);
+  check("middleware: traversal taskId rejected (-32602), handler not run",
+        body && body.error && body.error.code === -32602 && handlerRan === false);
+}
+
 async function testMiddlewareSuccessSend() {
   var captured = null;
   var mw = b.a2a.middleware.tasks({
@@ -199,6 +238,9 @@ async function run() {
   await testMiddlewareInvalidJson();
   await testMiddlewareMethodNotFound();
   await testMiddlewareScopeDenied();
+  await testMiddlewareScopeNonStringThrows();
+  await testMiddlewareRejectsHostileSkill();
+  await testMiddlewareRejectsHostileTaskId();
   await testMiddlewareSuccessSend();
   await testAgentCardMiddleware();
 }

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

@@ -385,6 +385,41 @@ async function testEnvelopeMacTamperFails() {
   }
 }
 
+async function testCrossTopicReplayDropped() {
+  // A genuinely-MAC'd envelope for topic A, replayed verbatim onto topic B's
+  // channel, must NOT be delivered to B's handler — even when A and B share
+  // a schema + tenant. The MAC binds _topic=A (so it cannot be forged), but
+  // the subscriber must additionally bind the authenticated _topic to the
+  // channel it was registered for.
+  var tmpDir = _tmp();
+  await helpers.setupVaultOnly(tmpDir);
+  try {
+    var pubsub = _capturingPubsub();
+    var bus = b.agent.eventBus.create({ pubsub: pubsub });
+    bus.registerTopic("mail.scan.alpha", { schema: { source: "string" }, posture: "soc2" });
+    bus.registerTopic("mail.scan.beta", { schema: { source: "string" }, posture: "soc2" });
+    var gotA = [], gotB = [];
+    await bus.subscribe("mail.scan.alpha", function (p) { gotA.push(p); });
+    await bus.subscribe("mail.scan.beta", function (p) { gotB.push(p); });
+
+    await bus.publish("mail.scan.alpha", { source: "from-a" }, { actor: { id: "p1" } });
+    await helpers.waitUntil(function () { return gotA.length >= 1; }, {
+      timeoutMs: 5000, label: "cross-topic: baseline A delivery",
+    });
+    var genuineA = pubsub._lastEnvelope();
+    check("genuine A envelope carries _topic=mail.scan.alpha + a MAC",
+          genuineA._topic === "mail.scan.alpha" && typeof genuineA._mac === "string");
+
+    // Replay the verbatim, MAC-valid A envelope onto B's channel.
+    pubsub._deliver("mail.scan.beta", JSON.parse(JSON.stringify(genuineA)));
+    await helpers.passiveObserve(40, "cross-topic: A-event replayed onto B must NOT reach B's handler");
+    check("cross-topic replay (A envelope on B channel) is dropped", gotB.length === 0);
+    check("the legitimate A subscriber still got exactly its one event", gotA.length === 1);
+  } finally {
+    helpers.teardownVaultOnly(tmpDir);
+  }
+}
+
 async function testEnvelopeMacPublishFailsClosedWithoutVault() {
   // requireMac default ON + no vault → publish refuses (fail-closed)
   // rather than emitting an unauthenticatable envelope.
@@ -419,6 +454,7 @@ async function run() {
   await testEnvelopeMacForgedRefused();
   await testEnvelopeMacHonestDelivered();
   await testEnvelopeMacTamperFails();
+  await testCrossTopicReplayDropped();
   await testEnvelopeMacPublishFailsClosedWithoutVault();
 }
 

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

@@ -481,6 +481,52 @@ async function runReseal() {
   }
 }
 
+async function testAllowPlaintextRefusedUnderRegulatedPosture() {
+  // #112 — allowPlaintext claimed to be "refused under hipaa/pci-dss/gdpr/soc2"
+  // but had NO posture check: persist wrote a plaintext body and load waived
+  // signature verification (CWE-347) under a regulated posture. The dev escape
+  // hatch must actually refuse under a regulated posture, at BOTH boundaries.
+  var backend = _fakeBackend();
+  try {
+    b.compliance.clear();
+    b.compliance.set("hipaa");
+
+    // (A) persist must refuse the no-sealer plaintext path under hipaa.
+    var plain = b.agent.snapshot.create({
+      orchestrator:   _fakeOrch(),
+      backend:        backend,
+      signer:         _fakeSigner(),   // signer wired; sealer omitted -> plaintext body
+      allowPlaintext: true,
+    });
+    var sA = await plain.takeSnapshot({});
+    await expectRejection("persist allowPlaintext refused under hipaa",
+      plain.persist(sA), "agent-snapshot/plaintext-refused-under-posture");
+
+    // (B) load must NOT waive verify for an attacker-written unsigned snapshot
+    // under hipaa (the CWE-347 path).
+    var signed = _signedSnapshot({ backend: backend });
+    var sB = await signed.takeSnapshot({});
+    await backend.put(sB.snapshotId, Object.assign({}, sB, { sig: null }));
+    var plainLoader = b.agent.snapshot.create({
+      orchestrator: _fakeOrch(), backend: backend, signer: _fakeSigner(), allowPlaintext: true,
+    });
+    await expectRejection("load unsigned NOT waived under hipaa",
+      plainLoader.loadById(sB.snapshotId), "agent-snapshot/plaintext-refused-under-posture");
+  } finally {
+    b.compliance.clear();
+  }
+
+  // (C) control — with no regulated posture (dev), the escape hatch still works.
+  var devBackend = _fakeBackend();
+  var dev = b.agent.snapshot.create({
+    orchestrator: _fakeOrch(), backend: devBackend, signer: _fakeSigner(), allowPlaintext: true,
+  });
+  var sC = await dev.takeSnapshot({});
+  var persisted = await dev.persist(sC);
+  check("dev allowPlaintext persists without a regulated posture",
+    persisted && typeof persisted.snapshotId === "string");
+}
+
 async function run() {
   testSurface();
   await testCreateRequiresOrchestrator();
@@ -491,6 +537,7 @@ async function run() {
   await testLoadById();
   await testTamperedEnvelopeRefused();
   await testUnsignedEnvelopeRefused();
+  await testAllowPlaintextRefusedUnderRegulatedPosture();
   await testRestoreTopologyChange();
   await testRefuseOnTopologyChange();
   await testSchemaVersionMismatch();

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

@@ -54,6 +54,29 @@ async function testGzBombCapRefused() {
     refused !== null);
 }
 
+async function testGzRandomAccessSourceCapped() {
+  // The random-access branch must cap the COMPRESSED read before
+  // adapter.range(0, size) allocates the whole file — a hostile .gz (or an
+  // objectStore/HTTP source advertising a huge size) is an OOM lever.
+  // maxDecompressedBytes bounds the compressed read too. Use incompressible
+  // bytes so compressed.length stays well above the small cap.
+  var src = require("node:crypto").randomBytes(8192);
+  var compressed = b.archive.gz(src).toBuffer();   // ~8 KiB (random → no compression)
+  var refused = null;
+  try {
+    await b.archive.read.gz(b.archive.adapters.buffer(compressed), {
+      maxDecompressedBytes: 1024,
+    }).toBuffer();
+  } catch (e) { refused = e; }
+  check("archive.read.gz: random-access source over the read cap refused (OOM defense)",
+    refused && /source-too-large/.test(refused.code || refused.message));
+  // A generous cap still reads it (no over-rejection).
+  var ok = await b.archive.read.gz(b.archive.adapters.buffer(compressed), {
+    maxDecompressedBytes: 64 * 1024 * 1024,
+  }).toBuffer();
+  check("archive.read.gz: still reads within the cap", ok.equals(src));
+}
+
 async function testTarToGzip() {
   var t = b.archive.tar();
   t.addFile("payload.txt", "hello world");
@@ -144,6 +167,7 @@ async function run() {
   await testGzRoundTrip();
   await testGzBadMagicRefused();
   await testGzBombCapRefused();
+  await testGzRandomAccessSourceCapped();
   await testTarToGzip();
   await testBackupTarGzRoundTrip();
   await testBackupTarGzHighRatioRoundTrip();

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

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * b.archive.read.tar hardening — uncapped random-access read + PAX `size`
+ * NaN walker-desync.
+ *
+ *   - random-access cap: the random-access adapter branch read the WHOLE
+ *     source with `adapter.range(0, size)` and no ceiling — a multi-GiB
+ *     source is an OOM lever. It now refuses a source larger than the bomb
+ *     policy's maxTotalDecompressedBytes.
+ *   - PAX size NaN: a PAX extended header carrying a non-numeric `size`
+ *     ("abc") was `parseInt`'d to NaN, which silently bypassed the
+ *     entry-size bomb check (`NaN > max` is false) AND desynced the 512-byte
+ *     block walker (`Math.ceil(NaN / 512)` is NaN). It now refuses a
+ *     malformed PAX size.
+ */
+
+var helpers = require("../helpers");
+var check = helpers.check;
+var b = helpers.b;
+
+var BLOCK = 512;
+
+// Minimal ustar header builder with a valid POSIX checksum (sum of all 512
+// bytes with the chksum field treated as 8 spaces). Enough for the reader's
+// _parseHeader (magic + chksum validated).
+function _octal(n, width) {
+  var s = n.toString(8);
+  while (s.length < width - 1) s = "0" + s;
+  return s; // caller pads with NUL
+}
+function _header(name, size, typeflag) {
+  var buf = Buffer.alloc(BLOCK, 0);
+  buf.write(name, 0, Math.min(name.length, 100), "ascii");
+  buf.write("0000644\0", 100, 8, "ascii");          // mode
+  buf.write("0000000\0", 108, 8, "ascii");          // uid
+  buf.write("0000000\0", 116, 8, "ascii");          // gid
+  buf.write(_octal(size, 12) + "\0", 124, 12, "ascii");   // size (11 octal + NUL)
+  buf.write("00000000000\0", 136, 12, "ascii");     // mtime
+  buf.write(typeflag, 156, 1, "ascii");             // typeflag
+  buf.write("ustar\0", 257, 6, "ascii");            // magic
+  buf.write("00", 263, 2, "ascii");                 // version
+  // checksum: chksum field = 8 spaces while summing
+  for (var i = 148; i < 156; i++) buf[i] = 0x20;
+  var sum = 0;
+  for (var j = 0; j < BLOCK; j++) sum += buf[j];
+  var oct = sum.toString(8);
+  while (oct.length < 6) oct = "0" + oct;
+  buf.write(oct + "\0 ", 148, 8, "ascii");          // 6 octal + NUL + space
+  return buf;
+}
+function _pad512(buf) {
+  var rem = buf.length % BLOCK;
+  return rem === 0 ? buf : Buffer.concat([buf, Buffer.alloc(BLOCK - rem, 0)]);
+}
+// Build a tar whose first entry is a PAX extended header (typeflag 'x')
+// carrying `size=<paxSizeValue>`, followed by a real file entry.
+function _paxTar(paxSizeValue, fileBody) {
+  var rec = " size=" + paxSizeValue + "\n";
+  // PAX record = "<total-length> size=<value>\n"; total counts its own digits.
+  var total = rec.length;
+  while (String(total).length + rec.length !== total) total = String(total).length + rec.length;
+  var paxBody = Buffer.from(String(total) + rec, "ascii");
+  var paxHdr = _header("PaxHeader/file.txt", paxBody.length, "x");
+  var fileHdr = _header("file.txt", fileBody.length, "0");
+  return Buffer.concat([
+    paxHdr, _pad512(paxBody),
+    fileHdr, _pad512(Buffer.from(fileBody)),
+    Buffer.alloc(BLOCK * 2, 0),   // end-of-archive
+  ]);
+}
+
+function _codeOf(p) {
+  return p.then(function () { return null; }, function (e) { return (e && e.code) || (e && e.message) || "threw"; });
+}
+
+async function testRandomAccessReadIsCapped() {
+  var t = b.archive.tar();
+  t.addFile("a.txt", "hello world payload that is comfortably over a hundred bytes long ............................");
+  var bytes = t.toBuffer();   // ~2 KiB, random-access buffer adapter
+  // A tiny bomb policy → the 2 KiB source exceeds the read cap → refuse.
+  var code = await _codeOf(
+    b.archive.read.tar(b.archive.adapters.buffer(bytes), {
+      bombPolicy: { maxTotalDecompressedBytes: 100 },
+    }).inspect());
+  check("read.tar refuses a random-access source over the read cap (OOM defense)",
+    code === "archive-tar/source-too-large");
+
+  // A generous cap still reads it (no over-rejection).
+  var entries = await b.archive.read.tar(b.archive.adapters.buffer(bytes), {
+    bombPolicy: { maxTotalDecompressedBytes: 64 * 1024 * 1024 },
+  }).inspect();
+  check("read.tar still reads within the cap", entries.length === 1);
+}
+
+async function testPaxMalformedSizeRefused() {
+  // Truthy-but-non-integer PAX size values that reach the parser (an empty
+  // string is correctly treated as "no override" by the `if (pax.size)` guard).
+  var malformed = ["abc", "1e9", "100abc", "-5"];
+  for (var i = 0; i < malformed.length; i++) {
+    var tar = _paxTar(malformed[i], "x");
+    var code = await _codeOf(b.archive.read.tar(b.archive.adapters.buffer(tar)).inspect());
+    check("read.tar refuses malformed PAX size " + JSON.stringify(malformed[i]) +
+      " (no NaN bomb-bypass / walker desync)", code === "archive-tar/bad-pax-size");
+  }
+}
+
+async function testPaxValidSizeAccepted() {
+  // A well-formed PAX size override is honored (no over-rejection).
+  var tar = _paxTar("1", "x");
+  var entries = await b.archive.read.tar(b.archive.adapters.buffer(tar)).inspect();
+  check("read.tar accepts a valid PAX size override", entries.length >= 1);
+}
+
+// Build a tar whose first entry is a PAX extended header ('x') declaring a
+// LARGE body size, followed by a real file. The per-entry decompressed-bytes
+// cap previously only guarded regular entries (the check sat after the PAX
+// `continue`), so a PAX header body escaped it.
+function _largePaxBodyTar(bodyLen) {
+  var paxBody = Buffer.alloc(bodyLen, 0x41);            // content irrelevant — cap fires before parse
+  var paxHdr  = _header("PaxHeader/file.txt", paxBody.length, "x");
+  var fileHdr = _header("file.txt", 1, "0");
+  return Buffer.concat([
+    paxHdr, _pad512(paxBody),
+    fileHdr, _pad512(Buffer.from("x")),
+    Buffer.alloc(BLOCK * 2, 0),
+  ]);
+}
+
+async function testPaxBodyRespectsPerEntryCap() {
+  // A 4 KiB PAX header body under a 1 KiB per-entry cap must be refused — it
+  // previously bypassed maxEntryDecompressedBytes (which a regular 4 KiB entry
+  // would trip), forcing an over-cap string + record-Object materialization.
+  var tar = _largePaxBodyTar(4096);
+  var code = await _codeOf(b.archive.read.tar(b.archive.adapters.buffer(tar), {
+    bombPolicy: { maxEntryDecompressedBytes: 1024 },
+  }).inspect());
+  check("read.tar caps an oversized PAX header body (no per-entry-cap bypass)",
+    code === "archive-tar/entry-too-large");
+
+  // A small PAX body under the cap still parses (no over-rejection).
+  var okTar = _paxTar("1", "x");
+  var entries = await b.archive.read.tar(b.archive.adapters.buffer(okTar), {
+    bombPolicy: { maxEntryDecompressedBytes: 1024 },
+  }).inspect();
+  check("read.tar still accepts a small PAX body under the cap", entries.length >= 1);
+}
+
+async function run() {
+  await testRandomAccessReadIsCapped();
+  await testPaxMalformedSizeRefused();
+  await testPaxValidSizeAccepted();
+  await testPaxBodyRespectsPerEntryCap();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(function () { console.log("OK"); })
+       .catch(function (e) { console.error(e.stack || e); process.exit(1); });
+}

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

@@ -89,9 +89,54 @@ function testUnwrapExplicit() {
         asn1.readUnsignedInt(inner) === 7);
 }
 
+function testOidFirstSubidMultibyte() {
+  // OID 2.999 — first subidentifier = 40*2 + 999 = 1079, which is 0x88 0x37
+  // in base-128 (DER 06 02 88 37). A single-byte first-subid decoder reads
+  // it as "2.56.55"; a single-byte encoder truncates "2.999" to one octet
+  // and round-trips to "1.15".
+  var der = Buffer.from([0x06, 0x02, 0x88, 0x37]);
+  check("readOid: 2.999 (multi-byte first subidentifier) decodes correctly",
+        asn1.readOid(asn1.readNode(der)) === "2.999");
+  var enc = asn1.writeOid("2.999");
+  check("writeOid: 2.999 round-trips through readOid",
+        asn1.readOid(asn1.readNode(enc)) === "2.999");
+  check("writeOid: 2.999 emits the canonical 06 02 88 37",
+        Buffer.compare(enc, der) === 0);
+}
+
+function testOidNonMinimalRejected() {
+  // 06 04 2a 80 86 48 — the third subidentifier (840) carries a leading
+  // 0x80 continuation octet, which X.690 §8.19.2 forbids in DER. It would
+  // otherwise alias "1.2.840".
+  var der = Buffer.from([0x06, 0x04, 0x2a, 0x80, 0x86, 0x48]);
+  var threw = null;
+  try { asn1.readOid(asn1.readNode(der)); } catch (e) { threw = e; }
+  check("readOid: non-minimal (leading 0x80) subidentifier is refused",
+        threw && threw.code === "asn1/oid-non-minimal");
+}
+
+function testHighTagNumberNoOverflow() {
+  // 1f ff ff ff ff 7f 00 — high-tag-number form, five 7-bit octets =
+  // 0x7ffffffff = 34359738367. A `tag << 7` accumulator overflows 32-bit
+  // signed int and yields a negative/wrong tag; base-128 multiplication
+  // keeps it correct.
+  var node = asn1.readNode(Buffer.from([0x1f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00]));
+  check("readNode: high-tag-number does not overflow to a negative tag",
+        node.tag === 34359738367);
+  // A genuinely oversized tag (well past 2^53) must be refused, not wrap.
+  var huge = Buffer.from([0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00]);
+  var threw = null;
+  try { asn1.readNode(huge); } catch (e) { threw = e; }
+  check("readNode: tag past MAX_SAFE_INTEGER is refused",
+        threw && threw.code === "asn1/tag-too-large");
+}
+
 async function run() {
   testReadNodeShortFormLength();
   testReadOid();
+  testOidFirstSubidMultibyte();
+  testOidNonMinimalRejected();
+  testHighTagNumberNoOverflow();
   testReadSequence();
   testReadOctetString();
   testReadBitString();

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

@@ -40,6 +40,35 @@ function testReadsBufferAndString() {
   } finally { dir.cleanup(); }
 }
 
+function testWithStat() {
+  // #341: withStat returns the bound fd's fstat alongside the bytes, so the
+  // mode/owner describe the exact inode read (TOCTOU-free), not a re-stat.
+  var dir = _dir();
+  try {
+    var p = path.join(dir.path, "secret.bin");
+    var payload = Buffer.from("with-stat payload", "utf8");
+    fs.writeFileSync(p, payload, { mode: 0o600 });
+    var r = b.atomicFile.fdSafeReadSync(p, { withStat: true });
+    check("fdSafeReadSync withStat: returns { bytes, stat }",
+          r && Buffer.isBuffer(r.bytes) && r.bytes.equals(payload) && r.stat && typeof r.stat === "object");
+    check("fdSafeReadSync withStat: stat.size matches bytes", r.stat.size === payload.length);
+    check("fdSafeReadSync withStat: stat carries mode + ino",
+          typeof r.stat.mode === "number" && typeof r.stat.ino === "number");
+    // The mode is the bound fd's — on POSIX a 0o600 secret has no group/other
+    // bits. Windows doesn't enforce Unix permission bits, so gate the assertion.
+    if (process.platform !== "win32") {
+      check("fdSafeReadSync withStat: mode reflects 0o600 (no group/other)", (r.stat.mode & 0o077) === 0);
+    }
+    // withStat composes with encoding: bytes is the decoded string.
+    var rEnc = b.atomicFile.fdSafeReadSync(p, { withStat: true, encoding: "utf8" });
+    check("fdSafeReadSync withStat + encoding: bytes is a string",
+          rEnc.bytes === payload.toString("utf8") && rEnc.stat.size === payload.length);
+    // Without withStat, the bare value is still returned (back-compat).
+    var bare = b.atomicFile.fdSafeReadSync(p);
+    check("fdSafeReadSync: default still returns the bare Buffer", Buffer.isBuffer(bare));
+  } finally { dir.cleanup(); }
+}
+
 function testMaxBytesCap() {
   var dir = _dir();
   try {
@@ -134,6 +163,7 @@ function testRefuseSymlinkAndInodeHappyPath() {
 
 async function run() {
   testReadsBufferAndString();
+  testWithStat();
   testMaxBytesCap();
   testExpectedHash();
   testEnoent();

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

@@ -0,0 +1,79 @@
+"use strict";
+// b.atomicFile.openNoFollowSync — O_NOFOLLOW read-only open for streaming reads
+// that cannot buffer (static-serve range / SRI hashing, object-store download).
+// Opens a path read-only and refuses a symlink at the final component (ELOOP)
+// instead of following it — the streaming counterpart to fdSafeReadSync's
+// refuseSymlink. POSIX-only; on a platform without O_NOFOLLOW the flag is 0.
+
+var fs   = require("node:fs");
+var os   = require("node:os");
+var path = require("node:path");
+var helpers = require("../helpers");
+var b     = helpers.b;
+var check = helpers.check;
+
+function run() {
+  check("b.atomicFile.openNoFollowSync is a function",
+        typeof b.atomicFile.openNoFollowSync === "function");
+
+  var dir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-nofollow-"));
+  try {
+    var real = path.join(dir, "real.txt");
+    fs.writeFileSync(real, "payload-bytes");
+
+    // Regular file: opens, returns a numeric fd, reads the bytes, closes.
+    var fd = b.atomicFile.openNoFollowSync(real);
+    check("returns a numeric fd for a regular file", typeof fd === "number" && fd >= 0);
+    var buf = Buffer.alloc(64);
+    var n = fs.readSync(fd, buf, 0, buf.length, 0);
+    fs.closeSync(fd);
+    check("the fd reads the real file's bytes", buf.slice(0, n).toString("utf8") === "payload-bytes");
+
+    // Stream from the fd (the intended consumer shape).
+    var streamed = "";
+    // (synchronous read above already proves the fd; the stream shape is
+    // exercised by static-serve / object-store integration — here just assert
+    // the fd is consumable by createReadStream without double-open.)
+    var fd2 = b.atomicFile.openNoFollowSync(real);
+    var rs = fs.createReadStream(real, { fd: fd2 });
+    rs.on("data", function (c) { streamed += c.toString("utf8"); });
+    // Missing file → ENOENT (propagated raw).
+    var enoentCode = null;
+    try { b.atomicFile.openNoFollowSync(path.join(dir, "nope.txt")); }
+    catch (e) { enoentCode = e && e.code; }
+    check("missing file throws ENOENT", enoentCode === "ENOENT");
+
+    // Symlink at the final component → refused with ELOOP (POSIX). On a
+    // platform without O_NOFOLLOW (Windows) the flag is 0 and the open follows;
+    // symlink creation also often requires privilege there, so gate the assertion.
+    if (process.platform !== "win32") {
+      var linkPath = path.join(dir, "link.txt");
+      var symlinkMade = false;
+      try { fs.symlinkSync(real, linkPath); symlinkMade = true; } catch (_e) { /* no symlink priv */ }
+      if (symlinkMade) {
+        var loopCode = null;
+        try { b.atomicFile.openNoFollowSync(linkPath); }
+        catch (e) { loopCode = e && e.code; }
+        check("symlink final component is refused (ELOOP, not followed)", loopCode === "ELOOP");
+      }
+    }
+
+    return new Promise(function (resolve) {
+      rs.on("end", function () {
+        check("an fd from openNoFollowSync is consumable by createReadStream",
+              streamed === "payload-bytes");
+        resolve();
+      });
+    });
+  } finally {
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_e) { /* best-effort */ }
+  }
+}
+
+module.exports = { run: run };
+if (require.main === module) {
+  Promise.resolve(run()).then(
+    function () { console.log("OK — atomicFile.openNoFollowSync (" + helpers.getChecks() + " checks)"); process.exit(0); },
+    function (e) { console.error("FAIL: " + (e && e.message)); process.exit(1); }
+  );
+}