socketduct 0.1.25 → 0.1.26

package/test/unit/spool/spool-file.test.js

@@ -1,8 +1,7 @@
-import assert from "node:assert/strict"
+import {describe, expect, it} from "@velocious/testing"
 import {access, mkdtemp, readFile, rm, stat, writeFile} from "node:fs/promises"
 import {tmpdir} from "node:os"
 import {join} from "node:path"
-import test from "node:test"
 
 import {
   SessionSpool,
@@ -23,464 +22,481 @@ async function withTempDir(fn) {
   }
 }
 
-test("SessionSpool creates private per-session temp storage with metadata", async () => {
-  await withTempDir(async (root) => {
-    const spool = new SessionSpool({rootDir: root})
-    const session = await spool.create({sessionId: "session_1234567890", ownerId: "user-1"})
-    const mode = (await stat(session.directory)).mode & 0o777
+describe("session spool", () => {
+  it("SessionSpool creates private per-session temp storage with metadata", async () => {
+    await withTempDir(async (root) => {
+      const spool = new SessionSpool({rootDir: root})
+      const session = await spool.create({sessionId: "session_1234567890", ownerId: "user-1"})
+      const mode = (await stat(session.directory)).mode & 0o777
 
-    assert.equal(mode, 0o700)
-    assert.equal(session.metadata.sessionId, "session_1234567890")
-    assert.equal(session.metadata.ownerId, "user-1")
+      expect(mode).toBe(0o700)
+      expect(session.metadata.sessionId).toBe("session_1234567890")
+      expect(session.metadata.ownerId).toBe("user-1")
+    })
   })
-})
-
-test("SessionSpool writes chunks and reads only chunks after a requested sequence", async () => {
-  await withTempDir(async (root) => {
-    const spool = new SessionSpool({rootDir: root})
-    await spool.create({sessionId: "session_1234567890", ownerId: "user-1"})
-    await spool.appendChunk({sessionId: "session_1234567890", sequence: 1, data: Buffer.from("one")})
-    await spool.appendChunk({sessionId: "session_1234567890", sequence: 2, data: Buffer.from([0, 255])})
-    await spool.appendChunk({sessionId: "session_1234567890", sequence: 3, data: Buffer.from("three")})
 
-    const chunks = await spool.readChunksAfter("session_1234567890", 1)
-
-    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [2, 3])
-    assert.deepEqual(chunks[0]?.data, Buffer.from([0, 255]))
-    assert.equal(chunks[1]?.data.toString("utf8"), "three")
+  it("SessionSpool writes chunks and reads only chunks after a requested sequence", async () => {
+    await withTempDir(async (root) => {
+      const spool = new SessionSpool({rootDir: root})
+      await spool.create({sessionId: "session_1234567890", ownerId: "user-1"})
+      await spool.appendChunk({sessionId: "session_1234567890", sequence: 1, data: Buffer.from("one")})
+      await spool.appendChunk({sessionId: "session_1234567890", sequence: 2, data: Buffer.from([0, 255])})
+      await spool.appendChunk({sessionId: "session_1234567890", sequence: 3, data: Buffer.from("three")})
+
+      const chunks = await spool.readChunksAfter("session_1234567890", 1)
+
+      expect(chunks.map((chunk) => chunk.sequence)).toEqual([2, 3])
+      const firstData = chunks[0]?.data
+      if (firstData === undefined) throw new Error("Expected a chunk after sequence 1")
+      expect(firstData.equals(Buffer.from([0, 255]))).toBe(true)
+      expect(chunks[1]?.data.toString("utf8")).toBe("three")
+    })
   })
-})
 
-test("SessionSpool truncates acknowledged chunks", async () => {
-  await withTempDir(async (root) => {
-    const spool = new SessionSpool({rootDir: root})
-    await spool.create({sessionId: "session_1234567890", ownerId: "user-1"})
-    await spool.appendChunk({sessionId: "session_1234567890", sequence: 1, data: Buffer.from("one")})
-    await spool.appendChunk({sessionId: "session_1234567890", sequence: 2, data: Buffer.from("two")})
-    await spool.truncateAcked("session_1234567890", 1)
+  it("SessionSpool truncates acknowledged chunks", async () => {
+    await withTempDir(async (root) => {
+      const spool = new SessionSpool({rootDir: root})
+      await spool.create({sessionId: "session_1234567890", ownerId: "user-1"})
+      await spool.appendChunk({sessionId: "session_1234567890", sequence: 1, data: Buffer.from("one")})
+      await spool.appendChunk({sessionId: "session_1234567890", sequence: 2, data: Buffer.from("two")})
+      await spool.truncateAcked("session_1234567890", 1)
 
-    assert.deepEqual((await spool.readChunksAfter("session_1234567890", 0)).map((chunk) => chunk.sequence), [2])
+      expect((await spool.readChunksAfter("session_1234567890", 0)).map((chunk) => chunk.sequence)).toEqual([2])
+    })
   })
-})
-
-test("SessionSpool truncates an acknowledgement inside a chunk in application bytes", async () => {
-  await withTempDir(async (root) => {
-    const spool = new SessionSpool({rootDir: root})
-    const sessionId = "session_partial_ack"
-    await spool.create({sessionId, ownerId: "user-1"})
-    await spool.appendChunk({sessionId, sequence: 8, data: Buffer.from("abcdefgh")})
 
-    await spool.truncateAcked(sessionId, 3)
-
-    const chunks = await spool.readChunksAfter(sessionId, 3)
-    assert.deepEqual(chunks, [{sequence: 8, data: Buffer.from("defgh")}])
-    assert.equal(spool.getUsedBytes(sessionId), 5)
+  it("SessionSpool truncates an acknowledgement inside a chunk in application bytes", async () => {
+    await withTempDir(async (root) => {
+      const spool = new SessionSpool({rootDir: root})
+      const sessionId = "session_partial_ack"
+      await spool.create({sessionId, ownerId: "user-1"})
+      await spool.appendChunk({sessionId, sequence: 8, data: Buffer.from("abcdefgh")})
+
+      await spool.truncateAcked(sessionId, 3)
+
+      const chunks = await spool.readChunksAfter(sessionId, 3)
+      expect(chunks.map((chunk) => chunk.sequence)).toEqual([8])
+      const data = chunks[0]?.data
+      if (data === undefined) throw new Error("Expected a partially truncated chunk")
+      expect(data.equals(Buffer.from("defgh"))).toBe(true)
+      expect(spool.getUsedBytes(sessionId)).toBe(5)
+    })
   })
-})
 
-test("SessionSpool atomically admits a complete chunk batch before recovery commit", async () => {
-  await withTempDir(async (root) => {
-    const spool = new SessionSpool({rootDir: root, maxBytes: 32})
-    const sessionId = "session_durable_batch"
-    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
-    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 4, data: Buffer.from("base")})
-    await spool.writeRecoveryState(sessionId, {version: 3, sendSequence: 4})
-
-    await spool.appendChunksAndRecoveryState({
-      sessionId,
-      ownerId: "reverse-client-v3",
-      previousSequence: 4,
-      chunks: [
-        {sequence: 7, data: Buffer.from("one")},
-        {sequence: 10, data: Buffer.from("two")}
-      ],
-      recoveryState: {version: 3, sendSequence: 10}
+  it("SessionSpool atomically admits a complete chunk batch before recovery commit", async () => {
+    await withTempDir(async (root) => {
+      const spool = new SessionSpool({rootDir: root, maxBytes: 32})
+      const sessionId = "session_durable_batch"
+      await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+      await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 4, data: Buffer.from("base")})
+      await spool.writeRecoveryState(sessionId, {version: 3, sendSequence: 4})
+
+      await spool.appendChunksAndRecoveryState({
+        sessionId,
+        ownerId: "reverse-client-v3",
+        previousSequence: 4,
+        chunks: [
+          {sequence: 7, data: Buffer.from("one")},
+          {sequence: 10, data: Buffer.from("two")}
+        ],
+        recoveryState: {version: 3, sendSequence: 10}
+      })
+
+      expect((await spool.readChunksAfter(sessionId, 0)).map(({sequence, data}) => [sequence, data.toString()])).toEqual([
+        [4, "base"],
+        [7, "one"],
+        [10, "two"]
+      ])
+      expect(spool.readRecoveryStateSync(sessionId, "reverse-client-v3")).toEqual({version: 3, sendSequence: 10})
+      expect(spool.getUsedBytes(sessionId)).toBe(10)
     })
-
-    assert.deepEqual((await spool.readChunksAfter(sessionId, 0)).map(({sequence, data}) => [sequence, data.toString()]), [
-      [4, "base"],
-      [7, "one"],
-      [10, "two"]
-    ])
-    assert.deepEqual(spool.readRecoveryStateSync(sessionId, "reverse-client-v3"), {version: 3, sendSequence: 10})
-    assert.equal(spool.getUsedBytes(sessionId), 10)
   })
-})
 
-test("SessionSpool recovery lookup distinguishes missing state from invalid state", async () => {
-  await withTempDir(async (root) => {
-    const spool = new SessionSpool({rootDir: root})
-    assert.equal(spool.findRecoveryStateSync("missing_session", "edge-v3"), undefined)
+  it("SessionSpool recovery lookup distinguishes missing state from invalid state", async () => {
+    await withTempDir(async (root) => {
+      const spool = new SessionSpool({rootDir: root})
+      expect(spool.findRecoveryStateSync("missing_session", "edge-v3")).toBeUndefined()
 
-    await spool.createNew({sessionId: "present_session", ownerId: "edge-v3"})
-    await spool.writeRecoveryState("present_session", {version: 3})
-    assert.deepEqual(spool.findRecoveryStateSync("present_session", "edge-v3"), {version: 3})
+      await spool.createNew({sessionId: "present_session", ownerId: "edge-v3"})
+      await spool.writeRecoveryState("present_session", {version: 3})
+      expect(spool.findRecoveryStateSync("present_session", "edge-v3")).toEqual({version: 3})
 
-    await writeFile(join(root, "present_session", "recovery.json"), "{invalid\n")
-    assert.throws(() => spool.findRecoveryStateSync("present_session", "edge-v3"), /Invalid Socketduct recovery state/)
+      await writeFile(join(root, "present_session", "recovery.json"), "{invalid\n")
+      expect(() => spool.findRecoveryStateSync("present_session", "edge-v3")).toThrow(/Invalid Socketduct recovery state/)
+    })
   })
-})
 
-test("SessionSpool rejects path traversal and mismatched metadata", async () => {
-  await withTempDir(async (root) => {
-    const spool = new SessionSpool({rootDir: root})
+  it("SessionSpool rejects path traversal and mismatched metadata", async () => {
+    await withTempDir(async (root) => {
+      const spool = new SessionSpool({rootDir: root})
 
-    await assert.rejects(
-      spool.create({sessionId: "../escape", ownerId: "user-1"}),
-      /invalid session identifier/i
-    )
+      await expect(
+        spool.create({sessionId: "../escape", ownerId: "user-1"})
+      ).rejects.toThrow(/invalid session identifier/i)
 
-    await spool.create({sessionId: "session_1234567890", ownerId: "user-1"})
-    await assert.rejects(
-      spool.appendChunk({sessionId: "session_1234567890", ownerId: "other-user", sequence: 1, data: Buffer.from("nope")}),
-      /does not match spool metadata/i
-    )
+      await spool.create({sessionId: "session_1234567890", ownerId: "user-1"})
+      await expect(
+        spool.appendChunk({sessionId: "session_1234567890", ownerId: "other-user", sequence: 1, data: Buffer.from("nope")})
+      ).rejects.toThrow(/does not match spool metadata/i)
+    })
   })
-})
 
-test("SessionSpool.remove removes all session spool data and rejects subsequent operations", async () => {
-  await withTempDir(async (root) => {
-    const spool = new SessionSpool({rootDir: root})
-    const sessionId = "session_1234567890"
-    await spool.create({sessionId, ownerId: "user-1"})
-    await spool.appendChunk({sessionId, sequence: 1, data: Buffer.from("hello")})
+  it("SessionSpool.remove removes all session spool data and rejects subsequent operations", async () => {
+    await withTempDir(async (root) => {
+      const spool = new SessionSpool({rootDir: root})
+      const sessionId = "session_1234567890"
+      await spool.create({sessionId, ownerId: "user-1"})
+      await spool.appendChunk({sessionId, sequence: 1, data: Buffer.from("hello")})
 
-    const dir = join(root, sessionId)
-    await access(dir)
+      const dir = join(root, sessionId)
+      await access(dir)
 
-    await spool.remove(sessionId)
+      await spool.remove(sessionId)
 
-    await assert.rejects(
-      access(dir),
-      /ENOENT|no such file/i
-    )
+      await expect(
+        access(dir)
+      ).rejects.toThrow(/ENOENT|no such file/i)
 
-    await assert.rejects(
-      spool.readChunksAfter(sessionId, 0),
-      /ENOENT|no such file/i
-    )
+      await expect(
+        spool.readChunksAfter(sessionId, 0)
+      ).rejects.toThrow(/ENOENT|no such file/i)
+    })
   })
-})
 
-test("SessionSpool.remove is safe when session does not exist", async () => {
-  await withTempDir(async (root) => {
-    const spool = new SessionSpool({rootDir: root})
+  it("SessionSpool.remove is safe when session does not exist", async () => {
+    await withTempDir(async (root) => {
+      const spool = new SessionSpool({rootDir: root})
 
-    // does not throw
-    await spool.remove("nonexistent_session")
+      // does not throw
+      await spool.remove("nonexistent_session")
+    })
   })
-})
 
-test("SessionSpool enforces maxBytes quota on appendChunk", async () => {
-  await withTempDir(async (root) => {
-    const spool = new SessionSpool({rootDir: root, maxBytes: 100})
-    const sessionId = "session_1234567890"
-    await spool.create({sessionId, ownerId: "user-1"})
-
-    await spool.appendChunk({sessionId, sequence: 1, data: Buffer.alloc(50)})
-    await spool.appendChunk({sessionId, sequence: 2, data: Buffer.alloc(40)})
-
-    await assert.rejects(
-      spool.appendChunk({sessionId, sequence: 3, data: Buffer.alloc(30)}),
-      (err) => {
-        if (!(err instanceof SpoolQuotaError)) {
-          return false
-        }
-        assert.equal(err.code, "SPOOL_QUOTA_EXCEEDED")
-        assert.ok(err.message.includes("100"))
-        return true
+  it("SessionSpool enforces maxBytes quota on appendChunk", async () => {
+    await withTempDir(async (root) => {
+      const spool = new SessionSpool({rootDir: root, maxBytes: 100})
+      const sessionId = "session_1234567890"
+      await spool.create({sessionId, ownerId: "user-1"})
+
+      await spool.appendChunk({sessionId, sequence: 1, data: Buffer.alloc(50)})
+      await spool.appendChunk({sessionId, sequence: 2, data: Buffer.alloc(40)})
+
+      let error
+      try {
+        await spool.appendChunk({sessionId, sequence: 3, data: Buffer.alloc(30)})
+      } catch (caught) {
+        error = caught
       }
-    )
+      expect(error).toBeDefined()
+      expect(error instanceof SpoolQuotaError).toBe(true)
+      if (!(error instanceof SpoolQuotaError)) throw new Error("Expected a SpoolQuotaError")
+      expect(error.code).toBe("SPOOL_QUOTA_EXCEEDED")
+      expect(error.message.includes("100")).toBe(true)
+    })
   })
-})
 
-test("SessionSpool maxBytes quota does not block under-limit appends", async () => {
-  await withTempDir(async (root) => {
-    const spool = new SessionSpool({rootDir: root, maxBytes: 200})
-    const sessionId = "session_1234567890"
-    await spool.create({sessionId, ownerId: "user-1"})
+  it("SessionSpool maxBytes quota does not block under-limit appends", async () => {
+    await withTempDir(async (root) => {
+      const spool = new SessionSpool({rootDir: root, maxBytes: 200})
+      const sessionId = "session_1234567890"
+      await spool.create({sessionId, ownerId: "user-1"})
 
-    // exactly at limit
-    await spool.appendChunk({sessionId, sequence: 1, data: Buffer.alloc(200)})
+      // exactly at limit
+      await spool.appendChunk({sessionId, sequence: 1, data: Buffer.alloc(200)})
 
-    const chunks = await spool.readChunksAfter(sessionId, 0)
-    assert.equal(chunks.length, 1)
+      const chunks = await spool.readChunksAfter(sessionId, 0)
+      expect(chunks.length).toBe(1)
+    })
   })
-})
 
-test("SessionSpool enforces maxAgeMs quota for aged-out sessions", async () => {
-  await withTempDir(async (root) => {
-    let now = 1_000_000
-    const maxAgeMs = 60_000
-    const spool = new SessionSpool({rootDir: root, maxAgeMs, now: () => now})
-
-    const session = await spool.create({sessionId: "session_1234567890", ownerId: "user-1"})
-
-    now = 1_000_000 + maxAgeMs - 1
-    await spool.appendChunk({sessionId: session.metadata.sessionId, sequence: 1, data: Buffer.from("ok")})
-
-    now = 1_000_000 + maxAgeMs + 1
-    await assert.rejects(
-      spool.appendChunk({sessionId: session.metadata.sessionId, sequence: 2, data: Buffer.from("x")}),
-      (err) => {
-        if (!(err instanceof SpoolQuotaError)) {
-          return false
-        }
-        assert.equal(err.code, "SPOOL_AGE_EXCEEDED")
-        return true
+  it("SessionSpool enforces maxAgeMs quota for aged-out sessions", async () => {
+    await withTempDir(async (root) => {
+      let now = 1_000_000
+      const maxAgeMs = 60_000
+      const spool = new SessionSpool({rootDir: root, maxAgeMs, now: () => now})
+
+      const session = await spool.create({sessionId: "session_1234567890", ownerId: "user-1"})
+
+      now = 1_000_000 + maxAgeMs - 1
+      await spool.appendChunk({sessionId: session.metadata.sessionId, sequence: 1, data: Buffer.from("ok")})
+
+      now = 1_000_000 + maxAgeMs + 1
+      let error
+      try {
+        await spool.appendChunk({sessionId: session.metadata.sessionId, sequence: 2, data: Buffer.from("x")})
+      } catch (caught) {
+        error = caught
       }
-    )
+      expect(error).toBeDefined()
+      expect(error instanceof SpoolQuotaError).toBe(true)
+      if (!(error instanceof SpoolQuotaError)) throw new Error("Expected a SpoolQuotaError")
+      expect(error.code).toBe("SPOOL_AGE_EXCEEDED")
+    })
   })
-})
 
-test("SessionSpool synchronously rejects expired durable recovery state", async () => {
-  await withTempDir(async (root) => {
-    let now = 1_000_000
-    const spool = new SessionSpool({rootDir: root, maxAgeMs: 60_000, now: () => now})
-    const sessionId = "session_recovery_expired"
-    await spool.createNew({sessionId, ownerId: "edge-v3"})
-    await spool.writeRecoveryState(sessionId, {version: 3})
-
-    now += 60_001
-    assert.throws(
-      () => spool.readRecoveryStateSync(sessionId, "edge-v3"),
-      (error) => error instanceof SpoolQuotaError && error.code === "SPOOL_AGE_EXCEEDED"
-    )
+  it("SessionSpool synchronously rejects expired durable recovery state", async () => {
+    await withTempDir(async (root) => {
+      let now = 1_000_000
+      const spool = new SessionSpool({rootDir: root, maxAgeMs: 60_000, now: () => now})
+      const sessionId = "session_recovery_expired"
+      await spool.createNew({sessionId, ownerId: "edge-v3"})
+      await spool.writeRecoveryState(sessionId, {version: 3})
+
+      now += 60_001
+      let error
+      try {
+        spool.readRecoveryStateSync(sessionId, "edge-v3")
+      } catch (caught) {
+        error = caught
+      }
+      expect(error).toBeDefined()
+      expect(error instanceof SpoolQuotaError).toBe(true)
+      if (!(error instanceof SpoolQuotaError)) throw new Error("Expected a SpoolQuotaError")
+      expect(error.code).toBe("SPOOL_AGE_EXCEEDED")
+    })
   })
-})
 
-test("SessionSpool loadChunksSync restores only unacknowledged owned chunks", async () => {
-  await withTempDir(async (root) => {
-    const sessionId = "session_recovery_chunks"
-    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
-    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
-    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("old")})
-    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("new")})
-
-    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 3, 6)
-
-    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [6])
-    assert.equal(chunks[0]?.data.toString(), "new")
-    assert.equal(spool.getUsedBytes(sessionId), 3)
-    assert.throws(
-      () => spool.loadChunksSync(sessionId, "other-owner", 3, 6),
-      /Invalid Socketduct recovery chunks/
-    )
+  it("SessionSpool loadChunksSync restores only unacknowledged owned chunks", async () => {
+    await withTempDir(async (root) => {
+      const sessionId = "session_recovery_chunks"
+      const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+      await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+      await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("old")})
+      await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("new")})
+
+      const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 3, 6)
+
+      expect(chunks.map((chunk) => chunk.sequence)).toEqual([6])
+      expect(chunks[0]?.data.toString()).toBe("new")
+      expect(spool.getUsedBytes(sessionId)).toBe(3)
+      expect(
+        () => spool.loadChunksSync(sessionId, "other-owner", 3, 6)
+      ).toThrow(/Invalid Socketduct recovery chunks/)
+    })
   })
-})
 
-test("SessionSpool recovery repairs interruption after chunk append before usage update", async () => {
-  await withTempDir(async (root) => {
-    const sessionId = "session_append_interruption"
-    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
-    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
-    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
-    const chunksPath = join(root, sessionId, "chunks.jsonl")
-    const committed = await readFile(chunksPath, "utf8")
-    await writeFile(chunksPath, `${committed}${JSON.stringify({sequence: 6, dataBase64: Buffer.from("two").toString("base64")})}\n`)
-
-    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3)
-
-    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [3])
-    assert.equal(await readFile(chunksPath, "utf8"), committed)
-    assert.deepEqual(JSON.parse(await readFile(join(root, sessionId, "usage.json"), "utf8")), {totalBytes: 3})
-    assert.equal((await stat(chunksPath)).mode & 0o777, 0o600)
-    assert.equal((await stat(join(root, sessionId, "usage.json"))).mode & 0o777, 0o600)
+  it("SessionSpool recovery repairs interruption after chunk append before usage update", async () => {
+    await withTempDir(async (root) => {
+      const sessionId = "session_append_interruption"
+      const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+      await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+      await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+      const chunksPath = join(root, sessionId, "chunks.jsonl")
+      const committed = await readFile(chunksPath, "utf8")
+      await writeFile(chunksPath, `${committed}${JSON.stringify({sequence: 6, dataBase64: Buffer.from("two").toString("base64")})}\n`)
+
+      const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3)
+
+      expect(chunks.map((chunk) => chunk.sequence)).toEqual([3])
+      expect(await readFile(chunksPath, "utf8")).toBe(committed)
+      expect(JSON.parse(await readFile(join(root, sessionId, "usage.json"), "utf8"))).toEqual({totalBytes: 3})
+      expect((await stat(chunksPath)).mode & 0o777).toBe(0o600)
+      expect((await stat(join(root, sessionId, "usage.json"))).mode & 0o777).toBe(0o600)
+    })
   })
-})
 
-test("SessionSpool recovery repairs interruption after usage update before recovery commit", async () => {
-  await withTempDir(async (root) => {
-    const sessionId = "session_usage_interruption"
-    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
-    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
-    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
-    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("two")})
+  it("SessionSpool recovery repairs interruption after usage update before recovery commit", async () => {
+    await withTempDir(async (root) => {
+      const sessionId = "session_usage_interruption"
+      const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+      await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+      await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+      await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("two")})
 
-    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3)
+      const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3)
 
-    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [3])
-    assert.deepEqual(JSON.parse(await readFile(join(root, sessionId, "usage.json"), "utf8")), {totalBytes: 3})
+      expect(chunks.map((chunk) => chunk.sequence)).toEqual([3])
+      expect(JSON.parse(await readFile(join(root, sessionId, "usage.json"), "utf8"))).toEqual({totalBytes: 3})
+    })
   })
-})
 
-test("SessionSpool recovery repairs interruption after acknowledged chunk truncation", async () => {
-  await withTempDir(async (root) => {
-    const sessionId = "session_truncate_interruption"
-    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
-    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
-    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
-    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("two")})
-    const chunksPath = join(root, sessionId, "chunks.jsonl")
-    await writeFile(chunksPath, `${JSON.stringify({sequence: 6, dataBase64: Buffer.from("two").toString("base64")})}\n`)
+  it("SessionSpool recovery repairs interruption after acknowledged chunk truncation", async () => {
+    await withTempDir(async (root) => {
+      const sessionId = "session_truncate_interruption"
+      const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+      await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+      await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+      await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("two")})
+      const chunksPath = join(root, sessionId, "chunks.jsonl")
+      await writeFile(chunksPath, `${JSON.stringify({sequence: 6, dataBase64: Buffer.from("two").toString("base64")})}\n`)
 
-    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 3, 6)
+      const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 3, 6)
 
-    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [6])
-    assert.deepEqual(JSON.parse(await readFile(join(root, sessionId, "usage.json"), "utf8")), {totalBytes: 3})
+      expect(chunks.map((chunk) => chunk.sequence)).toEqual([6])
+      expect(JSON.parse(await readFile(join(root, sessionId, "usage.json"), "utf8"))).toEqual({totalBytes: 3})
+    })
   })
-})
 
-test("SessionSpool recovery repairs a partial trailing JSONL record after committed chunks", async () => {
-  await withTempDir(async (root) => {
-    const sessionId = "session_partial_interruption"
-    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
-    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
-    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
-    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("two")})
-    const chunksPath = join(root, sessionId, "chunks.jsonl")
-    const committed = await readFile(chunksPath, "utf8")
-    await writeFile(chunksPath, `${committed}{"sequence":9,"dataBase64":"thr`)
-
-    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 6)
-
-    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [3, 6])
-    assert.equal(await readFile(chunksPath, "utf8"), committed)
+  it("SessionSpool recovery repairs a partial trailing JSONL record after committed chunks", async () => {
+    await withTempDir(async (root) => {
+      const sessionId = "session_partial_interruption"
+      const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+      await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+      await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+      await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("two")})
+      const chunksPath = join(root, sessionId, "chunks.jsonl")
+      const committed = await readFile(chunksPath, "utf8")
+      await writeFile(chunksPath, `${committed}{"sequence":9,"dataBase64":"thr`)
+
+      const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 6)
+
+      expect(chunks.map((chunk) => chunk.sequence)).toEqual([3, 6])
+      expect(await readFile(chunksPath, "utf8")).toBe(committed)
+    })
   })
-})
 
-test("SessionSpool recovery rejects corruption before or outside a partial uncommitted tail", async () => {
-  await withTempDir(async (root) => {
-    const sessionId = "session_committed_corruption"
-    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
-    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
-    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
-    const chunksPath = join(root, sessionId, "chunks.jsonl")
-    await writeFile(chunksPath, `${await readFile(chunksPath, "utf8")}{"sequence":6,"dataBase64":"tw`)
-
-    assert.throws(
-      () => spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 6),
-      /Invalid Socketduct recovery chunks/
-    )
-  })
+  it("SessionSpool recovery rejects corruption before or outside a partial uncommitted tail", async () => {
+    await withTempDir(async (root) => {
+      const sessionId = "session_committed_corruption"
+      const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+      await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+      await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+      const chunksPath = join(root, sessionId, "chunks.jsonl")
+      await writeFile(chunksPath, `${await readFile(chunksPath, "utf8")}{"sequence":6,"dataBase64":"tw`)
+
+      expect(
+        () => spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 6)
+      ).toThrow(/Invalid Socketduct recovery chunks/)
+    })
 
-  await withTempDir(async (root) => {
-    const sessionId = "session_tail_corruption"
-    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
-    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
-    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
-    const chunksPath = join(root, sessionId, "chunks.jsonl")
-    await writeFile(chunksPath, `${await readFile(chunksPath, "utf8")}{not-json}\n`)
-
-    assert.throws(
-      () => spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3),
-      /Invalid Socketduct recovery chunks/
-    )
-  })
+    await withTempDir(async (root) => {
+      const sessionId = "session_tail_corruption"
+      const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+      await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+      await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+      const chunksPath = join(root, sessionId, "chunks.jsonl")
+      await writeFile(chunksPath, `${await readFile(chunksPath, "utf8")}{not-json}\n`)
+
+      expect(
+        () => spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3)
+      ).toThrow(/Invalid Socketduct recovery chunks/)
+    })
+
+    await withTempDir(async (root) => {
+      const sessionId = "session_usage_corruption"
+      const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+      await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+      await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+      await writeFile(join(root, sessionId, "usage.json"), "{not-json\n")
 
-  await withTempDir(async (root) => {
-    const sessionId = "session_usage_corruption"
-    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
-    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
-    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
-    await writeFile(join(root, sessionId, "usage.json"), "{not-json\n")
-
-    assert.throws(
-      () => spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3),
-      /Invalid Socketduct recovery chunks/
-    )
+      expect(
+        () => spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3)
+      ).toThrow(/Invalid Socketduct recovery chunks/)
+    })
   })
-})
 
-test("SessionSpool cleans expired abandoned entries so their stable IDs can be reused", async () => {
-  await withTempDir(async (root) => {
-    let now = 1_000_000
-    const sessionId = "session_abandoned_expired"
-    const first = new SessionSpool({rootDir: root, maxAgeMs: 60_000, now: () => now})
-    await first.createNew({sessionId, ownerId: "edge-v3"})
-
-    now += 60_001
-    const replacement = new SessionSpool({rootDir: root, maxAgeMs: 60_000, now: () => now})
-    await replacement.createNew({sessionId, ownerId: "edge-v3"})
-    await access(join(root, sessionId))
+  it("SessionSpool cleans expired abandoned entries so their stable IDs can be reused", async () => {
+    await withTempDir(async (root) => {
+      let now = 1_000_000
+      const sessionId = "session_abandoned_expired"
+      const first = new SessionSpool({rootDir: root, maxAgeMs: 60_000, now: () => now})
+      await first.createNew({sessionId, ownerId: "edge-v3"})
+
+      now += 60_001
+      const replacement = new SessionSpool({rootDir: root, maxAgeMs: 60_000, now: () => now})
+      await replacement.createNew({sessionId, ownerId: "edge-v3"})
+      await access(join(root, sessionId))
+    })
   })
-})
 
-test("SessionSpool appendChunk appends lines without rewriting whole file", async () => {
-  await withTempDir(async (root) => {
-    const spool = new SessionSpool({rootDir: root})
-    const sessionId = "session_1234567890"
-    await spool.create({sessionId, ownerId: "user-1"})
-
-    await spool.appendChunk({sessionId, sequence: 1, data: Buffer.from("first")})
-    await spool.appendChunk({sessionId, sequence: 2, data: Buffer.from("second")})
-    await spool.appendChunk({sessionId, sequence: 3, data: Buffer.from("third")})
-
-    const raw = await readFile(join(root, sessionId, "chunks.jsonl"), "utf8")
-    const lines = raw.trimEnd().split("\n")
-
-    assert.ok(lines.length >= 3)
-    const chunk1 = JSON.parse(/** @type {string} */ (lines[0]))
-    const chunk2 = JSON.parse(/** @type {string} */ (lines[1]))
-    const chunk3 = JSON.parse(/** @type {string} */ (lines[2]))
-    assert.equal(chunk1.sequence, 1)
-    assert.equal(chunk2.sequence, 2)
-    assert.equal(chunk3.sequence, 3)
+  it("SessionSpool appendChunk appends lines without rewriting whole file", async () => {
+    await withTempDir(async (root) => {
+      const spool = new SessionSpool({rootDir: root})
+      const sessionId = "session_1234567890"
+      await spool.create({sessionId, ownerId: "user-1"})
+
+      await spool.appendChunk({sessionId, sequence: 1, data: Buffer.from("first")})
+      await spool.appendChunk({sessionId, sequence: 2, data: Buffer.from("second")})
+      await spool.appendChunk({sessionId, sequence: 3, data: Buffer.from("third")})
+
+      const raw = await readFile(join(root, sessionId, "chunks.jsonl"), "utf8")
+      const lines = raw.trimEnd().split("\n")
+
+      expect(lines.length >= 3).toBeTruthy()
+      const chunk1 = JSON.parse(/** @type {string} */ (lines[0]))
+      const chunk2 = JSON.parse(/** @type {string} */ (lines[1]))
+      const chunk3 = JSON.parse(/** @type {string} */ (lines[2]))
+      expect(chunk1.sequence).toBe(1)
+      expect(chunk2.sequence).toBe(2)
+      expect(chunk3.sequence).toBe(3)
+    })
   })
-})
 
-test("SessionSpool getUsedBytes tracks per-session spool byte usage", async () => {
-  await withTempDir(async (root) => {
-    const spool = new SessionSpool({rootDir: root, maxBytes: 1000})
-    const sessionId = "session_1234567890"
-    await spool.create({sessionId, ownerId: "user-1"})
+  it("SessionSpool getUsedBytes tracks per-session spool byte usage", async () => {
+    await withTempDir(async (root) => {
+      const spool = new SessionSpool({rootDir: root, maxBytes: 1000})
+      const sessionId = "session_1234567890"
+      await spool.create({sessionId, ownerId: "user-1"})
 
-    assert.equal(spool.getUsedBytes(sessionId), 0)
+      expect(spool.getUsedBytes(sessionId)).toBe(0)
 
-    await spool.appendChunk({sessionId, sequence: 1, data: Buffer.alloc(50)})
-    assert.equal(spool.getUsedBytes(sessionId), 50)
+      await spool.appendChunk({sessionId, sequence: 1, data: Buffer.alloc(50)})
+      expect(spool.getUsedBytes(sessionId)).toBe(50)
 
-    await spool.appendChunk({sessionId, sequence: 2, data: Buffer.alloc(30)})
-    assert.equal(spool.getUsedBytes(sessionId), 80)
+      await spool.appendChunk({sessionId, sequence: 2, data: Buffer.alloc(30)})
+      expect(spool.getUsedBytes(sessionId)).toBe(80)
 
-    await spool.truncateAcked(sessionId, 1)
-    assert.equal(spool.getUsedBytes(sessionId), 30)
+      await spool.truncateAcked(sessionId, 1)
+      expect(spool.getUsedBytes(sessionId)).toBe(30)
+    })
   })
-})
 
-test("SessionSpool getUsedBytes returns undefined for non-existent session", () => {
-  const spool = new SessionSpool({rootDir: "/tmp"})
-  assert.equal(spool.getUsedBytes("nonexistent_session"), undefined)
-})
-
-test("SessionSpool reopened with existing data enforces maxBytes quota from durable usage", async () => {
-  await withTempDir(async (root) => {
-    const sessionId = "session_1234567890"
+  it("SessionSpool getUsedBytes returns undefined for non-existent session", () => {
+    const spool = new SessionSpool({rootDir: "/tmp"})
+    expect(spool.getUsedBytes("nonexistent_session")).toBeUndefined()
+  })
 
-    const spool1 = new SessionSpool({rootDir: root, maxBytes: 100})
-    await spool1.create({sessionId, ownerId: "user-1"})
-    await spool1.appendChunk({sessionId, sequence: 1, data: Buffer.alloc(60)})
+  it("SessionSpool reopened with existing data enforces maxBytes quota from durable usage", async () => {
+    await withTempDir(async (root) => {
+      const sessionId = "session_1234567890"
 
-    const spool2 = new SessionSpool({rootDir: root, maxBytes: 100})
-    await spool2.appendChunk({sessionId, sequence: 2, data: Buffer.alloc(30)})
+      const spool1 = new SessionSpool({rootDir: root, maxBytes: 100})
+      await spool1.create({sessionId, ownerId: "user-1"})
+      await spool1.appendChunk({sessionId, sequence: 1, data: Buffer.alloc(60)})
 
-    await assert.rejects(
-      spool2.appendChunk({sessionId, sequence: 3, data: Buffer.alloc(20)}),
-      (err) => err instanceof SpoolQuotaError && err.code === "SPOOL_QUOTA_EXCEEDED"
-    )
+      const spool2 = new SessionSpool({rootDir: root, maxBytes: 100})
+      await spool2.appendChunk({sessionId, sequence: 2, data: Buffer.alloc(30)})
 
-    const chunks = await spool2.readChunksAfter(sessionId, 0)
-    assert.equal(chunks.length, 2)
-    assert.equal(chunks[0]?.sequence, 1)
-    assert.equal(chunks[1]?.sequence, 2)
+      let error
+      try {
+        await spool2.appendChunk({sessionId, sequence: 3, data: Buffer.alloc(20)})
+      } catch (caught) {
+        error = caught
+      }
+      expect(error).toBeDefined()
+      expect(error instanceof SpoolQuotaError).toBe(true)
+      if (!(error instanceof SpoolQuotaError)) throw new Error("Expected a SpoolQuotaError")
+      expect(error.code).toBe("SPOOL_QUOTA_EXCEEDED")
+
+      const chunks = await spool2.readChunksAfter(sessionId, 0)
+      expect(chunks.length).toBe(2)
+      expect(chunks[0]?.sequence).toBe(1)
+      expect(chunks[1]?.sequence).toBe(2)
+    })
   })
-})
 
-test("SessionSpool reconciles a stale usage sidecar from durable chunks when reopened", async () => {
-  await withTempDir(async (root) => {
-    const sessionId = "session_1234567890"
-    const spool1 = new SessionSpool({rootDir: root, maxBytes: 20})
-    await spool1.create({sessionId, ownerId: "user-1"})
-    await spool1.appendChunk({sessionId, sequence: 1, data: Buffer.alloc(10)})
-    await writeFile(join(root, sessionId, "usage.json"), JSON.stringify({totalBytes: 20}) + "\n")
-
-    const spool2 = new SessionSpool({rootDir: root, maxBytes: 20})
-    await spool2.appendChunk({sessionId, sequence: 2, data: Buffer.alloc(10)})
-
-    await assert.rejects(
-      spool2.appendChunk({sessionId, sequence: 3, data: Buffer.alloc(1)}),
-      (err) => err instanceof SpoolQuotaError && err.code === "SPOOL_QUOTA_EXCEEDED"
-    )
-    assert.deepEqual((await spool2.readChunksAfter(sessionId, 0)).map((chunk) => chunk.data.length), [10, 10])
+  it("SessionSpool reconciles a stale usage sidecar from durable chunks when reopened", async () => {
+    await withTempDir(async (root) => {
+      const sessionId = "session_1234567890"
+      const spool1 = new SessionSpool({rootDir: root, maxBytes: 20})
+      await spool1.create({sessionId, ownerId: "user-1"})
+      await spool1.appendChunk({sessionId, sequence: 1, data: Buffer.alloc(10)})
+      await writeFile(join(root, sessionId, "usage.json"), JSON.stringify({totalBytes: 20}) + "\n")
+
+      const spool2 = new SessionSpool({rootDir: root, maxBytes: 20})
+      await spool2.appendChunk({sessionId, sequence: 2, data: Buffer.alloc(10)})
+
+      let error
+      try {
+        await spool2.appendChunk({sessionId, sequence: 3, data: Buffer.alloc(1)})
+      } catch (caught) {
+        error = caught
+      }
+      expect(error).toBeDefined()
+      expect(error instanceof SpoolQuotaError).toBe(true)
+      if (!(error instanceof SpoolQuotaError)) throw new Error("Expected a SpoolQuotaError")
+      expect(error.code).toBe("SPOOL_QUOTA_EXCEEDED")
+      expect((await spool2.readChunksAfter(sessionId, 0)).map((chunk) => chunk.data.length)).toEqual([10, 10])
+    })
   })
 })