@blamejs/blamejs-shop 0.0.44

package/lib/vendor/blamejs/test/layer-0-primitives/queue-flow-repeat.test.js

@@ -0,0 +1,322 @@
+"use strict";
+/**
+ * v0.4.21 queue — repeat-in-queue (cron) + parent-child Flows.
+ *
+ * Run standalone: `node test/layer-0-primitives/queue-flow-repeat.test.js`
+ * Or via smoke:   `node test/smoke.js`
+ */
+
+var helpers = require("../helpers");
+var b              = helpers.b;
+var fs             = helpers.fs;
+var os             = helpers.os;
+var path           = helpers.path;
+var check          = helpers.check;
+var setupTestDb    = helpers.setupTestDb;
+var teardownTestDb = helpers.teardownTestDb;
+
+function _tmp() { return fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-q-flow-")); }
+
+
+// ---- Repeat-in-queue ----
+
+async function testRepeatCronReEnqueuesAfterComplete() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    b.queue.init({ backends: { primary: { protocol: "local" } } });
+
+    // "* * * * *" → every minute; first re-enqueue lands roughly 1 minute
+    // out from now. We don't wait for it to fire — we just confirm a NEW
+    // pending row was inserted with availableAt > now.
+    var enq = await b.queue.enqueue("cron-q", { tag: "loop" },
+      { repeat: { cron: "* * * * *" } });
+
+    var seen = 0;
+    var consumer = b.queue.consume("cron-q",
+      async function (job) {
+        seen++;
+        // Confirm the leased row carries the cron metadata so a handler
+        // could inspect it (e.g. to decide whether to do extra work).
+        check("repeat: leased job carries repeatCron",  job.repeatCron === "* * * * *");
+      },
+      { concurrency: 1, pollIntervalMs: 25, fastPollMs: 5 });
+    await helpers.waitUntil(function () { return seen >= 1; }, {
+      timeoutMs: 3000, label: "queue cron-repeat: consumer saw the job",
+    });
+
+    // After complete, a second pending row should exist for the next minute.
+    // The cron rounds UP to the next whole-minute boundary, so availableAt
+    // lands on a :00 second boundary in the future relative to when
+    // complete() ran. enqueue() honours opts.availableAt directly, so the
+    // boundary survives the round-trip without drift.
+    var pending = await b.db.from("_blamejs_jobs")
+      .where({ queueName: "cron-q", status: "pending" }).all();
+    check("repeat: a follow-up pending row was scheduled",  pending.length === 1);
+    var availableAt = Number(pending[0].availableAt);
+    check("repeat: next availableAt is on a minute boundary",
+          availableAt % 60000 === 0);
+    check("repeat: follow-up carries the same cron",
+          pending[0].repeatCron === "* * * * *");
+
+    consumer.cancel();
+    void enq;
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testRepeatStopsOnFinalFailure() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    b.queue.init({ backends: { primary: { protocol: "local" } } });
+
+    await b.queue.enqueue("cron-fail", { tag: "broken" },
+      { repeat: { cron: "* * * * *" }, maxAttempts: 1 });
+
+    var attempts = 0;
+    var consumer = b.queue.consume("cron-fail",
+      async function () { attempts++; throw new Error("always fails"); },
+      { concurrency: 1, pollIntervalMs: 25, fastPollMs: 5 });
+    await helpers.waitUntil(function () { return attempts >= 1; }, {
+      timeoutMs: 3000, label: "queue cron-fail: consumer attempted the job once",
+    });
+    // Give the failure path a tick to record before cancelling.
+    await helpers.passiveObserve(100, "queue cron-fail: failure path records before consumer cancel");
+    consumer.cancel();
+
+    var pending = await b.db.from("_blamejs_jobs")
+      .where({ queueName: "cron-fail", status: "pending" }).all();
+    check("repeat: no follow-up scheduled after final failure",
+          pending.length === 0);
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+// ---- Flows ----
+
+async function testFlowSurface() {
+  check("b.queue.enqueueFlow is a function",  typeof b.queue.enqueueFlow === "function");
+}
+
+async function testFlowLinearChain() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    b.queue.init({ backends: { primary: { protocol: "local" } } });
+
+    var ord = [];
+    var consumer = b.queue.consume("flow-q",
+      async function (job) { ord.push(job.payload.tag); },
+      { concurrency: 4, pollIntervalMs: 25, fastPollMs: 5 });
+
+    var flow = await b.queue.enqueueFlow({
+      queueName: "flow-q",
+      children: [
+        { name: "fetch",     payload: { tag: "fetch"     } },
+        { name: "transform", payload: { tag: "transform" }, dependsOn: ["fetch"] },
+        { name: "publish",   payload: { tag: "publish"   }, dependsOn: ["transform"] },
+      ],
+    });
+    check("flow: returns flowId",            typeof flow.flowId === "string" && flow.flowId.indexOf("flow-") === 0);
+    check("flow: returns 3 child jobIds",     flow.jobs.length === 3);
+
+    await helpers.waitUntil(function () { return ord.length === 3; }, {
+      timeoutMs: 5000, label: "queue flow: 3 jobs processed",
+    });
+    consumer.cancel();
+
+    check("flow: chain order fetch → transform → publish",
+          ord[0] === "fetch" && ord[1] === "transform" && ord[2] === "publish");
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testFlowDiamondWaitsForAllDeps() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    b.queue.init({ backends: { primary: { protocol: "local" } } });
+
+    // Diamond: root → [a, b] → end. End must NOT run until both a and b finish.
+    var ord = [];
+    var consumer = b.queue.consume("diamond-q",
+      async function (job) {
+        ord.push(job.payload.tag);
+        // Slow down 'a' so 'b' would otherwise finish first.
+        if (job.payload.tag === "a") {
+          await helpers.passiveObserve(80, "queue diamond: slow 'a' so 'b' would otherwise finish first");
+        }
+      },
+      { concurrency: 4, pollIntervalMs: 25, fastPollMs: 5 });
+
+    await b.queue.enqueueFlow({
+      queueName: "diamond-q",
+      children: [
+        { name: "root", payload: { tag: "root" } },
+        { name: "a",    payload: { tag: "a"    }, dependsOn: ["root"] },
+        { name: "b",    payload: { tag: "b"    }, dependsOn: ["root"] },
+        { name: "end",  payload: { tag: "end"  }, dependsOn: ["a", "b"] },
+      ],
+    });
+    await helpers.waitUntil(function () { return ord.length === 4; }, {
+      timeoutMs: 5000, label: "queue diamond: 4 jobs processed",
+    });
+    consumer.cancel();
+
+    var endIdx = ord.indexOf("end");
+    var aIdx   = ord.indexOf("a");
+    var bIdx   = ord.indexOf("b");
+    check("flow: end ran after both a + b",  endIdx > aIdx && endIdx > bIdx);
+    check("flow: root ran first",            ord[0] === "root");
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testFlowCycleDetection() {
+  // No DB needed — cycle detection runs at registration before insert.
+  // But the queue dispatcher requires init; we're inside a setupTestDb caller
+  // for safety.
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    b.queue.init({ backends: { primary: { protocol: "local" } } });
+    var threw = null;
+    try {
+      await b.queue.enqueueFlow({
+        queueName: "cycle-q",
+        children: [
+          { name: "a", payload: {}, dependsOn: ["b"] },
+          { name: "b", payload: {}, dependsOn: ["c"] },
+          { name: "c", payload: {}, dependsOn: ["a"] },
+        ],
+      });
+    } catch (e) { threw = e; }
+    check("flow: cycle detected at enqueue",
+          threw && /flow cycle detected/i.test(threw.message));
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testFlowUnknownDepRejected() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    b.queue.init({ backends: { primary: { protocol: "local" } } });
+    var threw = null;
+    try {
+      await b.queue.enqueueFlow({
+        queueName: "unknown-dep-q",
+        children: [{ name: "a", payload: {}, dependsOn: ["does-not-exist"] }],
+      });
+    } catch (e) { threw = e; }
+    check("flow: unknown dep rejected",
+          threw && /unknown name 'does-not-exist'/i.test(threw.message));
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testFlowValidation() {
+  var threw = false;
+  try { await b.queue.enqueueFlow(); } catch (_e) { threw = true; }
+  check("flow: rejects missing opts",  threw);
+
+  threw = false;
+  try { await b.queue.enqueueFlow({ queueName: "x" }); } catch (_e) { threw = true; }
+  check("flow: rejects missing children",  threw);
+
+  threw = false;
+  try {
+    await b.queue.enqueueFlow({
+      queueName: "x",
+      children: [{ name: "a" }, { name: "a" }],
+    });
+  } catch (_e) { threw = true; }
+  check("flow: rejects duplicate child name",  threw);
+}
+
+// Round-trip preservation regression gate — enqueue({availableAt: T})
+// stores T in the row; future-self reads back exactly T. Catches the
+// v0.6.21 bug shape ("primitive computes precise value, silently re-
+// derives a less precise version on the way to storage") for any
+// caller that wires availableAt directly.
+async function testEnqueueRoundTripsAvailableAt() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    b.queue.init({ backends: { primary: { protocol: "local" } } });
+    // Three precise targets — sub-second, exact second, far future
+    var targets = [
+      Date.now() + 12345,           // ms-precision in the future
+      Date.now() + 60000,           // exactly one minute out
+      1888000000999,                // arbitrary future (ms precision)
+    ];
+    for (var i = 0; i < targets.length; i++) {
+      var T = targets[i];
+      await b.queue.enqueue("rt-q", { i: i }, { availableAt: T });
+      var rows = await b.db.from("_blamejs_jobs")
+        .where({ queueName: "rt-q", status: "pending" }).all();
+      var row = rows.find(function (r) {
+        // Compare the exact ms — round-trip preservation is what we test.
+        return Number(r.availableAt) === T;
+      });
+      check("enqueue round-trips availableAt=" + T + " exactly", !!row);
+    }
+    // delaySeconds-only path still works (no availableAt provided)
+    var beforeMs = Date.now();
+    await b.queue.enqueue("rt-q", { tag: "rel" }, { delaySeconds: 5 });
+    var relRows = await b.db.from("_blamejs_jobs")
+      .where({ queueName: "rt-q", status: "pending" }).all();
+    var relRow = relRows.find(function (r) {
+      var aa = Number(r.availableAt);
+      return aa >= beforeMs + 5000 && aa <= beforeMs + 5000 + 100;
+    });
+    check("enqueue with delaySeconds only computes nowMs+5000ms", !!relRow);
+    // Both opts present — availableAt wins, delaySeconds is ignored
+    var explicitT = Date.now() + 30000;
+    await b.queue.enqueue("rt-q", { tag: "both" }, {
+      availableAt:  explicitT,
+      delaySeconds: 999,    // would be 999s if it won — but it shouldn't
+    });
+    var bothRows = await b.db.from("_blamejs_jobs")
+      .where({ queueName: "rt-q", status: "pending" }).all();
+    var bothRow = bothRows.find(function (r) { return Number(r.availableAt) === explicitT; });
+    check("enqueue with both opts: availableAt wins, delaySeconds ignored", !!bothRow);
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function run() {
+  await testFlowSurface();
+  await testRepeatCronReEnqueuesAfterComplete();
+  await testRepeatStopsOnFinalFailure();
+  await testEnqueueRoundTripsAvailableAt();
+  await testFlowLinearChain();
+  await testFlowDiamondWaitsForAllDeps();
+  await testFlowCycleDetection();
+  await testFlowUnknownDepRejected();
+  await testFlowValidation();
+}
+
+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/queue-priority-rate-progress.test.js

@@ -0,0 +1,266 @@
+"use strict";
+/**
+ * v0.4.20 queue + jobs — priority on enqueue, consume rate-limit,
+ * handler ctx.progress(0..100).
+ *
+ * Run standalone: `node test/layer-0-primitives/queue-priority-rate-progress.test.js`
+ * Or via smoke:   `node test/smoke.js`
+ */
+
+var helpers = require("../helpers");
+var b              = helpers.b;
+var fs             = helpers.fs;
+var os             = helpers.os;
+var path           = helpers.path;
+var check          = helpers.check;
+var setupTestDb    = helpers.setupTestDb;
+var teardownTestDb = helpers.teardownTestDb;
+
+function _tmp() { return fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-q-prio-")); }
+
+function _waitFor(predicate, timeoutMs) {
+  return helpers.waitUntil(predicate, {
+    timeoutMs: timeoutMs || 3000,
+    label: "queue-priority _waitFor",
+  });
+}
+
+async function testEnqueuePriorityHeadOfQueue() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    b.queue.init({ backends: { primary: { protocol: "local" } } });
+    // Three jobs: low (priority 0), high (priority 10), mid (priority 5)
+    // — enqueue in low/high/mid order, expect lease order high/mid/low.
+    await b.queue.enqueue("prio-q", { id: "low" });
+    await b.queue.enqueue("prio-q", { id: "high" }, { priority: 10 });
+    await b.queue.enqueue("prio-q", { id: "mid"  }, { priority: 5 });
+
+    var seen = [];
+    var consumer = b.queue.consume("prio-q",
+      async function (job) { seen.push(job.payload.id); },
+      { concurrency: 1, pollIntervalMs: 25, fastPollMs: 5 });
+    await _waitFor(function () { return seen.length >= 3; }, 5000);
+    consumer.cancel();
+    check("priority: high lease first",  seen[0] === "high");
+    check("priority: mid lease second",  seen[1] === "mid");
+    check("priority: low lease last",    seen[2] === "low");
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testEnqueueDefaultPriorityZero() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    b.queue.init({ backends: { primary: { protocol: "local" } } });
+    await b.queue.enqueue("zero-prio", { id: "a" });
+    await b.queue.enqueue("zero-prio", { id: "b" });
+    var seen = [];
+    var consumer = b.queue.consume("zero-prio",
+      async function (job) { seen.push(job.payload.id); },
+      { concurrency: 1, pollIntervalMs: 25, fastPollMs: 5 });
+    await _waitFor(function () { return seen.length >= 2; }, 3000);
+    consumer.cancel();
+    check("priority: equal priorities preserve insertion order",
+          seen[0] === "a" && seen[1] === "b");
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testRateLimitCapsThroughput() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    b.queue.init({ backends: { primary: { protocol: "local" } } });
+    // 6 jobs queued; rate cap at 3 per second; with the consumer running
+    // ~1 second total we should observe AT MOST max + slack handlers.
+    for (var i = 0; i < 6; i++) await b.queue.enqueue("rl-q", { i: i });
+
+    var startedAt = Date.now();
+    var doneTimestamps = [];
+    var consumer = b.queue.consume("rl-q",
+      async function () { doneTimestamps.push(Date.now() - startedAt); },
+      { concurrency: 6, rateLimit: { max: 3, perSeconds: 1 },
+        pollIntervalMs: 25, fastPollMs: 5 });
+    // Wait long enough to drain — at 3/sec we expect ~2 seconds for 6 jobs.
+    await _waitFor(function () { return doneTimestamps.length >= 6; }, 6000);
+    consumer.cancel();
+
+    // First 3 land roughly inside the first window; jobs 4..6 wait for
+    // the next window. Assert jobs[3..5] all start at >= 1000ms.
+    var firstThree = doneTimestamps.slice(0, 3);
+    var lastThree  = doneTimestamps.slice(3, 6);
+    check("rateLimit: first 3 within first window",
+          firstThree.every(function (t) { return t < 1500; }));
+    check("rateLimit: jobs 4-6 deferred to next window",
+          lastThree.every(function (t) { return t >= 900; }));
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testRateLimitValidation() {
+  var threw = false;
+  try {
+    b.queue.consume("any", function () {}, { rateLimit: { max: 5 } });   // missing perSeconds
+  } catch (_e) { threw = true; }
+  check("rateLimit: rejects missing perSeconds",  threw);
+
+  threw = false;
+  try {
+    b.queue.consume("any", function () {}, { rateLimit: { max: "5", perSeconds: 1 } });
+  } catch (_e) { threw = true; }
+  check("rateLimit: rejects non-numeric max",     threw);
+
+  function rejects(label, opts) {
+    var t = false;
+    try { b.queue.consume("any", function () {}, { rateLimit: opts }); }
+    catch (_e) { t = true; }
+    check("rateLimit: " + label,  t);
+  }
+  rejects("rejects negative max",        { max: -1, perSeconds: 1 });
+  rejects("rejects zero max",            { max: 0, perSeconds: 1 });
+  rejects("rejects fractional max",      { max: 1.5, perSeconds: 1 });
+  rejects("rejects NaN max",             { max: NaN, perSeconds: 1 });
+  rejects("rejects Infinity max",        { max: Infinity, perSeconds: 1 });
+  rejects("rejects negative perSeconds", { max: 5, perSeconds: -1 });
+  rejects("rejects zero perSeconds",     { max: 5, perSeconds: 0 });
+  rejects("rejects NaN perSeconds",      { max: 5, perSeconds: NaN });
+  rejects("rejects Infinity perSeconds", { max: 5, perSeconds: Infinity });
+}
+
+async function testProgressEmitsAuditAndObservability() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    b.queue.init({ backends: { primary: { protocol: "local" } } });
+    await b.queue.enqueue("prog-q", { id: "p1" });
+
+    var capturedObs = [];
+    var origObsEvent = b.observability.event;
+    b.observability.event = function (n, v, l) {
+      if (n === "queue.progress") capturedObs.push({ v: v, l: l });
+      return origObsEvent.apply(b.observability, arguments);
+    };
+
+    var done = false;
+    var consumer = b.queue.consume("prog-q",
+      async function (_job, ctx) {
+        ctx.progress(0);
+        ctx.progress(50);
+        ctx.progress(100);
+        done = true;
+      },
+      { concurrency: 1, pollIntervalMs: 25, fastPollMs: 5 });
+    await _waitFor(function () { return done; }, 3000);
+    consumer.cancel();
+
+    b.observability.event = origObsEvent;
+
+    // 0 and 100 are markers (always emit). 50 may or may not pass the
+    // throttle depending on timing — it's allowed but not required.
+    var values = capturedObs.map(function (e) { return e.v; }).sort(function (a, b) { return a - b; });
+    check("progress: emits 0 marker", values.indexOf(0) !== -1);
+    check("progress: emits 100 marker", values.indexOf(100) !== -1);
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testProgressThrottlesChattyHandler() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    b.queue.init({ backends: { primary: { protocol: "local" } } });
+    await b.queue.enqueue("chatty-q", { id: "c1" });
+
+    var capturedObs = [];
+    var origObsEvent = b.observability.event;
+    b.observability.event = function (n, v) {
+      if (n === "queue.progress") capturedObs.push(v);
+      return origObsEvent.apply(b.observability, arguments);
+    };
+
+    var done = false;
+    var consumer = b.queue.consume("chatty-q",
+      async function (_job, ctx) {
+        // Spam a hundred non-marker progress reports synchronously.
+        // Throttle (PROGRESS_MIN_INTERVAL_MS = 250 in queue.js) means
+        // most should be suppressed.
+        for (var i = 1; i < 100; i++) ctx.progress(i);
+        ctx.progress(100);
+        done = true;
+      },
+      { concurrency: 1, pollIntervalMs: 25, fastPollMs: 5 });
+    await _waitFor(function () { return done; }, 3000);
+    consumer.cancel();
+
+    b.observability.event = origObsEvent;
+
+    // Synchronous burst: throttle window means most non-marker calls
+    // silently drop. Worst case we see 0 (start), maybe one mid value,
+    // and 100 (end). Definitely not 100 distinct events.
+    check("progress: synchronous burst is throttled",  capturedObs.length < 10);
+    check("progress: 100 marker still landed",          capturedObs.indexOf(100) !== -1);
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testProgressBadInputIgnored() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    b.queue.init({ backends: { primary: { protocol: "local" } } });
+    await b.queue.enqueue("bad-prog-q", { id: "x" });
+
+    var threw = null;
+    var done = false;
+    var consumer = b.queue.consume("bad-prog-q",
+      async function (_job, ctx) {
+        // None of these should throw.
+        try {
+          ctx.progress("nope");
+          ctx.progress(NaN);
+          ctx.progress(undefined);
+          ctx.progress(150);   // clamps to 100; allowed but not asserted
+          ctx.progress(-1);    // clamps to 0
+        } catch (e) { threw = e; }
+        done = true;
+      },
+      { concurrency: 1, pollIntervalMs: 25, fastPollMs: 5 });
+    await _waitFor(function () { return done; }, 3000);
+    consumer.cancel();
+    check("progress: bad input doesn't throw",  threw === null);
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function run() {
+  await testEnqueuePriorityHeadOfQueue();
+  await testEnqueueDefaultPriorityZero();
+  await testRateLimitCapsThroughput();
+  await testRateLimitValidation();
+  await testProgressEmitsAuditAndObservability();
+  await testProgressThrottlesChattyHandler();
+  await testProgressBadInputIgnored();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("OK — " + helpers.getChecks() + " checks passed"); },
+    function (e) { console.error("FAIL:", e.message); process.exit(1); }
+  );
+}