@stream-io/video-client 1.57.0 → 1.58.0

package/src/rtc/e2ee/__tests__/codec.test.ts

@@ -0,0 +1,247 @@
+import { describe, expect, it } from 'vitest';
+import {
+  boundarySeedZeros,
+  getCodecProfile,
+  isSupportedCodec,
+  rbspEscapeInto,
+  rbspEscapedLength,
+  rbspUnescape,
+} from '../e2ee-worker/codec';
+
+// Single-buffer escape helper. Production only ever escapes the
+// [ciphertext, trailer] segment pair via rbspEscapedLength + rbspEscapeInto, so
+// this convenience wrapper lives in the test rather than the shipped worker.
+const rbspEscape = (data: Uint8Array, seedZeros = 0): Uint8Array => {
+  const out = new Uint8Array(rbspEscapedLength([data], seedZeros));
+  rbspEscapeInto(out, 0, [data], seedZeros);
+  return out;
+};
+
+describe('rbspEscape + rbspUnescape', () => {
+  // deterministic "random" to exercise many byte values
+  const pseudoRandom = Array.from({ length: 256 }, (_, i) => (i * 31) & 0xff);
+
+  it.each([
+    ['no escapable sequence', [1, 2, 3, 4, 5]],
+    ['a run of zeros', [0, 0, 0, 0, 0, 0]],
+    ['mixed content', [0xaa, 0, 0, 1, 0xbb, 0xcc, 0, 0, 2, 0xdd]],
+    ['empty input', []],
+    ['a 256-byte buffer', pseudoRandom],
+  ])('round-trips %s', (_label, input) => {
+    const escaped = rbspEscape(new Uint8Array(input));
+    expect(Array.from(rbspUnescape(escaped, 0))).toEqual(input);
+  });
+
+  it('is byte-identical when nothing needs escaping', () => {
+    // No zero pairs → no emulation-prevention bytes inserted.
+    expect(rbspEscape(new Uint8Array([1, 2, 3, 4, 5]))).toEqual(
+      new Uint8Array([1, 2, 3, 4, 5]),
+    );
+  });
+
+  it('inserts 0x03 between 00 00 and 00-03', () => {
+    // [0, 0, 1] → [0, 0, 3, 1]
+    const out = rbspEscape(new Uint8Array([0, 0, 1]));
+    expect(Array.from(out)).toEqual([0, 0, 3, 1]);
+  });
+
+  it('produces a buffer free of forbidden start-code-like sequences', () => {
+    // After RBSP escaping, the sequences 00 00 00, 00 00 01, and 00 00 02
+    // must not appear. 00 00 03 is allowed — it's the escape marker itself.
+    const escaped = rbspEscape(new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]));
+    for (let i = 0; i < escaped.length - 2; i++) {
+      if (escaped[i] === 0 && escaped[i + 1] === 0) {
+        expect(escaped[i + 2]).toBeGreaterThanOrEqual(3);
+      }
+    }
+  });
+});
+
+describe('rbspEscapeInto + rbspEscapedLength (multi-segment)', () => {
+  // The H264 encode path escapes [ciphertext, trailer] as one stream straight
+  // behind the clear header. These lock in that escaping the segments is
+  // byte-identical to escaping their concatenation, including when an escape
+  // sequence straddles the segment boundary.
+  const concat = (...segs: number[][]) => new Uint8Array(segs.flat());
+
+  const escapeSegments = (segs: number[][], seedZeros = 0) => {
+    const segments = segs.map((s) => new Uint8Array(s));
+    const out = new Uint8Array(rbspEscapedLength(segments, seedZeros));
+    rbspEscapeInto(out, 0, segments, seedZeros);
+    return out;
+  };
+
+  it('matches single-buffer escaping of the concatenation', () => {
+    const a = [0xaa, 0, 0, 1, 0xbb];
+    const b = [0, 0, 2, 0xcc];
+    expect(Array.from(escapeSegments([a, b]))).toEqual(
+      Array.from(rbspEscape(concat(a, b))),
+    );
+  });
+
+  it('escapes a 00 00 run that straddles the segment boundary', () => {
+    // a ends in 00 00, b starts with 01 -> the escape byte must be inserted at
+    // the boundary exactly as if the bytes were one buffer.
+    const a = [0xaa, 0, 0];
+    const b = [1, 0xbb];
+    const escaped = escapeSegments([a, b]);
+    expect(Array.from(escaped)).toEqual([0xaa, 0, 0, 3, 1, 0xbb]);
+    expect(Array.from(rbspUnescape(escaped, 0))).toEqual([...a, ...b]);
+  });
+
+  it('writes at a non-zero offset, leaving earlier bytes untouched', () => {
+    const segments = [new Uint8Array([0, 0, 1])];
+    const out = new Uint8Array(2 + rbspEscapedLength(segments, 0));
+    out[0] = 0x11;
+    out[1] = 0x22;
+    rbspEscapeInto(out, 2, segments, 0);
+    expect(Array.from(out)).toEqual([0x11, 0x22, 0, 0, 3, 1]);
+  });
+});
+
+describe('boundary seeding (clear header ending in zeros)', () => {
+  // The encoder never escapes the clear header itself, but on the wire the
+  // header's tail and the escaped unit are contiguous. Seeding the escaper
+  // with the header's trailing zeros keeps a start code from forming across
+  // that boundary, e.g. header ...00 + ciphertext 00 01 -> 00 00 01.
+
+  it('boundarySeedZeros counts trailing zeros, capped at 2', () => {
+    expect(boundarySeedZeros(new Uint8Array([1, 2, 3]))).toBe(0);
+    expect(boundarySeedZeros(new Uint8Array([1, 2, 0]))).toBe(1);
+    expect(boundarySeedZeros(new Uint8Array([1, 0, 0]))).toBe(2);
+    expect(boundarySeedZeros(new Uint8Array([0, 0, 0, 0]))).toBe(2);
+    expect(boundarySeedZeros(new Uint8Array([0]))).toBe(1);
+    expect(boundarySeedZeros(new Uint8Array([]))).toBe(0);
+  });
+
+  it('escapes a start code forming across the clear/encrypted boundary', () => {
+    // Header ends in one 0x00 (seed 1); the unit starts 00 01. Unseeded this
+    // would ship ...00 | 00 01 (a 3-byte start code); seeded, an escape byte
+    // lands before the 01.
+    const escaped = rbspEscape(new Uint8Array([0, 1, 0xbb]), 1);
+    expect(Array.from(escaped)).toEqual([0, 3, 1, 0xbb]);
+    expect(Array.from(rbspUnescape(escaped, 1))).toEqual([0, 1, 0xbb]);
+  });
+
+  it('escapes the very first unit byte when the header ends in 00 00', () => {
+    const escaped = rbspEscape(new Uint8Array([1, 0xbb]), 2);
+    expect(Array.from(escaped)).toEqual([3, 1, 0xbb]);
+    expect(Array.from(rbspUnescape(escaped, 2))).toEqual([1, 0xbb]);
+  });
+
+  it('leaves a safe boundary alone', () => {
+    // The unit starts with a non-start-code byte; nothing to escape.
+    const escaped = rbspEscape(new Uint8Array([0xaa, 0, 1]), 2);
+    expect(Array.from(escaped)).toEqual([0xaa, 0, 1]);
+    expect(Array.from(rbspUnescape(escaped, 2))).toEqual([0xaa, 0, 1]);
+  });
+
+  it('round-trips with any seed on content needing internal escapes', () => {
+    const input = [0, 0, 1, 0xaa, 0, 0, 0, 2, 0xbb];
+    for (const seed of [0, 1, 2]) {
+      const escaped = rbspEscape(new Uint8Array(input), seed);
+      expect(Array.from(rbspUnescape(escaped, seed))).toEqual(input);
+    }
+  });
+});
+
+describe('codec clear-byte rules', () => {
+  // The clear-byte count per codec, via the same profile.clearBytes path the
+  // encoder uses (getClearByteCount delegate removed to save a hot-path frame).
+  const clearBytes = (
+    codec: string | undefined,
+    frameType: string | undefined,
+    data: Uint8Array,
+  ) => getCodecProfile(codec).clearBytes(frameType, data);
+
+  // Annex B: [00 00 00 01][SPS][00 00 00 01][slice NALU type 5][...]. The slice
+  // start code sits at byte 8 and is 4 bytes long, so clear = 8 + 4 + 2 = 14.
+  const h264Idr = new Uint8Array([
+    0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01,
+    0x65, 0xb8, 0x40,
+  ]);
+  // Only SPS (type 7), so no slice NALU to end the clear header on.
+  const h264NoSlice = new Uint8Array([0x00, 0x00, 0x00, 0x01, 0x67, 0x42]);
+  const big = new Uint8Array(50);
+
+  it.each([
+    // Audio is identified by the absence of a key/delta type; the Opus TOC
+    // byte stays clear so the SFU can read it.
+    ['audio, codec unlabeled', undefined, undefined, big, 1],
+    ['audio, opus', 'opus', undefined, big, 1],
+    ['vp8 keyframe', 'vp8', 'key', big, 10],
+    ['vp8 delta', 'vp8', 'delta', big, 3],
+    ['vp9 keyframe', 'vp9', 'key', big, 10],
+    ['vp9 delta', 'vp9', 'delta', big, 3],
+    // A frame shorter than the nominal count must not claim more clear bytes
+    // than it has, or encode zero-pads the header and decode builds an AAD of
+    // a different length, failing GCM for a frame that should round-trip.
+    ['vp8 delta shorter than 3 bytes', 'vp8', 'delta', new Uint8Array(2), 2],
+    ['vp9 keyframe shorter than 10 bytes', 'vp9', 'key', new Uint8Array(5), 5],
+    ['h264 up to the first slice NALU', 'h264', 'key', h264Idr, 14],
+    ['h264 with no slice NALU', 'h264', 'key', h264NoSlice, 0],
+    ['an unknown codec', 'unknown', 'delta', big, 0],
+  ])('%s -> %s clear bytes', (_label, codec, frameType, data, expected) => {
+    expect(clearBytes(codec, frameType, data)).toBe(expected);
+  });
+});
+
+describe('getCodecProfile', () => {
+  it('marks only h264 for RBSP escaping', () => {
+    // The load-bearing invariant of the table: a codec is fully described in one
+    // place, so a half-wired codec (e.g. NALU escaping forgotten) is impossible.
+    expect(getCodecProfile('h264')).toMatchObject({ rbsp: true });
+    for (const codec of ['opus', 'vp8', 'vp9']) {
+      expect(getCodecProfile(codec)).toMatchObject({ rbsp: false });
+    }
+  });
+
+  it('falls back to a passthrough profile for unknown / absent codecs', () => {
+    for (const codec of [undefined, 'h265', 'video/vp8']) {
+      expect(getCodecProfile(codec)).toMatchObject({ rbsp: false });
+    }
+  });
+
+  it('does not resolve Object.prototype members to a profile', () => {
+    // Looked up with `in` rather than Object.hasOwn, 'toString' resolves to a
+    // function: getCodecProfile returns it and profile.clearBytes is undefined,
+    // so every frame on that track throws inside the encode path.
+    for (const codec of ['toString', 'constructor', 'valueOf', '__proto__']) {
+      expect(getCodecProfile(codec)).toBe(getCodecProfile('no-such-codec'));
+      expect(typeof getCodecProfile(codec).clearBytes).toBe('function');
+    }
+  });
+});
+
+describe('isSupportedCodec', () => {
+  it('accepts the known codecs, and undefined for unlabeled audio', () => {
+    for (const codec of ['opus', 'vp8', 'vp9', 'h264', undefined]) {
+      expect(isSupportedCodec(codec)).toBe(true);
+    }
+  });
+
+  it('rejects unknown or mis-cased codecs', () => {
+    expect(isSupportedCodec('H264')).toBe(false);
+    expect(isSupportedCodec('video/vp8')).toBe(false);
+  });
+
+  it('rejects Object.prototype members', () => {
+    // `codec in CODEC_PROFILES` walks the prototype chain and would report
+    // these as supported, sending the track down the encode path with no
+    // usable profile behind it.
+    for (const codec of [
+      'toString',
+      'constructor',
+      'valueOf',
+      'hasOwnProperty',
+    ])
+      expect(isSupportedCodec(codec)).toBe(false);
+  });
+
+  it('rejects av1, which has no E2EE framing scheme yet', () => {
+    // The encode path turns this into a fail-closed transform: every frame is
+    // dropped and e2ee.encryption_failed is emitted, so an AV1 track can never
+    // be published in the clear on an encrypted call.
+    expect(isSupportedCodec('av1')).toBe(false);
+  });
+});

package/src/rtc/e2ee/__tests__/conformance.test.ts

@@ -0,0 +1,184 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+/**
+ * SPEC.md §11 conformance vectors, pinned byte-for-byte.
+ *
+ * These lock the wire format: a refactor of the trailer writer, IV derivation,
+ * clear-byte rules or RBSP escaping that changes any output byte breaks
+ * interop with every other SDK, and the symmetric round-trip tests would not
+ * notice. Any intentional change here is a wire break: bump the trailer
+ * `version` and regenerate the vectors in SPEC.md §11.
+ */
+
+// The worker registers its listeners at import time and uses self.postMessage;
+// capture both so the tests can drive it through its real message interface.
+const handlers: Record<string, (e: { data: unknown }) => void> = {};
+vi.stubGlobal(
+  'addEventListener',
+  (type: string, h: (e: { data: unknown }) => void) => {
+    handlers[type] = h;
+  },
+);
+vi.stubGlobal('self', { postMessage: () => undefined });
+
+// The vectors fix `ivPrefix` = 11 11 11 11 11 11 11 11, but the prefix is
+// drawn from the CSPRNG on key import, so pin the RNG. SubtleCrypto stays real:
+// the ciphertext bytes come from actual AES-GCM.
+const realCrypto = globalThis.crypto;
+vi.stubGlobal('crypto', {
+  subtle: realCrypto.subtle,
+  getRandomValues: (arr: Uint8Array) => arr.fill(0x11),
+});
+
+await import('../e2ee-worker/e2ee-worker-impl');
+const { enqueue } = await import('../e2ee-worker/queue');
+const { keyStore } = await import('../e2ee-worker/keyStore');
+const { __resetFrameCounterForTest } =
+  await import('../e2ee-worker/frameCounter');
+
+type Frame = {
+  data: ArrayBuffer;
+  type?: 'key' | 'delta' | 'empty';
+  timestamp: number;
+};
+
+// key = 000102030405060708090a0b0c0d0e0f (AES-128-GCM), keyIndex = 0.
+const KEY = Array.from({ length: 16 }, (_, i) => i);
+
+const hex = (s: string): Uint8Array => {
+  const clean = s.replace(/\s+/g, '');
+  const out = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+};
+const toHex = (b: Uint8Array): string =>
+  Array.from(b, (x) => x.toString(16).padStart(2, '0')).join('');
+
+const message = (data: unknown) => handlers.message({ data });
+const flush = () => enqueue(async () => undefined);
+
+const setKey = async (userId: string) => {
+  message({
+    type: 'cmd.set_key',
+    userId,
+    keyIndex: 0,
+    rawKey: new Uint8Array(KEY).buffer,
+  });
+  await flush();
+};
+
+const drive = async (
+  operation: 'encode' | 'decode',
+  userId: string,
+  codec: string | undefined,
+  frames: Frame[],
+): Promise<Frame[]> => {
+  const out: Frame[] = [];
+  const readable = new ReadableStream<Frame>({
+    start(c) {
+      for (const f of frames) c.enqueue(f);
+      c.close();
+    },
+  });
+  let resolveDone!: () => void;
+  const done = new Promise<void>((r) => (resolveDone = r));
+  const writable = new WritableStream<Frame>({
+    write(f) {
+      out.push(f);
+    },
+    close: () => resolveDone(),
+    abort: () => resolveDone(),
+  });
+  message({
+    type: 'cmd.setup_transform',
+    readable,
+    writable,
+    operation,
+    userId,
+    codec,
+  });
+  await done;
+  return out;
+};
+
+let nextUser = 0;
+// A fresh user starts at frame counter 0, so the first frame uses counter 1,
+// matching the vectors.
+const freshUser = () => `vector-user-${nextUser++}`;
+
+afterEach(async () => {
+  await flush();
+  keyStore.clear();
+  __resetFrameCounterForTest();
+});
+
+interface Vector {
+  codec: string;
+  frameType: Frame['type'];
+  input: string;
+  output: string;
+}
+
+const VECTORS: Record<string, Vector> = {
+  'opus (audio, clearBytes 1)': {
+    codec: 'opus',
+    frameType: undefined,
+    input: '78aabbccdd',
+    output:
+      '78' +
+      'd02bf795e85c0bed034f7b282ca617cf76d57eb0' +
+      '00000001 1111111111111111 00 0001 01 e2eefeed',
+  },
+  'vp8 keyframe (clearBytes 10)': {
+    codec: 'vp8',
+    frameType: 'key',
+    input: '10111213141516171819aabb',
+    output:
+      '10111213141516171819' +
+      'd02b0484ce4aa2b21a4a83cbfe2ed6511c68' +
+      '00000001 1111111111111111 00 000a 01 e2eefeed',
+  },
+  'h264 IDR (clearBytes 6, RBSP escaping)': {
+    codec: 'h264',
+    frameType: 'key',
+    input: '00000001 65 8884deadbe',
+    output:
+      '000000016588' +
+      'fe4e96f631df11f57a43ed2003eaad0c5d6db632' +
+      // Escaped trailer: 0x03 inserted into the counter's 00 00 00 01 run,
+      // and clearBytes carries the RBSP flag (0x8006).
+      '0000030001 1111111111111111 00 8006 01 e2eefeed',
+  },
+};
+
+describe('SPEC §11 conformance vectors', () => {
+  it.each(Object.entries(VECTORS))(
+    'encodes %s to the exact spec bytes',
+    async (_label, v) => {
+      const user = freshUser();
+      await setKey(user);
+      const [encrypted] = await drive('encode', user, v.codec, [
+        { data: hex(v.input).buffer, type: v.frameType, timestamp: 1 },
+      ]);
+      expect(encrypted).toBeDefined();
+      expect(toHex(new Uint8Array(encrypted.data))).toBe(toHex(hex(v.output)));
+    },
+  );
+
+  it.each(Object.entries(VECTORS))(
+    'decodes the %s spec bytes back to the input',
+    async (_label, v) => {
+      const user = freshUser();
+      await setKey(user);
+      // Decode the pinned bytes, not this build's encode output, so the
+      // decoder is checked against the format other SDKs will send.
+      const [decrypted] = await drive('decode', user, undefined, [
+        { data: hex(v.output).buffer, type: v.frameType, timestamp: 1 },
+      ]);
+      expect(decrypted).toBeDefined();
+      expect(toHex(new Uint8Array(decrypted.data))).toBe(toHex(hex(v.input)));
+    },
+  );
+});

package/src/rtc/e2ee/__tests__/failureTracker.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+import { FAILURE_TOLERANCE } from '../e2ee-worker/constants';
+import { FailureTracker } from '../e2ee-worker/failureTracker';
+
+describe('FailureTracker', () => {
+  it('flags the break only on the failure that crosses tolerance', () => {
+    const tracker = new FailureTracker();
+    // The first FAILURE_TOLERANCE failures stay under the bar.
+    for (let i = 0; i < FAILURE_TOLERANCE; i++) {
+      expect(tracker.recordFailure(1)).toBe(false);
+    }
+    // The next one crosses it - the break transition fires exactly once.
+    expect(tracker.recordFailure(1)).toBe(true);
+    expect(tracker.recordFailure(1)).toBe(false); // already stalled, no re-fire
+  });
+
+  it('recordSuccess clears the count and reports whether there were failures', () => {
+    const tracker = new FailureTracker();
+    expect(tracker.recordSuccess(1)).toBe(false); // nothing to resume
+    tracker.recordFailure(1);
+    expect(tracker.recordSuccess(1)).toBe(true); // had a failure -> recovered
+    expect(tracker.recordSuccess(1)).toBe(false); // already clear
+    // After a reset the tolerance bar can be crossed (and reported) again.
+    for (let i = 0; i < FAILURE_TOLERANCE; i++) tracker.recordFailure(1);
+    expect(tracker.recordFailure(1)).toBe(true);
+  });
+
+  it('counts each keyIndex independently within a track', () => {
+    const tracker = new FailureTracker();
+    for (let i = 0; i <= FAILURE_TOLERANCE; i++) tracker.recordFailure(1);
+    // keyIndex 2 starts fresh: a key rotation does not inherit index 1's count.
+    expect(tracker.recordFailure(2)).toBe(false);
+  });
+
+  it('scopes failures per tracker so one track cannot reset another', () => {
+    const video = new FailureTracker();
+    const audio = new FailureTracker();
+    for (let i = 0; i <= FAILURE_TOLERANCE; i++) video.recordFailure(1);
+    // The audio track shares neither the count nor the recovery edge.
+    expect(audio.recordFailure(1)).toBe(false);
+    expect(audio.recordSuccess(1)).toBe(true); // only its own single failure
+    // ...and video's break state is untouched by audio's activity.
+    expect(video.recordSuccess(1)).toBe(true);
+  });
+});

package/src/rtc/e2ee/__tests__/frameCounter.test.ts

@@ -0,0 +1,90 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { COUNTER_HARD_LIMIT } from '../e2ee-worker/constants';
+
+// The counter itself posts nothing, but importing a key to prove a rekey does
+// not reset it goes through notifications.ts on failure.
+const postMessage = vi.fn();
+vi.stubGlobal('self', { postMessage });
+
+import {
+  __resetFrameCounterForTest,
+  __setFrameCounterForTest,
+  nextFrameCounter,
+} from '../e2ee-worker/frameCounter';
+import { keyStore } from '../e2ee-worker/keyStore';
+
+const rawKey = (seed = 0xab): ArrayBuffer => {
+  const buf = new ArrayBuffer(16);
+  const bytes = new Uint8Array(buf);
+  for (let i = 0; i < 16; i++) bytes[i] = (seed + i) & 0xff;
+  return buf;
+};
+
+beforeEach(() => {
+  __resetFrameCounterForTest();
+  keyStore.clear();
+  postMessage.mockClear();
+});
+
+describe('nextFrameCounter', () => {
+  it('increments monotonically, shared across every track', () => {
+    // One counter per worker, drawn from by every encode transform. Separate
+    // counters per track would let two of this sender's tracks land on the
+    // same (ivPrefix, counter) pair under one key.
+    expect(nextFrameCounter()).toBe(1);
+    expect(nextFrameCounter()).toBe(2);
+    expect(nextFrameCounter()).toBe(3);
+  });
+
+  it('survives removeAllKeys — counter is never rolled back', async () => {
+    await keyStore.importKey('alice', 1, rawKey());
+    expect(nextFrameCounter()).toBe(1);
+    expect(nextFrameCounter()).toBe(2);
+
+    keyStore.removeAllKeys('alice');
+
+    // Re-import the same raw key. Counter must NOT restart — otherwise
+    // we'd reuse IVs on the new import's first frames.
+    await keyStore.importKey('alice', 1, rawKey());
+    expect(nextFrameCounter()).toBe(3);
+  });
+
+  it('throws at the 32-bit hard limit and stays exhausted', () => {
+    __setFrameCounterForTest(COUNTER_HARD_LIMIT);
+    expect(() => nextFrameCounter()).toThrow(/counter exhausted/);
+    // Every later frame must fail identically rather than wrapping into a
+    // counter that was already used with this ivPrefix.
+    expect(() => nextFrameCounter()).toThrow(/counter exhausted/);
+    expect(() => nextFrameCounter()).toThrow(/counter exhausted/);
+  });
+
+  it('a rekey does not recover an exhausted counter', async () => {
+    __setFrameCounterForTest(COUNTER_HARD_LIMIT);
+    expect(() => nextFrameCounter()).toThrow(/new EncryptionManager/);
+
+    // Importing fresh key material is the remedy an integrator would reach
+    // for first. It gives a new ivPrefix, but the counter is scoped to the
+    // worker rather than to the key, so encryption stays dead.
+    await keyStore.importKey('alice', 7, rawKey());
+    expect(() => nextFrameCounter()).toThrow(/counter exhausted/);
+
+    // Same after dropping the user's keys entirely.
+    keyStore.removeAllKeys('alice');
+    await keyStore.importKey('alice', 8, rawKey());
+    expect(() => nextFrameCounter()).toThrow(/counter exhausted/);
+  });
+
+  it('never posts a rotation warning ahead of the hard limit', () => {
+    // The 2^31 soft threshold and its `e2ee.rotation_needed` event were
+    // removed: rotating cannot buy back counter budget, so the signal named a
+    // remedy that does nothing. Only the fail-closed ceiling remains.
+    __setFrameCounterForTest(0x80000000 - 1);
+    nextFrameCounter();
+    nextFrameCounter();
+    expect(
+      postMessage.mock.calls.filter(([msg]) =>
+        String(msg?.type).startsWith('e2ee.'),
+      ),
+    ).toHaveLength(0);
+  });
+});