socketduct 0.1.25 → 0.1.26

package/test/unit/index.test.js

@@ -1,5 +1,4 @@
-import assert from "node:assert/strict"
-import test from "node:test"
+import {describe, expect, it} from "@velocious/testing"
 
 import {
   connectSocketduct,
@@ -23,61 +22,63 @@ import {connectSocketduct as directConnectSocketduct, SocketductSocket as Direct
 import {createJsonlFileLogger as directCreateJsonlFileLogger} from "../../src/logging/structured-logger.js"
 import {createCompressedJsonlFileLogger as directCreateCompressedJsonlFileLogger} from "../../src/logging/compressed-log-writer.js"
 
-test("getStartupSummary returns the Socketduct service identity and default mode", () => {
-  assert.deepEqual(getStartupSummary(), {
-    name: "Socketduct",
-    runtime: "node",
-    mode: "single-worker"
+describe("public index exports", () => {
+  it("getStartupSummary returns the Socketduct service identity and default mode", () => {
+    expect(getStartupSummary()).toEqual({
+      name: "Socketduct",
+      runtime: "node",
+      mode: "single-worker"
+    })
   })
-})
 
-test("index exports the public SocketductSocket client API", () => {
-  assert.equal(SocketductSocket, DirectSocketductSocket)
-  assert.equal(connectSocketduct, directConnectSocketduct)
-  assert.equal(createSocketductConnectionFactory, directCreateSocketductConnectionFactory)
-  assert.equal(createJsonlFileLogger, directCreateJsonlFileLogger)
-  assert.equal(createCompressedJsonlFileLogger, directCreateCompressedJsonlFileLogger)
-  assert.equal(SocketductHttpAgent, DirectSocketductHttpAgent)
-})
+  it("index exports the public SocketductSocket client API", () => {
+    expect(SocketductSocket).toBe(DirectSocketductSocket)
+    expect(connectSocketduct).toBe(directConnectSocketduct)
+    expect(createSocketductConnectionFactory).toBe(directCreateSocketductConnectionFactory)
+    expect(createJsonlFileLogger).toBe(directCreateJsonlFileLogger)
+    expect(createCompressedJsonlFileLogger).toBe(directCreateCompressedJsonlFileLogger)
+    expect(SocketductHttpAgent).toBe(DirectSocketductHttpAgent)
+  })
 
-test("package exports expose dedicated HTTP and HTTPS adapter entrypoints without an HTTPS barrel export", async () => {
-  const socketduct = await import("socketduct")
-  const socketductHttp = await import("socketduct/http")
-  const socketductHttps = await import("socketduct/https")
-  const {SocketductHttpsAgent} = await import("../../src/client/https-agent.js")
+  it("package exports expose dedicated HTTP and HTTPS adapter entrypoints without an HTTPS barrel export", async () => {
+    const socketduct = await import("socketduct")
+    const socketductHttp = await import("socketduct/http")
+    const socketductHttps = await import("socketduct/https")
+    const {SocketductHttpsAgent} = await import("../../src/client/https-agent.js")
 
-  assert.equal(socketduct.SocketductHttpAgent, DirectSocketductHttpAgent)
-  assert.equal(socketductHttp.SocketductHttpAgent, DirectSocketductHttpAgent)
-  assert.equal(socketductHttps.SocketductHttpsAgent, SocketductHttpsAgent)
-  assert.equal("SocketductHttpsAgent" in socketduct, false)
-})
+    expect(socketduct.SocketductHttpAgent).toBe(DirectSocketductHttpAgent)
+    expect(socketductHttp.SocketductHttpAgent).toBe(DirectSocketductHttpAgent)
+    expect(socketductHttps.SocketductHttpsAgent).toBe(SocketductHttpsAgent)
+    expect("SocketductHttpsAgent" in socketduct).toBe(false)
+  })
 
-test("package exports the protocol-v3 pooled connection and relay entrypoints", async () => {
-  const multiplexed = await import("socketduct/multiplexed")
-  const relay = await import("socketduct/relay")
+  it("package exports the protocol-v3 pooled connection and relay entrypoints", async () => {
+    const multiplexed = await import("socketduct/multiplexed")
+    const relay = await import("socketduct/relay")
 
-  assert.equal(multiplexed.MultiplexedSocketductConnection, MultiplexedSocketductConnection)
-  assert.equal(multiplexed.MultiplexedSocketductTransportSet, MultiplexedSocketductTransportSet)
-  assert.equal(multiplexed.SocketductRecoveryLookupError, SocketductRecoveryLookupError)
-  assert.equal(createMultiplexedSocketductConnection({
-    relay: {host: "127.0.0.1", port: 3100, token: "test-token"}
-  }) instanceof MultiplexedSocketductConnection, true)
-  assert.equal(createMultiplexedSocketductTransportSet({
-    connectionId: "process_identity_01",
-    spoolDirectory: "/tmp/socketduct-index-test",
-    maxTotalBufferBytes: 1024,
-    maxTotalSpoolBytes: 1024,
-    maxTotalQueuedBytes: 2048,
-    gateways: [{gatewayId: "starlink", endpoint: {relay: {host: "127.0.0.1", port: 3100, token: "test-token"}}}]
-  }) instanceof MultiplexedSocketductTransportSet, true)
-  assert.equal(typeof relay.startMultiplexedTcpRelay, "function")
-})
+    expect(multiplexed.MultiplexedSocketductConnection).toBe(MultiplexedSocketductConnection)
+    expect(multiplexed.MultiplexedSocketductTransportSet).toBe(MultiplexedSocketductTransportSet)
+    expect(multiplexed.SocketductRecoveryLookupError).toBe(SocketductRecoveryLookupError)
+    expect(createMultiplexedSocketductConnection({
+      relay: {host: "127.0.0.1", port: 3100, token: "test-token"}
+    }) instanceof MultiplexedSocketductConnection).toBe(true)
+    expect(createMultiplexedSocketductTransportSet({
+      connectionId: "process_identity_01",
+      spoolDirectory: "/tmp/socketduct-index-test",
+      maxTotalBufferBytes: 1024,
+      maxTotalSpoolBytes: 1024,
+      maxTotalQueuedBytes: 2048,
+      gateways: [{gatewayId: "starlink", endpoint: {relay: {host: "127.0.0.1", port: 3100, token: "test-token"}}}]
+    }) instanceof MultiplexedSocketductTransportSet).toBe(true)
+    expect(typeof relay.startMultiplexedTcpRelay).toBe("function")
+  })
 
-test("package exports native reverse hub, gateway, and client entrypoints", async () => {
-  const reverse = await import("socketduct/reverse")
-  const relay = await import("socketduct/relay")
-  assert.equal(reverse.OutboundReverseGateway, OutboundReverseGateway)
-  assert.equal(reverse.ReverseGatewayConnection, ReverseGatewayConnection)
-  assert.equal(typeof reverse.startReverseGatewayHub, "function")
-  assert.equal(relay.startReverseGatewayHub, reverse.startReverseGatewayHub)
+  it("package exports native reverse hub, gateway, and client entrypoints", async () => {
+    const reverse = await import("socketduct/reverse")
+    const relay = await import("socketduct/relay")
+    expect(reverse.OutboundReverseGateway).toBe(OutboundReverseGateway)
+    expect(reverse.ReverseGatewayConnection).toBe(ReverseGatewayConnection)
+    expect(typeof reverse.startReverseGatewayHub).toBe("function")
+    expect(relay.startReverseGatewayHub).toBe(reverse.startReverseGatewayHub)
+  })
 })

package/test/unit/logging/compressed-log-worker.test.js

@@ -1,29 +1,30 @@
-import assert from "node:assert/strict"
-import test from "node:test"
+import {describe, expect, it} from "@velocious/testing"
 
 import {writeAll} from "../../../src/logging/compressed-log-worker.js"
 
-test("worker positional writes preserve every byte across all short-write offsets", async () => {
-  const source = Buffer.from("short-write-safe-durable-frame")
-  for (let maximum = 1; maximum <= source.length; maximum += 1) {
-    const destination = Buffer.alloc(source.length + 7)
-    /** @type {number[]} */
-    const positions = []
-    const handle = {
-      async write(/** @type {Buffer} */ bytes, /** @type {number} */ offset, /** @type {number} */ length, /** @type {number} */ position) {
-        const bytesWritten = Math.min(maximum, length)
-        positions.push(position)
-        Buffer.from(bytes).copy(destination, position, offset, offset + bytesWritten)
-        return {bytesWritten, buffer: bytes}
+describe("compressed log worker", () => {
+  it("worker positional writes preserve every byte across all short-write offsets", async () => {
+    const source = Buffer.from("short-write-safe-durable-frame")
+    for (let maximum = 1; maximum <= source.length; maximum += 1) {
+      const destination = Buffer.alloc(source.length + 7)
+      /** @type {number[]} */
+      const positions = []
+      const handle = {
+        async write(/** @type {Buffer} */ bytes, /** @type {number} */ offset, /** @type {number} */ length, /** @type {number} */ position) {
+          const bytesWritten = Math.min(maximum, length)
+          positions.push(position)
+          Buffer.from(bytes).copy(destination, position, offset, offset + bytesWritten)
+          return {bytesWritten, buffer: bytes}
+        }
       }
+      await writeAll(/** @type {import('node:fs/promises').FileHandle} */ (handle), source, 7)
+      expect(destination.subarray(7).equals(source)).toBe(true)
+      expect(positions).toEqual(Array.from({length: Math.ceil(source.length / maximum)}, (_, index) => 7 + index * maximum))
     }
-    await writeAll(/** @type {import('node:fs/promises').FileHandle} */ (handle), source, 7)
-    assert.deepEqual(destination.subarray(7), source)
-    assert.deepEqual(positions, Array.from({length: Math.ceil(source.length / maximum)}, (_, index) => 7 + index * maximum))
-  }
-})
+  })
 
-test("worker positional writes fail loudly on zero progress", async () => {
-  const handle = {async write(/** @type {Buffer} */ bytes) { return {bytesWritten: 0, buffer: bytes} }}
-  await assert.rejects(() => writeAll(/** @type {import('node:fs/promises').FileHandle} */ (handle), Buffer.from("frame"), 0), /no progress/)
+  it("worker positional writes fail loudly on zero progress", async () => {
+    const handle = {async write(/** @type {Buffer} */ bytes) { return {bytesWritten: 0, buffer: bytes} }}
+    await expect(writeAll(/** @type {import('node:fs/promises').FileHandle} */ (handle), Buffer.from("frame"), 0)).rejects.toThrow(/no progress/)
+  })
 })

package/test/unit/logging/compressed-log-writer.test.js

@@ -1,175 +1,176 @@
-import assert from "node:assert/strict"
+import {describe, expect, it, withTestCleanup} from "@velocious/testing"
 import {mkdtemp, readdir, rm, stat} from "node:fs/promises"
 import {tmpdir} from "node:os"
 import {join} from "node:path"
-import test from "node:test"
 
 import {readCompressedLogDirectory} from "../../../src/logging/compressed-log-reader.js"
 import {createCompressedJsonlFileLogger} from "../../../src/logging/compressed-log-writer.js"
 
-test("compressed logger durably acknowledges ordered records and closes asynchronously", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-writer-"))
-  const directory = join(root, "logs")
-  let tick = 0
-  const logger = createCompressedJsonlFileLogger({
-    directory,
-    role: "reverse-hub",
-    now: () => new Date(1_795_000_000_000 + tick++),
-    frameMaxBytes: 256,
-    flushIntervalMs: 60_000,
-    criticalFlushIntervalMs: 60_000,
-    maxSegmentBytes: 2048
-  })
-  t.after(async () => { await logger.close().catch(() => {}); await rm(root, {recursive: true, force: true}) })
+describe("compressed log writer", () => {
+  it("compressed logger durably acknowledges ordered records and closes asynchronously", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-writer-"))
+    const directory = join(root, "logs")
+    let tick = 0
+    const logger = createCompressedJsonlFileLogger({
+      directory,
+      role: "reverse-hub",
+      now: () => new Date(1_795_000_000_000 + tick++),
+      frameMaxBytes: 256,
+      flushIntervalMs: 60_000,
+      criticalFlushIntervalMs: 60_000,
+      maxSegmentBytes: 2048
+    })
+    after(async () => { await logger.close().catch(() => {}); await rm(root, {recursive: true, force: true}) })
 
-  assert.equal(logger.log("process.started", {runtimeMode: "reverse-hub", token: "must-not-survive"}), "accepted")
-  assert.equal(logger.log("runtime.status", {virtualStreams: 4}), "accepted")
-  assert.equal(logger.log("runtime.status", {virtualStreams: 5}), "accepted")
-  assert.equal(logger.status().acceptedHighWater, "3")
-  await logger.flush()
+    expect(logger.log("process.started", {runtimeMode: "reverse-hub", token: "must-not-survive"})).toBe("accepted")
+    expect(logger.log("runtime.status", {virtualStreams: 4})).toBe("accepted")
+    expect(logger.log("runtime.status", {virtualStreams: 5})).toBe("accepted")
+    expect(logger.status().acceptedHighWater).toBe("3")
+    await logger.flush()
 
-  const durable = logger.status()
-  assert(Number(durable.durableHighWater) >= 3)
-  assert.equal(durable.health, "healthy")
-  const result = await readCompressedLogDirectory(directory)
-  assert.equal(result.incomplete, false)
-  assert.deepEqual(result.records.map((record) => record.eventSequence), Array.from({length: result.records.length}, (_, index) => String(index + 1)))
-  assert.deepEqual(result.records.filter((record) => !String(record.event).startsWith("log_")).map((record) => record.event), ["process.started", "runtime.status", "runtime.status"])
-  assert.equal(new Set(result.records.map((record) => record.writerEpoch)).size, 1)
-  assert.doesNotMatch(JSON.stringify(result.records), /must-not-survive/)
+    const durable = logger.status()
+    expect(Number(durable.durableHighWater) >= 3).toBeTruthy()
+    expect(durable.health).toBe("healthy")
+    const result = await readCompressedLogDirectory(directory)
+    expect(result.incomplete).toBe(false)
+    expect(result.records.map((record) => record.eventSequence)).toEqual(Array.from({length: result.records.length}, (_, index) => String(index + 1)))
+    expect(result.records.filter((record) => !String(record.event).startsWith("log_")).map((record) => record.event)).toEqual(["process.started", "runtime.status", "runtime.status"])
+    expect(new Set(result.records.map((record) => record.writerEpoch)).size).toBe(1)
+    expect(JSON.stringify(result.records)).not.toMatch(/must-not-survive/)
 
-  const filesBeforeClose = await readdir(directory)
-  assert(filesBeforeClose.some((name) => name.endsWith(".jsonl.zst")))
-  assert(filesBeforeClose.some((name) => name.endsWith(".jsonl.zst.idx")))
-  assert.equal(filesBeforeClose.some((name) => name.endsWith(".jsonl")), false)
-  assert.equal((await stat(directory)).mode & 0o777, 0o700)
-  for (const name of filesBeforeClose) assert.equal((await stat(join(directory, name))).mode & 0o777, 0o600)
+    const filesBeforeClose = await readdir(directory)
+    expect(filesBeforeClose.some((name) => name.endsWith(".jsonl.zst"))).toBeTruthy()
+    expect(filesBeforeClose.some((name) => name.endsWith(".jsonl.zst.idx"))).toBeTruthy()
+    expect(filesBeforeClose.some((name) => name.endsWith(".jsonl"))).toBe(false)
+    expect((await stat(directory)).mode & 0o777).toBe(0o700)
+    for (const name of filesBeforeClose) expect((await stat(join(directory, name))).mode & 0o777).toBe(0o600)
 
-  const firstClose = logger.close()
-  const secondClose = logger.close()
-  assert.equal(firstClose, secondClose)
-  const finalStatus = await firstClose
-  assert.equal(finalStatus.state, "closed")
-  assert.equal(logger.log("process.started", {runtimeMode: "reverse-hub"}), "dropped")
-  assert((await readdir(directory)).some((name) => name.endsWith(".jsonl.zst.sealed")))
-  const closed = await readCompressedLogDirectory(directory)
-  assert(closed.records.some((record) => record.event === "log_batch_accepted"))
-  assert(closed.records.some((record) => record.event === "log_frame_committed"))
-  assert.equal(closed.records.at(-1)?.event, "log_closed")
-})
+    const firstClose = logger.close()
+    const secondClose = logger.close()
+    expect(firstClose).toBe(secondClose)
+    const finalStatus = await firstClose
+    expect(finalStatus.state).toBe("closed")
+    expect(logger.log("process.started", {runtimeMode: "reverse-hub"})).toBe("dropped")
+    expect((await readdir(directory)).some((name) => name.endsWith(".jsonl.zst.sealed"))).toBeTruthy()
+    const closed = await readCompressedLogDirectory(directory)
+    expect(closed.records.some((record) => record.event === "log_batch_accepted")).toBeTruthy()
+    expect(closed.records.some((record) => record.event === "log_frame_committed")).toBeTruthy()
+    expect(closed.records.at(-1)?.event).toBe("log_closed")
+  }))
 
-test("compressed logger enforces one shared bounded queue with a critical reserve", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-pressure-"))
-  const directory = join(root, "logs")
-  // The reserve must cover the critical event's conservative charge (line bytes × 3 + 128);
-  // an accepted-but-undelivered sequence can never be evicted without tearing the durable journal.
-  const logger = createCompressedJsonlFileLogger({
-    directory,
-    role: "reverse-client",
-    maxQueueBytes: 4096,
-    criticalReserveBytes: 2048,
-    frameMaxBytes: 1024,
-    flushIntervalMs: 60_000,
-    criticalFlushIntervalMs: 60_000
-  })
-  t.after(async () => { await logger.close().catch(() => {}); await rm(root, {recursive: true, force: true}) })
+  it("compressed logger enforces one shared bounded queue with a critical reserve", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-pressure-"))
+    const directory = join(root, "logs")
+    // The reserve must cover the critical event's conservative charge (line bytes × 3 + 128);
+    // an accepted-but-undelivered sequence can never be evicted without tearing the durable journal.
+    const logger = createCompressedJsonlFileLogger({
+      directory,
+      role: "reverse-client",
+      maxQueueBytes: 4096,
+      criticalReserveBytes: 2048,
+      frameMaxBytes: 1024,
+      flushIntervalMs: 60_000,
+      criticalFlushIntervalMs: 60_000
+    })
+    after(async () => { await logger.close().catch(() => {}); await rm(root, {recursive: true, force: true}) })
 
-  const outcomes = Array.from({length: 40}, () => logger.log("runtime.status", {virtualStreams: 1}))
-  assert(outcomes.includes("dropped") || outcomes.includes("coalesced"))
-  assert(logger.status().queuedBytes <= 4096)
-  assert.equal(logger.log("transport.disconnected", {
-    clientConnectionGeneration: 1,
-    disconnectIncidentId: "AAAAAAAAAAAAAAAAAAAAAA",
-    disconnectReason: "remote_eof",
-    incidentOrigin: "reverse_client",
-    physicalRole: "client",
-    fanOutCount: 1,
-    resumeSuccessCount: 0,
-    terminalStreamCount: 0
-  }), "accepted")
-  assert(logger.status().queuedBytes <= 4096)
-  await logger.flush()
-})
+    const outcomes = Array.from({length: 40}, () => logger.log("runtime.status", {virtualStreams: 1}))
+    expect(outcomes.includes("dropped") || outcomes.includes("coalesced")).toBeTruthy()
+    expect(logger.status().queuedBytes <= 4096).toBeTruthy()
+    expect(logger.log("transport.disconnected", {
+      clientConnectionGeneration: 1,
+      disconnectIncidentId: "AAAAAAAAAAAAAAAAAAAAAA",
+      disconnectReason: "remote_eof",
+      incidentOrigin: "reverse_client",
+      physicalRole: "client",
+      fanOutCount: 1,
+      resumeSuccessCount: 0,
+      terminalStreamCount: 0
+    })).toBe("accepted")
+    expect(logger.status().queuedBytes <= 4096).toBeTruthy()
+    await logger.flush()
+  }))
 
-test("compressed logger caps worker restarts and retains only bounded critical evidence after failure", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-worker-death-"))
-  const directory = join(root, "logs")
-  const logger = createCompressedJsonlFileLogger({
-    directory,
-    role: "reverse-hub",
-    frameMaxBytes: 256,
-    maxSegmentBytes: 1024,
-    maxQueueBytes: 65_536,
-    criticalReserveBytes: 8192,
-    flushIntervalMs: 60_000,
-    criticalFlushIntervalMs: 60_000,
-    stderr: {write: () => true}
-  })
-  t.after(async () => { await logger.close().catch(() => {}); await rm(root, {recursive: true, force: true}) })
-  logger.log("process.started", {runtimeMode: "reverse-hub"})
-  await logger.flush()
-  await rm(directory, {recursive: true, force: true})
+  it("compressed logger caps worker restarts and retains only bounded critical evidence after failure", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-worker-death-"))
+    const directory = join(root, "logs")
+    const logger = createCompressedJsonlFileLogger({
+      directory,
+      role: "reverse-hub",
+      frameMaxBytes: 256,
+      maxSegmentBytes: 1024,
+      maxQueueBytes: 65_536,
+      criticalReserveBytes: 8192,
+      flushIntervalMs: 60_000,
+      criticalFlushIntervalMs: 60_000,
+      stderr: {write: () => true}
+    })
+    after(async () => { await logger.close().catch(() => {}); await rm(root, {recursive: true, force: true}) })
+    logger.log("process.started", {runtimeMode: "reverse-hub"})
+    await logger.flush()
+    await rm(directory, {recursive: true, force: true})
 
-  for (let index = 0; index < 20; index += 1) logger.log("process.started", {runtimeMode: "reverse-hub"})
-  await assert.rejects(() => logger.flush())
-  assert.equal(logger.status().state, "failed")
-  assert.equal(logger.status().workerRestarts, 3)
-  assert.equal(logger.log("runtime.status", {virtualStreams: 1}), "dropped")
-  assert.equal(logger.log("process.started", {runtimeMode: "reverse-hub"}), "accepted")
-  assert(logger.status().allocatedBytes <= 65_536)
-})
+    for (let index = 0; index < 20; index += 1) logger.log("process.started", {runtimeMode: "reverse-hub"})
+    await expect(logger.flush()).rejects.toThrow()
+    expect(logger.status().state).toBe("failed")
+    expect(logger.status().workerRestarts).toBe(3)
+    expect(logger.log("runtime.status", {virtualStreams: 1})).toBe("dropped")
+    expect(logger.log("process.started", {runtimeMode: "reverse-hub"})).toBe("accepted")
+    expect(logger.status().allocatedBytes <= 65_536).toBeTruthy()
+  }))
 
-test("compressed logger flush is a caller-time durability barrier", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-barrier-"))
-  const logger = createCompressedJsonlFileLogger({
-    directory: join(root, "logs"),
-    role: "reverse-hub",
-    frameMaxBytes: 256,
-    flushIntervalMs: 60_000,
-    criticalFlushIntervalMs: 60_000,
-    maxQueueBytes: 1_000_000,
-    criticalReserveBytes: 1024
-  })
-  t.after(async () => { await logger.close().catch(() => {}); await rm(root, {recursive: true, force: true}) })
-  await logger.flush()
-  assert.equal(logger.log("process.started", {runtimeMode: "reverse-hub"}), "accepted")
-  const barrier = logger.flush()
-  for (let index = 0; index < 8; index += 1) assert.equal(logger.log("process.started", {runtimeMode: "reverse-hub"}), "accepted")
-  await barrier
-  const status = logger.status()
-  assert(BigInt(status.durableHighWater) >= 1n)
-  assert(BigInt(status.durableHighWater) < BigInt(status.acceptedHighWater))
-})
+  it("compressed logger flush is a caller-time durability barrier", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-barrier-"))
+    const logger = createCompressedJsonlFileLogger({
+      directory: join(root, "logs"),
+      role: "reverse-hub",
+      frameMaxBytes: 256,
+      flushIntervalMs: 60_000,
+      criticalFlushIntervalMs: 60_000,
+      maxQueueBytes: 1_000_000,
+      criticalReserveBytes: 1024
+    })
+    after(async () => { await logger.close().catch(() => {}); await rm(root, {recursive: true, force: true}) })
+    await logger.flush()
+    expect(logger.log("process.started", {runtimeMode: "reverse-hub"})).toBe("accepted")
+    const barrier = logger.flush()
+    for (let index = 0; index < 8; index += 1) expect(logger.log("process.started", {runtimeMode: "reverse-hub"})).toBe("accepted")
+    await barrier
+    const status = logger.status()
+    expect(BigInt(status.durableHighWater) >= 1n).toBeTruthy()
+    expect(BigInt(status.durableHighWater) < BigInt(status.acceptedHighWater)).toBeTruthy()
+  }))
 
-test("compressed logger flushes immediately at frame size and critical deadlines do not slide", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-deadline-"))
-  const directory = join(root, "logs")
-  const logger = createCompressedJsonlFileLogger({
-    directory,
-    role: "reverse-hub",
-    frameMaxBytes: 256,
-    flushIntervalMs: 60_000,
-    criticalFlushIntervalMs: 40,
-    maxQueueBytes: 1_000_000,
-    criticalReserveBytes: 1024
-  })
-  t.after(async () => { await logger.close().catch(() => {}); await rm(root, {recursive: true, force: true}) })
-  await logger.flush()
+  it("compressed logger flushes immediately at frame size and critical deadlines do not slide", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-deadline-"))
+    const directory = join(root, "logs")
+    const logger = createCompressedJsonlFileLogger({
+      directory,
+      role: "reverse-hub",
+      frameMaxBytes: 256,
+      flushIntervalMs: 60_000,
+      criticalFlushIntervalMs: 40,
+      maxQueueBytes: 1_000_000,
+      criticalReserveBytes: 1024
+    })
+    after(async () => { await logger.close().catch(() => {}); await rm(root, {recursive: true, force: true}) })
+    await logger.flush()
 
-  assert.equal(logger.log("runtime.status", {virtualStreams: 1}), "accepted")
-  assert.equal(logger.log("process.started", {runtimeMode: "reverse-hub"}), "accepted")
-  await waitUntil(() => BigInt(logger.status().durableHighWater) > 0n, 1_000)
+    expect(logger.log("runtime.status", {virtualStreams: 1})).toBe("accepted")
+    expect(logger.log("process.started", {runtimeMode: "reverse-hub"})).toBe("accepted")
+    await waitUntil(() => BigInt(logger.status().durableHighWater) > 0n, 1_000)
 
-  await logger.flush()
-  const before = BigInt(logger.status().durableHighWater)
-  const producer = setInterval(() => logger.log("process.started", {runtimeMode: "reverse-hub"}), 5)
-  try {
-    await waitUntil(() => BigInt(logger.status().durableHighWater) > before, 500)
-  } finally {
-    clearInterval(producer)
-  }
-  const durable = await readCompressedLogDirectory(directory)
-  assert(durable.records.some((record) => record.event === "runtime.status"))
+    await logger.flush()
+    const before = BigInt(logger.status().durableHighWater)
+    const producer = setInterval(() => logger.log("process.started", {runtimeMode: "reverse-hub"}), 5)
+    try {
+      await waitUntil(() => BigInt(logger.status().durableHighWater) > before, 500)
+    } finally {
+      clearInterval(producer)
+    }
+    const durable = await readCompressedLogDirectory(directory)
+    expect(durable.records.some((record) => record.event === "runtime.status")).toBeTruthy()
+  }))
 })
 
 /**
@@ -179,7 +180,7 @@ test("compressed logger flushes immediately at frame size and critical deadlines
 async function waitUntil(predicate, timeoutMs) {
   const deadline = Date.now() + timeoutMs
   while (!predicate()) {
-    if (Date.now() >= deadline) assert.fail("timed out waiting for compressed logger progress")
+    if (Date.now() >= deadline) throw new Error("timed out waiting for compressed logger progress")
     await new Promise((resolve) => setTimeout(resolve, 5))
   }
 }