socketduct 0.1.19 → 0.1.21

package/test/e2e/logger-shutdown-process.test.js

@@ -0,0 +1,86 @@
+/* eslint-disable jsdoc/escape-inline-tags, jsdoc/require-param, jsdoc/require-returns */
+import assert from "node:assert/strict"
+import {spawn} from "node:child_process"
+import {mkdtemp, rm} from "node:fs/promises"
+import {createServer} from "node:net"
+import {tmpdir} from "node:os"
+import {join} from "node:path"
+import test from "node:test"
+
+import {readCompressedLogDirectory} from "../../src/logging/compressed-log-reader.js"
+
+const TIMEOUT_MS = 8_000
+
+test("SIGTERM durably flushes queued critical lifecycle records before exit", async (t) => {
+  const root = await mkdtemp(join(tmpdir(), "socketduct-logger-shutdown-"))
+  const directory = join(root, "logs")
+  const port = await reservePort()
+  const child = spawn(process.execPath, ["src/index.js"], {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      SOCKETDUCT_MODE: "relay",
+      SOCKETDUCT_RELAY_HOST: "127.0.0.1",
+      SOCKETDUCT_RELAY_PORT: String(port),
+      SOCKETDUCT_AUTH_TOKENS: "shutdown-test:shutdown-test-token",
+      SOCKETDUCT_TARGET_ALLOWLIST: "127.0.0.1:1",
+      SOCKETDUCT_STATUS_INTERVAL_MS: "0",
+      SOCKETDUCT_LOG_DIRECTORY: directory,
+      SOCKETDUCT_LOG_FLUSH_INTERVAL_MS: "60000",
+      SOCKETDUCT_LOG_CRITICAL_FLUSH_INTERVAL_MS: "60000"
+    },
+    stdio: ["ignore", "pipe", "pipe"]
+  })
+  let output = ""
+  child.stdout.on("data", (chunk) => { output += chunk.toString() })
+  child.stderr.on("data", (chunk) => { output += chunk.toString() })
+  t.after(async () => {
+    if (child.exitCode === null) child.kill("SIGKILL")
+    await rm(root, {recursive: true, force: true})
+  })
+
+  await waitUntil(() => output.includes('"event":"relay.started"'), child, () => output)
+  assert.equal(child.kill("SIGTERM"), true)
+  const exit = await withTimeout(new Promise((resolve) => child.once("exit", (code, signal) => resolve({code, signal}))), "process exit")
+  assert.deepEqual(exit, {code: 0, signal: null})
+
+  const result = await readCompressedLogDirectory(directory)
+  assert.equal(result.incomplete, false)
+  assert.deepEqual(result.records.map((record) => record.event), ["process.started", "process.stopped", "log_batch_accepted", "log_frame_committed", "log_closed"])
+})
+
+/** @returns {Promise<number>} A released loopback port. */
+async function reservePort() {
+  const server = createServer()
+  await new Promise((resolve, reject) => {
+    server.once("error", reject)
+    server.listen(0, "127.0.0.1", () => { server.off("error", reject); resolve(undefined) })
+  })
+  const address = server.address()
+  assert(address !== null && typeof address !== "string")
+  await new Promise((resolve) => server.close(() => resolve(undefined)))
+  return address.port
+}
+
+/** @param {() => boolean} predicate - Completion check. @param {import('node:child_process').ChildProcess} child - Child process. @param {() => string} output - Captured output. */
+async function waitUntil(predicate, child, output) {
+  if (predicate()) return
+  await withTimeout(new Promise((resolve, reject) => {
+    const onData = () => { if (predicate()) { cleanup(); resolve(undefined) } }
+    const onExit = (/** @type {number | null} */ code) => { cleanup(); reject(new Error(`process exited ${code}: ${output()}`)) }
+    const cleanup = () => { child.stdout?.off("data", onData); child.stderr?.off("data", onData); child.off("exit", onExit) }
+    child.stdout?.on("data", onData)
+    child.stderr?.on("data", onData)
+    child.once("exit", onExit)
+  }), "process startup")
+}
+
+/** @template T @param {Promise<T>} promise - Work. @param {string} label - Timeout label. @returns {Promise<T>} Result. */
+async function withTimeout(promise, label) {
+  let timer
+  try {
+    return await Promise.race([promise, new Promise((_, reject) => { timer = setTimeout(() => reject(new Error(`Timed out: ${label}`)), TIMEOUT_MS) })])
+  } finally {
+    if (timer !== undefined) clearTimeout(timer)
+  }
+}

package/test/e2e/reverse-client-recovery-process.test.js

@@ -154,6 +154,9 @@ test("SIGKILLed reverse client process recovers its durable stream while hub gat
   assert.equal(recovered.openFrames, 0)
   assert(/** @type {number} */ (recovered.generation) > /** @type {number} */ (connected.generation))
   assert.equal(targetAccepts, 1)
+  replacement.child.send({type: "acknowledge", bytes: replayedTargetBytes.length})
+  const acknowledged = await waitForMessage(replacement, "acknowledged")
+  assert.equal(acknowledged.sequence, replayedTargetBytes.length)
   await waitUntil(() => Buffer.concat(targetReceived).toString() === "before-killduring-kill", "replay strictly above gateway high-water")
 
   replacement.child.send({type: "write", payload: Buffer.from("after-kill").toString("base64")})

package/test/e2e/reverse-gateway-process.test.js

@@ -1,7 +1,7 @@
 /* eslint-disable jsdoc/escape-inline-tags, jsdoc/require-param, jsdoc/require-returns */
 import assert from "node:assert/strict"
 import {spawn} from "node:child_process"
-import {mkdtemp, readFile, readdir, rm} from "node:fs/promises"
+import {mkdtemp, rm} from "node:fs/promises"
 import {createServer} from "node:net"
 import {tmpdir} from "node:os"
 import {join} from "node:path"
@@ -9,10 +9,12 @@ import test from "node:test"
 import {connect as connectTls} from "node:tls"
 
 import {ReverseGatewayConnection} from "../../src/reverse/client.js"
+import {readCompressedLogDirectory} from "../../src/logging/compressed-log-reader.js"
 import {generateTestCertificates} from "../helpers/tls-certificates.js"
 
 const PROCESS_TIMEOUT_MS = 8_000
 const PROCESS_LISTEN_ATTEMPTS = 3
+const TEST_FINGERPRINT_KEY = Buffer.alloc(32, 0x5a).toString("base64url")
 
 /** A child exit observed before its expected startup event. */
 class ProcessStartupExitError extends Error {
@@ -234,8 +236,9 @@ test("spawned reverse hub and outbound gateway expose an allowlisted Docker stre
     SOCKETDUCT_REVERSE_ROUTES: `tensorbuzz:o2:127.0.0.1:${targetPort}`,
     SOCKETDUCT_STATUS_INTERVAL_MS: "0",
     SOCKETDUCT_LOG_DIRECTORY: logDirectory,
-    SOCKETDUCT_LOG_MAX_FILE_BYTES: "4096",
-    SOCKETDUCT_LOG_MAX_FILES: "2"
+    SOCKETDUCT_LOG_SEGMENT_MAX_BYTES: "4096",
+    SOCKETDUCT_CONNECTION_FINGERPRINT_KEY: TEST_FINGERPRINT_KEY,
+    SOCKETDUCT_CONNECTION_FINGERPRINT_KEY_EPOCH: "process-test"
   }, "reverse-hub.started")
   t.after(() => stopProcess(hub))
   const gateway = await startProcess({
@@ -250,8 +253,7 @@ test("spawned reverse hub and outbound gateway expose an allowlisted Docker stre
     SOCKETDUCT_TARGET_ALLOWLIST: `127.0.0.1:${targetPort}`,
     SOCKETDUCT_STATUS_INTERVAL_MS: "0",
     SOCKETDUCT_LOG_DIRECTORY: logDirectory,
-    SOCKETDUCT_LOG_MAX_FILE_BYTES: "4096",
-    SOCKETDUCT_LOG_MAX_FILES: "2"
+    SOCKETDUCT_LOG_SEGMENT_MAX_BYTES: "4096"
   }, "reverse-gateway.started")
   t.after(() => stopProcess(gateway))
 
@@ -270,19 +272,18 @@ test("spawned reverse hub and outbound gateway expose an allowlisted Docker stre
   assert.equal(Buffer.from(/** @type {Uint8Array} */ (await withTimeout(response, "process response"))).toString(), "docker:GET /version")
   assert.equal(client.status().compression, "zstd")
   socket.destroy()
+  client.close()
+  await stopProcess(gateway)
+  await stopProcess(hub)
 
-  assert(hub.pid !== undefined)
-  assert(gateway.pid !== undefined)
-  const files = (await readdir(logDirectory)).sort()
-  assert(files.includes(`reverse-hub-${hub.pid}.jsonl`))
-  assert(files.includes(`reverse-gateway-${gateway.pid}.jsonl`))
-  const hubEntries = (await readFile(join(logDirectory, `reverse-hub-${hub.pid}.jsonl`), "utf8")).trim().split("\n").map((line) => JSON.parse(line))
-  const gatewayContents = await readFile(join(logDirectory, `reverse-gateway-${gateway.pid}.jsonl`), "utf8")
-  const gatewayEntries = gatewayContents.trim().split("\n").map((line) => JSON.parse(line))
+  const logs = await readCompressedLogDirectory(logDirectory)
+  assert.equal(logs.incomplete, false)
+  const hubEntries = logs.records.filter(({role}) => role === "reverse-hub")
+  const gatewayEntries = logs.records.filter(({role}) => role === "reverse-gateway")
   assert(hubEntries.some(({event}) => event === "process.started"))
   assert(gatewayEntries.some(({event}) => event === "process.started"))
   assert(gatewayEntries.some(({event}) => event === "transport.connected"))
-  assert.doesNotMatch(gatewayContents, /process-gateway-token|127\.0\.0\.1|docker-server/)
+  assert.doesNotMatch(JSON.stringify(logs.records), /process-gateway-token|127\.0\.0\.1|docker-server|process_home_o2_gateway/)
 })
 
 test("one route-class client physical connection interleaves streams through different gateway processes", async (t) => {

package/test/fixtures/reverse-client-recovery.mjs

@@ -37,6 +37,7 @@ const client = new ReverseGatewayConnection({
 
 const streamOptions = {
   recover: true,
+  manualReceiveAck: true,
   identifier: configuration.identifier,
   sessionName: configuration.sessionName,
   host: "127.0.0.1",
@@ -74,7 +75,8 @@ if (activeSocket !== undefined) {
     identifier: configuration.identifier,
     sessionName: configuration.sessionName,
     host: "127.0.0.1",
-    port: configuration.targetPort
+    port: configuration.targetPort,
+    manualReceiveAck: true
   })
   installSocketEvents(activeSocket)
 }
@@ -86,7 +88,17 @@ process.on("message", (message) => {
     return
   }
   if (message?.type === "write") {
-    activeSocket.write(Buffer.from(message.payload, "base64"), (error) => report("written", {code: error?.code ?? null}))
+    void activeSocket.writeDurable(Buffer.from(message.payload, "base64")).then(
+      () => report("written", {code: null}),
+      (error) => report("written", {code: error?.code ?? "ERROR"})
+    )
+    return
+  }
+  if (message?.type === "acknowledge") {
+    void activeSocket.acknowledgeReceive(message.bytes).then(
+      (sequence) => report("acknowledged", {sequence}),
+      (error) => report("acknowledge-error", {code: error?.code ?? "ERROR"})
+    )
     return
   }
   if (message?.type === "observe-buffer") {

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

@@ -0,0 +1,168 @@
+/* eslint-disable jsdoc/escape-inline-tags, jsdoc/require-param, jsdoc/require-returns */
+import assert from "node:assert/strict"
+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"
+import {CompressedLogTailReader} from "../../src/logging/compressed-log-reader.js"
+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)
+})
+
+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/)
+})
+
+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)
+})
+
+/** @param {...string} args - CLI arguments. */
+async function invoke(...args) {
+  try {
+    const result = await run(process.execPath, [cli.pathname, ...args])
+    return {code: 0, stdout: result.stdout, stderr: result.stderr}
+  } catch (error) {
+    if (error === null || typeof error !== "object") throw error
+    return {
+      code: /** @type {{code?: number}} */ (error).code,
+      stdout: /** @type {{stdout?: string}} */ (error).stdout ?? "",
+      stderr: /** @type {{stderr?: string}} */ (error).stderr ?? ""
+    }
+  }
+}
+
+/** @param {() => boolean} predicate - Completion check. @param {import('node:child_process').ChildProcess} child - CLI process. @param {() => string} stderr - Error output. */
+async function waitFor(predicate, child, stderr) {
+  if (predicate()) return
+  /** @type {ReturnType<typeof setTimeout> | undefined} */
+  let timer
+  await new Promise((resolve, reject) => {
+    const cleanup = () => { if (timer !== undefined) clearTimeout(timer); child.stdout?.off("data", onData); child.off("exit", onExit) }
+    const onData = () => { if (predicate()) { cleanup(); resolve(undefined) } }
+    const onExit = (/** @type {number | null} */ code) => { cleanup(); reject(new Error(`CLI exited ${code}: ${stderr()}`)) }
+    timer = setTimeout(() => { cleanup(); reject(new Error(`Timed out waiting for CLI output: ${stderr()}`)) }, 5_000)
+    child.stdout?.on("data", onData)
+    child.once("exit", onExit)
+  })
+}

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

@@ -0,0 +1,186 @@
+/* eslint-disable jsdoc/escape-inline-tags, jsdoc/require-param-type, jsdoc/require-returns */
+import assert from "node:assert/strict"
+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"
+import {CompressedLogWorkerSink} from "../../src/logging/compressed-log-worker.js"
+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)
+
+  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 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()
+})
+
+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 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()
+  }
+  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 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/)
+})
+
+/**
+ * @param {string} directory - Fixture directory. @param {boolean} torn - Whether to tear the orphan frame.
+ * @param torn
+ */
+async function createRecoveryFixture(directory, torn) {
+  const writerEpoch = randomBytes(16)
+  const writerEpochText = writerEpoch.toString("base64url")
+  const segmentUuidText = "123e4567-e89b-42d3-a456-426614174000"
+  const segmentUuid = uuidBytes(segmentUuidText)
+  const stem = `reverse-hub-${writerEpochText}-${segmentUuidText}.jsonl.zst`
+  const dataPath = join(directory, stem)
+  const indexPath = `${dataPath}.idx`
+  const firstRaw = record(writerEpochText, 1, "process.started")
+  const secondRaw = record(writerEpochText, 2, "runtime.status")
+  const firstFrame = await compressLogFrame(firstRaw)
+  const secondFrame = await compressLogFrame(secondRaw)
+  const first = inspectLogBatch(firstRaw, writerEpoch)
+  const firstEntry = createIndexEntry({
+    segmentUuid,
+    writerEpoch,
+    batchId: first.batchId,
+    firstSequence: first.firstSequence,
+    lastSequence: first.lastSequence,
+    dataOffset: 0n,
+    compressedLength: BigInt(firstFrame.length),
+    uncompressedLength: BigInt(firstRaw.length),
+    recordCount: 1,
+    minTimestamp: first.minTimestamp,
+    maxTimestamp: first.maxTimestamp,
+    frameSha256: createHash("sha256").update(firstFrame).digest()
+  })
+  await writeFile(dataPath, Buffer.concat([firstFrame, torn ? secondFrame.subarray(0, secondFrame.length - 3) : secondFrame]), {mode: 0o600})
+  await writeFile(indexPath, Buffer.concat([createIndexHeader({segmentUuid, writerEpoch}), firstEntry]), {mode: 0o600})
+  const secondBatchId = createLogBatchId(writerEpoch, 2n, 2n, secondRaw).toString("base64url")
+  return {
+    options: {directory, role: "reverse-hub", writerEpoch: writerEpochText, maxSegmentBytes: 4096, compressionLevel: 19},
+    dataPath,
+    indexPath,
+    firstFrame,
+    secondFrame,
+    secondBatchId,
+    secondMessage: {batchId: secondBatchId, firstSequence: "2", lastSequence: "2", jsonl: secondRaw}
+  }
+}
+
+/**
+ * @param {string} writerEpoch - Epoch. @param {number} sequence - Event sequence. @param {string} event - Event name.
+ * @param sequence
+ * @param event
+ */
+function record(writerEpoch, sequence, event) {
+  return Buffer.from(`${JSON.stringify({timestamp: new Date(1_795_000_000_000 + sequence).toISOString(), event, processId: 1, role: "reverse-hub", writerEpoch, eventSequence: String(sequence)})}\n`)
+}
+
+/**
+ * @param {Buffer} writerEpoch - Epoch.
+ * @param {number} sequence - Event sequence.
+ */
+function batchMessage(writerEpoch, sequence) {
+  const jsonl = record(writerEpoch.toString("base64url"), sequence, "runtime.status")
+  return {
+    batchId: createLogBatchId(writerEpoch, BigInt(sequence), BigInt(sequence), jsonl).toString("base64url"),
+    firstSequence: String(sequence),
+    lastSequence: String(sequence),
+    jsonl
+  }
+}

package/test/integration/multiplexed-transport-set.test.js

@@ -431,11 +431,7 @@ test("process replacement recovers a durable stream on its original named gatewa
   t.after(() => { SessionSpool.prototype.readChunksAfter = originalReadChunksAfter })
   replacement = new MultiplexedSocketductTransportSet(setOptions)
   const recovered = replacement.recoverConnection({
-    gatewayId: "starlink",
-    host: "127.0.0.1",
-    port: targetPort,
-    identifier: "gateway_bound_stream_01",
-    sessionName: "gateway-bound"
+    identifier: "gateway_bound_stream_01"
   })
   await recoveryRead
   await new Promise((resolve) => setImmediate(resolve))