@blamejs/blamejs-shop 0.0.44

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

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * b.router.create({ tls0Rtt }) — RFC 8446 §8 / RFC 8470 anti-replay
+ * posture surface tests.
+ *
+ * Validates that:
+ *   - tls0Rtt defaults to "refuse"
+ *   - tls0Rtt accepts "refuse" / "replay-cache" only
+ *   - replay-cache fail-closes under pci-dss / fapi2 postures
+ *   - Early-Data: 1 inbound requests are gated per posture
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+function _mockReq(method, url, headers) {
+  return {
+    method:  method || "POST",
+    url:     url    || "/",
+    headers: headers || {},
+  };
+}
+
+function testCreateDefaultsToRefuse() {
+  var r = b.router.create();
+  check("router.create() defaults tls0Rtt to 'refuse'",
+        r.tls0RttPosture() === "refuse");
+}
+
+function testCreateRefusesUnknownPosture() {
+  var threw = null;
+  try { b.router.create({ tls0Rtt: "allow-everything" }); }
+  catch (e) { threw = e; }
+  check("router.create({ tls0Rtt: 'allow-everything' }) throws TypeError",
+        threw instanceof TypeError);
+}
+
+function testCreateAcceptsValidPostures() {
+  var refuse = b.router.create({ tls0Rtt: "refuse" });
+  var replay = b.router.create({ tls0Rtt: "replay-cache" });
+  check("router.create accepts 'refuse'", refuse.tls0RttPosture() === "refuse");
+  check("router.create accepts 'replay-cache'", replay.tls0RttPosture() === "replay-cache");
+}
+
+function testRefusePostureRejectsEarlyData() {
+  var r = b.router.create({ tls0Rtt: "refuse" });
+  var verdict = r._check0RttReplay(_mockReq("POST", "/api/charge",
+    { "early-data": "1" }));
+  check("refuse posture refuses Early-Data: 1 with 425",
+        verdict && verdict.status === 425 && verdict.reason === "early-data-refused");
+}
+
+function testRefusePostureAllowsNonEarlyData() {
+  var r = b.router.create({ tls0Rtt: "refuse" });
+  var verdict = r._check0RttReplay(_mockReq("POST", "/api/charge", {}));
+  check("refuse posture allows non-Early-Data request",
+        verdict === null);
+}
+
+function testReplayCacheAdmitsFirstRequest() {
+  var r = b.router.create({ tls0Rtt: "replay-cache" });
+  var verdict = r._check0RttReplay(_mockReq("POST", "/api/charge",
+    { "early-data": "1", host: "api.example.com",
+      authorization: "Bearer abc", date: "Fri, 01 Jan 2026 00:00:00 GMT" }));
+  check("replay-cache admits first Early-Data: 1 request",
+        verdict === null);
+}
+
+function testReplayCacheRefusesSecondIdentical() {
+  var r = b.router.create({ tls0Rtt: "replay-cache" });
+  var headers = { "early-data": "1", host: "api.example.com",
+                  authorization: "Bearer abc", date: "Fri, 01 Jan 2026 00:00:00 GMT" };
+  r._check0RttReplay(_mockReq("POST", "/api/charge", headers));
+  var second = r._check0RttReplay(_mockReq("POST", "/api/charge", headers));
+  check("replay-cache refuses identical-bytes replay with 425",
+        second && second.status === 425 && second.reason === "early-data-replay");
+}
+
+function testReplayCacheDistinguishesDifferentRequests() {
+  var r = b.router.create({ tls0Rtt: "replay-cache" });
+  r._check0RttReplay(_mockReq("POST", "/api/charge",
+    { "early-data": "1", "idempotency-key": "key-1" }));
+  var second = r._check0RttReplay(_mockReq("POST", "/api/charge",
+    { "early-data": "1", "idempotency-key": "key-2" }));
+  check("replay-cache admits different idempotency-keyed requests",
+        second === null);
+}
+
+function testReplayCacheFailClosesUnderPciDss() {
+  var compliance = b.compliance;
+  var prior = null;
+  try { prior = compliance.current ? compliance.current() : null; } catch (_e) {}
+  if (prior) {
+    // Posture is sticky once set; can't toggle in a test. Skip.
+    check("replay-cache fail-close under pci-dss (skipped: posture already set to '" +
+          prior + "')", true);
+    return;
+  }
+  try { compliance.set("pci-dss"); }
+  catch (e) {
+    check("replay-cache fail-close under pci-dss (skipped: " + e.message + ")", true);
+    return;
+  }
+  try {
+    var r = b.router.create({ tls0Rtt: "replay-cache" });
+    var posture = r._effective0RttPosture();
+    check("replay-cache → refuse under pci-dss posture",
+          posture === "refuse");
+  } finally {
+    try { if (typeof compliance.clear === "function") compliance.clear(); }
+    catch (_e) { /* clear best-effort */ }
+  }
+}
+
+async function run() {
+  testCreateDefaultsToRefuse();
+  testCreateRefusesUnknownPosture();
+  testCreateAcceptsValidPostures();
+  testRefusePostureRejectsEarlyData();
+  testRefusePostureAllowsNonEarlyData();
+  testReplayCacheAdmitsFirstRequest();
+  testReplayCacheRefusesSecondIdentical();
+  testReplayCacheDistinguishesDifferentRequests();
+  testReplayCacheFailClosesUnderPciDss();
+}
+
+module.exports = { run: run };

package/lib/vendor/blamejs/test/layer-0-primitives/safe-async-loops.test.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * b.safeAsync.repeating + b.safeAsync.flushLoop — bounded-cadence + flush
+ * loop primitives that replace ad-hoc setInterval / setTimeout chains.
+ */
+
+var helpers = require("../helpers");
+var b         = helpers.b;
+var check     = helpers.check;
+var waitUntil = helpers.waitUntil;
+
+function _sleep(ms) { return helpers.passiveObserve(ms, "safe-async-loops: real-time tick-window observation"); }
+
+async function run() {
+  // ---- Surface ----
+  check("safeAsync.repeating is fn",   typeof b.safeAsync.repeating === "function");
+  check("safeAsync.flushLoop is fn",   typeof b.safeAsync.flushLoop === "function");
+
+  // ---- repeating: fires periodically; stop() halts ----
+  var ticks = 0;
+  var loop = b.safeAsync.repeating(function () { ticks += 1; }, 25);
+  await waitUntil(function () { return ticks >= 2; }, {
+    timeoutMs: 5000,
+    label:     "safe-async-loops: repeating fired >= 2 ticks",
+  });
+  loop.stop();
+  var snap = ticks;
+  await _sleep(60);
+  check("repeating: tick count > 0",          ticks >= 2);
+  check("repeating: stop() halts ticks",      ticks === snap);
+
+  // ---- repeating: returns { stop } shape ----
+  var loop2 = b.safeAsync.repeating(function () {}, 60000);
+  check("repeating: returns object with stop",  typeof loop2.stop === "function");
+  loop2.stop();
+  loop2.stop();   // idempotent
+
+  // ---- repeating: async fn; rejection routed through onError ----
+  var caughtError = null;
+  var loop3 = b.safeAsync.repeating(
+    async function () { throw new Error("boom"); },
+    25,
+    { onError: function (e) { caughtError = e; } }
+  );
+  await _sleep(60);
+  loop3.stop();
+  check("repeating: async rejection caught by onError",
+        caughtError && caughtError.message === "boom");
+
+  // ---- repeating: sync throw → onError ----
+  var caughtSync = null;
+  var loop4 = b.safeAsync.repeating(
+    function () { throw new Error("sync-boom"); },
+    25,
+    { onError: function (e) { caughtSync = e; } }
+  );
+  await _sleep(60);
+  loop4.stop();
+  check("repeating: sync throw caught by onError",
+        caughtSync && caughtSync.message === "sync-boom");
+
+  // ---- repeating: rejection without onError → drop-silent (no crash) ----
+  var loopSilent = b.safeAsync.repeating(
+    async function () { throw new Error("silent"); },
+    25
+  );
+  await _sleep(60);
+  loopSilent.stop();
+  // No assertion — the goal is "process didn't crash from unhandled rejection."
+  check("repeating: drop-silent path survives reject",  true);
+
+  // ---- repeating: rejects bad args ----
+  function rejects(label, fn, codeRe) {
+    var threw = null;
+    try { fn(); } catch (e) { threw = e; }
+    check("repeating: rejects " + label,
+          threw && codeRe.test(threw.code || ""));
+  }
+  rejects("non-fn",            function () { b.safeAsync.repeating("nope", 100); }, /async\/bad-arg/);
+  rejects("bad ms (string)",   function () { b.safeAsync.repeating(function () {}, "100"); }, /async\/bad-arg/);
+  rejects("bad ms (NaN)",      function () { b.safeAsync.repeating(function () {}, NaN); }, /async\/bad-arg/);
+  rejects("bad ms (zero)",     function () { b.safeAsync.repeating(function () {}, 0); }, /async\/bad-arg/);
+  rejects("bad ms (negative)", function () { b.safeAsync.repeating(function () {}, -1); }, /async\/bad-arg/);
+
+  // ---- flushLoop: fires fn after intervalMs delay; reschedules after settle ----
+  var flushCount = 0;
+  var lp = b.safeAsync.flushLoop(async function () {
+    flushCount += 1;
+  }, 30);
+  await waitUntil(function () { return flushCount >= 2; }, {
+    timeoutMs: 5000,
+    label:     "flushLoop: invoked >= 2 times",
+  });
+  lp.stop();
+  var fSnap = flushCount;
+  await _sleep(60);
+  check("flushLoop: invoked multiple times",      flushCount >= 2);
+  check("flushLoop: stop() halts further runs",   flushCount === fSnap);
+
+  // ---- flushLoop: rejection routed through onError ----
+  var fErr = null;
+  var lp2 = b.safeAsync.flushLoop(
+    async function () { throw new Error("flush-fail"); },
+    25,
+    { onError: function (e) { fErr = e; } }
+  );
+  await _sleep(80);
+  lp2.stop();
+  check("flushLoop: rejection caught by onError",
+        fErr && fErr.message === "flush-fail");
+
+  // ---- flushLoop: drop-silent without onError ----
+  var lpSilent = b.safeAsync.flushLoop(
+    async function () { throw new Error("silent-flush"); }, 25
+  );
+  await _sleep(60);
+  lpSilent.stop();
+  check("flushLoop: drop-silent path survives reject",  true);
+
+  // ---- flushLoop: sync throw still reschedules ----
+  var syncThrows = 0;
+  var lpSync = b.safeAsync.flushLoop(
+    function () { syncThrows += 1; throw new Error("s"); },
+    25
+  );
+  await _sleep(200);
+  lpSync.stop();
+  check("flushLoop: sync throw reschedules",   syncThrows >= 2);
+
+  // ---- flushLoop: respects stop in mid-flight ----
+  var midFlight = 0;
+  var lp3;
+  lp3 = b.safeAsync.flushLoop(async function () {
+    midFlight += 1;
+    await _sleep(100);
+    if (midFlight === 1) lp3.stop();   // stop while in-flight
+  }, 25);
+  await _sleep(200);
+  var mfSnap = midFlight;
+  await _sleep(120);
+  check("flushLoop: stop during in-flight prevents reschedule",  midFlight === mfSnap);
+
+  // ---- flushLoop: rejects bad args ----
+  function rejectsF(label, fn, codeRe) {
+    var threw = null;
+    try { fn(); } catch (e) { threw = e; }
+    check("flushLoop: rejects " + label,
+          threw && codeRe.test(threw.code || ""));
+  }
+  rejectsF("non-fn",          function () { b.safeAsync.flushLoop("nope", 100); }, /async\/bad-arg/);
+  rejectsF("bad ms (NaN)",    function () { b.safeAsync.flushLoop(function () {}, NaN); }, /async\/bad-arg/);
+  rejectsF("bad ms (zero)",   function () { b.safeAsync.flushLoop(function () {}, 0); }, /async\/bad-arg/);
+  rejectsF("bad ms (string)", function () { b.safeAsync.flushLoop(function () {}, "x"); }, /async\/bad-arg/);
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("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/safe-async-parallel.test.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * b.safeAsync.parallel — bounded-concurrency mapAsync with continuous
+ * worker queue (no Promise.all-batched chunks). Exercises ordering,
+ * concurrency cap, error propagation, abort signal, config-time
+ * validation.
+ */
+
+var helpers = require("../helpers");
+var b     = helpers.b;
+var check = helpers.check;
+
+function _sleep(ms) { return helpers.passiveObserve(ms, "safe-async-parallel: simulated task duration"); }
+
+async function run() {
+  // ---- Surface ----
+  check("safeAsync.parallel is fn", typeof b.safeAsync.parallel === "function");
+
+  // ---- Empty input → empty results ----
+  var empty = await b.safeAsync.parallel([], async function (x) { return x; });
+  check("parallel: empty input → []", Array.isArray(empty) && empty.length === 0);
+
+  // ---- Results in input order, not completion order ----
+  var input = [1, 2, 3, 4, 5];
+  var doubled = await b.safeAsync.parallel(input, async function (n, i) {
+    // Stagger settlement so completion order != input order.
+    await _sleep((input.length - i) * 10);
+    return n * 2;
+  }, { concurrency: 3 });
+  check("parallel: results in input order",
+        doubled.length === 5 && doubled.join(",") === "2,4,6,8,10");
+
+  // ---- fn receives (item, index) ----
+  var seenIdx = [];
+  await b.safeAsync.parallel(["a", "b", "c"], async function (item, idx) {
+    seenIdx.push(idx);
+    return item;
+  }, { concurrency: 1 });
+  check("parallel: fn receives index", seenIdx.join(",") === "0,1,2");
+
+  // ---- Concurrency cap respected (continuous-queue, not batched) ----
+  var inFlight = 0;
+  var maxInFlight = 0;
+  var n = 20;
+  var items = [];
+  for (var i = 0; i < n; i++) items.push(i);
+
+  await b.safeAsync.parallel(items, async function (idx) {
+    inFlight += 1;
+    if (inFlight > maxInFlight) maxInFlight = inFlight;
+    // Variable durations — short items must NOT wait for long items
+    // in the same chunk (continuous queue would let workers grab the
+    // next index immediately).
+    await _sleep(idx % 4 === 0 ? 40 : 5);
+    inFlight -= 1;
+    return idx;
+  }, { concurrency: 4 });
+  check("parallel: concurrency cap honored (max in-flight ≤ 4)", maxInFlight <= 4);
+  check("parallel: concurrency cap reached",                     maxInFlight === 4);
+
+  // ---- Continuous worker queue (no batched chunks) ----
+  // If parallel batched chunks-of-N, the slow item in one chunk would
+  // block the rest of the pool. Track "did any new task start while a
+  // long task was still in-flight from an earlier index?"
+  var startTimes = [];
+  var longRunningStill = false;
+  var workItems = [0, 1, 2, 3, 4, 5];   // 6 items, concurrency 2
+  await b.safeAsync.parallel(workItems, async function (i) {
+    startTimes[i] = Date.now();
+    // Item 0 is the long-pole. Items 1..5 are short — under continuous
+    // queue semantics, they should all complete before item 0 finishes.
+    if (i === 0) {
+      await _sleep(150);
+      // By now, the rest should have started.
+      for (var k = 1; k < workItems.length; k++) {
+        if (startTimes[k] && startTimes[k] - startTimes[0] < 150) {
+          longRunningStill = true;
+        }
+      }
+      return i;
+    }
+    await _sleep(5);
+    return i;
+  }, { concurrency: 2 });
+  check("parallel: continuous queue (short items don't wait for long-pole)",
+        longRunningStill);
+
+  // ---- First rejection propagates; results not partial ----
+  var threwErr = null;
+  try {
+    await b.safeAsync.parallel([1, 2, 3], async function (n) {
+      if (n === 2) throw new Error("boom-" + n);
+      return n;
+    }, { concurrency: 2 });
+  } catch (e) { threwErr = e; }
+  check("parallel: first rejection propagates",
+        threwErr && /boom-2/.test(threwErr.message));
+
+  // ---- Sync throw inside fn → rejection ----
+  var syncErr = null;
+  try {
+    await b.safeAsync.parallel([1], function () { throw new Error("sync"); });
+  } catch (e) { syncErr = e; }
+  check("parallel: sync throw routed through rejection",
+        syncErr && /sync/.test(syncErr.message));
+
+  // ---- AbortSignal cancels further dispatch ----
+  var controller = new AbortController();
+  var seen = 0;
+  var abortErr = null;
+  var pAbort = b.safeAsync.parallel(items, async function (idx) {
+    seen += 1;
+    if (seen === 3) controller.abort();
+    await _sleep(20);
+    return idx;
+  }, { concurrency: 2, signal: controller.signal }).catch(function (e) {
+    abortErr = e;
+  });
+  await pAbort;
+  check("parallel: aborted run rejects with async/aborted",
+        abortErr && abortErr.code === "async/aborted");
+  check("parallel: aborted run does NOT dispatch all items", seen < items.length);
+
+  // ---- Pre-aborted signal rejects immediately ----
+  var preAbortErr = null;
+  var c2 = new AbortController();
+  c2.abort();
+  try {
+    await b.safeAsync.parallel([1, 2, 3], async function (n) { return n; },
+                                { signal: c2.signal });
+  } catch (e) { preAbortErr = e; }
+  check("parallel: pre-aborted signal short-circuits",
+        preAbortErr && preAbortErr.code === "async/aborted");
+
+  // ---- Config-time validation (throws synchronously, not as rejection) ----
+  function rejects(label, fn, codeRe) {
+    var threw = null;
+    try { fn(); } catch (e) { threw = e; }
+    check("parallel: rejects " + label,
+          threw && codeRe.test(threw.code || ""));
+  }
+  rejects("non-array items",   function () { b.safeAsync.parallel("nope", function () {}); }, /async\/bad-arg/);
+  rejects("non-fn",            function () { b.safeAsync.parallel([1], "nope"); },             /async\/bad-arg/);
+  rejects("concurrency 0",     function () { b.safeAsync.parallel([1], function () {}, { concurrency: 0 }); }, /async\/bad-arg/);
+  rejects("concurrency 257",   function () { b.safeAsync.parallel([1], function () {}, { concurrency: 257 }); }, /async\/bad-arg/);
+  rejects("concurrency NaN",   function () { b.safeAsync.parallel([1], function () {}, { concurrency: NaN }); }, /async\/bad-arg/);
+  rejects("concurrency float", function () { b.safeAsync.parallel([1], function () {}, { concurrency: 2.5 }); }, /async\/bad-arg/);
+
+  // ---- Default concurrency = 8 (no opts) ----
+  var defaultMax = 0;
+  var defaultIn = 0;
+  var manyItems = [];
+  for (var j = 0; j < 32; j++) manyItems.push(j);
+  await b.safeAsync.parallel(manyItems, async function () {
+    defaultIn += 1;
+    if (defaultIn > defaultMax) defaultMax = defaultIn;
+    await _sleep(5);
+    defaultIn -= 1;
+  });
+  check("parallel: default concurrency is 8", defaultMax === 8);
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("OK — " + helpers.getChecks() + " checks passed"); },
+    function (e) { console.error("FAIL:", e && e.stack || e); process.exit(1); }
+  );
+}