@syncular/core 0.58.0 → 0.60.0

package/dist/message.js

@@ -14,6 +14,7 @@
 import { ByteReader, ByteWriter, readStringListMap, readStringMap, utf8Encode, writeStringListMap, writeStringMap, } from './bytes.js';
 import { isSupportedProtocolWireVersion, SYNC_PACK_MAGIC } from './constants.js';
 import { DecodeError } from './errors.js';
+import { parseJsonDocument } from './json-document.js';
 import { FrameType, KNOWN_FRAME_TYPES, REQUEST_FRAME_TYPES, RESPONSE_FRAME_TYPES, } from './frames.js';
 import { normalizeRejectionDetails, } from './rejection-details.js';
 import { decodeRowsSegment } from './segment.js';
@@ -28,13 +29,10 @@ function definedObject(record) {
 function invalid(message) {
     throw new DecodeError('sync.invalid_request', message);
 }
-function requireJsonDocument(raw, what) {
-    try {
-        JSON.parse(raw);
-    }
-    catch {
-        invalid(`${what} is not a valid JSON document`);
-    }
+/** A `json` field: a valid JSON document (Conventions), kept as raw text. */
+function readJson(r, what) {
+    const raw = r.str();
+    parseJsonDocument(raw, what);
     return raw;
 }
 /** §1.5: a `ROUND_FAILURE` code is a lowercase dotted catalog code. */
@@ -50,29 +48,63 @@ function validateRoundFailureCode(code, fail) {
         fail('ROUND_FAILURE.code must be a lowercase dotted code of at most 64 bytes');
     }
 }
+/** §1.5, §1.7: a present `outboxId` is non-empty and at most 64 bytes. */
+function checkOutboxId(outboxId, fail) {
+    if (outboxId.length === 0 || utf8Encode(outboxId).length > 64) {
+        fail('REQ_HEADER.outboxId must be non-empty and at most 64 bytes');
+    }
+}
+/** §4.3, §4.4: a unit id is 32 lowercase hex characters. */
+function checkUnitId(id, frame, fail) {
+    if (!/^[0-9a-f]{32}$/.test(id)) {
+        fail(`${frame}.id must be 32 lowercase hex characters`);
+    }
+}
+/** §4.2, §4.4: a digest is 32 bytes; an echo digest may also be empty. */
+function checkDigest(digest, field, fail) {
+    const emptyAllowed = field !== 'PULL_HEADER.registrationDigest';
+    if (digest.length !== 32 && !(emptyAllowed && digest.length === 0)) {
+        fail(`${field} must be ${emptyAllowed ? '0 or ' : ''}32 bytes`);
+    }
+}
+/** §4.2, §4.3: a cursor is `-1` or a commitSeq. */
+function checkCursor(cursor, field, fail) {
+    if (cursor < -1)
+        fail(`${field} must be >= -1`);
+}
+/** §4.4: fenced records in strictly ascending code-unit order of `table`. */
+function checkFencedOrder(fenced, fail) {
+    for (let i = 1; i < fenced.length; i++) {
+        if (fenced[i - 1].table >= fenced[i].table) {
+            fail('SUB_START.fenced tables must be unique and in ascending order');
+        }
+    }
+}
 // ---------------------------------------------------------------------------
 // Frame payload decoders (each consumes exactly the frame payload)
 // ---------------------------------------------------------------------------
-function decodeReqHeader(r, wireVersion) {
+function decodeReqHeader(r) {
     const clientId = r.str();
     if (clientId.length === 0)
         invalid('REQ_HEADER.clientId must be non-empty');
     const schemaVersion = r.i32();
     if (schemaVersion < 1)
         invalid('REQ_HEADER.schemaVersion must be >= 1');
-    const logEpoch = wireVersion >= 2
-        ? r.opt(() => {
-            const value = r.str();
-            if (value.length === 0)
-                invalid('REQ_HEADER.logEpoch must be non-empty');
-            return value;
-        })
-        : undefined;
+    const logEpoch = r.opt(() => {
+        const value = r.str();
+        if (value.length === 0)
+            invalid('REQ_HEADER.logEpoch must be non-empty');
+        return value;
+    });
+    const outboxId = r.opt(() => r.str());
+    if (outboxId !== undefined)
+        checkOutboxId(outboxId, invalid);
     return definedObject({
         type: 'REQ_HEADER',
         clientId,
         schemaVersion,
         logEpoch: logEpoch,
+        outboxId: outboxId,
     });
 }
 function decodeRoundFailure(r) {
@@ -85,6 +117,9 @@ function decodePushCommit(r) {
     if (clientCommitId.length === 0) {
         invalid('PUSH_COMMIT.clientCommitId must be non-empty');
     }
+    const clientSeq = r.i64();
+    if (clientSeq < 0)
+        invalid('PUSH_COMMIT.clientSeq must be >= 0');
     const operationCount = r.u32();
     if (operationCount === 0) {
         throw new DecodeError('sync.empty_commit', 'PUSH_COMMIT must carry at least one operation');
@@ -117,7 +152,7 @@ function decodePushCommit(r) {
             payload: payload,
         }));
     }
-    return { type: 'PUSH_COMMIT', clientCommitId, operations };
+    return { type: 'PUSH_COMMIT', clientCommitId, clientSeq, operations };
 }
 function decodePullHeader(r) {
     const limitCommits = r.i32();
@@ -127,45 +162,50 @@ function decodePullHeader(r) {
     if ((accept & 0xf0) !== 0) {
         invalid('PULL_HEADER.accept bits 4-7 must be zero');
     }
+    const cursor = r.i64();
+    checkCursor(cursor, 'PULL_HEADER.cursor', invalid);
+    const registrationDigest = r.bytes();
+    checkDigest(registrationDigest, 'PULL_HEADER.registrationDigest', invalid);
+    const echoDigest = r.bytes();
+    checkDigest(echoDigest, 'PULL_HEADER.echoDigest', invalid);
     return {
         type: 'PULL_HEADER',
         limitCommits,
         limitSnapshotRows,
         maxSnapshotPages,
         accept,
+        cursor,
+        registrationDigest,
+        echoDigest,
     };
 }
-function decodeSubscription(r) {
+function decodeProgress(r) {
     const id = r.str();
-    const table = r.str();
-    const scopes = readStringListMap(r);
-    const params = r.opt(() => requireJsonDocument(r.str(), 'SUBSCRIPTION.params'));
+    checkUnitId(id, 'PROGRESS', invalid);
     const cursor = r.i64();
-    const bootstrapState = r.opt(() => requireJsonDocument(r.str(), 'SUBSCRIPTION.bootstrapState'));
+    checkCursor(cursor, 'PROGRESS.cursor', invalid);
+    const bootstrapState = r.opt(() => readJson(r, 'PROGRESS.bootstrapState'));
     return definedObject({
-        type: 'SUBSCRIPTION',
+        type: 'PROGRESS',
         id,
-        table,
-        scopes,
-        params: params,
         cursor,
         bootstrapState: bootstrapState,
     });
 }
-function decodeRespHeader(r, wireVersion) {
+function decodeRespHeader(r) {
     const requiredSchemaVersion = r.opt(() => r.i32());
     const latestSchemaVersion = r.opt(() => r.i32());
-    const logEpoch = wireVersion >= 2 ? r.str() : undefined;
-    if (logEpoch !== undefined && logEpoch.length === 0) {
+    const logEpoch = r.str();
+    if (logEpoch.length === 0) {
         invalid('RESP_HEADER.logEpoch must be non-empty');
     }
-    const resetRequired = wireVersion >= 2 ? r.bool() : undefined;
+    const resetRequired = r.bool();
     return definedObject({
         type: 'RESP_HEADER',
         requiredSchemaVersion: requiredSchemaVersion,
         latestSchemaVersion: latestSchemaVersion,
-        logEpoch: logEpoch,
-        resetRequired: resetRequired,
+        logEpoch,
+        resetRequired,
     });
 }
 function decodeLease(r) {
@@ -250,9 +290,10 @@ function decodePushResultDetails(r) {
             invalid('PUSH_RESULT_DETAILS opIndex values must be unique and non-negative');
         }
         seen.add(opIndex);
+        const parsed = parseJsonDocument(r.str(), 'PUSH_RESULT_DETAILS.details');
         let details;
         try {
-            details = normalizeRejectionDetails(JSON.parse(r.str()));
+            details = normalizeRejectionDetails(parsed);
         }
         catch (error) {
             invalid(`invalid PUSH_RESULT_DETAILS.details: ${error instanceof Error ? error.message : String(error)}`);
@@ -263,6 +304,7 @@ function decodePushResultDetails(r) {
 }
 function decodeSubStart(r) {
     const id = r.str();
+    checkUnitId(id, 'SUB_START', invalid);
     const statusByte = r.u8();
     let status;
     if (statusByte === 1)
@@ -274,16 +316,42 @@ function decodeSubStart(r) {
     else
         invalid(`invalid SUB_START status byte ${statusByte}`);
     const reasonCode = r.str();
-    const effectiveScopes = readStringListMap(r);
     const bootstrap = r.bool();
-    return {
-        type: 'SUB_START',
-        id,
-        status,
-        reasonCode,
-        effectiveScopes,
-        bootstrap,
-    };
+    const fencedCount = r.u32();
+    const fenced = [];
+    for (let i = 0; i < fencedCount; i++) {
+        const table = r.str();
+        const fencedStatus = r.u8();
+        if (fencedStatus !== 1 && fencedStatus !== 2) {
+            invalid('invalid fenced record status byte');
+        }
+        fenced.push({
+            table,
+            status: fencedStatus === 1 ? 'active' : 'revoked',
+            scopes: readStringListMap(r),
+        });
+    }
+    checkFencedOrder(fenced, invalid);
+    return { type: 'SUB_START', id, status, reasonCode, bootstrap, fenced };
+}
+function decodeLiveStart(r) {
+    const statusByte = r.u8();
+    let status;
+    if (statusByte === 1)
+        status = 'active';
+    else if (statusByte === 3)
+        status = 'reset';
+    else if (statusByte === 4)
+        status = 'unregistered';
+    else
+        invalid('invalid LIVE_START status byte');
+    return { type: 'LIVE_START', status, reasonCode: r.str() };
+}
+function decodeLiveEnd(r) {
+    const throughSeq = r.i64();
+    const echoDigest = r.bytes();
+    checkDigest(echoDigest, 'LIVE_END.echoDigest', invalid);
+    return { type: 'LIVE_END', throughSeq, echoDigest };
 }
 function decodeCommit(r) {
     const commitSeq = r.i64();
@@ -309,23 +377,15 @@ function decodeCommit(r) {
             op = 'delete';
         else
             invalid(`invalid change op byte ${opByte}`);
-        const rowVersion = r.opt(() => r.i64());
+        const rowVersion = r.i64();
+        if (rowVersion < 1)
+            invalid('change rowVersion must be at least 1');
         const scopes = readStringMap(r);
         const row = r.opt(() => r.bytes());
-        if (op === 'upsert' && (rowVersion === undefined || row === undefined)) {
-            invalid('upsert change requires rowVersion and row');
-        }
-        if (op === 'delete' && (rowVersion !== undefined || row !== undefined)) {
-            invalid('delete change must not carry rowVersion or row');
+        if ((op === 'upsert') !== (row !== undefined)) {
+            invalid('change row must be present iff op is upsert');
         }
-        changes.push(definedObject({
-            tableIndex,
-            rowId,
-            op,
-            rowVersion: rowVersion,
-            scopes,
-            row: row,
-        }));
+        changes.push(definedObject({ tableIndex, rowId, op, rowVersion, scopes, row }));
     }
     return { type: 'COMMIT', commitSeq, createdAtMs, actorId, tables, changes };
 }
@@ -375,7 +435,7 @@ function decodeSegmentInline(r) {
 }
 function decodeSubEnd(r) {
     const nextCursor = r.i64();
-    const bootstrapState = r.opt(() => requireJsonDocument(r.str(), 'SUB_END.bootstrapState'));
+    const bootstrapState = r.opt(() => readJson(r, 'SUB_END.bootstrapState'));
     return definedObject({
         type: 'SUB_END',
         nextCursor,
@@ -388,7 +448,7 @@ function decodeErrorFrame(r) {
     const category = r.str();
     const retryable = r.bool();
     const recommendedAction = r.str();
-    const details = r.opt(() => requireJsonDocument(r.str(), 'ERROR.details'));
+    const details = r.opt(() => readJson(r, 'ERROR.details'));
     return definedObject({
         type: 'ERROR',
         code,
@@ -399,12 +459,12 @@ function decodeErrorFrame(r) {
         details: details,
     });
 }
-function decodeRequestFrame(frameType, payload, wireVersion) {
+function decodeRequestFrame(frameType, payload) {
     const r = new ByteReader(payload);
     let frame;
     switch (frameType) {
         case FrameType.REQ_HEADER:
-            frame = decodeReqHeader(r, wireVersion);
+            frame = decodeReqHeader(r);
             break;
         case FrameType.ROUND_FAILURE:
             frame = decodeRoundFailure(r);
@@ -415,8 +475,11 @@ function decodeRequestFrame(frameType, payload, wireVersion) {
         case FrameType.PULL_HEADER:
             frame = decodePullHeader(r);
             break;
-        case FrameType.SUBSCRIPTION:
-            frame = decodeSubscription(r);
+        case FrameType.UNIT:
+            frame = { type: 'UNIT', scopes: readStringMap(r) };
+            break;
+        case FrameType.PROGRESS:
+            frame = decodeProgress(r);
             break;
         default:
             if (RESPONSE_FRAME_TYPES.has(frameType)) {
@@ -427,12 +490,12 @@ function decodeRequestFrame(frameType, payload, wireVersion) {
     r.expectFullyConsumed(`${frame.type} frame payload`);
     return frame;
 }
-function decodeResponseFrame(frameType, payload, wireVersion) {
+function decodeResponseFrame(frameType, payload) {
     const r = new ByteReader(payload);
     let frame;
     switch (frameType) {
         case FrameType.RESP_HEADER:
-            frame = decodeRespHeader(r, wireVersion);
+            frame = decodeRespHeader(r);
             break;
         case FrameType.LEASE:
             frame = decodeLease(r);
@@ -458,6 +521,12 @@ function decodeResponseFrame(frameType, payload, wireVersion) {
         case FrameType.SUB_END:
             frame = decodeSubEnd(r);
             break;
+        case FrameType.LIVE_START:
+            frame = decodeLiveStart(r);
+            break;
+        case FrameType.LIVE_END:
+            frame = decodeLiveEnd(r);
+            break;
         case FrameType.ERROR:
             frame = decodeErrorFrame(r);
             break;
@@ -480,6 +549,7 @@ function validateRequestSequence(frames) {
     }
     let pushCount = 0;
     let hasPull = false;
+    let hasProgress = false;
     let index = 1;
     let sawRoundFailure = false;
     for (const frame of frames.slice(1)) {
@@ -506,9 +576,16 @@ function validateRequestSequence(frames) {
                     invalid('duplicate PULL_HEADER frame');
                 hasPull = true;
                 break;
-            case 'SUBSCRIPTION':
+            case 'UNIT':
                 if (!hasPull)
-                    invalid('SUBSCRIPTION frame without a PULL_HEADER');
+                    invalid('UNIT frame without a PULL_HEADER');
+                if (hasProgress)
+                    invalid('UNIT frame after a PROGRESS frame');
+                break;
+            case 'PROGRESS':
+                if (!hasPull)
+                    invalid('PROGRESS frame without a PULL_HEADER');
+                hasProgress = true;
                 break;
             case 'UNKNOWN':
                 break;
@@ -524,12 +601,12 @@ function validateResponseSequence(frames) {
     if (first === undefined || first.type !== 'RESP_HEADER') {
         invalid('response must start with a RESP_HEADER frame');
     }
-    let inSubscription = false;
-    let sawSubscription = false;
+    // §1.6 sections: unit sections, then at most one live section.
+    let section = 'none';
+    let sawUnitSection = false;
+    let sawLive = false;
     let sawLease = false;
     let sawBody = false;
-    let subscriptionHasCommits = false;
-    let subscriptionHasSegments = false;
     let errorSeen = false;
     let lastPushResult;
     let lastPushResultHasDetails = false;
@@ -541,8 +618,7 @@ function validateResponseSequence(frames) {
                 invalid('duplicate RESP_HEADER frame');
                 break;
             case 'LEASE':
-                // §7.3.2: at most one LEASE, immediately after RESP_HEADER (before
-                // any PUSH_RESULT / subscription section / ERROR).
+                // §7.3.2: at most one LEASE, immediately after RESP_HEADER.
                 if (sawLease)
                     invalid('duplicate LEASE frame');
                 if (sawBody)
@@ -550,15 +626,16 @@ function validateResponseSequence(frames) {
                 sawLease = true;
                 break;
             case 'PUSH_RESULT':
-                if (sawSubscription)
-                    invalid('PUSH_RESULT frame after SUB_START');
+                if (sawUnitSection || sawLive) {
+                    invalid('PUSH_RESULT frame after a unit or live section');
+                }
                 lastPushResult = frame;
                 lastPushResultHasDetails = false;
                 sawBody = true;
                 break;
             case 'PUSH_RESULT_DETAILS': {
-                if (sawSubscription) {
-                    invalid('PUSH_RESULT_DETAILS frame after SUB_START');
+                if (sawUnitSection || sawLive) {
+                    invalid('PUSH_RESULT_DETAILS frame after a unit or live section');
                 }
                 if (lastPushResult === undefined) {
                     invalid('PUSH_RESULT_DETAILS without a preceding PUSH_RESULT');
@@ -579,36 +656,43 @@ function validateResponseSequence(frames) {
                 break;
             }
             case 'SUB_START':
-                if (inSubscription)
+                if (section === 'unit')
                     invalid('nested SUB_START frame');
-                inSubscription = true;
-                sawSubscription = true;
+                if (sawLive)
+                    invalid('SUB_START frame inside or after the live section');
+                section = 'unit';
+                sawUnitSection = true;
                 sawBody = true;
                 lastPushResult = undefined;
-                subscriptionHasCommits = false;
-                subscriptionHasSegments = false;
-                break;
-            case 'COMMIT':
-                if (!inSubscription)
-                    invalid('COMMIT frame outside a subscription');
-                if (subscriptionHasSegments) {
-                    invalid('COMMIT and segment frames must not both appear for one subscription');
-                }
-                subscriptionHasCommits = true;
                 break;
             case 'SEGMENT_REF':
             case 'SEGMENT_INLINE':
-                if (!inSubscription)
-                    invalid('segment frame outside a subscription');
-                if (subscriptionHasCommits) {
-                    invalid('COMMIT and segment frames must not both appear for one subscription');
-                }
-                subscriptionHasSegments = true;
+                if (section !== 'unit')
+                    invalid('segment frame outside a unit section');
                 break;
             case 'SUB_END':
-                if (!inSubscription)
+                if (section !== 'unit')
                     invalid('SUB_END frame without an open SUB_START');
-                inSubscription = false;
+                section = 'none';
+                break;
+            case 'LIVE_START':
+                if (section === 'unit')
+                    invalid('LIVE_START frame inside a unit section');
+                if (sawLive)
+                    invalid('second LIVE_START frame');
+                section = 'live';
+                sawLive = true;
+                sawBody = true;
+                lastPushResult = undefined;
+                break;
+            case 'COMMIT':
+                if (section !== 'live')
+                    invalid('COMMIT frame outside the live section');
+                break;
+            case 'LIVE_END':
+                if (section !== 'live')
+                    invalid('LIVE_END frame without an open LIVE_START');
+                section = 'none';
                 break;
             case 'ERROR':
                 errorSeen = true;
@@ -621,28 +705,33 @@ function validateResponseSequence(frames) {
                 break;
         }
     }
-    if (inSubscription && !errorSeen) {
-        invalid('subscription not terminated by SUB_END');
+    if (section !== 'none' && !errorSeen) {
+        invalid('unit or live section not terminated');
     }
 }
-export function validateFrameSequence(message) {
-    if (message.msgKind === 'request')
-        validateRequestSequence(message.frames);
-    else
-        validateResponseSequence(message.frames);
-}
 // ---------------------------------------------------------------------------
 // Frame payload encoders
 // ---------------------------------------------------------------------------
 const OP_BYTES = { upsert: 1, delete: 2 };
 const PUSH_STATUS_BYTES = { applied: 1, cached: 2, rejected: 3 };
 const SUB_STATUS_BYTES = { active: 1, revoked: 2, reset: 3 };
+const LIVE_STATUS_BYTES = { active: 1, reset: 3, unregistered: 4 };
 const MEDIA_TYPE_BYTES = { rows: 1, sqlite: 2 };
 function encodeInvalid(message) {
     throw new Error(message);
 }
-function encodeFrame(frame, wireVersion) {
-    const w = new ByteWriter();
+function encodeUnknown(frame, w) {
+    if (!Number.isInteger(frame.frameType) ||
+        frame.frameType < 0 ||
+        frame.frameType > 0xff ||
+        KNOWN_FRAME_TYPES.has(frame.frameType)) {
+        encodeInvalid(`UNKNOWN frame type ${frame.frameType} collides with a defined frame type`);
+    }
+    w.raw(frame.payload);
+    return frame.frameType;
+}
+/** Writes the payload; returns the frame type byte. */
+function encodeRequestFrame(frame, w) {
     switch (frame.type) {
         case 'REQ_HEADER': {
             if (frame.clientId.length === 0) {
@@ -653,15 +742,14 @@ function encodeFrame(frame, wireVersion) {
             }
             w.str(frame.clientId);
             w.i32(frame.schemaVersion);
-            if (wireVersion >= 2) {
-                if (frame.logEpoch === '') {
-                    encodeInvalid('REQ_HEADER.logEpoch must be non-empty');
-                }
-                w.opt(frame.logEpoch, (v) => w.str(v));
+            if (frame.logEpoch === '') {
+                encodeInvalid('REQ_HEADER.logEpoch must be non-empty');
             }
-            else if (frame.logEpoch !== undefined) {
-                encodeInvalid('REQ_HEADER.logEpoch requires wireVersion 2');
+            w.opt(frame.logEpoch, (v) => w.str(v));
+            if (frame.outboxId !== undefined) {
+                checkOutboxId(frame.outboxId, encodeInvalid);
             }
+            w.opt(frame.outboxId, (v) => w.str(v));
             break;
         }
         case 'ROUND_FAILURE': {
@@ -676,7 +764,11 @@ function encodeFrame(frame, wireVersion) {
             if (frame.operations.length === 0) {
                 encodeInvalid('PUSH_COMMIT must carry at least one operation');
             }
+            if (frame.clientSeq < 0) {
+                encodeInvalid('PUSH_COMMIT.clientSeq must be >= 0');
+            }
             w.str(frame.clientCommitId);
+            w.i64(frame.clientSeq);
             w.u32(frame.operations.length);
             for (const operation of frame.operations) {
                 if (operation.op === 'upsert' && operation.payload === undefined) {
@@ -700,35 +792,43 @@ function encodeFrame(frame, wireVersion) {
             w.i32(frame.limitCommits);
             w.i32(frame.limitSnapshotRows);
             w.i32(frame.maxSnapshotPages);
+            checkCursor(frame.cursor, 'PULL_HEADER.cursor', encodeInvalid);
+            checkDigest(frame.registrationDigest, 'PULL_HEADER.registrationDigest', encodeInvalid);
+            checkDigest(frame.echoDigest, 'PULL_HEADER.echoDigest', encodeInvalid);
             w.u8(frame.accept);
+            w.i64(frame.cursor);
+            w.bytes(frame.registrationDigest);
+            w.bytes(frame.echoDigest);
             break;
         }
-        case 'SUBSCRIPTION': {
+        case 'UNIT': {
+            writeStringMap(w, frame.scopes);
+            break;
+        }
+        case 'PROGRESS': {
+            checkUnitId(frame.id, 'PROGRESS', encodeInvalid);
+            checkCursor(frame.cursor, 'PROGRESS.cursor', encodeInvalid);
             w.str(frame.id);
-            w.str(frame.table);
-            writeStringListMap(w, frame.scopes);
-            w.opt(frame.params, (v) => w.str(v));
             w.i64(frame.cursor);
             w.opt(frame.bootstrapState, (v) => w.str(v));
             break;
         }
+        case 'UNKNOWN':
+            return encodeUnknown(frame, w);
+    }
+    return FrameType[frame.type];
+}
+/** Writes the payload; returns the frame type byte. */
+function encodeResponseFrame(frame, w) {
+    switch (frame.type) {
         case 'RESP_HEADER': {
             w.opt(frame.requiredSchemaVersion, (v) => w.i32(v));
             w.opt(frame.latestSchemaVersion, (v) => w.i32(v));
-            if (wireVersion >= 2) {
-                if (frame.logEpoch === undefined || frame.logEpoch.length === 0) {
-                    encodeInvalid('RESP_HEADER.logEpoch is required and non-empty');
-                }
-                if (frame.resetRequired === undefined) {
-                    encodeInvalid('RESP_HEADER.resetRequired is required');
-                }
-                w.str(frame.logEpoch);
-                w.bool(frame.resetRequired);
-            }
-            else if (frame.logEpoch !== undefined ||
-                frame.resetRequired !== undefined) {
-                encodeInvalid('RESP_HEADER epoch fields require wireVersion 2');
+            if (frame.logEpoch.length === 0) {
+                encodeInvalid('RESP_HEADER.logEpoch must be non-empty');
             }
+            w.str(frame.logEpoch);
+            w.bool(frame.resetRequired);
             break;
         }
         case 'LEASE': {
@@ -796,11 +896,29 @@ function encodeFrame(frame, wireVersion) {
             break;
         }
         case 'SUB_START': {
+            checkUnitId(frame.id, 'SUB_START', encodeInvalid);
+            checkFencedOrder(frame.fenced, encodeInvalid);
             w.str(frame.id);
             w.u8(SUB_STATUS_BYTES[frame.status]);
             w.str(frame.reasonCode);
-            writeStringListMap(w, frame.effectiveScopes);
             w.bool(frame.bootstrap);
+            w.u32(frame.fenced.length);
+            for (const record of frame.fenced) {
+                w.str(record.table);
+                w.u8(SUB_STATUS_BYTES[record.status]);
+                writeStringListMap(w, record.scopes);
+            }
+            break;
+        }
+        case 'LIVE_START': {
+            w.u8(LIVE_STATUS_BYTES[frame.status]);
+            w.str(frame.reasonCode);
+            break;
+        }
+        case 'LIVE_END': {
+            checkDigest(frame.echoDigest, 'LIVE_END.echoDigest', encodeInvalid);
+            w.i64(frame.throughSeq);
+            w.bytes(frame.echoDigest);
             break;
         }
         case 'COMMIT': {
@@ -815,18 +933,16 @@ function encodeFrame(frame, wireVersion) {
                 if (change.tableIndex >= frame.tables.length) {
                     encodeInvalid(`change tableIndex ${change.tableIndex} out of range`);
                 }
-                if (change.op === 'upsert' &&
-                    (change.rowVersion === undefined || change.row === undefined)) {
-                    encodeInvalid('upsert change requires rowVersion and row');
+                if ((change.op === 'upsert') !== (change.row !== undefined)) {
+                    encodeInvalid('change row must be present iff op is upsert');
                 }
-                if (change.op === 'delete' &&
-                    (change.rowVersion !== undefined || change.row !== undefined)) {
-                    encodeInvalid('delete change must not carry rowVersion or row');
+                if (change.rowVersion < 1) {
+                    encodeInvalid('change rowVersion must be at least 1');
                 }
                 w.u16(change.tableIndex);
                 w.str(change.rowId);
                 w.u8(OP_BYTES[change.op]);
-                w.opt(change.rowVersion, (v) => w.i64(v));
+                w.i64(change.rowVersion);
                 writeStringMap(w, change.scopes);
                 w.opt(change.row, (v) => w.bytes(v));
             }
@@ -850,7 +966,8 @@ function encodeFrame(frame, wireVersion) {
             break;
         }
         case 'SEGMENT_INLINE': {
-            return { frameType: FrameType.SEGMENT_INLINE, payload: frame.payload };
+            w.raw(frame.payload);
+            break;
         }
         case 'SUB_END': {
             w.i64(frame.nextCursor);
@@ -866,33 +983,29 @@ function encodeFrame(frame, wireVersion) {
             w.opt(frame.details, (v) => w.str(v));
             break;
         }
-        case 'UNKNOWN': {
-            if (!Number.isInteger(frame.frameType) ||
-                frame.frameType < 0 ||
-                frame.frameType > 0xff ||
-                KNOWN_FRAME_TYPES.has(frame.frameType)) {
-                encodeInvalid(`UNKNOWN frame type ${frame.frameType} collides with a defined frame type`);
-            }
-            return { frameType: frame.frameType, payload: frame.payload };
-        }
+        case 'UNKNOWN':
+            return encodeUnknown(frame, w);
     }
-    return { frameType: FrameType[frame.type], payload: w.finish() };
+    return FrameType[frame.type];
 }
 // ---------------------------------------------------------------------------
-// Envelope
+// Envelope. The kind-specific codecs let a peer bundle only the direction it
+// speaks; `encodeMessage` and `decodeMessage` dispatch on the kind.
 // ---------------------------------------------------------------------------
-export function encodeMessage(message) {
-    if (!isSupportedProtocolWireVersion(message.wireVersion)) {
-        encodeInvalid(`unsupported wireVersion ${message.wireVersion}`);
+function encodeEnvelope(wireVersion, kindByte, frames, validate, encode) {
+    if (!isSupportedProtocolWireVersion(wireVersion)) {
+        encodeInvalid(`unsupported wireVersion ${wireVersion}`);
     }
-    validateFrameSequence(message);
+    validate(frames);
     const w = new ByteWriter();
     w.raw(MAGIC_BYTES);
-    w.u16(message.wireVersion);
-    w.u8(message.msgKind === 'request' ? 0x01 : 0x02);
+    w.u16(wireVersion);
+    w.u8(kindByte);
     w.u8(0x00);
-    for (const frame of message.frames) {
-        const { frameType, payload } = encodeFrame(frame, message.wireVersion);
+    for (const frame of frames) {
+        const p = new ByteWriter();
+        const frameType = encode(frame, p);
+        const payload = p.finish();
         w.u8(frameType);
         w.u32(payload.length);
         w.raw(payload);
@@ -901,6 +1014,17 @@ export function encodeMessage(message) {
     w.u32(0);
     return w.finish();
 }
+export function encodeRequest(message) {
+    return encodeEnvelope(message.wireVersion, 0x01, message.frames, validateRequestSequence, encodeRequestFrame);
+}
+export function encodeResponse(message) {
+    return encodeEnvelope(message.wireVersion, 0x02, message.frames, validateResponseSequence, encodeResponseFrame);
+}
+export function encodeMessage(message) {
+    return message.msgKind === 'request'
+        ? encodeRequest(message)
+        : encodeResponse(message);
+}
 function readFrames(r, decodeFrame_) {
     const frames = [];
     for (;;) {
@@ -922,7 +1046,7 @@ function readFrames(r, decodeFrame_) {
         frames.push(decodeFrame_(frameType, payload));
     }
 }
-export function decodeMessage(bytes) {
+function decodeEnvelope(bytes) {
     const r = new ByteReader(bytes);
     if (r.remaining < 8)
         invalid('truncated envelope header');
@@ -944,20 +1068,31 @@ export function decodeMessage(bytes) {
     const flags = r.u8();
     if (flags !== 0)
         invalid(`non-zero envelope flags 0x${flags.toString(16)}`);
-    if (kindByte === 0x01) {
-        const message = {
-            wireVersion,
-            msgKind: 'request',
-            frames: readFrames(r, (frameType, payload) => decodeRequestFrame(frameType, payload, wireVersion)),
-        };
-        validateRequestSequence(message.frames);
-        return message;
-    }
-    const message = {
-        wireVersion,
-        msgKind: 'response',
-        frames: readFrames(r, (frameType, payload) => decodeResponseFrame(frameType, payload, wireVersion)),
-    };
-    validateResponseSequence(message.frames);
-    return message;
+    return { r, wireVersion, request: kindByte === 0x01 };
+}
+function requestBody(r, wireVersion) {
+    const frames = readFrames(r, decodeRequestFrame);
+    validateRequestSequence(frames);
+    return { wireVersion, msgKind: 'request', frames };
+}
+function responseBody(r, wireVersion) {
+    const frames = readFrames(r, decodeResponseFrame);
+    validateResponseSequence(frames);
+    return { wireVersion, msgKind: 'response', frames };
+}
+export function decodeRequest(bytes) {
+    const { r, wireVersion, request } = decodeEnvelope(bytes);
+    if (!request)
+        invalid('expected a request message');
+    return requestBody(r, wireVersion);
+}
+export function decodeResponse(bytes) {
+    const { r, wireVersion, request } = decodeEnvelope(bytes);
+    if (request)
+        invalid('expected a response message');
+    return responseBody(r, wireVersion);
+}
+export function decodeMessage(bytes) {
+    const { r, wireVersion, request } = decodeEnvelope(bytes);
+    return request ? requestBody(r, wireVersion) : responseBody(r, wireVersion);
 }