@evolu/common 8.17.0 → 8.18.0

package/src/local-first/Protocol.test.ts

@@ -1,7 +1,10 @@
 import * as fc from "fast-check";
 import { describe, it, test } from "node:test";
+import { setFlagsFromString } from "node:v8";
+import { runInNewContext } from "node:vm";
 import type { NonEmptyReadonlyArray } from "../Array.ts";
 import {
+  assert,
   assertEqual,
   assertEqualBytes,
   assertErr,
@@ -14,8 +17,22 @@ import {
   assertThrowsInstanceOf,
   assertTrue,
 } from "../Assert.ts";
-import { createBuffer, encodeNonNegativeInt } from "../Bytes.ts";
-import { EncryptionKey } from "../Crypto.ts";
+import {
+  createBuffer,
+  decodeLength,
+  decodeNonNegativeInt,
+  encodeLength,
+  encodeNonNegativeInt,
+} from "../Bytes.ts";
+import {
+  decryptWithXChaCha20Poly1305,
+  EncryptionKey,
+  encryptWithXChaCha20Poly1305,
+  Entropy24,
+  XChaCha20Poly1305Ciphertext,
+  xChaCha20Poly1305NonceLength,
+} from "../Crypto.ts";
+import { createUnknownError } from "../Error.ts";
 import { constFalse, constTrue } from "../Function.ts";
 import { SqliteValue } from "../Sqlite.ts";
 import {
@@ -29,7 +46,9 @@ import {
   createProtocolMessageBuffer,
   createProtocolBroadcastMessagesFromCrdtMessages,
   defaultProtocolMessageMaxSize,
+  defaultProtocolMessageRangesMaxSize,
   ProtocolMessageMaxSize,
+  ProtocolMessageRangesMaxSize,
   ProtocolErrorCode,
   createProtocolMessageFromCrdtMessages,
   createProtocolMessageForSync,
@@ -43,12 +62,19 @@ import {
   ProtocolValueType,
   protocolVersion,
   SubscriptionFlags,
+  type ApplyProtocolMessageAsClientOptions,
+  type ApplyProtocolMessageAsRelayOptions,
+  type ProtocolChangeTooLargeError,
   type ProtocolError,
+  type ProtocolMessageBuffer,
+  type TimestampsBuffer,
+  type TimestampsRangeWithTimestampsBuffer,
 } from "./Protocol.ts";
 import type {
   CrdtMessage,
   EncryptedCrdtMessage,
   EncryptedDbChange,
+  FingerprintRange,
   StorageDep,
 } from "./Storage.ts";
 import {
@@ -61,6 +87,7 @@ import {
 } from "./Storage.ts";
 import { err, getOrThrow, ok } from "../Result.ts";
 import {
+  AbortError,
   createAbortError,
   testCreateDeps,
   testCreateRun,
@@ -78,10 +105,12 @@ import {
   PositiveInt,
 } from "../Type.ts";
 import {
+  Counter,
   createInitialTimestamp,
   createTimestamp,
   maxCounter,
   maxNodeId,
+  NodeId,
   timestampBytesToTimestamp,
   timestampToTimestampBytes,
 } from "./Timestamp.ts";
@@ -103,6 +132,25 @@ test("protocolVersion", () => {
   assertEqual(protocolVersion, 1);
 });
 
+test("ProtocolErrorCode", () => {
+  assertType<ProtocolErrorCode, 0 | 1 | 2 | 3 | 4>();
+});
+
+test("apply options are readonly", () => {
+  assertType<
+    ApplyProtocolMessageAsClientOptions,
+    Readonly<ApplyProtocolMessageAsClientOptions>
+  >();
+  assertType<
+    ApplyProtocolMessageAsRelayOptions,
+    Readonly<ApplyProtocolMessageAsRelayOptions>
+  >();
+
+  const options: ApplyProtocolMessageAsClientOptions = {};
+  // @ts-expect-error Cannot assign to 'rangesMaxSize' because it is a read-only property.
+  options.rangesMaxSize = defaultProtocolMessageRangesMaxSize;
+});
+
 test("ProtocolValueType", () => {
   assertEqual(ProtocolValueType, {
     Base64Url: 32,
@@ -207,6 +255,23 @@ test("encodeSqliteValue/decodeSqliteValue preserves an own __proto__ JSON object
   assertEqual(decodeSqliteValue(buffer), value);
 });
 
+test("encodeSqliteValue/decodeSqliteValue replaces a lone surrogate in a string with U+FFFD", () => {
+  const buffer = createBuffer();
+
+  encodeSqliteValue(buffer, "a\uD800b");
+
+  assertEqualBytes(buffer.unwrap(), [20, 5, 97, 0xef, 0xbf, 0xbd, 98]);
+  assertSame(decodeSqliteValue(buffer), "a�b");
+});
+
+test("encodeSqliteValue/decodeSqliteValue keeps a byte order mark in a string", () => {
+  for (const value of ["\uFEFFabc", "\uFEFF", "a\uFEFFb"]) {
+    const buffer = createBuffer();
+    encodeSqliteValue(buffer, value);
+    assertSame(decodeSqliteValue(buffer), value);
+  }
+});
+
 test("encodeSqliteValue encodes JSON nested deeper than decoding allows as a string", () => {
   for (const [depth, type] of [
     [1_000, ProtocolValueType.Json],
@@ -224,6 +289,54 @@ test("encodeSqliteValue encodes JSON nested deeper than decoding allows as a str
   }
 });
 
+test("encodeSqliteValue does not retain memory for a large JSON value", () => {
+  setFlagsFromString("--expose-gc");
+  const gc = runInNewContext("gc") as () => void;
+  // Earlier tests in this process may still hold memory, so this measures
+  // only what encoding adds.
+  gc();
+  gc();
+  const before = process.memoryUsage().arrayBuffers;
+  const buffer = createBuffer();
+
+  encodeSqliteValue(buffer, JSON.stringify(["x".repeat(3_000_000)]));
+  gc();
+  gc();
+
+  const retained =
+    process.memoryUsage().arrayBuffers - before - buffer.getCapacity();
+  assert(retained < 1_000_000, "Expected JSON encoding memory released.", {
+    actual: retained,
+  });
+});
+
+test("encoding and decoding errors do not need Error.captureStackTrace", () => {
+  const descriptor = Object.getOwnPropertyDescriptor(
+    Error,
+    "captureStackTrace",
+  );
+  assertNonNullable(descriptor);
+  Reflect.deleteProperty(Error, "captureStackTrace");
+  try {
+    const value = "[".repeat(1_001) + "]".repeat(1_001);
+    const buffer = createBuffer();
+    encodeSqliteValue(buffer, value);
+    assertEqual(buffer.unwrap()[0], ProtocolValueType.String);
+    assertEqual(decodeSqliteValue(buffer), value);
+
+    const invalidTypeMessage = createBuffer();
+    encodeNonNegativeInt(invalidTypeMessage, protocolVersion);
+    invalidTypeMessage.extend(ownerIdToOwnerIdBytes(testAppOwner.id));
+    invalidTypeMessage.extend([9]);
+    const invalidType = parseProtocolHeader(invalidTypeMessage.unwrap());
+    assertErr(invalidType);
+    assertInstanceOf(invalidType.error.error, Error);
+    assertEqual(invalidType.error.error.message, "Invalid MessageType");
+  } finally {
+    Object.defineProperty(Error, "captureStackTrace", descriptor);
+  }
+});
+
 test("encodeSqliteValue/decodeSqliteValue property tests", () => {
   const deps = testCreateDeps();
   // Property test: round-trip encoding/decoding should preserve the value
@@ -547,6 +660,69 @@ test("decryptAndDecodeDbChange timestamp tamper-proofing", () => {
   );
 });
 
+test("decryptAndDecodeDbChange rejects a newer EncryptedDbChange version", () => {
+  const deps = testCreateDeps();
+  const crdtMessage = createTestCrdtMessage(deps);
+  const encryptedMessage = createEncryptedCrdtMessage(deps, crdtMessage);
+
+  const envelope = createBuffer(encryptedMessage.change);
+  const nonce = envelope.shiftN(
+    NonNegativeInt.orThrow(xChaCha20Poly1305NonceLength),
+  );
+  const plaintext = getOrThrow(
+    decryptWithXChaCha20Poly1305(
+      XChaCha20Poly1305Ciphertext.orThrow(
+        envelope.shiftN(decodeLength(envelope)),
+      ),
+      Entropy24.orThrow(nonce),
+      testAppOwner.encryptionKey,
+    ),
+  );
+  assertEqual(plaintext[0], 1);
+
+  const reencryptWithVersion = (version: number): EncryptedCrdtMessage => {
+    const forged = new Uint8Array(plaintext);
+    forged[0] = version;
+    const [ciphertext, forgedNonce] = encryptWithXChaCha20Poly1305(deps)(
+      forged,
+      testAppOwner.encryptionKey,
+    );
+    const buffer = createBuffer();
+    buffer.extend(forgedNonce);
+    encodeLength(buffer, ciphertext);
+    buffer.extend(ciphertext);
+    return {
+      timestamp: crdtMessage.timestamp,
+      change: buffer.unwrap() as EncryptedDbChange,
+    };
+  };
+
+  // 6.0.1-preview.35 wrote version 0 with the same layout.
+  assertOk(
+    decryptAndDecodeDbChange(
+      reencryptWithVersion(0),
+      testAppOwner.encryptionKey,
+    ),
+    crdtMessage.change,
+  );
+
+  const newerVersion = reencryptWithVersion(2);
+  const newer = decryptAndDecodeDbChange(
+    newerVersion,
+    testAppOwner.encryptionKey,
+  );
+  assertErr(newer);
+  assertEqual(newer.error.type, "ProtocolInvalidDataError");
+  if (newer.error.type === "ProtocolInvalidDataError") {
+    assertSame(newer.error.data, newerVersion.change);
+    assertInstanceOf(newer.error.error, Error);
+    assertEqual(
+      newer.error.error.message,
+      "Unsupported EncryptedDbChange version",
+    );
+  }
+});
+
 const shouldNotBeCalled = () => {
   throw new Error("should not be called");
 };
@@ -559,7 +735,6 @@ const shouldNotBeCalledStorageDep: StorageDep = {
     findLowerBound: shouldNotBeCalled,
     iterate: shouldNotBeCalled,
     validateWriteKey: shouldNotBeCalled,
-    setWriteKey: shouldNotBeCalled,
     writeMessages: shouldNotBeCalled,
     readDbChange: shouldNotBeCalled,
     deleteOwner: shouldNotBeCalled,
@@ -594,7 +769,464 @@ test("createTimestampsBuffer maxTimestamp", () => {
   assertEqual(buffer.getLength(), 21);
 });
 
+const createTestTimestamp = (millis: number) =>
+  createTimestamp({ millis: Millis.orThrow(millis) });
+
+const setupTimestampsBuffer = (millises: ReadonlyArray<number>) => {
+  const timestamps = createTimestampsBuffer();
+  for (const millis of millises) timestamps.add(createTestTimestamp(millis));
+  return timestamps;
+};
+
+const timestampsBufferToBytes = (timestamps: TimestampsBuffer) => {
+  const buffer = createBuffer();
+  timestamps.append(buffer);
+  return buffer.unwrap();
+};
+
+describe("TimestampsBuffer checkpoint", () => {
+  it("restores the count across the 127/128 varint boundary", () => {
+    const millises = Array.from({ length: 128 }, (_, index) => index);
+    const timestamps = setupTimestampsBuffer(millises.slice(0, 127));
+    const restore = timestamps.checkpoint();
+    timestamps.add(createTestTimestamp(127));
+    assertEqualBytes(timestampsBufferToBytes(timestamps).slice(0, 2), [128, 1]);
+
+    restore();
+    assertSame(timestamps.getCount(), 127);
+    assertSame(timestampsBufferToBytes(timestamps)[0], 127);
+    assertEqualBytes(
+      timestampsBufferToBytes(timestamps),
+      timestampsBufferToBytes(setupTimestampsBuffer(millises.slice(0, 127))),
+    );
+    assertSame(
+      timestamps.getLength(),
+      setupTimestampsBuffer(millises.slice(0, 127)).getLength(),
+    );
+
+    timestamps.add(createTestTimestamp(127));
+    assertEqualBytes(
+      timestampsBufferToBytes(timestamps),
+      timestampsBufferToBytes(setupTimestampsBuffer(millises)),
+    );
+  });
+
+  it("restores the previous millis", () => {
+    const timestamps = setupTimestampsBuffer([100]);
+    const restore = timestamps.checkpoint();
+    timestamps.add(createTestTimestamp(500));
+    restore();
+    timestamps.add(createTestTimestamp(700));
+
+    // Millis are encoded as deltas after the count.
+    const buffer = createBuffer(timestampsBufferToBytes(timestamps));
+    assertSame(decodeNonNegativeInt(buffer), 2);
+    const first = decodeNonNegativeInt(buffer);
+    const second = first + decodeNonNegativeInt(buffer);
+    assertEqual([first, second], [100, 700]);
+    assertEqualBytes(
+      timestampsBufferToBytes(timestamps),
+      timestampsBufferToBytes(setupTimestampsBuffer([100, 700])),
+    );
+  });
+
+  it("restores infinite entries", () => {
+    const timestamps = setupTimestampsBuffer([1]);
+    const restoreFinite = timestamps.checkpoint();
+    timestamps.addInfinite();
+    const restoreInfinite = timestamps.checkpoint();
+    timestamps.addInfinite();
+    assertSame(timestamps.getCount(), 3);
+
+    restoreInfinite();
+    assertSame(timestamps.getCount(), 2);
+
+    restoreFinite();
+    assertSame(timestamps.getCount(), 1);
+    assertEqualBytes(
+      timestampsBufferToBytes(timestamps),
+      timestampsBufferToBytes(setupTimestampsBuffer([1])),
+    );
+  });
+
+  it("restores an empty buffer", () => {
+    const timestamps = createTimestampsBuffer();
+    const restore = timestamps.checkpoint();
+    timestamps.add(
+      createTimestamp({
+        millis: Millis.orThrow(5),
+        counter: maxCounter,
+        nodeId: maxNodeId,
+      }),
+    );
+    timestamps.addInfinite();
+
+    restore();
+    assertSame(timestamps.getCount(), 0);
+    assertEqualBytes(timestampsBufferToBytes(timestamps), [0]);
+
+    timestamps.add(createTestTimestamp(7));
+    assertEqualBytes(
+      timestampsBufferToBytes(timestamps),
+      timestampsBufferToBytes(setupTimestampsBuffer([7])),
+    );
+  });
+});
+
+describe("ProtocolMessageBuffer tryWrite", () => {
+  const setupRequestBuffer = ({
+    rangesMaxSize,
+  }: {
+    rangesMaxSize?: ProtocolMessageRangesMaxSize;
+  } = {}) =>
+    createProtocolMessageBuffer(testAppOwner.id, {
+      messageType: MessageType.Request,
+      rangesMaxSize,
+    });
+
+  const createTestMessage = (
+    millis: number,
+    changeLength: number,
+  ): EncryptedCrdtMessage => ({
+    timestamp: createTimestamp({
+      millis: Millis.orThrow(millis),
+      counter: maxCounter,
+      nodeId: maxNodeId,
+    }),
+    change: new Uint8Array(changeLength).fill(millis) as EncryptedDbChange,
+  });
+
+  const createTestBound = (millis: number) =>
+    timestampToTimestampBytes(createTestTimestamp(millis));
+
+  const closingRange: FingerprintRange = {
+    type: RangeType.Fingerprint,
+    upperBound: InfiniteUpperBound,
+    fingerprint: zeroFingerprint,
+  };
+
+  // The first range adds the ranges count, and Fingerprint(InfiniteUpperBound)
+  // adds its type and fingerprint without an upper bound.
+  const firstClosingRangeSize = 1 + 1 + 12;
+
+  const emptyRequestLength = setupRequestBuffer().unwrap().length;
+
+  it("keeps a write that fits the total budget exactly", () => {
+    // Changes near the limit and this probe have a 3-byte length varint.
+    const probe = setupRequestBuffer();
+    probe.addMessage(createTestMessage(1, 100_000));
+    const messageOverhead = probe.unwrap().length - 100_000;
+
+    for (const reserve of [0, 5]) {
+      const fittingLength =
+        defaultProtocolMessageMaxSize -
+        messageOverhead -
+        firstClosingRangeSize -
+        reserve;
+
+      const fits = setupRequestBuffer();
+      assertTrue(
+        fits.tryWrite(() => {
+          fits.addMessage(createTestMessage(1, fittingLength));
+        }, NonNegativeInt.orThrow(reserve)),
+      );
+      fits.addRange(closingRange);
+      assertSame(fits.getSize(), defaultProtocolMessageMaxSize - reserve);
+      assertSame(fits.unwrap().length, defaultProtocolMessageMaxSize - reserve);
+
+      const over = setupRequestBuffer();
+      assertFalse(
+        over.tryWrite(() => {
+          over.addMessage(createTestMessage(1, fittingLength + 1));
+        }, NonNegativeInt.orThrow(reserve)),
+      );
+      assertEqualBytes(over.unwrap(), setupRequestBuffer().unwrap());
+    }
+  });
+
+  it("keeps a write that fits the ranges budget exactly", () => {
+    const addLargeRange = (buffer: ProtocolMessageBuffer) => () => {
+      // 3-byte millis deltas make the range a little over 3,000 bytes.
+      const timestamps = createTimestampsBuffer();
+      for (let index = 1; index <= 1_000; index++) {
+        timestamps.add(createTestTimestamp(index * 100_000));
+      }
+      buffer.addRange({
+        type: RangeType.Timestamps,
+        upperBound: createTestBound(200_000_000),
+        timestamps,
+      });
+    };
+
+    const probe = setupRequestBuffer();
+    addLargeRange(probe)();
+    probe.addRange(closingRange);
+    const closedRangesSize = probe.unwrap().length - emptyRequestLength;
+
+    for (const reserve of [0, 5]) {
+      const fits = setupRequestBuffer({
+        rangesMaxSize: ProtocolMessageRangesMaxSize.orThrow(
+          closedRangesSize + reserve,
+        ),
+      });
+      assertTrue(
+        fits.tryWrite(addLargeRange(fits), NonNegativeInt.orThrow(reserve)),
+      );
+      fits.addRange(closingRange);
+      assertSame(fits.unwrap().length - emptyRequestLength, closedRangesSize);
+
+      const over = setupRequestBuffer({
+        rangesMaxSize: ProtocolMessageRangesMaxSize.orThrow(
+          closedRangesSize + reserve - 1,
+        ),
+      });
+      assertFalse(
+        over.tryWrite(addLargeRange(over), NonNegativeInt.orThrow(reserve)),
+      );
+      assertEqualBytes(over.unwrap(), setupRequestBuffer().unwrap());
+    }
+  });
+
+  it("reserves exactly the bytes of the closing range", () => {
+    // Closing adds a range type and a fingerprint, and a byte to the ranges
+    // count varint when the count becomes 1 or 128.
+    for (const [rangesCount, closingRangeSize] of [
+      [0, 14],
+      [1, 13],
+      [127, 14],
+      [128, 13],
+    ] as const) {
+      const setupBuffer = () => {
+        const buffer = setupRequestBuffer();
+        for (let index = 1; index <= rangesCount; index++) {
+          buffer.addRange({
+            type: RangeType.Skip,
+            upperBound: createTestBound(index),
+          });
+        }
+        return buffer;
+      };
+      const probe = setupBuffer();
+      probe.addMessage(createTestMessage(1, 100_000));
+      const fittingLength =
+        defaultProtocolMessageMaxSize -
+        (probe.getSize() - 100_000) -
+        closingRangeSize;
+
+      const fits = setupBuffer();
+      assertTrue(
+        fits.tryWrite(() => {
+          fits.addMessage(createTestMessage(1, fittingLength));
+        }),
+      );
+      fits.addRange(closingRange);
+      assertSame(fits.unwrap().length, defaultProtocolMessageMaxSize);
+
+      const over = setupBuffer();
+      assertFalse(
+        over.tryWrite(() => {
+          over.addMessage(createTestMessage(1, fittingLength + 1));
+        }),
+      );
+    }
+  });
+
+  it("reserves nothing once an infinite range closed the frame", () => {
+    const probe = setupRequestBuffer();
+    probe.addRange(closingRange);
+    probe.addMessage(createTestMessage(1, 100_000));
+    const fittingLength =
+      defaultProtocolMessageMaxSize - (probe.getSize() - 100_000);
+
+    const fits = setupRequestBuffer();
+    fits.addRange(closingRange);
+    assertTrue(
+      fits.tryWrite(() => {
+        fits.addMessage(createTestMessage(1, fittingLength));
+      }),
+    );
+    assertSame(fits.unwrap().length, defaultProtocolMessageMaxSize);
+
+    const over = setupRequestBuffer();
+    over.addRange(closingRange);
+    assertFalse(
+      over.tryWrite(() => {
+        over.addMessage(createTestMessage(1, fittingLength + 1));
+      }),
+    );
+  });
+
+  it("leaves no trace of a rejected write", () => {
+    const setupBuffer = () => {
+      const buffer = setupRequestBuffer();
+      buffer.addMessage(createTestMessage(1, 10));
+      buffer.addMessage(createTestMessage(2, 10));
+      buffer.addRange({
+        type: RangeType.Skip,
+        upperBound: createTestBound(10),
+      });
+      buffer.addRange({
+        type: RangeType.Fingerprint,
+        upperBound: createTestBound(20),
+        fingerprint: zeroFingerprint,
+      });
+      return buffer;
+    };
+
+    const untouched = setupBuffer();
+    const rejected = setupBuffer();
+    assertFalse(
+      rejected.tryWrite(() => {
+        // The same counter and NodeId rewrite the runs in place.
+        rejected.addMessage(createTestMessage(3, 10));
+        rejected.addRange({
+          type: RangeType.Fingerprint,
+          upperBound: createTestBound(30),
+          fingerprint: zeroFingerprint,
+        });
+        rejected.addMessage(
+          createTestMessage(4, defaultProtocolMessageMaxSize),
+        );
+      }),
+    );
+    assertSame(rejected.getSize(), untouched.getSize());
+
+    for (const buffer of [untouched, rejected]) {
+      buffer.addMessage(createTestMessage(5, 10));
+      buffer.addRange({
+        type: RangeType.Timestamps,
+        upperBound: createTestBound(40),
+        timestamps: setupTimestampsBuffer([25, 35]),
+      });
+      buffer.addRange(closingRange);
+    }
+    assertEqualBytes(rejected.unwrap(), untouched.unwrap());
+  });
+
+  it("asserts the size limit only outside a trial", () => {
+    const buffer = setupRequestBuffer();
+    const tooLarge = createTestMessage(2, defaultProtocolMessageMaxSize);
+    assertFalse(
+      buffer.tryWrite(() => {
+        assertFalse(
+          buffer.tryWrite(() => {
+            buffer.addMessage(tooLarge);
+          }),
+        );
+        // The outer trial is still running.
+        buffer.addMessage(tooLarge);
+      }),
+    );
+
+    const error = assertThrowsInstanceOf(() => {
+      buffer.addMessage(tooLarge);
+    }, Error);
+    assertSame(error.message, "the message is too big");
+  });
+
+  it("undoes a write that throws", () => {
+    const failure = new Error("storage unavailable");
+    const buffer = setupRequestBuffer();
+    assertSame(
+      assertThrowsInstanceOf(
+        () =>
+          buffer.tryWrite(() => {
+            buffer.addMessage(createTestMessage(1, 10));
+            buffer.addRange(closingRange);
+            throw failure;
+          }),
+        Error,
+      ),
+      failure,
+    );
+
+    buffer.addRange(closingRange);
+    const expected = setupRequestBuffer();
+    expected.addRange(closingRange);
+    assertEqualBytes(buffer.unwrap(), expected.unwrap());
+  });
+
+  it("keeps or undoes a compound write as a whole", () => {
+    const addRanges = (buffer: ProtocolMessageBuffer) => () => {
+      buffer.addMessage(createTestMessage(1, 10));
+      // A coalesced skip followed by the ranges of a split.
+      buffer.addRange({
+        type: RangeType.Skip,
+        upperBound: createTestBound(10),
+      });
+      buffer.addRange({
+        type: RangeType.Fingerprint,
+        upperBound: createTestBound(20),
+        fingerprint: zeroFingerprint,
+      });
+      const timestamps = createTimestampsBuffer();
+      for (let index = 1; index <= 1_000; index++) {
+        timestamps.add(createTestTimestamp(20 + index * 100_000));
+      }
+      buffer.addRange({
+        type: RangeType.Timestamps,
+        upperBound: createTestBound(200_000_000),
+        timestamps,
+      });
+    };
+
+    const expectedKept = setupRequestBuffer();
+    addRanges(expectedKept)();
+    expectedKept.addRange(closingRange);
+
+    const kept = setupRequestBuffer({
+      rangesMaxSize: ProtocolMessageRangesMaxSize.orThrow(100_000),
+    });
+    assertTrue(kept.tryWrite(addRanges(kept)));
+    kept.addRange(closingRange);
+    assertEqualBytes(kept.unwrap(), expectedKept.unwrap());
+
+    const expectedUndone = setupRequestBuffer();
+    expectedUndone.addRange(closingRange);
+
+    const undone = setupRequestBuffer({
+      rangesMaxSize: ProtocolMessageRangesMaxSize.orThrow(3_000),
+    });
+    assertFalse(undone.tryWrite(addRanges(undone)));
+    undone.addRange(closingRange);
+    // Neither the ranges nor the message remain.
+    assertEqualBytes(undone.unwrap(), expectedUndone.unwrap());
+  });
+});
+
 describe("createProtocolMessageBuffer", () => {
+  it("unwraps repeatedly without changing the builder", () => {
+    const deps = testCreateDeps();
+    const setupBuffer = () =>
+      createProtocolMessageBuffer(testAppOwner.id, {
+        messageType: MessageType.Request,
+        writeKey: testAppOwner.writeKey,
+      });
+    const first = createEncryptedCrdtMessage(deps, createTestCrdtMessage(deps));
+    const second = createEncryptedCrdtMessage(
+      deps,
+      createTestCrdtMessage(deps),
+    );
+    const range: FingerprintRange = {
+      type: RangeType.Fingerprint,
+      upperBound: InfiniteUpperBound,
+      fingerprint: zeroFingerprint,
+    };
+
+    const buffer = setupBuffer();
+    buffer.addMessage(first);
+    const message = buffer.unwrap();
+    assertEqualBytes(buffer.unwrap(), message);
+
+    buffer.addMessage(second);
+    buffer.addRange(range);
+    const expected = setupBuffer();
+    expected.addMessage(first);
+    expected.addMessage(second);
+    expected.addRange(range);
+    assertEqualBytes(buffer.unwrap(), expected.unwrap());
+  });
+
   it("should allow no ranges", () => {
     const buffer = createProtocolMessageBuffer(testAppOwner.id, {
       messageType: MessageType.Request,
@@ -888,56 +1520,266 @@ describe("E2E versioning", () => {
   });
 });
 
+/**
+ * Applies `message` as a relay and returns the message of the error that
+ * rejected it as `ProtocolInvalidDataError`.
+ */
+const getRelayDecodeErrorMessage = async (
+  message: Uint8Array,
+  storage: StorageDep["storage"] = shouldNotBeCalledStorageDep.storage,
+): Promise<string> => {
+  await using run = testCreateRun({ storage });
+  const result = await run(applyProtocolMessageAsRelay(message));
+  assertErr(result);
+  assertSame(result.error.type, "ProtocolInvalidDataError");
+  assertInstanceOf(result.error.error, Error);
+  return result.error.error.message;
+};
+
+/** Returns a Buffer holding a Request header with the given flag bytes. */
+const setupRequestHeader = (hasWriteKey = 0, subscriptionFlag = 0) => {
+  const buffer = createBuffer();
+  encodeNonNegativeInt(buffer, protocolVersion);
+  buffer.extend(ownerIdToOwnerIdBytes(testAppOwner.id));
+  buffer.extend([MessageType.Request, hasWriteKey, subscriptionFlag]);
+  return buffer;
+};
+
 describe("E2E errors", () => {
-  it("ProtocolInvalidDataError", async () => {
-    await using run = testCreateRun(shouldNotBeCalledStorageDep);
-    const malformedMessage = createBuffer();
-    // Only version, no ownerId
-    encodeNonNegativeInt(malformedMessage, 1 as NonNegativeInt);
+  it("rejects a ranges section larger than any conforming sender produces", async () => {
+    const request = createProtocolMessageBuffer(testAppOwner.id, {
+      messageType: MessageType.Request,
+    });
+    const upperBound = timestampToTimestampBytes(createTestTimestamp(1));
+    // Equal bounds take about 2 bytes per range.
+    for (let i = 0; i < 100_500; i++)
+      request.addRange({ type: RangeType.Skip, upperBound });
+    request.addRange({
+      type: RangeType.Fingerprint,
+      upperBound: InfiniteUpperBound,
+      fingerprint: zeroFingerprint,
+    });
 
-    const clientResult = await run(
-      applyProtocolMessageAsClient(malformedMessage.unwrap(), {
-        version: 0 as NonNegativeInt,
-      }),
+    assertSame(
+      await getRelayDecodeErrorMessage(request.unwrap()),
+      "Ranges section exceeds 200000 bytes",
     );
+  });
 
-    assertFalse(clientResult.ok);
-    assertEqual(clientResult.error.type, "ProtocolInvalidDataError");
+  it("rejects a ranges count larger than the remaining bytes", async () => {
+    const request = setupRequestHeader();
+    request.extend([0]);
+    encodeNonNegativeInt(request, NonNegativeInt.orThrow(1e9));
+    request.extend(new Uint8Array(1000));
+
+    // Every range but the last has an upper bound timestamp.
+    assertSame(
+      await getRelayDecodeErrorMessage(request.unwrap()),
+      "Invalid timestamps count",
+    );
   });
 
-  it("ProtocolWriteKeyError", async () => {
-    const deps = testCreateDeps();
-    const timestamp = timestampBytesToTimestamp(testTimestampsAsc[0]);
-    const dbChange = createDbChange(deps);
+  it("rejects a timestamps count larger than the remaining bytes", async () => {
+    const count = NonNegativeInt.orThrow(1e9);
 
-    const messages: NonEmptyReadonlyArray<CrdtMessage> = [
-      { timestamp, change: dbChange },
-    ];
+    const messages = setupRequestHeader();
+    encodeNonNegativeInt(messages, count);
+    messages.extend(new Uint8Array(1000));
 
-    const initiatorMessage = createProtocolMessageFromCrdtMessages(deps)(
-      testAppOwner,
-      messages,
-    );
+    // One range with InfiniteUpperBound listing its timestamps.
+    const nested = setupRequestHeader();
+    nested.extend([0, 1, RangeType.Timestamps]);
+    encodeNonNegativeInt(nested, count);
+    nested.extend(new Uint8Array(1000));
 
-    let responseMessage: Uint8Array;
-    {
-      await using run = testCreateRun({
-        storage: {
-          ...shouldNotBeCalledStorageDep.storage,
-          validateWriteKey: constFalse,
-        },
-      });
-      const response = await run.orThrow(
-        applyProtocolMessageAsRelay(initiatorMessage),
-      );
-      assertEqualBytes(
-        response.message,
-        [
-          1, 5, 39, 254, 242, 108, 77, 142, 9, 59, 219, 32, 254, 15, 186, 235,
-          212, 1, 1, 0,
-        ],
+    for (const request of [messages, nested])
+      assertSame(
+        await getRelayDecodeErrorMessage(request.unwrap()),
+        "Invalid timestamps count",
       );
-      responseMessage = response.message;
+  });
+
+  it("rejects descending range upper bounds before touching storage", async () => {
+    const createBound = (counter: number, nodeId: string) =>
+      timestampToTimestampBytes(
+        createTimestamp({
+          millis: Millis.orThrow(1500),
+          counter: Counter.orThrow(counter),
+          nodeId: NodeId.orThrow(nodeId),
+        }),
+      );
+
+    const descendingCounters = createProtocolMessageBuffer(testAppOwner.id, {
+      messageType: MessageType.Request,
+    });
+    for (const counter of [2, 1, 0])
+      descendingCounters.addRange({
+        type: RangeType.Fingerprint,
+        upperBound: createBound(counter, "0000000000000000"),
+        fingerprint: zeroFingerprint,
+      });
+
+    const descendingNodeIds = createProtocolMessageBuffer(testAppOwner.id, {
+      messageType: MessageType.Request,
+    });
+    for (const nodeId of ["0000000000000002", "0000000000000001"])
+      descendingNodeIds.addRange({
+        type: RangeType.Skip,
+        upperBound: createBound(0, nodeId),
+      });
+
+    for (const request of [descendingCounters, descendingNodeIds]) {
+      request.addRange({
+        type: RangeType.Fingerprint,
+        upperBound: InfiniteUpperBound,
+        fingerprint: zeroFingerprint,
+      });
+      assertSame(
+        await getRelayDecodeErrorMessage(request.unwrap()),
+        "Range upper bounds must be non-decreasing",
+      );
+    }
+  });
+
+  it("relay rejects a change shorter than the encryption envelope", async () => {
+    const createRequestWithChange = (length: number) => {
+      const request = createProtocolMessageBuffer(testAppOwner.id, {
+        messageType: MessageType.Request,
+        writeKey: testAppOwner.writeKey,
+      });
+      request.addMessage({
+        timestamp: createTestTimestamp(1),
+        change: new Uint8Array(length) as EncryptedDbChange,
+      });
+      return request.unwrap();
+    };
+    const storage: StorageDep["storage"] = {
+      ...shouldNotBeCalledStorageDep.storage,
+      validateWriteKey: constTrue,
+    };
+
+    for (const length of [0, 40])
+      assertSame(
+        await getRelayDecodeErrorMessage(
+          createRequestWithChange(length),
+          storage,
+        ),
+        "EncryptedDbChange is too short",
+      );
+
+    // A 24-byte nonce, a 1-byte length, and a 16-byte tag.
+    const writtenLengths: Array<number> = [];
+    await using run = testCreateRun({
+      storage: {
+        ...storage,
+        writeMessages: (_ownerId, messages) => () => {
+          for (const { change } of messages) writtenLengths.push(change.length);
+          return ok();
+        },
+      },
+    } satisfies StorageDep);
+    assertOk(
+      await run(applyProtocolMessageAsRelay(createRequestWithChange(41))),
+    );
+    assertEqual(writtenLengths, [41]);
+  });
+
+  it("client passes a change shorter than the encryption envelope to storage", async () => {
+    // Deployed relays store such changes, and client storage skips a change
+    // it cannot read instead of rejecting the response.
+    const response = createProtocolMessageBuffer(testAppOwner.id, {
+      messageType: MessageType.Response,
+      errorCode: ProtocolErrorCode.NoError,
+    });
+    response.addMessage({
+      timestamp: createTestTimestamp(1),
+      change: new Uint8Array(0) as EncryptedDbChange,
+    });
+    const writtenLengths: Array<number> = [];
+    await using run = testCreateRun({
+      storage: {
+        ...shouldNotBeCalledStorageDep.storage,
+        writeMessages: (_ownerId, messages) => () => {
+          for (const { change } of messages) writtenLengths.push(change.length);
+          return ok();
+        },
+      },
+    } satisfies StorageDep);
+
+    assertOk(await run(applyProtocolMessageAsClient(response.unwrap())), {
+      type: "Readonly",
+    });
+    assertEqual(writtenLengths, [0]);
+  });
+
+  it("ProtocolInvalidDataError", async () => {
+    await using run = testCreateRun(shouldNotBeCalledStorageDep);
+    const malformedMessage = createBuffer();
+    // Only version, no ownerId
+    encodeNonNegativeInt(malformedMessage, 1 as NonNegativeInt);
+
+    const clientResult = await run(
+      applyProtocolMessageAsClient(malformedMessage.unwrap(), {
+        version: 0 as NonNegativeInt,
+      }),
+    );
+
+    assertFalse(clientResult.ok);
+    assertEqual(clientResult.error.type, "ProtocolInvalidDataError");
+  });
+
+  // Every released client does this, so it is what a relay adding a code under
+  // protocol version 1 gets.
+  it("reports an unknown ProtocolErrorCode as ProtocolInvalidDataError", async () => {
+    const response = createBuffer();
+    encodeNonNegativeInt(response, protocolVersion);
+    response.extend(ownerIdToOwnerIdBytes(testAppOwner.id));
+    response.extend([MessageType.Response, 5]);
+    await using run = testCreateRun(shouldNotBeCalledStorageDep);
+
+    const result = await run(applyProtocolMessageAsClient(response.unwrap()));
+
+    assertErr(result);
+    const { error } = result;
+    assert(error.type === "ProtocolInvalidDataError", "Expected invalid data");
+    assertFalse("ownerId" in error);
+    assertInstanceOf(error.error, Error);
+    assertSame(error.error.message, "Invalid ProtocolErrorCode: 5");
+  });
+
+  it("ProtocolWriteKeyError", async () => {
+    const deps = testCreateDeps();
+    const timestamp = timestampBytesToTimestamp(testTimestampsAsc[0]);
+    const dbChange = createDbChange(deps);
+
+    const messages: NonEmptyReadonlyArray<CrdtMessage> = [
+      { timestamp, change: dbChange },
+    ];
+
+    const initiatorMessage = createProtocolMessageFromCrdtMessages(deps)(
+      testAppOwner,
+      messages,
+    );
+
+    let responseMessage: Uint8Array;
+    {
+      await using run = testCreateRun({
+        storage: {
+          ...shouldNotBeCalledStorageDep.storage,
+          validateWriteKey: constFalse,
+        },
+      });
+      const response = await run.orThrow(
+        applyProtocolMessageAsRelay(initiatorMessage),
+      );
+      assertEqualBytes(
+        response.message,
+        [
+          1, 5, 39, 254, 242, 108, 77, 142, 9, 59, 219, 32, 254, 15, 186, 235,
+          212, 1, 1, 0,
+        ],
+      );
+      responseMessage = response.message;
     }
 
     await using run = testCreateRun(shouldNotBeCalledStorageDep);
@@ -950,7 +1792,7 @@ describe("E2E errors", () => {
     );
   });
 
-  it("reports a rejected relay write as a quota and a thrown one as a write failure", async () => {
+  it("reports a rejected relay write as a quota and a failed one as a write failure", async () => {
     const deps = testCreateDeps();
     const initiatorMessage = createProtocolMessageFromCrdtMessages(deps)(
       testAppOwner,
@@ -1003,10 +1845,51 @@ describe("E2E errors", () => {
       ["error"],
     );
     assertSame(thrown.logged[0]?.args[0], failure);
+    // So is a write SQLite fails, such as on a full disk, which the storage
+    // returns.
+    const unknownError = createUnknownError(new Error("disk full"));
+    const failed = await relayResponseFor(() => () => err(unknownError));
+    assertEqual(
+      await run(applyProtocolMessageAsClient(failed.message)),
+      err({ type: "ProtocolWriteError", ownerId: testAppOwner.id }),
+    );
+    assertEqual(
+      failed.logged.map(({ method }) => method),
+      ["error"],
+    );
+    assertSame(failed.logged[0]?.args[0], unknownError);
   });
 });
 
 describe("E2E relay options", () => {
+  it("rejects unknown request flags before any side effect", async () => {
+    for (const [hasWriteKey, subscriptionFlag, errorMessage] of [
+      [2, SubscriptionFlags.Subscribe, "Invalid hasWriteKey: 2"],
+      [0, 7, "Invalid SubscriptionFlag: 7"],
+    ] as const) {
+      const request = setupRequestHeader(hasWriteKey, subscriptionFlag);
+      request.extend([0]);
+      const subscriptions: Array<string> = [];
+      await using run = testCreateRun(shouldNotBeCalledStorageDep);
+
+      const result = await run(
+        applyProtocolMessageAsRelay(request.unwrap(), {
+          subscribe: () => {
+            subscriptions.push("subscribe");
+          },
+          unsubscribe: () => {
+            subscriptions.push("unsubscribe");
+          },
+        }),
+      );
+
+      assertErr(result);
+      assertInstanceOf(result.error.error, Error);
+      assertSame(result.error.error.message, errorMessage);
+      assertEqual(subscriptions, []);
+    }
+  });
+
   it("subscribe", async () => {
     await using run = testCreateRun(shouldNotBeCalledStorageDep);
     const message = createProtocolMessageBuffer(testAppOwner.id, {
@@ -1026,6 +1909,39 @@ describe("E2E relay options", () => {
     assertEqual(subscribeCalledWithOwnerId, testAppOwner.id);
   });
 
+  it("subscribes before rejecting the write key", async () => {
+    const message = createProtocolMessageBuffer(testAppOwner.id, {
+      messageType: MessageType.Request,
+      writeKey: testAppOwner.writeKey,
+      subscriptionFlag: SubscriptionFlags.Subscribe,
+    }).unwrap();
+    const subscribedOwnerIds: Array<string> = [];
+
+    let response: Uint8Array;
+    {
+      await using run = testCreateRun({
+        storage: {
+          ...shouldNotBeCalledStorageDep.storage,
+          validateWriteKey: constFalse,
+        },
+      });
+      ({ message: response } = await run.orThrow(
+        applyProtocolMessageAsRelay(message, {
+          subscribe: (ownerId) => {
+            subscribedOwnerIds.push(ownerId);
+          },
+        }),
+      ));
+    }
+
+    assertEqual(subscribedOwnerIds, [testAppOwner.id]);
+    await using run = testCreateRun(shouldNotBeCalledStorageDep);
+    assertEqual(
+      await run(applyProtocolMessageAsClient(response)),
+      err({ type: "ProtocolWriteKeyError", ownerId: testAppOwner.id }),
+    );
+  });
+
   it("unsubscribe", async () => {
     await using run = testCreateRun(shouldNotBeCalledStorageDep);
     const message = createProtocolMessageBuffer(testAppOwner.id, {
@@ -1332,6 +2248,367 @@ describe("applyProtocolMessageAsClient results", () => {
   });
 });
 
+describe("decoding before applying", () => {
+  it("relay rejects a request with descending range bounds before any side effect", async () => {
+    const deps = testCreateDeps();
+    const request = createProtocolMessageBuffer(testAppOwner.id, {
+      messageType: MessageType.Request,
+      writeKey: testAppOwner.writeKey,
+      subscriptionFlag: SubscriptionFlags.Subscribe,
+    });
+    request.addMessage(
+      createEncryptedCrdtMessage(deps, createTestCrdtMessage(deps)),
+    );
+    for (const counter of [2, 1])
+      request.addRange({
+        type: RangeType.Skip,
+        upperBound: timestampToTimestampBytes(
+          createTimestamp({
+            millis: Millis.orThrow(1500),
+            counter: Counter.orThrow(counter),
+          }),
+        ),
+      });
+    request.addRange({
+      type: RangeType.Fingerprint,
+      upperBound: InfiniteUpperBound,
+      fingerprint: zeroFingerprint,
+    });
+    const sideEffects: Array<string> = [];
+    await using run = testCreateRun({
+      storage: {
+        ...shouldNotBeCalledStorageDep.storage,
+        // A relay storage stores the write key of a new owner.
+        validateWriteKey: () => {
+          sideEffects.push("validateWriteKey");
+          return true;
+        },
+        writeMessages: () => () => {
+          sideEffects.push("writeMessages");
+          return ok();
+        },
+      },
+    } satisfies StorageDep);
+
+    const result = await run(
+      applyProtocolMessageAsRelay(request.unwrap(), {
+        subscribe: () => {
+          sideEffects.push("subscribe");
+        },
+        broadcast: () => {
+          sideEffects.push("broadcast");
+        },
+      }),
+    );
+
+    assertErr(result);
+    assertInstanceOf(result.error.error, Error);
+    assertSame(
+      result.error.error.message,
+      "Range upper bounds must be non-decreasing",
+    );
+    assertEqual(sideEffects, []);
+  });
+
+  it("relay rejects a request over its totalMaxSize before any side effect", async () => {
+    const setupRequest = (changeLength: number) => {
+      const request = createProtocolMessageBuffer(testAppOwner.id, {
+        messageType: MessageType.Request,
+        writeKey: testAppOwner.writeKey,
+        subscriptionFlag: SubscriptionFlags.Subscribe,
+        totalMaxSize: ProtocolMessageMaxSize.orThrow(2_000_000),
+      });
+      request.addMessage({
+        timestamp: createTimestamp(),
+        change: new Uint8Array(changeLength) as EncryptedDbChange,
+      });
+      return request.unwrap();
+    };
+    const overhead = setupRequest(999_000).length - 999_000;
+    const sideEffects: Array<string> = [];
+    await using run = testCreateRun({
+      storage: {
+        ...shouldNotBeCalledStorageDep.storage,
+        validateWriteKey: () => {
+          sideEffects.push("validateWriteKey");
+          return true;
+        },
+        writeMessages: () => () => {
+          sideEffects.push("writeMessages");
+          return ok();
+        },
+      },
+    } satisfies StorageDep);
+    const apply = (request: Uint8Array) =>
+      run(
+        applyProtocolMessageAsRelay(request, {
+          subscribe: () => {
+            sideEffects.push("subscribe");
+          },
+          broadcast: () => {
+            sideEffects.push("broadcast");
+          },
+        }),
+      );
+
+    const largest = setupRequest(defaultProtocolMessageMaxSize - overhead);
+    assertSame(largest.length, defaultProtocolMessageMaxSize);
+    assertOk(await apply(largest));
+    assertEqual(sideEffects, [
+      "subscribe",
+      "validateWriteKey",
+      "writeMessages",
+      "broadcast",
+    ]);
+
+    sideEffects.length = 0;
+    const tooLarge = setupRequest(defaultProtocolMessageMaxSize - overhead + 1);
+    const result = await apply(tooLarge);
+
+    assertErr(result);
+    assertSame(result.error.data, tooLarge);
+    assertInstanceOf(result.error.error, Error);
+    assertSame(result.error.error.message, "Request is too large");
+    assertEqual(sideEffects, []);
+  });
+
+  for (const hasWriteKey of [true, false]) {
+    it(`client rejects a response with malformed ranges before storing its messages ${hasWriteKey ? "with" : "without"} a write key`, async () => {
+      const deps = testCreateDeps();
+      const response = createProtocolMessageBuffer(testAppOwner.id, {
+        messageType: MessageType.Response,
+        errorCode: ProtocolErrorCode.NoError,
+      });
+      response.addMessage(
+        createEncryptedCrdtMessage(deps, createTestCrdtMessage(deps)),
+      );
+      // One range of an unknown type.
+      const message = new Uint8Array([...response.unwrap(), 1, 127]);
+      let writeCount = 0;
+      await using run = testCreateRun({
+        storage: {
+          ...shouldNotBeCalledStorageDep.storage,
+          writeMessages: () => () => {
+            writeCount++;
+            return ok();
+          },
+        },
+      } satisfies StorageDep);
+
+      const result = await run(
+        applyProtocolMessageAsClient(
+          message,
+          hasWriteKey ? { writeKey: testAppOwner.writeKey } : {},
+        ),
+      );
+
+      assertErr(result);
+      const { error } = result;
+      assert(
+        error.type === "ProtocolInvalidDataError",
+        "Expected invalid data",
+      );
+      assertSame(error.data, message);
+      assertInstanceOf(error.error, Error);
+      assertSame(error.error.message, "Invalid RangeType: 127");
+      assertSame(writeCount, 0);
+    });
+  }
+
+  it("relay answers a write key its storage fails to validate with WriteError", async () => {
+    const deps = testCreateDeps();
+    const request = createProtocolMessageFromCrdtMessages(deps)(testAppOwner, [
+      createTestCrdtMessage(deps),
+    ]);
+    // SQLite can fail to store the write key of a new owner, such as on a full
+    // disk.
+    const failure = new Error("database or disk is full");
+    let response: Uint8Array;
+    {
+      await using run = testCreateRun({
+        storage: {
+          ...shouldNotBeCalledStorageDep.storage,
+          validateWriteKey: () => {
+            throw failure;
+          },
+        },
+      } satisfies StorageDep);
+
+      ({ message: response } = await run.orThrow(
+        applyProtocolMessageAsRelay(request),
+      ));
+
+      const entries = run.deps.console.getEntriesSnapshot();
+      assertEqual(
+        entries.map(({ method }) => method),
+        ["error"],
+      );
+      assertSame(entries[0].args[0], failure);
+    }
+    await using run = testCreateRun(shouldNotBeCalledStorageDep);
+    assertEqual(
+      await run(applyProtocolMessageAsClient(response)),
+      err({ type: "ProtocolWriteError", ownerId: testAppOwner.id }),
+    );
+  });
+
+  it("relay propagates a throw from its broadcast callback as a defect", async () => {
+    const deps = testCreateDeps();
+    const request = createProtocolMessageFromCrdtMessages(deps)(testAppOwner, [
+      createTestCrdtMessage(deps),
+    ]);
+    const defect = new Error("broadcast failed");
+    await using run = testCreateRun({
+      storage: {
+        ...shouldNotBeCalledStorageDep.storage,
+        validateWriteKey: constTrue,
+        writeMessages: () => () => ok(),
+      },
+    } satisfies StorageDep);
+
+    const result = await run.abortable(
+      applyProtocolMessageAsRelay(request, {
+        broadcast: () => {
+          throw defect;
+        },
+      }),
+    );
+
+    assertErr(result);
+    assert(AbortError.is(result.error), "A defect panics the Run.");
+    assertEqual(result.error.reason.type, "PanicAbortReason");
+    assertSame(result.error.reason.defect, defect);
+  });
+
+  /**
+   * Returns a response that asks for every change and a storage holding one
+   * change that no message can hold, whose iterate throws `iterateFailure`
+   * after visiting it.
+   */
+  const setupTooLargeChange = (iterateFailure?: Error) => {
+    const response = createProtocolMessageBuffer(testAppOwner.id, {
+      messageType: MessageType.Response,
+      errorCode: ProtocolErrorCode.NoError,
+    });
+    response.addRange({
+      type: RangeType.Timestamps,
+      upperBound: InfiniteUpperBound,
+      timestamps: createTimestampsBuffer(),
+    });
+    const storage: StorageDep["storage"] = {
+      ...shouldNotBeCalledStorageDep.storage,
+      getSize: () => NonNegativeInt.orThrow(1),
+      findLowerBound: (_ownerId, _begin, end) => end,
+      iterate: (_ownerId, _begin, _end, callback) => {
+        callback(testTimestampsAsc[0], NonNegativeInt.orThrow(0));
+        if (iterateFailure) throw iterateFailure;
+      },
+      readDbChange: () =>
+        new Uint8Array(defaultProtocolMessageMaxSize) as EncryptedDbChange,
+    };
+    return { message: response.unwrap(), storage };
+  };
+
+  it("client propagates a throw from onChangeTooLarge as a defect", async () => {
+    const { message, storage } = setupTooLargeChange();
+    const defect = new Error("onChangeTooLarge failed");
+    await using run = testCreateRun({ storage } satisfies StorageDep);
+
+    const result = await run.abortable(
+      applyProtocolMessageAsClient(message, {
+        writeKey: testAppOwner.writeKey,
+        onChangeTooLarge: () => {
+          throw defect;
+        },
+      }),
+    );
+
+    assertErr(result);
+    assert(AbortError.is(result.error), "A defect panics the Run.");
+    assertEqual(result.error.reason.type, "PanicAbortReason");
+    assertSame(result.error.reason.defect, defect);
+  });
+
+  it("client reports a change too large before an iteration that fails", async () => {
+    const failure = new Error("iterate failed");
+    const { message, storage } = setupTooLargeChange(failure);
+    const changesTooLarge: Array<ProtocolChangeTooLargeError> = [];
+    await using run = testCreateRun({ storage } satisfies StorageDep);
+
+    const result = await run(
+      applyProtocolMessageAsClient(message, {
+        writeKey: testAppOwner.writeKey,
+        onChangeTooLarge: (error) => {
+          changesTooLarge.push(error);
+        },
+      }),
+    );
+
+    assertOk(result, { type: "Failed", cause: "Sync" });
+    assertEqual(changesTooLarge, [
+      {
+        type: "ProtocolChangeTooLargeError",
+        timestamp: timestampBytesToTimestamp(testTimestampsAsc[0]),
+        size: defaultProtocolMessageMaxSize,
+      },
+    ]);
+    const entries = run.deps.console.getEntriesSnapshot();
+    assertEqual(
+      entries.map(({ method }) => method),
+      ["error"],
+    );
+    assertSame(entries[0].args[0], failure);
+  });
+
+  it("client rejects a Request before storing its changes", async () => {
+    const deps = testCreateDeps();
+    const request = createProtocolMessageFromCrdtMessages(deps)(testAppOwner, [
+      createTestCrdtMessage(deps),
+    ]);
+    await using run = testCreateRun(shouldNotBeCalledStorageDep);
+
+    const result = await run(
+      applyProtocolMessageAsClient(request, {
+        writeKey: testAppOwner.writeKey,
+      }),
+    );
+
+    assertErr(result);
+    const { error } = result;
+    assert(error.type === "ProtocolInvalidDataError", "Expected invalid data");
+    assertSame(error.data, request);
+    assertInstanceOf(error.error, Error);
+    assertSame(error.error.message, "Expected a Response or a Broadcast");
+  });
+
+  it("relay rejects a Response or a Broadcast before any side effect", async () => {
+    const deps = testCreateDeps();
+    const message = createEncryptedCrdtMessage(
+      deps,
+      createTestCrdtMessage(deps),
+    );
+    const response = createProtocolMessageBuffer(testAppOwner.id, {
+      messageType: MessageType.Response,
+      errorCode: ProtocolErrorCode.NoError,
+    });
+    response.addMessage(message);
+    const errorResponse = createProtocolMessageBuffer(testAppOwner.id, {
+      messageType: MessageType.Response,
+      errorCode: ProtocolErrorCode.WriteError,
+    });
+    const broadcast = createProtocolMessageBuffer(testAppOwner.id, {
+      messageType: MessageType.Broadcast,
+    });
+    broadcast.addMessage(message);
+
+    for (const input of [response, errorResponse, broadcast])
+      assertSame(
+        await getRelayDecodeErrorMessage(input.unwrap()),
+        "Expected a Request",
+      );
+  });
+});
+
 describe("split-range failures", () => {
   for (const role of ["client", "relay"] as const) {
     for (const method of ["fingerprintRanges", "iterate"] as const) {
@@ -1409,6 +2686,111 @@ describe("split-range failures", () => {
   }
 });
 
+describe("sync defects", () => {
+  const setupInput = (
+    role: "client" | "relay",
+    range: FingerprintRange | TimestampsRangeWithTimestampsBuffer,
+  ) => {
+    const input = createProtocolMessageBuffer(
+      testAppOwner.id,
+      role === "client"
+        ? {
+            messageType: MessageType.Response,
+            errorCode: ProtocolErrorCode.NoError,
+          }
+        : {
+            messageType: MessageType.Request,
+            writeKey: testAppOwner.writeKey,
+          },
+    );
+    input.addRange(range);
+    return input.unwrap();
+  };
+
+  for (const role of ["client", "relay"] as const) {
+    it(`${role} propagates a throw while writing a split as a defect`, async () => {
+      const message = setupInput(role, {
+        type: RangeType.Fingerprint,
+        upperBound: InfiniteUpperBound,
+        fingerprint: zeroFingerprint,
+      });
+      const range: FingerprintRange = {
+        type: RangeType.Fingerprint,
+        upperBound: InfiniteUpperBound,
+        fingerprint: timestampBytesToFingerprint(testTimestampsAsc[0]),
+      };
+      await using run = testCreateRun({
+        storage: {
+          ...shouldNotBeCalledStorageDep.storage,
+          getSize: () => NonNegativeInt.orThrow(32),
+          findLowerBound: (_ownerId, _begin, end) => end,
+          fingerprint: () => range.fingerprint,
+          validateWriteKey: constTrue,
+          // A second range after an InfiniteUpperBound one fails the builder's
+          // assertion inside the split's trial.
+          fingerprintRanges: () => [range, range],
+        },
+      } satisfies StorageDep);
+
+      const result =
+        role === "client"
+          ? await run.abortable(
+              applyProtocolMessageAsClient(message, {
+                writeKey: testAppOwner.writeKey,
+              }),
+            )
+          : await run.abortable(applyProtocolMessageAsRelay(message));
+
+      assertErr(result);
+      assert(AbortError.is(result.error), "A defect panics the Run.");
+      assertEqual(result.error.reason.type, "PanicAbortReason");
+      assertInstanceOf(result.error.reason.defect, Error);
+      assertSame(
+        result.error.reason.defect.message,
+        "Cannot add a range after an InfiniteUpperBound range",
+      );
+    });
+
+    it(`${role} propagates a throw while answering a Timestamps range as a defect`, async () => {
+      const message = setupInput(role, {
+        type: RangeType.Timestamps,
+        upperBound: InfiniteUpperBound,
+        timestamps: createTimestampsBuffer(),
+      });
+      await using run = testCreateRun({
+        storage: {
+          ...shouldNotBeCalledStorageDep.storage,
+          getSize: () => NonNegativeInt.orThrow(2),
+          findLowerBound: (_ownerId, _begin, end) => end,
+          validateWriteKey: constTrue,
+          // Descending millis fail the assertion of the answer's timestamps.
+          iterate: (_ownerId, _begin, _end, callback) => {
+            if (callback(testTimestampsAsc[1], NonNegativeInt.orThrow(0)))
+              callback(testTimestampsAsc[0], NonNegativeInt.orThrow(1));
+          },
+          readDbChange: () => new Uint8Array(41) as EncryptedDbChange,
+        },
+      } satisfies StorageDep);
+
+      const result =
+        role === "client"
+          ? await run.abortable(
+              applyProtocolMessageAsClient(message, {
+                writeKey: testAppOwner.writeKey,
+              }),
+            )
+          : await run.abortable(applyProtocolMessageAsRelay(message));
+
+      assertErr(result);
+      assert(AbortError.is(result.error), "A defect panics the Run.");
+      assertEqual(result.error.reason.type, "PanicAbortReason");
+      assertInstanceOf(result.error.reason.defect, Error);
+      assertSame(result.error.reason.defect.message, "Expected NonNegative.");
+      assertEqual(run.deps.console.getEntriesSnapshot(), []);
+    });
+  }
+});
+
 test("local mutation broadcasts contain every message in nonempty size-limited frames", async () => {
   const deps = testCreateDeps();
   const messages: NonEmptyReadonlyArray<CrdtMessage> = [
@@ -1516,6 +2898,121 @@ test("local mutation broadcasts reject a message that cannot fit in an empty fra
   }
 });
 
+const setupFrameFillingMessages = (deps: TestDeps) => {
+  const large: CrdtMessage = {
+    timestamp: createTimestamp({ millis: Millis.orThrow(1) }),
+    change: DbChange.orThrow({
+      ...createDbChange(deps),
+      values: { data: new Uint8Array(1_000_000).fill(1) },
+    }),
+  };
+  const small: CrdtMessage = {
+    timestamp: createTimestamp({ millis: Millis.orThrow(2) }),
+    change: createDbChange(deps),
+  };
+  // Padding makes the length the same for every encryption.
+  const largeChangeLength = createEncryptedDbChange(deps, large).length;
+
+  const measureFrame = (buffer: ProtocolMessageBuffer) => {
+    buffer.addMessage({
+      timestamp: large.timestamp,
+      change: new Uint8Array(largeChangeLength) as EncryptedDbChange,
+    });
+    return buffer.unwrap().length;
+  };
+
+  return { large, small, measureFrame };
+};
+
+test("upload requests fill a frame exactly before their continuation range", async () => {
+  const deps = testCreateDeps();
+  const { large, small, measureFrame } = setupFrameFillingMessages(deps);
+  // The continuation range is the first range, which takes 14 bytes.
+  const exactSize =
+    measureFrame(
+      createProtocolMessageBuffer(testAppOwner.id, {
+        messageType: MessageType.Request,
+        writeKey: testAppOwner.writeKey,
+        totalMaxSize: ProtocolMessageMaxSize.orThrow(2_000_000),
+      }),
+    ) + 14;
+
+  for (const [maxSize, expectedUploaded] of [
+    [exactSize, [large]],
+    [exactSize - 1, []],
+  ] as const) {
+    const request = createProtocolMessageFromCrdtMessages(deps)(
+      testAppOwner,
+      [large, small],
+      ProtocolMessageMaxSize.orThrow(maxSize),
+    );
+    assertTrue(request.length <= maxSize);
+    if (expectedUploaded.length > 0) assertSame(request.length, maxSize);
+    // The frame ends with one Fingerprint range and its fingerprint.
+    assertEqualBytes(request.subarray(-14, -12), [1, RangeType.Fingerprint]);
+
+    const uploaded: Array<CrdtMessage> = [];
+    await using run = testCreateRun({
+      storage: {
+        ...shouldNotBeCalledStorageDep.storage,
+        validateWriteKey: constTrue,
+        writeMessages: (_ownerId, messages) => () => {
+          for (const message of messages) {
+            uploaded.push({
+              timestamp: message.timestamp,
+              change: getOrThrow(
+                decryptAndDecodeDbChange(message, testAppOwner.encryptionKey),
+              ),
+            });
+          }
+          return ok();
+        },
+        getSize: () => NonNegativeInt.orThrow(0),
+        findLowerBound: () => NonNegativeInt.orThrow(0),
+        fingerprint: () => zeroFingerprint,
+        iterate: () => {},
+      },
+    } satisfies StorageDep);
+    await run.orThrow(
+      applyProtocolMessageAsRelay(request, {
+        totalMaxSize: ProtocolMessageMaxSize.orThrow(maxSize),
+      }),
+    );
+    assertEqual(uploaded, expectedUploaded);
+  }
+});
+
+test("local mutation broadcasts fill a frame exactly", () => {
+  const deps = testCreateDeps();
+  const { large, small, measureFrame } = setupFrameFillingMessages(deps);
+  // Broadcasts hold no ranges, so nothing is reserved to close them.
+  const exactSize = measureFrame(
+    createProtocolMessageBuffer(testAppOwner.id, {
+      messageType: MessageType.Broadcast,
+      totalMaxSize: ProtocolMessageMaxSize.orThrow(2_000_000),
+    }),
+  );
+
+  const broadcasts = createProtocolBroadcastMessagesFromCrdtMessages(deps)(
+    testAppOwner,
+    [large, small],
+    ProtocolMessageMaxSize.orThrow(exactSize),
+  );
+  assertSame(broadcasts.length, 2);
+  assertSame(broadcasts[0].length, exactSize);
+
+  const error = assertThrowsInstanceOf(
+    () =>
+      createProtocolBroadcastMessagesFromCrdtMessages(deps)(
+        testAppOwner,
+        [large],
+        ProtocolMessageMaxSize.orThrow(exactSize - 1),
+      ),
+    Error,
+  );
+  assertSame(error.message, "the message is too big");
+});
+
 test("client continuation broadcasts exactly the uploaded messages within the frame limit", async () => {
   const deps = testCreateDeps();
   const messages = [1, 2].map((millis) => {