socketduct 0.1.25 → 0.1.26

package/test/integration/logging-cli.test.js

@@ -1,10 +1,9 @@
 /* eslint-disable jsdoc/escape-inline-tags, jsdoc/require-param, jsdoc/require-returns */
-import assert from "node:assert/strict"
+import {describe, expect, it, withTestCleanup} from "@velocious/testing"
 import {execFile, spawn} from "node:child_process"
 import {mkdtemp, readFile, readdir, rm, utimes, writeFile} from "node:fs/promises"
 import {tmpdir} from "node:os"
 import {join} from "node:path"
-import test from "node:test"
 import {promisify} from "node:util"
 
 import {createCompressedJsonlFileLogger} from "../../src/logging/compressed-log-writer.js"
@@ -14,127 +13,130 @@ import {enforceLogRetention} from "../../src/logging/log-retention.js"
 const run = promisify(execFile)
 const cli = new URL("../../src/cli/socketduct.js", import.meta.url)
 
-test("owned CLI searches and tails durable compressed records with stable exits", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-logs-cli-"))
-  const directory = join(root, "logs")
-  t.after(() => rm(root, {recursive: true, force: true}))
-  const logger = createCompressedJsonlFileLogger({directory, role: "reverse-hub"})
-  logger.log("process.started", {runtimeMode: "reverse-hub"})
-  logger.log("runtime.status", {virtualStreams: 7})
-  await logger.close()
-
-  const match = await invoke("logs", "search", "--directory", directory, "--event", "runtime.status")
-  assert.equal(match.code, 0)
-  assert.deepEqual(match.stdout.trim().split("\n").map((line) => JSON.parse(line).event), ["runtime.status"])
-
-  const absent = await invoke("logs", "search", "--directory", directory, "--event", "transport.failed")
-  assert.equal(absent.code, 1)
-  assert.equal(absent.stdout, "")
-
-  const tail = await invoke("logs", "tail", "--directory", directory)
-  assert.equal(tail.code, 0)
-  assert.deepEqual(tail.stdout.trim().split("\n").map((line) => JSON.parse(line).event), ["process.started", "runtime.status", "log_batch_accepted", "log_frame_committed", "log_closed"])
-
-  const invalid = await invoke("logs", "search", "--directory", directory, "--client-generation", "not-a-number")
-  assert.equal(invalid.code, 2)
-  assert.match(invalid.stderr, /Socketduct logs error/)
-})
-
-test("owned CLI follow stays live and emits newly durable writer records", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-logs-follow-"))
-  const directory = join(root, "logs")
-  t.after(() => rm(root, {recursive: true, force: true}))
-  const initial = createCompressedJsonlFileLogger({directory, role: "reverse-client"})
-  initial.log("process.started", {runtimeMode: "reverse-client"})
-  await initial.close()
-
-  const child = spawn(process.execPath, [cli.pathname, "logs", "tail", "--directory", directory, "--follow", "--poll-ms", "10"], {stdio: ["ignore", "pipe", "pipe"]})
-  let stdout = ""
-  let stderr = ""
-  child.stdout.on("data", (chunk) => { stdout += chunk.toString() })
-  child.stderr.on("data", (chunk) => { stderr += chunk.toString() })
-  t.after(() => { if (child.exitCode === null) child.kill("SIGKILL") })
-  await waitFor(() => stdout.includes('"eventSequence":"1"'), child, () => stderr)
-
-  const later = createCompressedJsonlFileLogger({directory, role: "reverse-client"})
-  later.log("runtime.status", {virtualStreams: 2})
-  await later.close()
-  await waitFor(() => stdout.includes('"event":"runtime.status"'), child, () => stderr)
-  child.kill("SIGTERM")
-  const code = await new Promise((resolve) => child.once("exit", resolve))
-  assert.equal(code, 0)
-})
+describe("socketduct logs CLI", () => {
+  it("owned CLI searches and tails durable compressed records with stable exits", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-logs-cli-"))
+    const directory = join(root, "logs")
+    after(() => rm(root, {recursive: true, force: true}))
+    const logger = createCompressedJsonlFileLogger({directory, role: "reverse-hub"})
+    logger.log("process.started", {runtimeMode: "reverse-hub"})
+    logger.log("runtime.status", {virtualStreams: 7})
+    await logger.close()
+
+    const match = await invoke("logs", "search", "--directory", directory, "--event", "runtime.status")
+    expect(match.code).toBe(0)
+    expect(match.stdout.trim().split("\n").map((line) => JSON.parse(line).event)).toEqual(["runtime.status"])
+
+    const absent = await invoke("logs", "search", "--directory", directory, "--event", "transport.failed")
+    expect(absent.code).toBe(1)
+    expect(absent.stdout).toBe("")
+
+    const tail = await invoke("logs", "tail", "--directory", directory)
+    expect(tail.code).toBe(0)
+    expect(tail.stdout.trim().split("\n").map((line) => JSON.parse(line).event)).toEqual(["process.started", "runtime.status", "log_batch_accepted", "log_frame_committed", "log_closed"])
+
+    const invalid = await invoke("logs", "search", "--directory", directory, "--client-generation", "not-a-number")
+    expect(invalid.code).toBe(2)
+    expect(invalid.stderr).toMatch(/Socketduct logs error/)
+  }))
+
+  it("owned CLI follow stays live and emits newly durable writer records", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-logs-follow-"))
+    const directory = join(root, "logs")
+    after(() => rm(root, {recursive: true, force: true}))
+    const initial = createCompressedJsonlFileLogger({directory, role: "reverse-client"})
+    initial.log("process.started", {runtimeMode: "reverse-client"})
+    await initial.close()
+
+    const child = spawn(process.execPath, [cli.pathname, "logs", "tail", "--directory", directory, "--follow", "--poll-ms", "10"], {stdio: ["ignore", "pipe", "pipe"]})
+    let stdout = ""
+    let stderr = ""
+    child.stdout.on("data", (chunk) => { stdout += chunk.toString() })
+    child.stderr.on("data", (chunk) => { stderr += chunk.toString() })
+    after(() => { if (child.exitCode === null) child.kill("SIGKILL") })
+    await waitFor(() => stdout.includes('"eventSequence":"1"'), child, () => stderr)
+
+    const later = createCompressedJsonlFileLogger({directory, role: "reverse-client"})
+    later.log("runtime.status", {virtualStreams: 2})
+    await later.close()
+    await waitFor(() => stdout.includes('"event":"runtime.status"'), child, () => stderr)
+    child.kill("SIGTERM")
+    const code = await new Promise((resolve) => child.once("exit", resolve))
+    expect(code).toBe(0)
+  }))
+
+  it("owned CLI exits 2 instead of hiding corrupt interior evidence", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-logs-corrupt-"))
+    const directory = join(root, "logs")
+    after(() => rm(root, {recursive: true, force: true}))
+    const logger = createCompressedJsonlFileLogger({directory, role: "reverse-gateway"})
+    logger.log("process.started", {runtimeMode: "reverse-gateway"})
+    await logger.close()
+    const name = (await readdir(directory)).find((entry) => entry.endsWith(".jsonl.zst"))
+    expect(name).toBeDefined()
+    const path = join(directory, /** @type {string} */ (name))
+    const bytes = await readFile(path)
+    bytes[bytes.length - 1] = /** @type {number} */ (bytes[bytes.length - 1]) ^ 0xff
+    await writeFile(path, bytes)
+
+    const result = await invoke("logs", "search", "--directory", directory, "--event", "process.started")
+    expect(result.code).toBe(2)
+    expect(result.stdout).toBe("")
+    expect(result.stderr).toMatch(/Socketduct log evidence error/)
+  }))
+
+  it("tail reader incrementally follows rotation and prunes retention-deleted cursors", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-logs-incremental-tail-"))
+    const directory = join(root, "logs")
+    after(() => rm(root, {recursive: true, force: true}))
+    const logger = createCompressedJsonlFileLogger({directory, role: "reverse-hub", frameMaxBytes: 256, maxSegmentBytes: 1024, compressionLevel: 1})
+    await logger.flush()
+    for (let index = 0; index < 8; index += 1) {
+      logger.log("process.started", {runtimeMode: "reverse-hub"})
+      await logger.flush()
+    }
+    await logger.flush()
 
-test("owned CLI exits 2 instead of hiding corrupt interior evidence", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-logs-corrupt-"))
-  const directory = join(root, "logs")
-  t.after(() => rm(root, {recursive: true, force: true}))
-  const logger = createCompressedJsonlFileLogger({directory, role: "reverse-gateway"})
-  logger.log("process.started", {runtimeMode: "reverse-gateway"})
-  await logger.close()
-  const name = (await readdir(directory)).find((entry) => entry.endsWith(".jsonl.zst"))
-  assert(name !== undefined)
-  const path = join(directory, name)
-  const bytes = await readFile(path)
-  bytes[bytes.length - 1] = /** @type {number} */ (bytes[bytes.length - 1]) ^ 0xff
-  await writeFile(path, bytes)
-
-  const result = await invoke("logs", "search", "--directory", directory, "--event", "process.started")
-  assert.equal(result.code, 2)
-  assert.equal(result.stdout, "")
-  assert.match(result.stderr, /Socketduct log evidence error/)
-})
+    const reader = new CompressedLogTailReader(directory)
+    const initial = await reader.poll()
+    expect(initial.records.length > 0).toBeTruthy()
+    const identities = new Set(initial.records.map((record) => `${record.writerEpoch}\0${record.eventSequence}`))
+    expect(identities.size).toBe(initial.records.length)
+    const decoded = reader.status().decodedFrames
+    expect(decoded > 0).toBeTruthy()
+    expect((await reader.poll()).records).toEqual([])
+    expect(reader.status().decodedFrames).toBe(decoded)
 
-test("tail reader incrementally follows rotation and prunes retention-deleted cursors", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-logs-incremental-tail-"))
-  const directory = join(root, "logs")
-  t.after(() => rm(root, {recursive: true, force: true}))
-  const logger = createCompressedJsonlFileLogger({directory, role: "reverse-hub", frameMaxBytes: 256, maxSegmentBytes: 1024, compressionLevel: 1})
-  await logger.flush()
-  for (let index = 0; index < 8; index += 1) {
     logger.log("process.started", {runtimeMode: "reverse-hub"})
     await logger.flush()
-  }
-  await logger.flush()
-
-  const reader = new CompressedLogTailReader(directory)
-  const initial = await reader.poll()
-  assert(initial.records.length > 0)
-  const identities = new Set(initial.records.map((record) => `${record.writerEpoch}\0${record.eventSequence}`))
-  assert.equal(identities.size, initial.records.length)
-  const decoded = reader.status().decodedFrames
-  assert(decoded > 0)
-  assert.deepEqual((await reader.poll()).records, [])
-  assert.equal(reader.status().decodedFrames, decoded)
-
-  logger.log("process.started", {runtimeMode: "reverse-hub"})
-  await logger.flush()
-  await logger.flush()
-  const activeDelta = await reader.poll()
-  assert(activeDelta.records.length > 0)
-  for (const record of activeDelta.records) assert.equal(identities.has(`${record.writerEpoch}\0${record.eventSequence}`), false)
-  await logger.close()
-  const closeDelta = await reader.poll()
-  assert(closeDelta.records.length > 0)
-  for (const record of closeDelta.records) assert.equal(identities.has(`${record.writerEpoch}\0${record.eventSequence}`), false)
-
-  const oldSegments = (await readdir(directory)).filter((name) => name.endsWith(".jsonl.zst"))
-  assert(oldSegments.length > 1, "fixture must rotate through more than one segment")
-  for (const name of oldSegments) await utimes(join(directory, name), new Date(1_000), new Date(1_000))
-  const later = createCompressedJsonlFileLogger({directory, role: "reverse-hub", compressionLevel: 1})
-  later.log("runtime.status", {virtualStreams: 2})
-  await later.close()
-  const laterSegments = (await readdir(directory)).filter((name) => name.endsWith(".jsonl.zst") && !oldSegments.includes(name))
-  for (const name of laterSegments) await utimes(join(directory, name), new Date(10_000), new Date(10_000))
-  const laterDelta = await reader.poll()
-  assert(laterDelta.records.some((record) => record.event === "runtime.status"))
-
-  await enforceLogRetention({directory, maxAgeMs: 5_000, maxBytes: 1_000_000, now: () => new Date(10_000)})
-  const beforePruneDecode = reader.status().decodedFrames
-  assert.deepEqual((await reader.poll()).records, [])
-  const survivingSegments = (await readdir(directory)).filter((name) => name.endsWith(".jsonl.zst")).length
-  assert(reader.status().trackedSegments <= survivingSegments)
-  assert.equal(reader.status().decodedFrames, beforePruneDecode)
+    await logger.flush()
+    const activeDelta = await reader.poll()
+    expect(activeDelta.records.length > 0).toBeTruthy()
+    for (const record of activeDelta.records) expect(identities.has(`${record.writerEpoch}\0${record.eventSequence}`)).toBe(false)
+    await logger.close()
+    const closeDelta = await reader.poll()
+    expect(closeDelta.records.length > 0).toBeTruthy()
+    for (const record of closeDelta.records) expect(identities.has(`${record.writerEpoch}\0${record.eventSequence}`)).toBe(false)
+
+    const oldSegments = (await readdir(directory)).filter((name) => name.endsWith(".jsonl.zst"))
+    // fixture must rotate through more than one segment
+    expect(oldSegments.length > 1).toBeTruthy()
+    for (const name of oldSegments) await utimes(join(directory, name), new Date(1_000), new Date(1_000))
+    const later = createCompressedJsonlFileLogger({directory, role: "reverse-hub", compressionLevel: 1})
+    later.log("runtime.status", {virtualStreams: 2})
+    await later.close()
+    const laterSegments = (await readdir(directory)).filter((name) => name.endsWith(".jsonl.zst") && !oldSegments.includes(name))
+    for (const name of laterSegments) await utimes(join(directory, name), new Date(10_000), new Date(10_000))
+    const laterDelta = await reader.poll()
+    expect(laterDelta.records.some((record) => record.event === "runtime.status")).toBeTruthy()
+
+    await enforceLogRetention({directory, maxAgeMs: 5_000, maxBytes: 1_000_000, now: () => new Date(10_000)})
+    const beforePruneDecode = reader.status().decodedFrames
+    expect((await reader.poll()).records).toEqual([])
+    const survivingSegments = (await readdir(directory)).filter((name) => name.endsWith(".jsonl.zst")).length
+    expect(reader.status().trackedSegments <= survivingSegments).toBeTruthy()
+    expect(reader.status().decodedFrames).toBe(beforePruneDecode)
+  }))
 })
 
 /** @param {...string} args - CLI arguments. */

package/test/integration/logging-compressed-recovery.test.js

@@ -1,10 +1,9 @@
 /* eslint-disable jsdoc/escape-inline-tags, jsdoc/require-param-type, jsdoc/require-returns */
-import assert from "node:assert/strict"
+import {describe, expect, it, withTestCleanup} from "@velocious/testing"
 import {createHash, randomBytes} from "node:crypto"
 import {mkdtemp, readdir, rm, stat, utimes, writeFile} from "node:fs/promises"
 import {tmpdir} from "node:os"
 import {join} from "node:path"
-import test from "node:test"
 
 import {createLogBatchId, inspectLogBatch} from "../../src/logging/log-batch.js"
 import {readCompressedLogDirectory} from "../../src/logging/compressed-log-reader.js"
@@ -13,108 +12,110 @@ import {enforceLogRetention} from "../../src/logging/log-retention.js"
 import {createIndexEntry, createIndexHeader, INDEX_ENTRY_BYTES, INDEX_HEADER_BYTES, uuidBytes} from "../../src/logging/log-segment-index.js"
 import {compressLogFrame} from "../../src/logging/zstd-frame-codec.js"
 
-test("recovery indexes a complete data-synced orphan without duplicating its batch", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-orphan-"))
-  t.after(() => rm(root, {recursive: true, force: true}))
-  const fixture = await createRecoveryFixture(root, false)
-  const sink = new CompressedLogWorkerSink(fixture.options)
-  const recovered = await sink.start()
-  assert.equal(recovered.durableHighWater, "2")
-  assert.equal(recovered.orphanRecoveredCount, 1)
-  assert.equal(recovered.lastDurableBatch?.batchId, fixture.secondBatchId)
-  assert.equal((await stat(fixture.indexPath)).size, INDEX_HEADER_BYTES + 2 * INDEX_ENTRY_BYTES)
+describe("compressed log recovery", () => {
+  it("recovery indexes a complete data-synced orphan without duplicating its batch", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-orphan-"))
+    after(() => rm(root, {recursive: true, force: true}))
+    const fixture = await createRecoveryFixture(root, false)
+    const sink = new CompressedLogWorkerSink(fixture.options)
+    const recovered = await sink.start()
+    expect(recovered.durableHighWater).toBe("2")
+    expect(recovered.orphanRecoveredCount).toBe(1)
+    expect(recovered.lastDurableBatch?.batchId).toBe(fixture.secondBatchId)
+    expect((await stat(fixture.indexPath)).size).toBe(INDEX_HEADER_BYTES + 2 * INDEX_ENTRY_BYTES)
 
-  const duplicate = await sink.appendBatch(fixture.secondMessage)
-  assert.equal(duplicate.duplicate, true)
-  assert.equal((await stat(fixture.dataPath)).size, fixture.firstFrame.length + fixture.secondFrame.length)
-  await sink.close()
-  const result = await readCompressedLogDirectory(root)
-  assert.equal(result.incomplete, false)
-  assert.deepEqual(result.records.map((record) => record.eventSequence), ["1", "2"])
-})
-
-test("recovery truncates only a torn final data frame and accepts its replay", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-torn-"))
-  t.after(() => rm(root, {recursive: true, force: true}))
-  const fixture = await createRecoveryFixture(root, true)
-  const sink = new CompressedLogWorkerSink(fixture.options)
-  const recovered = await sink.start()
-  assert.equal(recovered.durableHighWater, "1")
-  assert.equal((await stat(fixture.dataPath)).size, fixture.firstFrame.length)
-
-  const replayed = await sink.appendBatch(fixture.secondMessage)
-  assert.equal(replayed.duplicate, false)
-  await sink.close()
-  const result = await readCompressedLogDirectory(root)
-  assert.equal(result.incomplete, false)
-  assert.deepEqual(result.records.map((record) => record.eventSequence), ["1", "2"])
-})
-
-test("worker acknowledgements retain only the latest durable batch identity", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-bounded-ack-"))
-  t.after(() => rm(root, {recursive: true, force: true}))
-  const writerEpoch = randomBytes(16)
-  const options = {directory: root, role: "reverse-hub", writerEpoch: writerEpoch.toString("base64url"), maxSegmentBytes: 4096, compressionLevel: 19}
-  const sink = new CompressedLogWorkerSink(options)
-  await sink.start()
-  let latest = await sink.appendBatch(batchMessage(writerEpoch, 1))
-  for (let sequence = 2; sequence <= 40; sequence += 1) latest = await sink.appendBatch(batchMessage(writerEpoch, sequence))
-  assert.equal(Object.hasOwn(latest, "durableBatchIds"), false)
-  assert.deepEqual(latest.lastDurableBatch, {
-    batchId: batchMessage(writerEpoch, 40).batchId,
-    firstSequence: "40",
-    lastSequence: "40"
-  })
-  assert.equal((await sink.appendBatch(batchMessage(writerEpoch, 40))).duplicate, true)
-  await sink.close()
+    const duplicate = await sink.appendBatch(fixture.secondMessage)
+    expect(duplicate.duplicate).toBe(true)
+    expect((await stat(fixture.dataPath)).size).toBe(fixture.firstFrame.length + fixture.secondFrame.length)
+    await sink.close()
+    const result = await readCompressedLogDirectory(root)
+    expect(result.incomplete).toBe(false)
+    expect(result.records.map((record) => record.eventSequence)).toEqual(["1", "2"])
+  }))
 
-  const restarted = new CompressedLogWorkerSink(options)
-  const recovered = await restarted.start()
-  assert.equal(Object.hasOwn(recovered, "durableBatchIds"), false)
-  assert.deepEqual(recovered.lastDurableBatch, latest.lastDurableBatch)
-  await restarted.close()
-})
+  it("recovery truncates only a torn final data frame and accepts its replay", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-torn-"))
+    after(() => rm(root, {recursive: true, force: true}))
+    const fixture = await createRecoveryFixture(root, true)
+    const sink = new CompressedLogWorkerSink(fixture.options)
+    const recovered = await sink.start()
+    expect(recovered.durableHighWater).toBe("1")
+    expect((await stat(fixture.dataPath)).size).toBe(fixture.firstFrame.length)
 
-test("recovery accepts a retention-deleted prefix but rejects interior gaps", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-retained-prefix-"))
-  t.after(() => rm(root, {recursive: true, force: true}))
-  const writerEpoch = randomBytes(16)
-  const options = {directory: root, role: "reverse-hub", writerEpoch: writerEpoch.toString("base64url"), maxSegmentBytes: 4096, compressionLevel: 19, retentionBytes: 1_000_000}
+    const replayed = await sink.appendBatch(fixture.secondMessage)
+    expect(replayed.duplicate).toBe(false)
+    await sink.close()
+    const result = await readCompressedLogDirectory(root)
+    expect(result.incomplete).toBe(false)
+    expect(result.records.map((record) => record.eventSequence)).toEqual(["1", "2"])
+  }))
 
-  const segments = []
-  for (let sequence = 1; sequence <= 3; sequence += 1) {
+  it("worker acknowledgements retain only the latest durable batch identity", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-bounded-ack-"))
+    after(() => rm(root, {recursive: true, force: true}))
+    const writerEpoch = randomBytes(16)
+    const options = {directory: root, role: "reverse-hub", writerEpoch: writerEpoch.toString("base64url"), maxSegmentBytes: 4096, compressionLevel: 19}
     const sink = new CompressedLogWorkerSink(options)
     await sink.start()
-    await sink.appendBatch(batchMessage(writerEpoch, sequence))
-    segments.push(/** @type {string} */ (sink.status().segmentPath))
+    let latest = await sink.appendBatch(batchMessage(writerEpoch, 1))
+    for (let sequence = 2; sequence <= 40; sequence += 1) latest = await sink.appendBatch(batchMessage(writerEpoch, sequence))
+    expect(Object.hasOwn(latest, "durableBatchIds")).toBe(false)
+    expect(latest.lastDurableBatch).toEqual({
+      batchId: batchMessage(writerEpoch, 40).batchId,
+      firstSequence: "40",
+      lastSequence: "40"
+    })
+    expect((await sink.appendBatch(batchMessage(writerEpoch, 40))).duplicate).toBe(true)
     await sink.close()
-  }
-  assert.equal(segments.length, 3)
-  for (let index = 0; index < segments.length; index += 1) {
-    await utimes(/** @type {string} */ (segments[index]), new Date(1_000 + index), new Date(1_000 + index))
-  }
-  await enforceLogRetention({directory: root, maxAgeMs: 1, maxBytes: 1_000_000, now: () => new Date(1_003)})
-  assert.equal((await readdir(root)).filter((name) => name.endsWith(".jsonl.zst")).length, 1)
 
-  const recovered = new CompressedLogWorkerSink(options)
-  assert.equal((await recovered.start()).durableHighWater, "3")
-  assert.equal((await recovered.appendBatch(batchMessage(writerEpoch, 4))).durableHighWater, "4")
-  await recovered.close()
+    const restarted = new CompressedLogWorkerSink(options)
+    const recovered = await restarted.start()
+    expect(Object.hasOwn(recovered, "durableBatchIds")).toBe(false)
+    expect(recovered.lastDurableBatch).toEqual(latest.lastDurableBatch)
+    await restarted.close()
+  }))
 
-  const gapDirectory = join(root, "interior-gap")
-  const gapEpoch = randomBytes(16)
-  const gapOptions = {...options, directory: gapDirectory, writerEpoch: gapEpoch.toString("base64url")}
-  const gapSegments = []
-  for (let sequence = 1; sequence <= 3; sequence += 1) {
-    const sink = new CompressedLogWorkerSink(gapOptions)
-    await sink.start()
-    await sink.appendBatch(batchMessage(gapEpoch, sequence))
-    gapSegments.push(/** @type {string} */ (sink.status().segmentPath))
-    await sink.close()
-  }
-  const missing = /** @type {string} */ (gapSegments[1])
-  await Promise.all([rm(missing), rm(`${missing}.idx`), rm(`${missing}.sealed`)])
-  await assert.rejects(() => new CompressedLogWorkerSink(gapOptions).start(), /interior sequence gap/)
+  it("recovery accepts a retention-deleted prefix but rejects interior gaps", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-compressed-retained-prefix-"))
+    after(() => rm(root, {recursive: true, force: true}))
+    const writerEpoch = randomBytes(16)
+    const options = {directory: root, role: "reverse-hub", writerEpoch: writerEpoch.toString("base64url"), maxSegmentBytes: 4096, compressionLevel: 19, retentionBytes: 1_000_000}
+
+    const segments = []
+    for (let sequence = 1; sequence <= 3; sequence += 1) {
+      const sink = new CompressedLogWorkerSink(options)
+      await sink.start()
+      await sink.appendBatch(batchMessage(writerEpoch, sequence))
+      segments.push(/** @type {string} */ (sink.status().segmentPath))
+      await sink.close()
+    }
+    expect(segments.length).toBe(3)
+    for (let index = 0; index < segments.length; index += 1) {
+      await utimes(/** @type {string} */ (segments[index]), new Date(1_000 + index), new Date(1_000 + index))
+    }
+    await enforceLogRetention({directory: root, maxAgeMs: 1, maxBytes: 1_000_000, now: () => new Date(1_003)})
+    expect((await readdir(root)).filter((name) => name.endsWith(".jsonl.zst")).length).toBe(1)
+
+    const recovered = new CompressedLogWorkerSink(options)
+    expect((await recovered.start()).durableHighWater).toBe("3")
+    expect((await recovered.appendBatch(batchMessage(writerEpoch, 4))).durableHighWater).toBe("4")
+    await recovered.close()
+
+    const gapDirectory = join(root, "interior-gap")
+    const gapEpoch = randomBytes(16)
+    const gapOptions = {...options, directory: gapDirectory, writerEpoch: gapEpoch.toString("base64url")}
+    const gapSegments = []
+    for (let sequence = 1; sequence <= 3; sequence += 1) {
+      const sink = new CompressedLogWorkerSink(gapOptions)
+      await sink.start()
+      await sink.appendBatch(batchMessage(gapEpoch, sequence))
+      gapSegments.push(/** @type {string} */ (sink.status().segmentPath))
+      await sink.close()
+    }
+    const missing = /** @type {string} */ (gapSegments[1])
+    await Promise.all([rm(missing), rm(`${missing}.idx`), rm(`${missing}.sealed`)])
+    await expect(new CompressedLogWorkerSink(gapOptions).start()).rejects.toThrow(/interior sequence gap/)
+  }))
 })
 
 /**