@syncular/core 0.58.0 → 0.60.0

package/dist/blob-ref.d.ts

@@ -9,10 +9,10 @@ export interface BlobRef {
     readonly name?: string;
 }
 /**
- * Parse and validate a raw `blob_ref` string against the §5.9.1 shape. A
- * failure is a row-codec decode error (`sync.invalid_request`), the same
- * class as the tag-5 json parse failure — so codec and §11 rendering can
- * never disagree.
+ * Parse and validate a raw `blob_ref` string (§5.9.1): a valid JSON document
+ * (Conventions JSON validity rule), the pinned shape, and text byte-identical
+ * to `serializeBlobRef` of the parsed fields. A failure is a row-codec decode
+ * error (`sync.invalid_request`) on every decode path.
  */
 export declare function parseBlobRef(raw: string): BlobRef;
 /** Serialize a BlobRef to its canonical string form (§5.9.1 key order). */

package/dist/blob-ref.js

@@ -2,46 +2,31 @@
  * Canonical BlobRef documents (SPEC.md §5.9.1) — the value carried by a
  * `blob_ref` column (§2.4 tag 7).
  *
- * A `blob_ref` value is a `str` holding a JSON document with a pinned shape
- * and pinned key order: `blobId` (content address), `byteLength`, then the
- * optional `mediaType` and `name`. On the wire and in the codec it is
- * byte-for-byte a `str`, validated at decode exactly like `json` (tag 5)
- * plus the shape check below; the raw string is preserved verbatim for
- * re-encoding. Nothing here re-serializes a decoded value — round-trip
- * fidelity is the same rule the `json` tag obeys.
+ * A `blob_ref` value is a `str` holding the canonical serialization of a
+ * pinned shape: `blobId` (content address), `byteLength`, then the optional
+ * `mediaType` and `name`. On the wire and in the codec it is byte-for-byte a
+ * `str`; decode accepts exactly the canonical text, so the raw string a
+ * decoder preserves for re-encoding is the canonical one.
  */
 import { DecodeError } from './errors.js';
+import { parseJsonDocument } from './json-document.js';
 /** The content-address prefix, identical in form to `segmentId` (§5.1). */
 const BLOB_ID_RE = /^sha256:[0-9a-f]{64}$/;
-/** Canonical key order (§5.9.1): blobId, byteLength, mediaType, name. */
-const CANONICAL_KEYS = [
-    'blobId',
-    'byteLength',
-    'mediaType',
-    'name',
-];
 /**
- * Parse and validate a raw `blob_ref` string against the §5.9.1 shape. A
- * failure is a row-codec decode error (`sync.invalid_request`), the same
- * class as the tag-5 json parse failure — so codec and §11 rendering can
- * never disagree.
+ * Parse and validate a raw `blob_ref` string (§5.9.1): a valid JSON document
+ * (Conventions JSON validity rule), the pinned shape, and text byte-identical
+ * to `serializeBlobRef` of the parsed fields. A failure is a row-codec decode
+ * error (`sync.invalid_request`) on every decode path.
  */
 export function parseBlobRef(raw) {
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        throw new DecodeError('sync.invalid_request', 'blob_ref value does not parse as a JSON document (§5.9.1)');
-    }
+    const parsed = parseJsonDocument(raw, 'blob_ref value');
     if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
         throw new DecodeError('sync.invalid_request', 'blob_ref value must be a JSON object (§5.9.1)');
     }
     const obj = parsed;
-    for (const key of Object.keys(obj)) {
-        if (!CANONICAL_KEYS.includes(key)) {
-            throw new DecodeError('sync.invalid_request', `blob_ref has unknown key ${JSON.stringify(key)} (§5.9.1)`);
-        }
+    const keys = ['blobId', 'byteLength', 'mediaType', 'name'];
+    if (Object.keys(obj).some((key) => !keys.includes(key))) {
+        throw new DecodeError('sync.invalid_request', 'blob_ref has an unknown key (§5.9.1)');
     }
     const { blobId, byteLength, mediaType, name } = obj;
     if (typeof blobId !== 'string' || !BLOB_ID_RE.test(blobId)) {
@@ -58,20 +43,18 @@ export function parseBlobRef(raw) {
     if (name !== undefined && typeof name !== 'string') {
         throw new DecodeError('sync.invalid_request', 'blob_ref.name must be a string when present (§5.9.1)');
     }
-    // Canonical key order: the raw string's keys, in appearance order, must be
-    // a prefix-consistent subsequence of CANONICAL_KEYS (present keys in the
-    // pinned order, absent keys omitted).
-    const presentInOrder = Object.keys(obj);
-    const expectedOrder = CANONICAL_KEYS.filter((k) => Object.hasOwn(obj, k));
-    if (presentInOrder.join(',') !== expectedOrder.join(',')) {
-        throw new DecodeError('sync.invalid_request', 'blob_ref keys are not in canonical order (§5.9.1)');
-    }
-    return {
+    const ref = {
         blobId,
         byteLength,
         ...(mediaType !== undefined ? { mediaType } : {}),
         ...(name !== undefined ? { name } : {}),
     };
+    // Reordered or duplicate keys, whitespace, and a byteLength written as
+    // `1e2`, `3.0` or `-0` all differ from the canonical text.
+    if (serializeBlobRef(ref) !== raw) {
+        throw new DecodeError('sync.invalid_request', 'blob_ref is not in canonical form (§5.9.1)');
+    }
+    return ref;
 }
 /** Serialize a BlobRef to its canonical string form (§5.9.1 key order). */
 export function serializeBlobRef(ref) {

package/dist/canonical-json.d.ts

@@ -1,10 +1,21 @@
-/**
- * Canonical JSON for digests (SPEC.md §11.2) — contractual across
- * implementations: UTF-8, no insignificant whitespace, object keys sorted
- * by code-unit, scope value lists sorted and deduplicated.
- *
- * Used for the scope digest (§3.5) and the `X-Syncular-Scopes` header
- * (§5.5). Hashing itself is the host's job; this module only produces the
- * canonical text.
- */
+import type { FencedRecord } from './message.js';
+/** A unit's scope map: one value per requested variable (§4.1). */
+export type UnitScopes = Readonly<Record<string, string>>;
 export declare function canonicalScopeJson(scopes: Readonly<Record<string, readonly string[]>>): string;
+/** §4.1: the canonical JSON of a unit's scope map. */
+export declare function canonicalUnitJson(scopes: UnitScopes): string;
+/** §4.1: lowercase hex of the first 16 bytes of SHA-256 over the canonical
+ * JSON of the unit's scope map. */
+export declare function unitId(scopes: UnitScopes): string;
+/** §4.1: SHA-256 over the canonical JSON array of the units' scope maps in
+ * registration order, as 32 raw bytes. */
+export declare function registrationDigest(units: readonly UnitScopes[]): Uint8Array;
+/** One unit of the effective list as the echo digest sees it (§4.4). */
+export interface UnitEcho {
+    id: string;
+    status: 'active' | 'revoked';
+    fenced: readonly FencedRecord[];
+}
+/** §4.4: SHA-256 over the canonical JSON array, in registration order, of
+ * `{"fenced":[…],"id":…,"status":…}` per unit, as 32 raw bytes. */
+export declare function echoDigest(units: readonly UnitEcho[]): Uint8Array;

package/dist/canonical-json.js

@@ -1,12 +1,13 @@
 /**
- * Canonical JSON for digests (SPEC.md §11.2) — contractual across
- * implementations: UTF-8, no insignificant whitespace, object keys sorted
- * by code-unit, scope value lists sorted and deduplicated.
+ * Canonical JSON for digests (SPEC.md §11.2) and the digests over it —
+ * contractual across implementations: UTF-8, no insignificant whitespace,
+ * object keys sorted by code-unit, scope value lists sorted and
+ * deduplicated, every other array in its stated order.
  *
- * Used for the scope digest (§3.5) and the `X-Syncular-Scopes` header
- * (§5.5). Hashing itself is the host's job; this module only produces the
- * canonical text.
+ * Used for the unit id and registration digest (§4.1), the echo digest
+ * (§4.4), the scope digest (§3.5) and the `X-Syncular-Scopes` header (§5.5).
  */
+import { utf8Encode } from './bytes.js';
 export function canonicalScopeJson(scopes) {
     const keys = Object.keys(scopes).sort();
     const parts = keys.map((key) => {
@@ -16,3 +17,104 @@ export function canonicalScopeJson(scopes) {
     });
     return `{${parts.join(',')}}`;
 }
+/** §4.1: the canonical JSON of a unit's scope map. */
+export function canonicalUnitJson(scopes) {
+    const keys = Object.keys(scopes).sort();
+    const parts = keys.map((key) => `${JSON.stringify(key)}:${JSON.stringify(scopes[key])}`);
+    return `{${parts.join(',')}}`;
+}
+/** §4.1: lowercase hex of the first 16 bytes of SHA-256 over the canonical
+ * JSON of the unit's scope map. */
+export function unitId(scopes) {
+    let hex = '';
+    for (const byte of sha256(utf8Encode(canonicalUnitJson(scopes))).subarray(0, 16)) {
+        hex += byte.toString(16).padStart(2, '0');
+    }
+    return hex;
+}
+/** §4.1: SHA-256 over the canonical JSON array of the units' scope maps in
+ * registration order, as 32 raw bytes. */
+export function registrationDigest(units) {
+    return sha256(utf8Encode(`[${units.map(canonicalUnitJson).join(',')}]`));
+}
+/** §4.4: SHA-256 over the canonical JSON array, in registration order, of
+ * `{"fenced":[…],"id":…,"status":…}` per unit, as 32 raw bytes. */
+export function echoDigest(units) {
+    const entries = units.map((unit) => {
+        const fenced = unit.fenced.map((record) => `{"scopes":${canonicalScopeJson(record.scopes)},"status":${JSON.stringify(record.status)},"table":${JSON.stringify(record.table)}}`);
+        return `{"fenced":[${fenced.join(',')}],"id":${JSON.stringify(unit.id)},"status":${JSON.stringify(unit.status)}}`;
+    });
+    return sha256(utf8Encode(`[${entries.join(',')}]`));
+}
+// FIPS 180-4 SHA-256. Synchronous so the unit id is a plain function of the
+// scope map on every runtime (WebCrypto digests are async only).
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+    0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+    0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+function sha256(data) {
+    const padded = new Uint8Array(((data.length + 72) >>> 6) << 6);
+    padded.set(data);
+    padded[data.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, Math.floor(data.length / 0x20000000));
+    view.setUint32(padded.length - 4, (data.length * 8) >>> 0);
+    const h = [
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
+        0x1f83d9ab, 0x5be0cd19,
+    ];
+    const w = new Uint32Array(64);
+    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+    for (let offset = 0; offset < padded.length; offset += 64) {
+        for (let i = 0; i < 16; i++)
+            w[i] = view.getUint32(offset + i * 4);
+        for (let i = 16; i < 64; i++) {
+            const a = w[i - 15];
+            const b = w[i - 2];
+            w[i] =
+                (rotr(b, 17) ^ rotr(b, 19) ^ (b >>> 10)) +
+                    w[i - 7] +
+                    (rotr(a, 7) ^ rotr(a, 18) ^ (a >>> 3)) +
+                    w[i - 16];
+        }
+        let [a, b, c, d, e, f, g, hh] = h;
+        for (let i = 0; i < 64; i++) {
+            const t1 = hh +
+                (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) +
+                ((e & f) ^ (~e & g)) +
+                K[i] +
+                w[i];
+            const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) +
+                ((a & b) ^ (a & c) ^ (b & c));
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) | 0;
+        }
+        h[0] = (h[0] + a) | 0;
+        h[1] = (h[1] + b) | 0;
+        h[2] = (h[2] + c) | 0;
+        h[3] = (h[3] + d) | 0;
+        h[4] = (h[4] + e) | 0;
+        h[5] = (h[5] + f) | 0;
+        h[6] = (h[6] + g) | 0;
+        h[7] = (h[7] + hh) | 0;
+    }
+    const out = new Uint8Array(32);
+    const outView = new DataView(out.buffer);
+    h.forEach((word, i) => outView.setUint32(i * 4, word));
+    return out;
+}

package/dist/constants.d.ts

@@ -1,10 +1,10 @@
 /** Protocol constants (SPEC.md §1.2, §9 are normative). */
 /** Latest SSP2 envelope wire version emitted by current clients. */
-export declare const PROTOCOL_WIRE_VERSION = 3;
-/** Oldest SSP2 envelope wire version accepted. Wire version 3 changed the
- * push payload to the sparse row codec (§2.4) and the conflict record shape
- * (§6.3); versions 1 and 2 are rejected as unknown (§9). */
-export declare const MINIMUM_PROTOCOL_WIRE_VERSION = 3;
+export declare const PROTOCOL_WIRE_VERSION = 4;
+/** Oldest SSP2 envelope wire version accepted. Wire version 4 replaced
+ * per-table subscriptions with units and the replica cursor (§4); earlier
+ * versions are rejected as unknown (§9). */
+export declare const MINIMUM_PROTOCOL_WIRE_VERSION = 4;
 /** Wire versions implemented by the reference codec, oldest first. */
 export declare const SUPPORTED_PROTOCOL_WIRE_VERSIONS: readonly number[];
 /** Whether the reference codec implements this exact wire version. */

package/dist/constants.js

@@ -1,10 +1,10 @@
 /** Protocol constants (SPEC.md §1.2, §9 are normative). */
 /** Latest SSP2 envelope wire version emitted by current clients. */
-export const PROTOCOL_WIRE_VERSION = 3;
-/** Oldest SSP2 envelope wire version accepted. Wire version 3 changed the
- * push payload to the sparse row codec (§2.4) and the conflict record shape
- * (§6.3); versions 1 and 2 are rejected as unknown (§9). */
-export const MINIMUM_PROTOCOL_WIRE_VERSION = 3;
+export const PROTOCOL_WIRE_VERSION = 4;
+/** Oldest SSP2 envelope wire version accepted. Wire version 4 replaced
+ * per-table subscriptions with units and the replica cursor (§4); earlier
+ * versions are rejected as unknown (§9). */
+export const MINIMUM_PROTOCOL_WIRE_VERSION = 4;
 /** Wire versions implemented by the reference codec, oldest first. */
 export const SUPPORTED_PROTOCOL_WIRE_VERSIONS = Object.freeze(Array.from({
     length: PROTOCOL_WIRE_VERSION - MINIMUM_PROTOCOL_WIRE_VERSION + 1,

package/dist/crypto.js

@@ -13,6 +13,7 @@
  * is the symmetric core and the envelope both sides agree on byte-for-byte.
  */
 import { ByteReader, ByteWriter } from './bytes.js';
+import { parseJsonDocument } from './json-document.js';
 /** Envelope version byte (SPEC.md §5.11). */
 export const ENVELOPE_VERSION = 0x01;
 /** AES-GCM nonce length (96-bit, the GCM standard). */
@@ -113,7 +114,7 @@ export function deserializePlain(declaredType, bytes) {
             }
             if (declaredType === 'json' || declaredType === 'blob_ref') {
                 try {
-                    JSON.parse(text);
+                    parseJsonDocument(text, `decrypted ${declaredType} value`);
                 }
                 catch {
                     throw new DecryptError(`decrypted ${declaredType} value does not parse`);

package/dist/frames.d.ts

@@ -1,11 +1,12 @@
-/** Frame type registry for wire versions 1 and 2 (SPEC.md §1.2). */
+/** Frame type registry for wire version 4 (SPEC.md §1.2). */
 export declare const FrameType: {
     readonly END: 0;
     readonly REQ_HEADER: 1;
     readonly PUSH_COMMIT: 2;
     readonly PULL_HEADER: 3;
-    readonly SUBSCRIPTION: 4;
+    readonly UNIT: 4;
     readonly ROUND_FAILURE: 5;
+    readonly PROGRESS: 6;
     readonly RESP_HEADER: 16;
     readonly PUSH_RESULT: 17;
     readonly SUB_START: 18;
@@ -15,6 +16,8 @@ export declare const FrameType: {
     readonly SUB_END: 22;
     readonly LEASE: 25;
     readonly PUSH_RESULT_DETAILS: 27;
+    readonly LIVE_START: 28;
+    readonly LIVE_END: 29;
     readonly ERROR: 31;
 };
 export type FrameTypeName = keyof typeof FrameType;
@@ -22,5 +25,5 @@ export type FrameTypeName = keyof typeof FrameType;
 export declare const REQUEST_FRAME_TYPES: ReadonlySet<number>;
 /** Known response frame types (excluding END). */
 export declare const RESPONSE_FRAME_TYPES: ReadonlySet<number>;
-/** Every frame type with a defined layout in wire versions 1 and 2. */
+/** Every frame type with a defined layout in wire version 4. */
 export declare const KNOWN_FRAME_TYPES: ReadonlySet<number>;

package/dist/frames.js

@@ -1,11 +1,12 @@
-/** Frame type registry for wire versions 1 and 2 (SPEC.md §1.2). */
+/** Frame type registry for wire version 4 (SPEC.md §1.2). */
 export const FrameType = {
     END: 0x00,
     REQ_HEADER: 0x01,
     PUSH_COMMIT: 0x02,
     PULL_HEADER: 0x03,
-    SUBSCRIPTION: 0x04,
+    UNIT: 0x04,
     ROUND_FAILURE: 0x05,
+    PROGRESS: 0x06,
     RESP_HEADER: 0x10,
     PUSH_RESULT: 0x11,
     SUB_START: 0x12,
@@ -15,6 +16,8 @@ export const FrameType = {
     SUB_END: 0x16,
     LEASE: 0x19,
     PUSH_RESULT_DETAILS: 0x1b,
+    LIVE_START: 0x1c,
+    LIVE_END: 0x1d,
     ERROR: 0x1f,
 };
 /** Known request frame types (excluding END). */
@@ -22,8 +25,9 @@ export const REQUEST_FRAME_TYPES = new Set([
     FrameType.REQ_HEADER,
     FrameType.PUSH_COMMIT,
     FrameType.PULL_HEADER,
-    FrameType.SUBSCRIPTION,
+    FrameType.UNIT,
     FrameType.ROUND_FAILURE,
+    FrameType.PROGRESS,
 ]);
 /** Known response frame types (excluding END). */
 export const RESPONSE_FRAME_TYPES = new Set([
@@ -36,9 +40,11 @@ export const RESPONSE_FRAME_TYPES = new Set([
     FrameType.SUB_END,
     FrameType.LEASE,
     FrameType.PUSH_RESULT_DETAILS,
+    FrameType.LIVE_START,
+    FrameType.LIVE_END,
     FrameType.ERROR,
 ]);
-/** Every frame type with a defined layout in wire versions 1 and 2. */
+/** Every frame type with a defined layout in wire version 4. */
 export const KNOWN_FRAME_TYPES = new Set([
     FrameType.END,
     ...REQUEST_FRAME_TYPES,

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export * from './constants.js';
 export * from './crypto.js';
 export * from './errors.js';
 export * from './frames.js';
+export * from './json-document.js';
 export * from './message.js';
 export * from './realtime.js';
 export * from './rejection-details.js';

package/dist/index.js

@@ -13,6 +13,7 @@ export * from './constants.js';
 export * from './crypto.js';
 export * from './errors.js';
 export * from './frames.js';
+export * from './json-document.js';
 export * from './message.js';
 export * from './realtime.js';
 export * from './rejection-details.js';

package/dist/json-document.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Parse `raw` as a JSON document under the validity rule, which is defined on
+ * the raw text: RFC 8259, at most 64 nested containers anywhere in the text,
+ * every number token a finite binary64, no U+0000 and no unpaired surrogate in
+ * any string token (key or value), written literally or as a `\u` escape.
+ * `JSON.parse` drops values shadowed by a duplicate key, so one lexical pass
+ * over the text checks what the parser cannot see. A violation throws
+ * `DecodeError` (`sync.invalid_request`); `what` names the field in the
+ * message.
+ */
+export declare function parseJsonDocument(raw: string, what: string): unknown;

package/dist/json-document.js

@@ -0,0 +1,50 @@
+/**
+ * The JSON validity rule (SPEC.md Conventions): the one definition of a valid
+ * JSON document for envelope `json` fields, push-payload `json` columns and
+ * `blob_ref` values. The Rust core (`ssp2::primitives::parse_json_document`)
+ * accepts exactly the same documents.
+ */
+import { DecodeError } from './errors.js';
+const MAX_DEPTH = 64;
+/**
+ * Parse `raw` as a JSON document under the validity rule, which is defined on
+ * the raw text: RFC 8259, at most 64 nested containers anywhere in the text,
+ * every number token a finite binary64, no U+0000 and no unpaired surrogate in
+ * any string token (key or value), written literally or as a `\u` escape.
+ * `JSON.parse` drops values shadowed by a duplicate key, so one lexical pass
+ * over the text checks what the parser cannot see. A violation throws
+ * `DecodeError` (`sync.invalid_request`); `what` names the field in the
+ * message.
+ */
+export function parseJsonDocument(raw, what) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new DecodeError('sync.invalid_request', `${what} does not parse as a JSON document`);
+    }
+    let depth = 0;
+    for (const [token] of raw.matchAll(/"(?:[^"\\]|\\.)*"|[[{\]}]|-?\d[\d.eE+-]*/g)) {
+        const head = token[0];
+        if (head === '[' || head === '{') {
+            if (++depth > MAX_DEPTH) {
+                throw new DecodeError('sync.invalid_request', `${what} nests deeper than ${MAX_DEPTH} containers`);
+            }
+        }
+        else if (head === ']' || head === '}') {
+            depth--;
+        }
+        else if (head === '"') {
+            // In `u` mode `\p{Cs}` matches only a surrogate outside a pair.
+            const text = token.includes('\\') ? JSON.parse(token) : token;
+            if (text.includes('\u0000') || /\p{Cs}/u.test(text)) {
+                throw new DecodeError('sync.invalid_request', `${what} holds a string with U+0000 or an unpaired surrogate`);
+            }
+        }
+        else if (!Number.isFinite(Number(token))) {
+            throw new DecodeError('sync.invalid_request', `${what} holds a number outside finite binary64`);
+        }
+    }
+    return value;
+}

package/dist/message.d.ts

@@ -4,8 +4,11 @@ export interface ReqHeaderFrame {
     type: 'REQ_HEADER';
     clientId: string;
     schemaVersion: number;
-    /** Wire v2 partition log identity; absent requests epoch acquisition. */
+    /** Partition log identity; absent requests epoch acquisition. */
     logEpoch?: string;
+    /** Identity of the sender's outbox sequence (§6.3.2, §7.1); absent for a
+     * sender without an outbox. Non-empty, at most 64 bytes. */
+    outboxId?: string;
 }
 export interface PushOperation {
     table: string;
@@ -19,6 +22,8 @@ export interface PushOperation {
 export interface PushCommitFrame {
     type: 'PUSH_COMMIT';
     clientCommitId: string;
+    /** Outbox sequence number (§6.3.2, §7.1); `0` without an outbox. */
+    clientSeq: number;
     operations: PushOperation[];
 }
 export interface PullHeaderFrame {
@@ -28,14 +33,24 @@ export interface PullHeaderFrame {
     maxSnapshotPages: number;
     /** Bitmask (§4.2): bit 0 inline rows, 1 external rows, 2 sqlite, 3 signed URLs. */
     accept: number;
+    /** The replica cursor (§4.5); `-1` when no unit is live. */
+    cursor: number;
+    /** §4.1 registration digest: exactly 32 bytes. */
+    registrationDigest: Uint8Array;
+    /** The last processed `LIVE_END.echoDigest`: empty or 32 bytes (§4.2). */
+    echoDigest: Uint8Array;
+}
+/** §4.3: one unit of a traveling registration list. */
+export interface UnitFrame {
+    type: 'UNIT';
+    scopes: Record<string, string>;
 }
-export interface SubscriptionFrame {
-    type: 'SUBSCRIPTION';
+/** §4.3: the progress of one catching-up unit. */
+export interface ProgressFrame {
+    type: 'PROGRESS';
+    /** The unit id (§4.1): 32 lowercase hex characters. */
     id: string;
-    table: string;
-    scopes: ScopeMap;
-    /** Host-opaque JSON document, preserved verbatim. */
-    params?: string;
+    /** `-1`, the §4.7 pin while a resume token is held, or the unit cursor. */
     cursor: number;
     /** Opaque resume token JSON, round-tripped byte-for-byte (§4.7). */
     bootstrapState?: string;
@@ -53,15 +68,15 @@ export interface RoundFailureFrame {
     type: 'ROUND_FAILURE';
     code: string;
 }
-export type RequestFrame = ReqHeaderFrame | RoundFailureFrame | PushCommitFrame | PullHeaderFrame | SubscriptionFrame | UnknownFrame;
+export type RequestFrame = ReqHeaderFrame | RoundFailureFrame | PushCommitFrame | PullHeaderFrame | UnitFrame | ProgressFrame | UnknownFrame;
 export interface RespHeaderFrame {
     type: 'RESP_HEADER';
     requiredSchemaVersion?: number;
     latestSchemaVersion?: number;
-    /** Required and non-empty on wire v2. */
-    logEpoch?: string;
-    /** Required on wire v2. True produces a header-only reset response. */
-    resetRequired?: boolean;
+    /** Partition log identity, non-empty. */
+    logEpoch: string;
+    /** True produces a header-only reset response. */
+    resetRequired: boolean;
 }
 /** §7.3.2: a server-issued auth lease delivered to the client (opaque). */
 export interface LeaseFrame {
@@ -118,20 +133,43 @@ export interface PushResultDetailsFrame {
         details: RejectionDetails;
     }>;
 }
+/** §4.4: one (unit, table) pair the wildcard fence touched. */
+export interface FencedRecord {
+    table: string;
+    status: 'active' | 'revoked';
+    /** Effective lists of the variables the fence added; empty when revoked. */
+    scopes: ScopeMap;
+}
 export interface SubStartFrame {
     type: 'SUB_START';
+    /** The unit id (§4.1): 32 lowercase hex characters. */
     id: string;
     status: 'active' | 'revoked' | 'reset';
     reasonCode: string;
-    effectiveScopes: ScopeMap;
     bootstrap: boolean;
+    /** The unit's echo, in ascending table order (§4.4). */
+    fenced: FencedRecord[];
+}
+export interface LiveStartFrame {
+    type: 'LIVE_START';
+    status: 'active' | 'reset' | 'unregistered';
+    reasonCode: string;
+}
+export interface LiveEndFrame {
+    type: 'LIVE_END';
+    /** Highest commitSeq the live section is complete through; `-1` for
+     * `reset` and `unregistered` (§4.4). */
+    throughSeq: number;
+    /** Echo digest of the request: empty or 32 bytes (§4.4). */
+    echoDigest: Uint8Array;
 }
 export interface CommitChange {
     tableIndex: number;
     rowId: string;
     op: 'upsert' | 'delete';
-    /** Present iff `op` is `upsert` (§4.5). */
-    rowVersion?: number;
+    /** The row's `server_version` after the write, ≥ 1; a delete's is the
+     * version its tombstone records (§2.2, §4.5). */
+    rowVersion: number;
     scopes: Record<string, string>;
     /** Generated-row-codec bytes; present iff `op` is `upsert` (§4.5). */
     row?: Uint8Array;
@@ -167,7 +205,7 @@ export interface SegmentInlineFrame {
 export interface SubEndFrame {
     type: 'SUB_END';
     nextCursor: number;
-    /** Present iff the bootstrap is incomplete (§4.4). */
+    /** Present iff the unit's bootstrap is incomplete (§4.4). */
     bootstrapState?: string;
 }
 export interface ErrorFrame {
@@ -179,7 +217,7 @@ export interface ErrorFrame {
     recommendedAction: string;
     details?: string;
 }
-export type ResponseFrame = RespHeaderFrame | LeaseFrame | PushResultFrame | PushResultDetailsFrame | SubStartFrame | CommitFrame | SegmentRefFrame | SegmentInlineFrame | SubEndFrame | ErrorFrame | UnknownFrame;
+export type ResponseFrame = RespHeaderFrame | LeaseFrame | PushResultFrame | PushResultDetailsFrame | SubStartFrame | CommitFrame | SegmentRefFrame | SegmentInlineFrame | SubEndFrame | LiveStartFrame | LiveEndFrame | ErrorFrame | UnknownFrame;
 export interface RequestMessage {
     wireVersion: number;
     msgKind: 'request';
@@ -193,6 +231,9 @@ export interface ResponseMessage {
 export type SyncMessage = RequestMessage | ResponseMessage;
 /** §1.5: `code` is a legal `ROUND_FAILURE` code (grammar and byte length). */
 export declare function isRoundFailureCode(code: string): boolean;
-export declare function validateFrameSequence(message: SyncMessage): void;
+export declare function encodeRequest(message: RequestMessage): Uint8Array;
+export declare function encodeResponse(message: ResponseMessage): Uint8Array;
 export declare function encodeMessage(message: SyncMessage): Uint8Array;
+export declare function decodeRequest(bytes: Uint8Array): RequestMessage;
+export declare function decodeResponse(bytes: Uint8Array): ResponseMessage;
 export declare function decodeMessage(bytes: Uint8Array): SyncMessage;