@blamejs/blamejs-shop 0.0.44

package/lib/vendor/blamejs/test/layer-0-primitives/app-shutdown.test.js

@@ -0,0 +1,311 @@
+"use strict";
+/**
+ * app-shutdown — graceful-shutdown orchestrator.
+ *
+ * Run standalone: `node test/layer-0-primitives/app-shutdown.test.js`
+ * Or via smoke:   `node test/smoke.js`
+ */
+
+var helpers = require("../helpers");
+var b         = helpers.b;
+var check     = helpers.check;
+var _bodyRes  = helpers._bodyRes;
+var _mockReq  = helpers._mockReq;
+
+function testAppShutdownSurface() {
+  check("b.appShutdown namespace present",     typeof b.appShutdown === "object");
+  check("b.appShutdown.create is a function",  typeof b.appShutdown.create === "function");
+  check("b.appShutdown.standardPhases is fn",  typeof b.appShutdown.standardPhases === "function");
+  check("AppShutdownError is a class",         typeof b.appShutdown.AppShutdownError === "function");
+  check("DEFAULT_GRACE_MS exposed",            typeof b.appShutdown.DEFAULT_GRACE_MS === "number");
+}
+
+async function testAppShutdownEmpty() {
+  var o = b.appShutdown.create({ phases: [] });
+  var r = await o.shutdown();
+  check("empty: ok=true",                       r.ok === true);
+  check("empty: no phases",                     r.phases.length === 0);
+  check("empty: draining=true after",           r.draining === true);
+  check("empty: idempotent — same Promise",     (await o.shutdown()).totalMs >= 0);
+  o._resetForTest();
+}
+
+async function testAppShutdownPhasesRunInOrder() {
+  var order = [];
+  var o = b.appShutdown.create({
+    phases: [
+      { name: "first",  run: function () { order.push("first"); } },
+      { name: "second", run: async function () { await Promise.resolve(); order.push("second"); } },
+      { name: "third",  run: function () { order.push("third"); } },
+    ],
+  });
+  var r = await o.shutdown();
+  check("phases: ran in array order",           order.join(",") === "first,second,third");
+  check("phases: 3 results",                    r.phases.length === 3);
+  check("phases: all ok",                       r.phases.every(function (p) { return p.ok; }));
+  check("phases: each has ms",                  r.phases.every(function (p) { return typeof p.ms === "number"; }));
+  o._resetForTest();
+}
+
+async function testAppShutdownPhaseFailureContinues() {
+  var ran = [];
+  var o = b.appShutdown.create({
+    phases: [
+      { name: "first",  run: function () { ran.push("first"); throw new Error("boom"); } },
+      { name: "second", run: function () { ran.push("second"); } },
+      { name: "third",  run: function () { ran.push("third"); } },
+    ],
+  });
+  var r = await o.shutdown();
+  check("phase failure: subsequent phases still ran",  ran.length === 3);
+  check("phase failure: first marked ok=false",        r.phases[0].ok === false);
+  check("phase failure: error message captured",       r.phases[0].error.indexOf("boom") !== -1);
+  check("phase failure: aggregate ok=false",           r.ok === false);
+  check("phase failure: later phases ok=true",         r.phases[1].ok && r.phases[2].ok);
+  o._resetForTest();
+}
+
+async function testAppShutdownPhaseTimeout() {
+  var o = b.appShutdown.create({
+    graceMs: 200,
+    phases: [
+      { name: "fast",  run: function () { return Promise.resolve(); } },
+      { name: "slow",  run: function () { return new Promise(function () {}); }, timeoutMs: 50 },
+    ],
+  });
+  var t0 = Date.now();
+  var r = await o.shutdown();
+  var elapsed = Date.now() - t0;
+  check("timeout: completed under graceMs",     elapsed < 500);
+  check("timeout: slow phase marked ok=false",  r.phases[1].ok === false);
+  check("timeout: error mentions timeout",      /time(d out|out)/i.test(r.phases[1].error));
+  check("timeout: fast phase still ok",         r.phases[0].ok === true);
+  o._resetForTest();
+}
+
+async function testAppShutdownIdempotent() {
+  var calls = 0;
+  var o = b.appShutdown.create({
+    phases: [{ name: "single", run: function () { calls++; } }],
+  });
+  var p1 = o.shutdown();
+  var p2 = o.shutdown();
+  check("idempotent: same Promise returned",   p1 === p2);
+  await p1;
+  await o.shutdown();   // third call after resolution
+  check("idempotent: phase only ran once",     calls === 1);
+  o._resetForTest();
+}
+
+async function testAppShutdownDrainingFlag() {
+  var o = b.appShutdown.create({
+    phases: [{ name: "x", run: function () {
+      return helpers.passiveObserve(30, "shutdown: phase x slow-work simulator");
+    } }],
+  });
+  check("draining: false before shutdown",      o.draining() === false);
+  var p = o.shutdown();
+  check("draining: true immediately after shutdown() called", o.draining() === true);
+  await p;
+  check("draining: stays true after complete",  o.draining() === true);
+  o._resetForTest();
+}
+
+async function testAppShutdownMiddleware503DuringDrain() {
+  var o = b.appShutdown.create({
+    phases: [{ name: "x", run: function () {
+      return helpers.passiveObserve(100, "shutdown: phase x slow-work for 503 window");
+    } }],
+  });
+  var mw = o.middleware();
+  var req1 = _mockReq();
+  var res1 = _bodyRes();
+  var passed = false;
+  // res1.end emits "finish" synchronously inside next(); register a
+  // listener BEFORE invoking the middleware so the wait below resolves.
+  var firstFinishP = new Promise(function (r) { res1.on("finish", r); });
+  mw(req1, res1, function () { passed = true; res1.writeHead(200); res1.end(); });
+  await firstFinishP;
+  check("middleware: pre-drain pass-through",   passed === true);
+
+  var sp = o.shutdown();
+  var req2 = _mockReq();
+  var res2 = _bodyRes();
+  var nextCalled = false;
+  mw(req2, res2, function () { nextCalled = true; });
+  check("middleware: draining → 503",           res2._endedStatus === 503);
+  check("middleware: draining → next() not called", nextCalled === false);
+  await sp;
+  o._resetForTest();
+}
+
+async function testAppShutdownInFlightTracking() {
+  var o = b.appShutdown.create({ phases: [] });
+  var mw = o.middleware();
+  var resolveReq;
+  var req = _mockReq();
+  var res = _bodyRes();
+  mw(req, res, function () {
+    check("inFlight: counted while in flight", o.inFlight() === 1);
+    resolveReq = function () { res.end(); };
+  });
+  var req2 = _mockReq();
+  var res2 = _bodyRes();
+  mw(req2, res2, function () {});
+  check("inFlight: counted across multiple requests", o.inFlight() === 2);
+  resolveReq();
+  res2.end();
+  await new Promise(function (r) { setImmediate(r); });
+  check("inFlight: decremented after res.end",  o.inFlight() === 0);
+  o._resetForTest();
+}
+
+async function testAppShutdownDrainPhaseWaitsForInFlight() {
+  var o = b.appShutdown.create({
+    graceMs: 1000,
+    phases: [],
+  });
+  o.addPhase({
+    name: "drain-in-flight",
+    run:  o.waitInFlight,
+    timeoutMs: 500,
+  });
+  var mw = o.middleware();
+  var req = _mockReq();
+  var res = _bodyRes();
+  mw(req, res, function () {});
+  setTimeout(function () { res.end(); }, 80);
+  var t0 = Date.now();
+  var result = await o.shutdown();
+  var elapsed = Date.now() - t0;
+  check("drain-in-flight: waited for in-flight to finish", elapsed >= 70 && elapsed < 500);
+  check("drain-in-flight: phase ok",                       result.phases[0].ok === true);
+  o._resetForTest();
+}
+
+async function testAppShutdownDrainTimeoutWhenInFlightStuck() {
+  var o = b.appShutdown.create({
+    graceMs: 200,
+    phases: [],
+  });
+  o.addPhase({
+    name: "drain-in-flight",
+    run:  o.waitInFlight,
+    timeoutMs: 80,
+  });
+  var mw = o.middleware();
+  var req = _mockReq();
+  var res = _bodyRes();
+  mw(req, res, function () {});
+  var result = await o.shutdown();
+  check("drain timeout: phase ok=false on stuck in-flight",   result.phases[0].ok === false);
+  check("drain timeout: error mentions timeout",              /time(d out|out)/i.test(result.phases[0].error));
+  o._resetForTest();
+}
+
+async function testAppShutdownAddPhaseRejectsAfterStart() {
+  var o = b.appShutdown.create({ phases: [{ name: "x", run: function () {} }] });
+  o.shutdown();
+  var threw = null;
+  try { o.addPhase({ name: "late", run: function () {} }); } catch (e) { threw = e; }
+  check("addPhase: rejected after shutdown started",
+        threw && threw.code === "app-shutdown/already-started");
+  o._resetForTest();
+}
+
+async function testAppShutdownStandardPhasesBuilder() {
+  var stops = [];
+  var components = {
+    health:     { markShuttingDown: function () { stops.push("health"); } },
+    scheduler:  { stop: function () { stops.push("scheduler"); } },
+    jobs:       { shutdown: function () { stops.push("jobs"); return Promise.resolve(); } },
+    router:     { closeWebSockets: function () { stops.push("websockets"); return Promise.resolve(); } },
+    server:     { close: function (cb) { stops.push("server"); cb(); } },
+    cluster:    { shutdown: function () { stops.push("cluster"); return Promise.resolve(); } },
+    db:         { close: function () { stops.push("db"); } },
+    externalDb: { shutdown: function () { stops.push("externalDb"); return Promise.resolve(); } },
+  };
+  var phases = b.appShutdown.standardPhases(components);
+  var names = phases.map(function (p) { return p.name; });
+  check("standardPhases: mark-draining first",   names[0] === "mark-draining");
+  check("standardPhases: scheduler before jobs", names.indexOf("scheduler") < names.indexOf("jobs"));
+  check("standardPhases: jobs before websockets", names.indexOf("jobs") < names.indexOf("websockets"));
+  check("standardPhases: websockets before http-server",
+        names.indexOf("websockets") < names.indexOf("http-server"));
+  check("standardPhases: cluster after http-server",
+        names.indexOf("cluster") > names.indexOf("http-server"));
+  check("standardPhases: db before external-db",
+        names.indexOf("db") < names.indexOf("external-db"));
+
+  var o = b.appShutdown.create({ phases: phases });
+  await o.shutdown();
+  check("standardPhases: execution mirrors declaration order",
+        stops.join(",") === "health,scheduler,jobs,websockets,server,cluster,db,externalDb");
+  o._resetForTest();
+}
+
+async function testAppShutdownStandardPhasesOmitsAbsentComponents() {
+  var phases = b.appShutdown.standardPhases({
+    db:      { close: function () {} },
+    cluster: { shutdown: function () { return Promise.resolve(); } },
+  });
+  var names = phases.map(function (p) { return p.name; });
+  check("standardPhases: only present components included",
+        names.length === 2 && names.indexOf("cluster") !== -1 && names.indexOf("db") !== -1);
+}
+
+async function testAppShutdownSignalHandlersInstall() {
+  var o = b.appShutdown.create({
+    phases: [{ name: "x", run: function () {} }],
+    installSignalHandlers: true,
+  });
+  var sigtermListeners = process.listeners("SIGTERM");
+  var sigintListeners = process.listeners("SIGINT");
+  check("signals: SIGTERM handler installed", sigtermListeners.length > 0);
+  check("signals: SIGINT handler installed",  sigintListeners.length > 0);
+  o.uninstallSignals();
+  check("signals: SIGTERM handler removed",   process.listeners("SIGTERM").length < sigtermListeners.length);
+  o._resetForTest();
+}
+
+async function testAppShutdownConfigValidation() {
+  var threw = null;
+  try {
+    b.appShutdown.create({ phases: [{ name: "ok", run: "not-a-fn" }] });
+  } catch (e) { threw = e; }
+  check("create: bad-shaped phase rejected",   threw && threw.code === "app-shutdown/bad-phase");
+
+  threw = null;
+  var o = b.appShutdown.create({ phases: [] });
+  try { o.addPhase({ name: "x" }); } catch (e) { threw = e; }
+  check("addPhase: missing run rejected",      threw && threw.code === "app-shutdown/bad-phase");
+  o._resetForTest();
+}
+
+async function run() {
+  testAppShutdownSurface();
+  await testAppShutdownEmpty();
+  await testAppShutdownPhasesRunInOrder();
+  await testAppShutdownPhaseFailureContinues();
+  await testAppShutdownPhaseTimeout();
+  await testAppShutdownIdempotent();
+  await testAppShutdownDrainingFlag();
+  await testAppShutdownMiddleware503DuringDrain();
+  await testAppShutdownInFlightTracking();
+  await testAppShutdownDrainPhaseWaitsForInFlight();
+  await testAppShutdownDrainTimeoutWhenInFlightStuck();
+  await testAppShutdownAddPhaseRejectsAfterStart();
+  await testAppShutdownStandardPhasesBuilder();
+  await testAppShutdownStandardPhasesOmitsAbsentComponents();
+  await testAppShutdownSignalHandlersInstall();
+  await testAppShutdownConfigValidation();
+}
+
+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); }
+  );
+}

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

@@ -0,0 +1,291 @@
+"use strict";
+/**
+ * b.archive — streaming ZIP creation (toStream + Readable addFile content).
+ *
+ * Covers: Readable as addFile content; toStream(writable) pipes through;
+ * toStream() with no writable returns a Readable; data-descriptor flag is
+ * set per APPNOTE 4.4.4 bit 3; central directory written only after every
+ * entry succeeds (atomic finalize); aborted source destroys the destination
+ * and emits archive.zip.streamed.aborted; mixed buffer + stream entries
+ * round-trip; toBuffer refuses streaming entries; audit emits the
+ * completed event with byte counts.
+ */
+
+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 stream  = require("node:stream");
+var zlib    = require("node:zlib");
+
+function _readU32LE(buf, off) {
+  return (buf[off] | (buf[off + 1] << 8) | (buf[off + 2] << 16) | (buf[off + 3] << 24)) >>> 0;
+}
+function _readU16LE(buf, off) {
+  return buf[off] | (buf[off + 1] << 8);
+}
+
+function _collect(readable) {
+  return new Promise(function (resolve, reject) {
+    var chunks = [];
+    readable.on("data", function (c) { chunks.push(c); });
+    readable.on("end", function () { resolve(Buffer.concat(chunks)); });
+    readable.on("error", reject);
+  });
+}
+
+function _readableFromBuffers(bufs) {
+  var i = 0;
+  return new stream.Readable({
+    read: function () {
+      if (i >= bufs.length) this.push(null);
+      else this.push(bufs[i++]);
+    },
+  });
+}
+
+async function testSurface() {
+  var arc = b.archive.zip();
+  check("archive.zip().toStream is a function",
+        typeof arc.toStream === "function");
+}
+
+async function testStreamReadableContent() {
+  // Two stream entries (one short, one larger) + one buffer entry. Pipe
+  // to PassThrough, collect bytes, validate the resulting archive.
+  var payload1 = Buffer.from("first stream content\n", "utf8");
+  var payload2 = Buffer.alloc(64 * 1024, 0x41);   // 64 KiB of 'A' — deflate-friendly
+  var arc = b.archive.zip();
+  arc.addFile("stream1.txt", _readableFromBuffers([payload1]));
+  arc.addFile("buffer.txt", "buffer entry\n");
+  arc.addFile("stream2.bin", _readableFromBuffers([
+    payload2.subarray(0, 32 * 1024),
+    payload2.subarray(32 * 1024),
+  ]));
+
+  var sink = new stream.PassThrough();
+  var collected = _collect(sink);
+  await arc.toStream(sink);
+  var buf = await collected;
+
+  check("toStream: produced archive starts with PK signature",
+        buf[0] === 0x50 && buf[1] === 0x4b);
+  // EOCD lives at the very end (no comment).
+  check("toStream: ends with EOCD signature",
+        _readU32LE(buf, buf.length - 22) === 0x06054b50);
+  check("toStream: EOCD records 3 entries",
+        _readU16LE(buf, buf.length - 22 + 10) === 3);
+
+  // First LFH for stream1.txt — flag bit 3 (data-descriptor) MUST be set
+  // because crc/sizes weren't known at LFH-write time.
+  var flags = _readU16LE(buf, 6);
+  check("toStream: stream entry LFH has data-descriptor flag (bit 3)",
+        (flags & 0x0008) === 0x0008);
+  check("toStream: stream entry LFH has UTF-8 flag (bit 11)",
+        (flags & 0x0800) === 0x0800);
+  // Stream entry LFH carries zero crc/csize/usize per APPNOTE 4.4.4.
+  check("toStream: stream entry LFH crc=0",
+        _readU32LE(buf, 14) === 0);
+  check("toStream: stream entry LFH csize=0",
+        _readU32LE(buf, 18) === 0);
+  check("toStream: stream entry LFH usize=0",
+        _readU32LE(buf, 22) === 0);
+
+  // Round-trip: extract stream1 by parsing LFH + finding the data
+  // descriptor. csize unknown until we read the descriptor — but we set
+  // method=DEFLATE so we can inflateRaw a streaming chunk.
+  var nameLen = _readU16LE(buf, 26);
+  var dataStart = 30 + nameLen;
+  // Hunt for the data-descriptor signature 0x08074b50 to bound csize.
+  var ddSig = 0x08074b50;
+  var ddOffset = -1;
+  for (var p = dataStart; p < buf.length - 16; p++) {
+    if (_readU32LE(buf, p) === ddSig) { ddOffset = p; break; }
+  }
+  check("toStream: data descriptor located after stream entry payload",
+        ddOffset > dataStart);
+  var ddCrc = _readU32LE(buf, ddOffset + 4);
+  var ddCsize = _readU32LE(buf, ddOffset + 8);
+  var ddUsize = _readU32LE(buf, ddOffset + 12);
+  check("toStream: data descriptor csize matches payload-to-descriptor distance",
+        ddCsize === (ddOffset - dataStart));
+  check("toStream: data descriptor usize matches uncompressed source",
+        ddUsize === payload1.length);
+  void ddCrc;
+
+  var compressed = buf.slice(dataStart, dataStart + ddCsize);
+  var inflated = zlib.inflateRawSync(compressed);
+  check("toStream: stream entry round-trips through inflate",
+        inflated.toString("utf8") === payload1.toString("utf8"));
+}
+
+async function testToStreamReturnsReadable() {
+  var arc = b.archive.zip();
+  arc.addFile("a.txt", _readableFromBuffers([Buffer.from("alpha", "utf8")]));
+  var rs = await arc.toStream();    // no writable supplied
+  check("toStream() without writable returns a Readable",
+        rs && typeof rs.pipe === "function");
+  var collected = await _collect(rs);
+  check("toStream(): readable emits a complete archive",
+        _readU32LE(collected, collected.length - 22) === 0x06054b50);
+}
+
+async function testWriteToHttpResShape() {
+  // Simulate piping to an HTTP res — a Writable with .write/.end. The
+  // wiki's documented shape: archive.toStream(res).
+  var written = [];
+  var fakeRes = new stream.Writable({
+    write: function (chunk, enc, cb) { written.push(chunk); cb(); },
+  });
+  var finished = new Promise(function (resolve) { fakeRes.on("finish", resolve); });
+
+  var arc = b.archive.zip();
+  arc.addFile("export.json", _readableFromBuffers([Buffer.from('{"k":1}', "utf8")]));
+  await arc.toStream(fakeRes);
+  await finished;
+
+  var buf = Buffer.concat(written);
+  check("toStream(res): wrote complete archive to res",
+        _readU32LE(buf, buf.length - 22) === 0x06054b50);
+  check("toStream(res): ended the writable",
+        fakeRes.writableEnded === true);
+}
+
+async function testAtomicAbortOnSourceError() {
+  // Source emits 'error' → toStream rejects, destination destroyed,
+  // central directory NEVER written (the surviving bytes do not form a
+  // valid archive — operators see the broken pipe, not a half-complete
+  // zip that pretends to be whole).
+  var bad = new stream.Readable({
+    read: function () {
+      var self = this;
+      process.nextTick(function () { self.destroy(new Error("source kaboom")); });
+    },
+  });
+  var sink = new stream.PassThrough();
+  var sinkBytes = [];
+  sink.on("data", function (c) { sinkBytes.push(c); });
+  sink.on("error", function () { /* expected — toStream destroys on abort */ });
+
+  var captured = [];
+  var fakeAudit = { safeEmit: function (e) { captured.push(e); } };
+
+  var arc = b.archive.zip();
+  arc.addFile("ok.txt", "ok\n");
+  arc.addFile("broken.bin", bad);
+  arc.addFile("never.txt", "never\n");
+
+  var threw = null;
+  try { await arc.toStream(sink, { audit: fakeAudit }); }
+  catch (e) { threw = e; }
+
+  check("aborted: toStream rejects on source error",
+        threw !== null);
+  // Whatever bytes leaked into the sink do NOT contain an EOCD signature
+  // — that's the proof "atomic finalize" held.
+  var leaked = Buffer.concat(sinkBytes);
+  var hasEocd = false;
+  for (var p = 0; p + 4 <= leaked.length; p++) {
+    if (_readU32LE(leaked, p) === 0x06054b50) { hasEocd = true; break; }
+  }
+  check("aborted: leaked bytes contain no EOCD (no central directory)",
+        hasEocd === false);
+
+  check("aborted: audit emits archive.zip.streamed.aborted",
+        captured.some(function (e) {
+          return e.action === "archive.zip.streamed.aborted" && e.outcome === "failure";
+        }));
+}
+
+async function testAuditCompletedEvent() {
+  var captured = [];
+  var fakeAudit = { safeEmit: function (e) { captured.push(e); } };
+
+  var arc = b.archive.zip();
+  arc.addFile("a.txt", _readableFromBuffers([Buffer.from("a", "utf8")]));
+  arc.addFile("b.txt", "b");
+  await arc.toStream(new stream.PassThrough(), { audit: fakeAudit });
+
+  var done = captured.find(function (e) {
+    return e.action === "archive.zip.streamed.completed";
+  });
+  check("audit: completed event emitted",
+        done && done.outcome === "success");
+  check("audit: completed event reports entry count",
+        done && done.metadata && done.metadata.entries === 2);
+  check("audit: completed event reports byte count > 0",
+        done && done.metadata && typeof done.metadata.bytes === "number" && done.metadata.bytes > 0);
+}
+
+function testToBufferRefusesStreamingEntry() {
+  var arc = b.archive.zip();
+  arc.addFile("s.txt", _readableFromBuffers([Buffer.from("x", "utf8")]));
+  var threw = null;
+  try { arc.toBuffer(); } catch (e) { threw = e; }
+  check("toBuffer refuses streaming entry",
+        threw && /streaming-entry/.test(threw.code || ""));
+}
+
+async function testStreamEntryNameValidation() {
+  // Streaming addFile must enforce the same name-validation as buffer
+  // addFile — `..` segments, null bytes, empty names all rejected before
+  // pipe time so the operator gets a clean throw at addFile rather than
+  // a half-built archive at toStream time.
+  function rejects(label, fn, codeRe) {
+    var threw = null;
+    try { fn(); } catch (e) { threw = e; }
+    check("stream addFile reject: " + label, threw && codeRe.test(threw.code || ""));
+  }
+  var src = function () {
+    return _readableFromBuffers([Buffer.from("x", "utf8")]);
+  };
+  rejects("empty name (stream)",   function () { b.archive.zip().addFile("", src()); }, /archive\/bad-name/);
+  rejects("null byte (stream)",    function () { b.archive.zip().addFile("a\0b", src()); }, /archive\/bad-name/);
+  rejects("..  segment (stream)",  function () { b.archive.zip().addFile("../etc/passwd", src()); }, /archive\/bad-name/);
+}
+
+async function testStreamThenWriteToFile() {
+  // End-to-end: stream a multi-entry archive into a fs.createWriteStream
+  // and unzip via stdlib parse to confirm the on-disk file is a valid
+  // archive operators can hand to `unzip`.
+  var tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-arch-stream-"));
+  try {
+    var outPath = path.join(tmpDir, "out.zip");
+    var ws = fs.createWriteStream(outPath);
+    var arc = b.archive.zip();
+    arc.addFile("hello.txt", _readableFromBuffers([Buffer.from("Hello\n", "utf8")]));
+    arc.addFile("data.bin", _readableFromBuffers([Buffer.alloc(8 * 1024, 0x42)]));
+    await arc.toStream(ws);
+    await new Promise(function (resolve) { ws.on("close", resolve); ws.end(); });
+    var onDisk = fs.readFileSync(outPath);
+    check("stream-to-file: ends with EOCD",
+          _readU32LE(onDisk, onDisk.length - 22) === 0x06054b50);
+    check("stream-to-file: byte count > 0",
+          onDisk.length > 0);
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+async function run() {
+  await testSurface();
+  await testStreamReadableContent();
+  await testToStreamReturnsReadable();
+  await testWriteToHttpResShape();
+  await testAtomicAbortOnSourceError();
+  await testAuditCompletedEvent();
+  testToBufferRefusesStreamingEntry();
+  await testStreamEntryNameValidation();
+  await testStreamThenWriteToFile();
+}
+
+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); }
+  );
+}