release(v4.0.0): Shade GA — V3.x consolidation + audit prep

V3.1 → V3.12 consolidated and tagged for the first GA release. Wire
format unchanged from 0.4.x — 4.0 peers interoperate with 0.4.x peers
byte-for-byte. The version bump is semantic: audit-cycle complete,
opt-in surface fully exposed, threat model refreshed for every new
surface.

Highlights:
- All 24 @shade/* packages bumped to 4.0.0 in lockstep.
- CHANGELOG 4.0.0 section is the canonical manifest of what landed.
- THREAT-MODEL extended (§10 fingerprint gates, §11 WebRTC P2P, §12
  Web-Worker boundary) + residual-risks table refreshed.
- OpenAPI now covers all 27 routes: prekey, transfer, KT, inbox,
  bridge, observer, /metrics, /healthz, /ready.
- MIGRATION 0.3.x → 4.0 documented + smoke-tested against
  shade migrate-storage on a real SQLite DB.
- docs/audit/REVIEW-BUNDLE.md + SCOPE.md ready for external reviewer.
- scripts/soak.ts harness for the GA-stable 2-week soak window.
- All V*.md plans archived under docs/archive/ with Status: Done.
- Voice/Video carved out into V5.0; 4.0 audit focuses on the frozen
  non-realtime stack.

Tests: TS 1000/1000 + Kotlin 11/11 cross-platform vectors green.
Docker: gt.zyon.no/stian/shade-prekey:4.0.0 builds and reports
  version 4.0.0 on /health.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

packages/shade-transport-webrtc/tests/wire.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'bun:test';
+import {
+  CHUNK_HEADER_LEN,
+  bytesEqual,
+  decodeFrame,
+  encodeChunkAckFrame,
+  encodeChunkFrame,
+  encodeErrorFrame,
+  encodePingFrame,
+  encodePongFrame,
+  encodeResumeQueryFrame,
+  encodeResumeStateFrame,
+  randomRequestId,
+  REQUEST_ID_LEN,
+  STREAM_ID_LEN,
+  streamIdBytesToString,
+  streamIdStringToBytes,
+  WIRE_CHUNK,
+  WIRE_CHUNK_ACK,
+  WIRE_ERROR,
+  WIRE_PING,
+  WIRE_PONG,
+  WIRE_RESUME_QUERY,
+  WIRE_RESUME_STATE,
+} from '../src/wire.js';
+
+describe('wire format', () => {
+  it('roundtrips a chunk frame', () => {
+    const requestId = randomRequestId();
+    const streamId = new Uint8Array(STREAM_ID_LEN).fill(0xab);
+    const envelope = new Uint8Array(1024);
+    for (let i = 0; i < envelope.length; i++) envelope[i] = i & 0xff;
+    const buf = encodeChunkFrame({
+      type: WIRE_CHUNK,
+      requestId,
+      streamId,
+      laneId: 7,
+      seq: 12345n,
+      envelope,
+    });
+    expect(buf.length).toBe(CHUNK_HEADER_LEN + envelope.length);
+
+    const decoded = decodeFrame(buf);
+    expect(decoded.type).toBe(WIRE_CHUNK);
+    if (decoded.type !== WIRE_CHUNK) throw new Error('type narrow failed');
+    expect(bytesEqual(decoded.requestId, requestId)).toBe(true);
+    expect(bytesEqual(decoded.streamId, streamId)).toBe(true);
+    expect(decoded.laneId).toBe(7);
+    expect(decoded.seq).toBe(12345n);
+    expect(bytesEqual(decoded.envelope, envelope)).toBe(true);
+  });
+
+  it('roundtrips a resume-query frame', () => {
+    const requestId = randomRequestId();
+    const streamId = new Uint8Array(STREAM_ID_LEN).fill(0x33);
+    const buf = encodeResumeQueryFrame({
+      type: WIRE_RESUME_QUERY,
+      requestId,
+      streamId,
+    });
+    const decoded = decodeFrame(buf);
+    if (decoded.type !== WIRE_RESUME_QUERY) throw new Error('type narrow failed');
+    expect(bytesEqual(decoded.requestId, requestId)).toBe(true);
+    expect(bytesEqual(decoded.streamId, streamId)).toBe(true);
+  });
+
+  it('roundtrips chunk-ack', () => {
+    const requestId = randomRequestId();
+    const buf = encodeChunkAckFrame({
+      type: WIRE_CHUNK_ACK,
+      requestId,
+      lastSeq: 42,
+      bytesReceived: 1024,
+    });
+    const decoded = decodeFrame(buf);
+    if (decoded.type !== WIRE_CHUNK_ACK) throw new Error('type narrow failed');
+    expect(decoded.lastSeq).toBe(42);
+    expect(decoded.bytesReceived).toBe(1024);
+  });
+
+  it('roundtrips resume-state frame', () => {
+    const json = JSON.stringify({
+      streamId: 'abc',
+      lanes: [{ laneId: 0, lastSeqAcked: 5 }],
+    });
+    const buf = encodeResumeStateFrame({
+      type: WIRE_RESUME_STATE,
+      requestId: randomRequestId(),
+      json,
+    });
+    const decoded = decodeFrame(buf);
+    if (decoded.type !== WIRE_RESUME_STATE) throw new Error('type narrow failed');
+    expect(decoded.json).toBe(json);
+  });
+
+  it('roundtrips ping/pong frames', () => {
+    const requestId = randomRequestId();
+    const ping = encodePingFrame({ type: WIRE_PING, requestId, nonce: 99n });
+    const decodedPing = decodeFrame(ping);
+    if (decodedPing.type !== WIRE_PING) throw new Error('type narrow failed');
+    expect(decodedPing.nonce).toBe(99n);
+
+    const pong = encodePongFrame({ type: WIRE_PONG, requestId, nonce: 99n });
+    const decodedPong = decodeFrame(pong);
+    if (decodedPong.type !== WIRE_PONG) throw new Error('type narrow failed');
+    expect(decodedPong.nonce).toBe(99n);
+  });
+
+  it('roundtrips error frame', () => {
+    const buf = encodeErrorFrame({
+      type: WIRE_ERROR,
+      requestId: randomRequestId(),
+      json: '{"error":"oh no"}',
+    });
+    const decoded = decodeFrame(buf);
+    if (decoded.type !== WIRE_ERROR) throw new Error('type narrow failed');
+    expect(JSON.parse(decoded.json)).toEqual({ error: 'oh no' });
+  });
+
+  it('rejects truncated frames', () => {
+    const tiny = new Uint8Array(8);
+    expect(() => decodeFrame(tiny)).toThrow();
+  });
+
+  it('rejects unknown type', () => {
+    const bad = new Uint8Array(REQUEST_ID_LEN + 1);
+    bad[0] = 0x77;
+    expect(() => decodeFrame(bad)).toThrow();
+  });
+});
+
+describe('streamId base64url codec', () => {
+  it('roundtrips arbitrary 16-byte ids', () => {
+    const original = new Uint8Array(STREAM_ID_LEN);
+    globalThis.crypto.getRandomValues(original);
+    const s = streamIdBytesToString(original);
+    const back = streamIdStringToBytes(s);
+    expect(bytesEqual(back, original)).toBe(true);
+  });
+});