socketduct 0.1.24 → 0.1.26

package/test/unit/protocol/frame.test.js

@@ -1,336 +1,340 @@
-import assert from "node:assert/strict"
-import test from "node:test"
+import {describe, expect, it} from "@velocious/testing"
 
 import {FrameDecoder, encodeCompactAck, encodeCompactData, encodeFrame} from "../../../src/protocol/frame.js"
 
-test("encodeFrame and FrameDecoder preserve header fields and payload bytes", () => {
-  const payload = Buffer.from([0, 1, 2, 253, 254, 255])
-  const encoded = encodeFrame({type: "stream.data", sessionId: "session-1", sequence: 42}, payload)
-
-  const decoder = new FrameDecoder()
-  const frames = decoder.push(encoded)
+describe("frame protocol", () => {
+  it("encodeFrame and FrameDecoder preserve header fields and payload bytes", () => {
+    const payload = Buffer.from([0, 1, 2, 253, 254, 255])
+    const encoded = encodeFrame({type: "stream.data", sessionId: "session-1", sequence: 42}, payload)
+
+    const decoder = new FrameDecoder()
+    const frames = decoder.push(encoded)
+
+    expect(frames.length).toBe(1)
+    expect(frames[0]?.header).toEqual({
+      type: "stream.data",
+      sessionId: "session-1",
+      sequence: 42
+    })
+    if (!frames[0]) throw new Error("expected a decoded stream.data frame")
+    expect(Buffer.from(frames[0].payload).equals(Buffer.from(payload))).toBe(true)
+    expect(frames[0]?.wireFormat).toBe("envelope")
+  })
 
-  assert.equal(frames.length, 1)
-  assert.deepEqual(frames[0]?.header, {
-    type: "stream.data",
-    sessionId: "session-1",
-    sequence: 42
+  it("FrameDecoder decodes frames split across multiple TCP chunks", () => {
+    const first = encodeFrame({type: "auth.request", requestId: "a"}, Buffer.from("one"))
+    const second = encodeFrame({type: "session.create", requestId: "b"}, Buffer.from("two"))
+    const combined = Buffer.concat([first, second])
+    const decoder = new FrameDecoder()
+
+    expect(decoder.push(combined.subarray(0, 2))).toEqual([])
+    expect(decoder.push(combined.subarray(2, 9))).toEqual([])
+    const frames = decoder.push(combined.subarray(9))
+
+    expect(frames.length).toBe(2)
+    expect(frames[0]?.header.type).toBe("auth.request")
+    expect(frames[0]?.payload.toString("utf8")).toBe("one")
+    expect(frames[1]?.header.type).toBe("session.create")
+    expect(frames[1]?.payload.toString("utf8")).toBe("two")
   })
-  assert.deepEqual(frames[0]?.payload, payload)
-  assert.equal(frames[0]?.wireFormat, "envelope")
-})
 
-test("FrameDecoder decodes frames split across multiple TCP chunks", () => {
-  const first = encodeFrame({type: "auth.request", requestId: "a"}, Buffer.from("one"))
-  const second = encodeFrame({type: "session.create", requestId: "b"}, Buffer.from("two"))
-  const combined = Buffer.concat([first, second])
-  const decoder = new FrameDecoder()
-
-  assert.deepEqual(decoder.push(combined.subarray(0, 2)), [])
-  assert.deepEqual(decoder.push(combined.subarray(2, 9)), [])
-  const frames = decoder.push(combined.subarray(9))
-
-  assert.equal(frames.length, 2)
-  assert.equal(frames[0]?.header.type, "auth.request")
-  assert.equal(frames[0]?.payload.toString("utf8"), "one")
-  assert.equal(frames[1]?.header.type, "session.create")
-  assert.equal(frames[1]?.payload.toString("utf8"), "two")
-})
+  it("FrameDecoder rejects invalid header lengths before allocating payload buffers", () => {
+    const decoder = new FrameDecoder({maxHeaderBytes: 8})
+    const invalid = Buffer.alloc(4)
+    invalid.writeUInt32BE(9, 0)
 
-test("FrameDecoder rejects invalid header lengths before allocating payload buffers", () => {
-  const decoder = new FrameDecoder({maxHeaderBytes: 8})
-  const invalid = Buffer.alloc(4)
-  invalid.writeUInt32BE(9, 0)
+    expect(() => decoder.push(invalid)).toThrow(/header length/i)
+  })
 
-  assert.throws(() => decoder.push(invalid), /header length/i)
-})
+  it("FrameDecoder rejects payloads larger than the configured limit", () => {
+    const decoder = new FrameDecoder({maxPayloadBytes: 2})
+    const encoded = encodeFrame({type: "stream.data"}, Buffer.from("too-large"))
 
-test("FrameDecoder rejects payloads larger than the configured limit", () => {
-  const decoder = new FrameDecoder({maxPayloadBytes: 2})
-  const encoded = encodeFrame({type: "stream.data"}, Buffer.from("too-large"))
+    expect(() => decoder.push(encoded)).toThrow(/payload length/i)
+  })
 
-  assert.throws(() => decoder.push(encoded), /payload length/i)
-})
+  it("FrameDecoder handles empty chunk without error", () => {
+    const decoder = new FrameDecoder()
+    const frames = decoder.push(Buffer.alloc(0))
+    expect(frames).toEqual([])
+  })
 
-test("FrameDecoder handles empty chunk without error", () => {
-  const decoder = new FrameDecoder()
-  const frames = decoder.push(Buffer.alloc(0))
-  assert.deepEqual(frames, [])
-})
+  it("compact v2 uncompressed data and ACK records round-trip beside envelope controls", () => {
+    const decoder = new FrameDecoder({compactDirection: "target-to-client"})
+    const frames = decoder.push(Buffer.concat([
+      encodeFrame({type: "session.resumed", identifier: "s1", framing: 2}),
+      encodeCompactData({sequence: 300, payload: Buffer.from("raw")}),
+      encodeCompactAck(257),
+      encodeFrame({type: "session.close", direction: "target-to-client"})
+    ]))
+    expect(frames.map(({header, payload}) => ({header, payload: payload.toString()}))).toEqual([
+      {header: {type: "session.resumed", identifier: "s1", framing: 2}, payload: ""},
+      {header: {type: "stream.data", direction: "target-to-client", sequence: 300, compact: true}, payload: "raw"},
+      {header: {type: "stream.ack", direction: "client-to-target", ackSequence: 257, compact: true}, payload: ""},
+      {header: {type: "session.close", direction: "target-to-client"}, payload: ""}
+    ])
+  })
 
-test("compact v2 uncompressed data and ACK records round-trip beside envelope controls", () => {
-  const decoder = new FrameDecoder({compactDirection: "target-to-client"})
-  const frames = decoder.push(Buffer.concat([
-    encodeFrame({type: "session.resumed", identifier: "s1", framing: 2}),
-    encodeCompactData({sequence: 300, payload: Buffer.from("raw")}),
-    encodeCompactAck(257),
-    encodeFrame({type: "session.close", direction: "target-to-client"})
-  ]))
-  assert.deepEqual(frames.map(({header, payload}) => ({header, payload: payload.toString()})), [
-    {header: {type: "session.resumed", identifier: "s1", framing: 2}, payload: ""},
-    {header: {type: "stream.data", direction: "target-to-client", sequence: 300, compact: true}, payload: "raw"},
-    {header: {type: "stream.ack", direction: "client-to-target", ackSequence: 257, compact: true}, payload: ""},
-    {header: {type: "session.close", direction: "target-to-client"}, payload: ""}
-  ])
-})
+  it("compact v2 zstd records normalize compression metadata", () => {
+    const decoder = new FrameDecoder({compactDirection: "client-to-target"})
+    const [frame] = decoder.push(encodeCompactData({sequence: Number.MAX_SAFE_INTEGER, dataLength: 4096, payload: Buffer.from([1, 2, 3])}))
+    expect(frame?.header).toEqual({type: "stream.data", direction: "client-to-target", sequence: Number.MAX_SAFE_INTEGER, compact: true, encoding: "zstd", dataLength: 4096})
+    if (!frame) throw new Error("expected a decoded compact frame")
+    expect(Buffer.from(frame.payload).equals(Buffer.from([1, 2, 3]))).toBe(true)
+    expect(frame?.wireFormat).toBe("compact")
+  })
 
-test("compact v2 zstd records normalize compression metadata", () => {
-  const decoder = new FrameDecoder({compactDirection: "client-to-target"})
-  const [frame] = decoder.push(encodeCompactData({sequence: Number.MAX_SAFE_INTEGER, dataLength: 4096, payload: Buffer.from([1, 2, 3])}))
-  assert.deepEqual(frame?.header, {type: "stream.data", direction: "client-to-target", sequence: Number.MAX_SAFE_INTEGER, compact: true, encoding: "zstd", dataLength: 4096})
-  assert.deepEqual(frame?.payload, Buffer.from([1, 2, 3]))
-  assert.equal(frame?.wireFormat, "compact")
-})
+  it("compact decoder waits for fragmented records", () => {
+    const encoded = encodeCompactData({sequence: 129, payload: Buffer.from("fragmented")})
+    const decoder = new FrameDecoder({compactDirection: "client-to-target"})
+    expect(decoder.push(encoded.subarray(0, 3))).toEqual([])
+    expect(decoder.push(encoded.subarray(3))[0]?.payload.toString()).toBe("fragmented")
+  })
 
-test("compact decoder waits for fragmented records", () => {
-  const encoded = encodeCompactData({sequence: 129, payload: Buffer.from("fragmented")})
-  const decoder = new FrameDecoder({compactDirection: "client-to-target"})
-  assert.deepEqual(decoder.push(encoded.subarray(0, 3)), [])
-  assert.equal(decoder.push(encoded.subarray(3))[0]?.payload.toString(), "fragmented")
-})
+  it("compact decoder rejects non-canonical, overflowing, and oversized varints", () => {
+    const options = /** @type {const} */ ({compactDirection: "client-to-target"})
+    expect(() => new FrameDecoder(options).push(Buffer.from([0x82, 0x80, 0x00]))).toThrow(/canonical/)
+    expect(() => new FrameDecoder(options).push(Buffer.from([0x82, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f]))).toThrow(/safe integer/)
+    expect(() => new FrameDecoder({...options, maxPayloadBytes: 2}).push(encodeCompactData({sequence: 3, payload: Buffer.from("abc")}))).toThrow(/payload length/)
+  })
 
-test("compact decoder rejects non-canonical, overflowing, and oversized varints", () => {
-  const options = /** @type {const} */ ({compactDirection: "client-to-target"})
-  assert.throws(() => new FrameDecoder(options).push(Buffer.from([0x82, 0x80, 0x00])), /canonical/)
-  assert.throws(() => new FrameDecoder(options).push(Buffer.from([0x82, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f])), /safe integer/)
-  assert.throws(() => new FrameDecoder({...options, maxPayloadBytes: 2}).push(encodeCompactData({sequence: 3, payload: Buffer.from("abc")})), /payload length/)
-})
+  it("FrameDecoder handles partial uint32 header length", () => {
+    const decoder = new FrameDecoder()
+    const partial = Buffer.alloc(2)
+    partial.writeUInt16BE(42, 0)
 
-test("FrameDecoder handles partial uint32 header length", () => {
-  const decoder = new FrameDecoder()
-  const partial = Buffer.alloc(2)
-  partial.writeUInt16BE(42, 0)
+    expect(decoder.push(partial)).toEqual([])
+  })
 
-  assert.deepEqual(decoder.push(partial), [])
-})
+  it("FrameDecoder handles partial header bytes after header length", () => {
+    const decoder = new FrameDecoder()
+    const buf = Buffer.alloc(6)
+    buf.writeUInt32BE(10, 0)
 
-test("FrameDecoder handles partial header bytes after header length", () => {
-  const decoder = new FrameDecoder()
-  const buf = Buffer.alloc(6)
-  buf.writeUInt32BE(10, 0)
+    expect(decoder.push(buf)).toEqual([])
+  })
 
-  assert.deepEqual(decoder.push(buf), [])
-})
+  it("FrameDecoder handles partial payload length uint32 after header", () => {
+    const header = JSON.stringify({type: "test"})
+    const buf = Buffer.alloc(4 + header.length + 2)
+    buf.writeUInt32BE(header.length, 0)
+    buf.write(header, 4, "utf8")
 
-test("FrameDecoder handles partial payload length uint32 after header", () => {
-  const header = JSON.stringify({type: "test"})
-  const buf = Buffer.alloc(4 + header.length + 2)
-  buf.writeUInt32BE(header.length, 0)
-  buf.write(header, 4, "utf8")
+    const decoder = new FrameDecoder()
+    expect(decoder.push(buf)).toEqual([])
+  })
 
-  const decoder = new FrameDecoder()
-  assert.deepEqual(decoder.push(buf), [])
-})
+  it("FrameDecoder handles partial payload bytes after full header and payload length", () => {
+    const header = JSON.stringify({type: "test"})
+    const buf = Buffer.alloc(4 + header.length + 4 + 3)
+    buf.writeUInt32BE(header.length, 0)
+    buf.write(header, 4, "utf8")
+    buf.writeUInt32BE(10, 4 + header.length)
 
-test("FrameDecoder handles partial payload bytes after full header and payload length", () => {
-  const header = JSON.stringify({type: "test"})
-  const buf = Buffer.alloc(4 + header.length + 4 + 3)
-  buf.writeUInt32BE(header.length, 0)
-  buf.write(header, 4, "utf8")
-  buf.writeUInt32BE(10, 4 + header.length)
+    const decoder = new FrameDecoder()
+    expect(decoder.push(buf)).toEqual([])
+  })
 
-  const decoder = new FrameDecoder()
-  assert.deepEqual(decoder.push(buf), [])
-})
+  it("FrameDecoder decodes one frame from a chunk that arrives byte-by-byte (uint32 split)", () => {
+    const payload = Buffer.from("hello")
+    const encoded = encodeFrame({type: "ping"}, payload)
+    const decoder = new FrameDecoder()
 
-test("FrameDecoder decodes one frame from a chunk that arrives byte-by-byte (uint32 split)", () => {
-  const payload = Buffer.from("hello")
-  const encoded = encodeFrame({type: "ping"}, payload)
-  const decoder = new FrameDecoder()
-
-  for (let i = 0; i < encoded.length; i++) {
-    const result = decoder.push(encoded.subarray(i, i + 1))
-    if (i < encoded.length - 1) {
-      assert.deepEqual(result, [])
-    } else {
-      assert.equal(result.length, 1)
-      assert.equal(result[0]?.header.type, "ping")
-      assert.deepEqual(result[0]?.payload, payload)
+    for (let i = 0; i < encoded.length; i++) {
+      const result = decoder.push(encoded.subarray(i, i + 1))
+      if (i < encoded.length - 1) {
+        expect(result).toEqual([])
+      } else {
+        expect(result.length).toBe(1)
+        expect(result[0]?.header.type).toBe("ping")
+        if (!result[0]) throw new Error("expected a decoded ping frame")
+        expect(Buffer.from(result[0].payload).equals(Buffer.from(payload))).toBe(true)
+      }
     }
-  }
-})
+  })
 
-test("FrameDecoder decodes multiple complete frames from a single push", () => {
-  const frame1 = encodeFrame({type: "alpha"}, Buffer.from("a"))
-  const frame2 = encodeFrame({type: "beta"}, Buffer.from("bb"))
-  const frame3 = encodeFrame({type: "gamma"}, Buffer.from("ccc"))
-  const combined = Buffer.concat([frame1, frame2, frame3])
-
-  const decoder = new FrameDecoder()
-  const frames = decoder.push(combined)
-
-  assert.equal(frames.length, 3)
-  assert.equal(frames[0]?.header.type, "alpha")
-  assert.equal(frames[0]?.payload.toString(), "a")
-  assert.equal(frames[1]?.header.type, "beta")
-  assert.equal(frames[1]?.payload.toString(), "bb")
-  assert.equal(frames[2]?.header.type, "gamma")
-  assert.equal(frames[2]?.payload.toString(), "ccc")
-})
+  it("FrameDecoder decodes multiple complete frames from a single push", () => {
+    const frame1 = encodeFrame({type: "alpha"}, Buffer.from("a"))
+    const frame2 = encodeFrame({type: "beta"}, Buffer.from("bb"))
+    const frame3 = encodeFrame({type: "gamma"}, Buffer.from("ccc"))
+    const combined = Buffer.concat([frame1, frame2, frame3])
+
+    const decoder = new FrameDecoder()
+    const frames = decoder.push(combined)
+
+    expect(frames.length).toBe(3)
+    expect(frames[0]?.header.type).toBe("alpha")
+    expect(frames[0]?.payload.toString()).toBe("a")
+    expect(frames[1]?.header.type).toBe("beta")
+    expect(frames[1]?.payload.toString()).toBe("bb")
+    expect(frames[2]?.header.type).toBe("gamma")
+    expect(frames[2]?.payload.toString()).toBe("ccc")
+  })
 
-test("FrameDecoder with maxInputBytes rejects over-budget input", () => {
-  const decoder = new FrameDecoder({maxInputBytes: 10})
-  const frame = encodeFrame({type: "test"}, Buffer.from("hello"))
+  it("FrameDecoder with maxInputBytes rejects over-budget input", () => {
+    const decoder = new FrameDecoder({maxInputBytes: 10})
+    const frame = encodeFrame({type: "test"}, Buffer.from("hello"))
 
-  assert.throws(() => decoder.push(frame), /input byte budget/i)
-})
+    expect(() => decoder.push(frame)).toThrow(/input byte budget/i)
+  })
 
-test("FrameDecoder with maxInputBytes allows input within budget and rejects on overflow", () => {
-  const decoder = new FrameDecoder({maxInputBytes: 100})
+  it("FrameDecoder with maxInputBytes allows input within budget and rejects on overflow", () => {
+    const decoder = new FrameDecoder({maxInputBytes: 100})
 
-  const header = JSON.stringify({type: "small"})
-  const smallFrame = Buffer.alloc(4 + header.length + 4 + 5)
-  smallFrame.writeUInt32BE(header.length, 0)
-  smallFrame.write(header, 4, "utf8")
-  smallFrame.writeUInt32BE(5, 4 + header.length)
-  smallFrame.write("hello", 4 + header.length + 4, "utf8")
+    const header = JSON.stringify({type: "small"})
+    const smallFrame = Buffer.alloc(4 + header.length + 4 + 5)
+    smallFrame.writeUInt32BE(header.length, 0)
+    smallFrame.write(header, 4, "utf8")
+    smallFrame.writeUInt32BE(5, 4 + header.length)
+    smallFrame.write("hello", 4 + header.length + 4, "utf8")
 
-  const frames = decoder.push(smallFrame.subarray(0, 7))
-  assert.deepEqual(frames, [])
+    const frames = decoder.push(smallFrame.subarray(0, 7))
+    expect(frames).toEqual([])
 
-  const frames2 = decoder.push(smallFrame.subarray(7))
-  assert.equal(frames2.length, 1)
-  assert.equal(frames2[0]?.header.type, "small")
+    const frames2 = decoder.push(smallFrame.subarray(7))
+    expect(frames2.length).toBe(1)
+    expect(frames2[0]?.header.type).toBe("small")
 
-  const big = Buffer.alloc(2000)
-  big.writeUInt32BE(5, 0)
-  assert.throws(() => decoder.push(big), /input byte budget/i)
-})
+    const big = Buffer.alloc(2000)
+    big.writeUInt32BE(5, 0)
+    expect(() => decoder.push(big)).toThrow(/input byte budget/i)
+  })
 
-test("FrameDecoder with zero maxInputBytes disables budget check", () => {
-  const decoder = new FrameDecoder({maxInputBytes: 0, maxHeaderBytes: 200_000})
+  it("FrameDecoder with zero maxInputBytes disables budget check", () => {
+    const decoder = new FrameDecoder({maxInputBytes: 0, maxHeaderBytes: 200_000})
 
-  const smallChunk = Buffer.alloc(100_001)
-  smallChunk.writeUInt32BE(100_000, 0)
+    const smallChunk = Buffer.alloc(100_001)
+    smallChunk.writeUInt32BE(100_000, 0)
 
-  assert.deepEqual(decoder.push(smallChunk), [])
-})
+    expect(decoder.push(smallChunk)).toEqual([])
+  })
 
-test("FrameDecoder byte-by-byte input exercises cursor path: one frame", () => {
-  const payload = Buffer.from("cursor")
-  const encoded = encodeFrame({type: "cursor-test"}, payload)
-  const decoder = new FrameDecoder()
+  it("FrameDecoder byte-by-byte input exercises cursor path: one frame", () => {
+    const payload = Buffer.from("cursor")
+    const encoded = encodeFrame({type: "cursor-test"}, payload)
+    const decoder = new FrameDecoder()
 
-  for (let i = 0; i < encoded.length; i++) {
-    const result = decoder.push(encoded.subarray(i, i + 1))
-    if (i < encoded.length - 1) {
-      assert.deepEqual(result, [])
+    for (let i = 0; i < encoded.length; i++) {
+      const result = decoder.push(encoded.subarray(i, i + 1))
+      if (i < encoded.length - 1) {
+        expect(result).toEqual([])
+      }
     }
-  }
 
-  const frames = decoder.push(Buffer.alloc(0))
+    const frames = decoder.push(Buffer.alloc(0))
 
-  assert.deepEqual(frames, [])
-})
+    expect(frames).toEqual([])
+  })
 
-test("FrameDecoder byte-by-byte input exercises cursor path: multiple queued frames", () => {
-  const frame1 = encodeFrame({type: "alpha"}, Buffer.from("a"))
-  const frame2 = encodeFrame({type: "beta"}, Buffer.from("bb"))
-  const frame3 = encodeFrame({type: "gamma"}, Buffer.from("ccc"))
-  const combined = Buffer.concat([frame1, frame2, frame3])
-  const decoder = new FrameDecoder()
-
-  /** @type {import('../../../src/protocol/frame.js').Frame[]} */
-  const allFrames = []
-  for (let i = 0; i < combined.length; i++) {
-    const result = decoder.push(combined.subarray(i, i + 1))
-    for (const f of result) {
+  it("FrameDecoder byte-by-byte input exercises cursor path: multiple queued frames", () => {
+    const frame1 = encodeFrame({type: "alpha"}, Buffer.from("a"))
+    const frame2 = encodeFrame({type: "beta"}, Buffer.from("bb"))
+    const frame3 = encodeFrame({type: "gamma"}, Buffer.from("ccc"))
+    const combined = Buffer.concat([frame1, frame2, frame3])
+    const decoder = new FrameDecoder()
+
+    /** @type {import('../../../src/protocol/frame.js').Frame[]} */
+    const allFrames = []
+    for (let i = 0; i < combined.length; i++) {
+      const result = decoder.push(combined.subarray(i, i + 1))
+      for (const f of result) {
+        allFrames.push(f)
+      }
+    }
+
+    for (const f of decoder.push(Buffer.alloc(0))) {
       allFrames.push(f)
     }
-  }
-
-  for (const f of decoder.push(Buffer.alloc(0))) {
-    allFrames.push(f)
-  }
-
-  assert.equal(allFrames.length, 3)
-  assert.equal(allFrames[0]?.header.type, "alpha")
-  assert.equal(allFrames[0]?.payload.toString(), "a")
-  assert.equal(allFrames[1]?.header.type, "beta")
-  assert.equal(allFrames[1]?.payload.toString(), "bb")
-  assert.equal(allFrames[2]?.header.type, "gamma")
-  assert.equal(allFrames[2]?.payload.toString(), "ccc")
-})
 
-test("FrameDecoder discards header read from garbage bytes and throws on oversized header", () => {
-  const decoder = new FrameDecoder()
+    expect(allFrames.length).toBe(3)
+    expect(allFrames[0]?.header.type).toBe("alpha")
+    expect(allFrames[0]?.payload.toString()).toBe("a")
+    expect(allFrames[1]?.header.type).toBe("beta")
+    expect(allFrames[1]?.payload.toString()).toBe("bb")
+    expect(allFrames[2]?.header.type).toBe("gamma")
+    expect(allFrames[2]?.payload.toString()).toBe("ccc")
+  })
 
-  const garbage = Buffer.alloc(5000, 0xFF)
-  assert.throws(() => decoder.push(garbage), /header length/i)
-})
+  it("FrameDecoder discards header read from garbage bytes and throws on oversized header", () => {
+    const decoder = new FrameDecoder()
 
-test("FrameDecoder compaction path: readPos shifts after partial consumption triggers compact", () => {
-  const frame1 = encodeFrame({type: "first"}, Buffer.from("data1"))
-  const frame2 = encodeFrame({type: "second"}, Buffer.from("data2"))
-  const combined = Buffer.concat([frame1, frame2])
-  const decoder = new FrameDecoder()
-
-  /** @type {import('../../../src/protocol/frame.js').Frame[]} */
-  const allFrames = []
-  for (const f of decoder.push(combined.subarray(0, frame1.length + 2))) {
-    allFrames.push(f)
-  }
-
-  for (const f of decoder.push(combined.subarray(frame1.length + 2))) {
-    allFrames.push(f)
-  }
-
-  for (const f of decoder.push(Buffer.alloc(0))) {
-    allFrames.push(f)
-  }
-
-  assert.equal(allFrames.length, 2)
-  assert.equal(allFrames[0]?.header.type, "first")
-  assert.equal(allFrames[1]?.header.type, "second")
-})
+    const garbage = Buffer.alloc(5000, 0xFF)
+    expect(() => decoder.push(garbage)).toThrow(/header length/i)
+  })
 
-test("FrameDecoder verifies the decoder is reusable across many byte-by-byte deliveries", () => {
-  const payload = Buffer.from("large-frame")
-  const encoded = encodeFrame({type: "reuse"}, payload)
-  const decoder = new FrameDecoder()
+  it("FrameDecoder compaction path: readPos shifts after partial consumption triggers compact", () => {
+    const frame1 = encodeFrame({type: "first"}, Buffer.from("data1"))
+    const frame2 = encodeFrame({type: "second"}, Buffer.from("data2"))
+    const combined = Buffer.concat([frame1, frame2])
+    const decoder = new FrameDecoder()
 
-  let totalFrames = 0
-  for (let round = 0; round < 5; round++) {
-    for (let i = 0; i < encoded.length; i++) {
-      const result = decoder.push(encoded.subarray(i, i + 1))
-      totalFrames += result.length
+    /** @type {import('../../../src/protocol/frame.js').Frame[]} */
+    const allFrames = []
+    for (const f of decoder.push(combined.subarray(0, frame1.length + 2))) {
+      allFrames.push(f)
     }
-  }
 
-  totalFrames += decoder.push(Buffer.alloc(0)).length
+    for (const f of decoder.push(combined.subarray(frame1.length + 2))) {
+      allFrames.push(f)
+    }
 
-  assert.equal(totalFrames, 5)
-})
+    for (const f of decoder.push(Buffer.alloc(0))) {
+      allFrames.push(f)
+    }
 
-test("FrameDecoder disableInputBudget allows exceeding original budget", () => {
-  const decoder = new FrameDecoder({maxInputBytes: 100})
-  const smallFrame = encodeFrame({type: "small"}, Buffer.from("hello"))
-  decoder.push(smallFrame)
+    expect(allFrames.length).toBe(2)
+    expect(allFrames[0]?.header.type).toBe("first")
+    expect(allFrames[1]?.header.type).toBe("second")
+  })
 
-  decoder.disableInputBudget()
+  it("FrameDecoder verifies the decoder is reusable across many byte-by-byte deliveries", () => {
+    const payload = Buffer.from("large-frame")
+    const encoded = encodeFrame({type: "reuse"}, payload)
+    const decoder = new FrameDecoder()
+
+    let totalFrames = 0
+    for (let round = 0; round < 5; round++) {
+      for (let i = 0; i < encoded.length; i++) {
+        const result = decoder.push(encoded.subarray(i, i + 1))
+        totalFrames += result.length
+      }
+    }
 
-  const largeFrame = encodeFrame({type: "large"}, Buffer.allocUnsafe(200_000))
-  const after = decoder.push(largeFrame)
-  assert.equal(after.length, 1)
-  assert.equal(after[0]?.header.type, "large")
-})
+    totalFrames += decoder.push(Buffer.alloc(0)).length
 
-test("FrameDecoder compaction reuses existing capacity instead of unbounded growth", () => {
-  const decoder = new FrameDecoder()
+    expect(totalFrames).toBe(5)
+  })
+
+  it("FrameDecoder disableInputBudget allows exceeding original budget", () => {
+    const decoder = new FrameDecoder({maxInputBytes: 100})
+    const smallFrame = encodeFrame({type: "small"}, Buffer.from("hello"))
+    decoder.push(smallFrame)
+
+    decoder.disableInputBudget()
+
+    const largeFrame = encodeFrame({type: "large"}, Buffer.allocUnsafe(200_000))
+    const after = decoder.push(largeFrame)
+    expect(after.length).toBe(1)
+    expect(after[0]?.header.type).toBe("large")
+  })
+
+  it("FrameDecoder compaction reuses existing capacity instead of unbounded growth", () => {
+    const decoder = new FrameDecoder()
 
-  const manyBytes = Buffer.alloc(1000, 0x41)
-  const bigFrame = encodeFrame({type: "big"}, manyBytes)
+    const manyBytes = Buffer.alloc(1000, 0x41)
+    const bigFrame = encodeFrame({type: "big"}, manyBytes)
 
-  const part1 = bigFrame.subarray(0, 800)
-  const part2 = bigFrame.subarray(800)
-  decoder.push(part1)
-  const extracted = decoder.push(part2)
-  assert.equal(extracted.length, 1)
+    const part1 = bigFrame.subarray(0, 800)
+    const part2 = bigFrame.subarray(800)
+    decoder.push(part1)
+    const extracted = decoder.push(part2)
+    expect(extracted.length).toBe(1)
 
-  for (let round = 0; round < 20; round++) {
-    const inner = encodeFrame({type: "small"}, Buffer.from("x"))
-    const result = decoder.push(inner)
-    assert.equal(result.length, 1)
-    assert.equal(result[0]?.header.type, "small")
-  }
+    for (let round = 0; round < 20; round++) {
+      const inner = encodeFrame({type: "small"}, Buffer.from("x"))
+      const result = decoder.push(inner)
+      expect(result.length).toBe(1)
+      expect(result[0]?.header.type).toBe("small")
+    }
+  })
 })