@syncular/server 0.32.0 → 0.32.1

package/dist/d1-storage.js

@@ -144,6 +144,7 @@ class D1Transaction {
      * `tbl\u0000rowId` → the pending state, consulted by `getRow` before D1.
      */
     #pending = new Map();
+    #clearedTombstones = new Set();
     constructor(db, partition, resolveTable, prepareQuery, pushApplySerialized) {
         this.#db = db;
         this.#partition = partition;
@@ -175,6 +176,9 @@ class D1Transaction {
     }
     async getTombstoneSeq(table, rowId) {
         this.#assertOpen();
+        if (this.#clearedTombstones.has(_a.#key(table, rowId))) {
+            return undefined;
+        }
         // Persisted read, no #pending overlay: a delete buffered by this commit
         // records its tombstone at appendCommit, matching the SQLite/Postgres
         // adapters where the tombstone insert also runs at commit append.
@@ -186,6 +190,7 @@ class D1Transaction {
     }
     async clearTombstone(table, rowId) {
         this.#assertOpen();
+        this.#clearedTombstones.add(_a.#key(table, rowId));
         this.#buffer_('DELETE FROM sync_tombstones WHERE partition=? AND tbl=? AND row_id=?', [this.#partition, table, rowId]);
     }
     async getPushResult(clientId, clientCommitId) {
@@ -250,7 +255,7 @@ class D1Transaction {
             }
         }
         return [...rows.values()]
-            .sort((left, right) => left.rowId.localeCompare(right.rowId))
+            .sort((left, right) => left.rowId < right.rowId ? -1 : left.rowId > right.rowId ? 1 : 0)
             .slice(0, query.limit);
     }
     async scanRowsByIndex(query) {
@@ -287,7 +292,7 @@ class D1Transaction {
                 rows.set(rowId, pending.row);
         }
         return [...rows.values()]
-            .sort((left, right) => left.rowId.localeCompare(right.rowId))
+            .sort((left, right) => left.rowId < right.rowId ? -1 : left.rowId > right.rowId ? 1 : 0)
             .slice(0, query.limit);
     }
     async queryAuthoritative(query) {
@@ -334,6 +339,7 @@ class D1Transaction {
         }
         this.#buffer.length = checkpoint;
         this.#pending.clear();
+        this.#clearedTombstones.clear();
         this.#maxCommitSeq = undefined;
         this.#applicationOpIndexes.clear();
         await this.putPushResult(clientId, clientCommitId, result);

package/dist/handler.js

@@ -341,25 +341,35 @@ async function* streamResponse(plan, ctx, schema, report) {
     }
     try {
         // Push half (§6): one PUSH_RESULT per PUSH_COMMIT, in request order.
+        const currentSchema = compileSchema(ctx.schema);
         let acceptedThrough = 0;
         for (const push of plan.pushes) {
-            const processed = await processPushCommitWithTrace(ctx, compileSchema(ctx.schema), plan.resolved, plan.header.clientId, push, schema);
+            const processed = await processPushCommitWithTrace(ctx, currentSchema, plan.resolved, plan.header.clientId, push, schema);
             acceptedThrough = Math.max(acceptedThrough, processed.frame.commitSeq ?? 0);
             const frame = {
                 ...processed.frame,
                 results: processed.frame.results.map((result) => {
-                    if (result.status !== 'conflict')
+                    if (result.status !== 'conflict' || schema === currentSchema) {
                         return result;
+                    }
                     const operation = push.operations[result.opIndex];
+                    // §2.3: a replay returns the persisted result without rebuilding
+                    // operations, so a reused clientCommitId with changed operations
+                    // leaves no table to project the stored conflict row through.
+                    if (operation === undefined) {
+                        throw syncError('sync.invalid_request', 'replayed clientCommitId carries changed operations', JSON.stringify({
+                            clientCommitId: push.clientCommitId,
+                            opIndex: result.opIndex,
+                        }));
+                    }
                     const target = schema.tables.get(operation.table);
-                    const current = compileSchema(ctx.schema).tables.get(operation.table);
+                    const bitmapBytes = Math.ceil(target.columns.length / 8);
                     return {
                         ...result,
-                        serverRow: projectRowPayload(current, target, result.serverRow),
+                        serverRow: projectRowPayload(currentSchema.tables.get(operation.table), target, result.serverRow),
                         conflictColumns: result.conflictColumns
-                            .slice(0, Math.ceil(target.columns.length / 8))
-                            .map((byte, i) => i === Math.ceil(target.columns.length / 8) - 1 &&
-                            target.columns.length % 8 !== 0
+                            .slice(0, bitmapBytes)
+                            .map((byte, i) => i === bitmapBytes - 1 && target.columns.length % 8 !== 0
                             ? byte & ((1 << (target.columns.length % 8)) - 1)
                             : byte),
                     };

package/dist/operations.js

@@ -4,7 +4,7 @@ import { REMOTE_COMMAND_CLIENT_ID_PREFIX, RESOLVER_OUTAGE, touchAuthenticatedPar
 import { reportError, SyncError, syncError } from './errors.js';
 import { processPushOperationsWithTrace } from './push.js';
 import { compileSchema } from './schema.js';
-import { authorizeWrite } from './scopes.js';
+import { authorizeWrite, renderScopeValue, } from './scopes.js';
 import { transactionQuery } from './storage-query.js';
 import { toValidateRow } from './validate.js';
 function scopeAllowed(allowed, variable, value) {
@@ -265,9 +265,9 @@ function commandOperations(mutations, schema) {
             }
             return mutation.values[column.name] ?? null;
         });
-        const rowId = values[table.primaryKeyIndex];
-        if (typeof rowId !== 'string' || rowId.length === 0) {
-            throw syncError('operation.invalid_request', 'command upsert requires a non-empty string primary key');
+        const rowId = renderScopeValue(values[table.primaryKeyIndex]);
+        if (rowId === undefined) {
+            throw syncError('operation.invalid_request', 'command upsert requires a non-empty primary key');
         }
         return {
             table: table.name,

package/dist/push.js

@@ -298,6 +298,7 @@ async function applyOperation(tx, schema, wireSchema, resolved, op, opIndex, blo
             for (let i = 0; i < table.columns.length; i++) {
                 if (present[i] &&
                     !crdtIndexes.has(i) &&
+                    i !== table.primaryKeyIndex &&
                     effectiveVersion(i) > op.baseVersion) {
                     marked.push(i);
                 }
@@ -602,7 +603,16 @@ async function enforceReferences(tx, schema, staged, clientOpCount, cascadeLimit
     const changes = [];
     const operations = [];
     const originByIndex = [];
+    const finalByRow = new Map();
     for (const write of staged) {
+        const rowKey = `${write.table.name}\u0000${write.rowId}`;
+        const existing = finalByRow.get(rowKey);
+        finalByRow.set(rowKey, {
+            first: existing?.first ?? write,
+            last: write,
+        });
+    }
+    for (const { last: write } of finalByRow.values()) {
         if (write.op !== 'upsert' || write.values === undefined)
             continue;
         for (const reference of write.table.references) {
@@ -636,9 +646,9 @@ async function enforceReferences(tx, schema, staged, clientOpCount, cascadeLimit
     const scheduled = new Set();
     const processed = new Set();
     const queue = [];
-    for (const write of staged) {
-        if (write.op === 'delete' && write.stored !== undefined) {
-            schedule(write.table, write.rowId, write.opIndex, scheduled, queue);
+    for (const { first, last } of finalByRow.values()) {
+        if (last.op === 'delete' && first.stored !== undefined) {
+            schedule(last.table, last.rowId, last.opIndex, scheduled, queue);
         }
     }
     for (let cursor = 0; cursor < queue.length; cursor++) {
@@ -649,6 +659,12 @@ async function enforceReferences(tx, schema, staged, clientOpCount, cascadeLimit
         if (processed.has(key))
             continue;
         processed.add(key);
+        const parentPkColumn = item.table.columns[item.table.primaryKeyIndex];
+        const parentKeyValue = parentPkColumn?.type === 'integer'
+            ? Number(item.rowId)
+            : parentPkColumn?.type === 'boolean'
+                ? item.rowId === 'true'
+                : item.rowId;
         for (const reference of item.table.referencedBy) {
             if (tx.scanRowsByIndex === undefined) {
                 throw new Error('storage transaction does not support declared-reference enforcement (scanRowsByIndex)');
@@ -659,7 +675,7 @@ async function enforceReferences(tx, schema, staged, clientOpCount, cascadeLimit
                 const page = await tx.scanRowsByIndex({
                     table: reference.table,
                     index: reference.index,
-                    values: [item.rowId],
+                    values: [parentKeyValue],
                     afterRowId,
                     limit: 1_000,
                 });
@@ -684,15 +700,20 @@ async function enforceReferences(tx, schema, staged, clientOpCount, cascadeLimit
                 throw new Error(`unreachable: reference child table ${reference.table} is not compiled`);
             }
             for (const childRow of children) {
+                if (reference.onDelete === 'CASCADE') {
+                    if (!schedule(child, childRow.rowId, item.originOpIndex, scheduled, queue)) {
+                        continue;
+                    }
+                }
+                else if (scheduled.has(`${child.name}\u0000${childRow.rowId}`)) {
+                    continue;
+                }
                 if (originByIndex.length >= cascadeLimit) {
                     return {
                         kind: 'terminate',
                         record: referenceRejection(item.originOpIndex, 'declared-reference cascade exceeded the per-commit operation cap (§6.11)', { reason: 'cascade_limit' }),
                     };
                 }
-                if (!schedule(child, childRow.rowId, item.originOpIndex, scheduled, queue)) {
-                    continue;
-                }
                 const syntheticIndex = clientOpCount + originByIndex.length;
                 const storedValues = decodeRow(child.columns, childRow.payload);
                 if (reference.onDelete === 'CASCADE') {

package/dist/realtime.js

@@ -16,7 +16,7 @@
  * one handler, two framings); the only JSON data-plane server event is
  * the `sync` wake-up (§8.3).
  */
-import { DecodeError, decodeMessage, encodeMessage, encodePresenceError, encodePresenceFanout, MessageStreamScanner, PROTOCOL_WIRE_VERSION, parseRealtimePresencePublish, REALTIME_TAG_DELTA, REALTIME_TAG_ROUND, } from '@syncular/core';
+import { DecodeError, decodeMessage, encodeMessage, encodePresenceError, encodePresenceFanout, isSupportedProtocolWireVersion, MessageStreamScanner, PROTOCOL_WIRE_VERSION, parseRealtimePresencePublish, REALTIME_TAG_DELTA, REALTIME_TAG_ROUND, } from '@syncular/core';
 import { REMOTE_COMMAND_CLIENT_ID_PREFIX, RESOLVER_OUTAGE, touchAuthenticatedPartition, } from './context.js';
 import { adapterSyncError, reportError, SyncError, syncError, } from './errors.js';
 import { emitEvent } from './events.js';
@@ -160,6 +160,8 @@ export class RealtimeSession {
     #registrationGeneration = 0;
     /** Generation of the most recent refresh whose result was applied. */
     #registrationApplied = 0;
+    /** Highest sequence that required a catch-up wake for this session. */
+    #wakeRequiredThroughSeq;
     constructor(hub, options, registrations, cursor, latestSeq, clock, maxDeltaBytes, storage, logEpoch, wireVersion, events) {
         this.sessionId = crypto.randomUUID();
         this.partition = options.partition;
@@ -170,6 +172,7 @@ export class RealtimeSession {
         this.cursor = cursor;
         this.lastKnownSeq = latestSeq;
         this.wakePending = cursor < latestSeq;
+        this.#wakeRequiredThroughSeq = cursor < latestSeq ? latestSeq : 0;
         this.registrations = registrations;
         this.openedAtMs = clock();
         this.#send = options.send;
@@ -208,10 +211,10 @@ export class RealtimeSession {
         // proves those commits no longer need socket notifications, so the next
         // notification must be adjacent to the acknowledged cursor.
         this.lastKnownSeq = Math.max(this.lastKnownSeq, this.cursor);
-        if (this.cursor >= this.lastKnownSeq)
+        if (this.cursor >= this.#wakeRequiredThroughSeq)
             this.wakePending = false;
         // §8.2: acks update the client cursor record without an HTTP pull.
-        this.#persistCursor();
+        this.#persistCursor(cursor);
     }
     /**
      * Resolve once every queued control-plane write has settled (§8.2). A host
@@ -413,7 +416,7 @@ export class RealtimeSession {
         };
         try {
             const requestedWireVersion = (requestBytes[4] ?? 0) | ((requestBytes[5] ?? 0) << 8);
-            if (requestedWireVersion === 1 || requestedWireVersion === 2) {
+            if (isSupportedProtocolWireVersion(requestedWireVersion)) {
                 this.wireVersion = requestedWireVersion;
             }
             let stream;
@@ -537,12 +540,12 @@ export class RealtimeSession {
         this.#closeSocket?.();
         this.#hub.disconnect(this);
     }
-    #persistCursor() {
+    #persistCursor(cursor) {
         // §8.2: start the write now and keep it on the control tail so `drain()`
         // can await it. Two acks may write concurrently: storage folds them with
         // `MAX(cursor, ?)`, so neither order loses the later cursor.
         const write = (async () => {
-            await this.#storage.advanceClientCursor(this.partition, this.clientId, this.actorId, this.logEpoch, this.cursor, this.#clock());
+            await this.#storage.advanceClientCursor(this.partition, this.clientId, this.actorId, this.logEpoch, cursor, this.#clock());
         })();
         write.catch((error) => {
             // Best-effort for the connection (the next pull repairs the cursor);
@@ -571,6 +574,7 @@ export class RealtimeSession {
     }
     sendWake(reason) {
         this.wakePending = true;
+        this.#wakeRequiredThroughSeq = Math.max(this.#wakeRequiredThroughSeq, this.lastKnownSeq);
         this.#sendSafe(JSON.stringify({
             event: 'sync',
             data: {
@@ -866,6 +870,12 @@ export class RealtimeHub {
             ...(this.#config.commitValidator !== undefined
                 ? { commitValidator: this.#config.commitValidator }
                 : {}),
+            ...(this.#config.reactionPlanner !== undefined
+                ? { reactionPlanner: this.#config.reactionPlanner }
+                : {}),
+            ...(this.#config.checkpoints !== undefined
+                ? { checkpoints: this.#config.checkpoints }
+                : {}),
             ...(this.#config.clock !== undefined
                 ? { clock: this.#config.clock }
                 : {}),
@@ -893,6 +903,9 @@ export class RealtimeHub {
             ...(this.#config.onError !== undefined
                 ? { onError: this.#config.onError }
                 : {}),
+            ...(this.#config.mapError !== undefined
+                ? { mapError: this.#config.mapError }
+                : {}),
             realtime: this,
         };
     }
@@ -929,7 +942,9 @@ export class RealtimeHub {
         const registrations = await this.loadRegistrations(options.partition, options.actorId, options.clientId);
         const latestSeq = await storage.getMaxCommitSeq(options.partition);
         const cursor = record?.cursor ?? -1;
-        const session = new RealtimeSession(this, options, registrations, cursor, latestSeq, clock, this.#config.maxDeltaBytes ?? DEFAULT_MAX_DELTA_BYTES, storage, registry.logEpoch, record?.wireVersion ?? PROTOCOL_WIRE_VERSION, this.#config.events);
+        const session = new RealtimeSession(this, options, registrations, cursor, latestSeq, clock, this.#config.maxDeltaBytes ?? DEFAULT_MAX_DELTA_BYTES, storage, registry.logEpoch, record !== undefined && isSupportedProtocolWireVersion(record.wireVersion)
+            ? record.wireVersion
+            : PROTOCOL_WIRE_VERSION, this.#config.events);
         this.#sessions.add(session);
         const helloResult = options.send(JSON.stringify({
             event: 'hello',

package/dist/seed.js

@@ -13,6 +13,7 @@ import { decodeMessage, encodeMessage, encodeSparseRow, PROTOCOL_WIRE_VERSION, }
 import { SyncError } from './errors.js';
 import { composeEvents } from './events-ring.js';
 import { handleSyncRequest } from './handler.js';
+import { renderScopeValue } from './scopes.js';
 /** Structured terminal failure from the real push path used by a seed. */
 export class SeedMutationError extends Error {
     name = 'SeedMutationError';
@@ -94,9 +95,9 @@ export async function seedMutations(config, target, mutations) {
         }
         const values = table.columns.map((column) => (byColumn.get(column.name) ?? null));
         const pkIndex = table.columns.findIndex((c) => c.name === table.primaryKey);
-        const rowId = values[pkIndex];
-        if (typeof rowId !== 'string' || rowId.length === 0) {
-            throw new SyncError('sync.invalid_request', `seedMutations: table ${table.name}: upsert requires a non-empty string primary key`);
+        const rowId = renderScopeValue(values[pkIndex]);
+        if (rowId === undefined) {
+            throw new SyncError('sync.invalid_request', `seedMutations: table ${table.name}: upsert requires a non-empty primary key`);
         }
         return {
             table: mutation.table,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/server",
-  "version": "0.32.0",
+  "version": "0.32.1",
   "description": "Syncular server: handleSyncRequest + storage/auth interfaces for the sync protocol",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -68,7 +68,7 @@
     "verify:node": "cd ../.. && bun build ./packages/server/test/sqlite-runtime/verify-node.mjs --target=node --conditions=bun --outfile=./packages/server/.verify-node.built.mjs && node ./packages/server/.verify-node.built.mjs"
   },
   "dependencies": {
-    "@syncular/core": "0.32.0"
+    "@syncular/core": "0.32.1"
   },
   "devDependencies": {
     "@electric-sql/pglite": "^0.5.4"

package/src/d1-storage.ts

@@ -302,6 +302,7 @@ class D1Transaction implements StorageTransaction {
    * `tbl\u0000rowId` → the pending state, consulted by `getRow` before D1.
    */
   readonly #pending = new Map<string, PendingRow>();
+  readonly #clearedTombstones = new Set<string>();
 
   constructor(
     db: Pick<D1Database, 'prepare' | 'batch'>,
@@ -347,6 +348,9 @@ class D1Transaction implements StorageTransaction {
     rowId: string,
   ): Promise<number | undefined> {
     this.#assertOpen();
+    if (this.#clearedTombstones.has(D1Transaction.#key(table, rowId))) {
+      return undefined;
+    }
     // Persisted read, no #pending overlay: a delete buffered by this commit
     // records its tombstone at appendCommit, matching the SQLite/Postgres
     // adapters where the tombstone insert also runs at commit append.
@@ -361,6 +365,7 @@ class D1Transaction implements StorageTransaction {
 
   async clearTombstone(table: string, rowId: string): Promise<void> {
     this.#assertOpen();
+    this.#clearedTombstones.add(D1Transaction.#key(table, rowId));
     this.#buffer_(
       'DELETE FROM sync_tombstones WHERE partition=? AND tbl=? AND row_id=?',
       [this.#partition, table, rowId],
@@ -448,7 +453,9 @@ class D1Transaction implements StorageTransaction {
       }
     }
     return [...rows.values()]
-      .sort((left, right) => left.rowId.localeCompare(right.rowId))
+      .sort((left, right) =>
+        left.rowId < right.rowId ? -1 : left.rowId > right.rowId ? 1 : 0,
+      )
       .slice(0, query.limit);
   }
 
@@ -502,7 +509,9 @@ class D1Transaction implements StorageTransaction {
       if (matches) rows.set(rowId, pending.row);
     }
     return [...rows.values()]
-      .sort((left, right) => left.rowId.localeCompare(right.rowId))
+      .sort((left, right) =>
+        left.rowId < right.rowId ? -1 : left.rowId > right.rowId ? 1 : 0,
+      )
       .slice(0, query.limit);
   }
 
@@ -574,6 +583,7 @@ class D1Transaction implements StorageTransaction {
     }
     this.#buffer.length = checkpoint;
     this.#pending.clear();
+    this.#clearedTombstones.clear();
     this.#maxCommitSeq = undefined;
     this.#applicationOpIndexes.clear();
     await this.putPushResult(clientId, clientCommitId, result);

package/src/handler.ts

@@ -526,11 +526,12 @@ async function* streamResponse(
   }
   try {
     // Push half (§6): one PUSH_RESULT per PUSH_COMMIT, in request order.
+    const currentSchema = compileSchema(ctx.schema);
     let acceptedThrough = 0;
     for (const push of plan.pushes) {
       const processed = await processPushCommitWithTrace(
         ctx,
-        compileSchema(ctx.schema),
+        currentSchema,
         plan.resolved,
         plan.header.clientId,
         push,
@@ -543,20 +544,36 @@ async function* streamResponse(
       const frame = {
         ...processed.frame,
         results: processed.frame.results.map((result) => {
-          if (result.status !== 'conflict') return result;
-          const operation = push.operations[result.opIndex]!;
+          if (result.status !== 'conflict' || schema === currentSchema) {
+            return result;
+          }
+          const operation = push.operations[result.opIndex];
+          // §2.3: a replay returns the persisted result without rebuilding
+          // operations, so a reused clientCommitId with changed operations
+          // leaves no table to project the stored conflict row through.
+          if (operation === undefined) {
+            throw syncError(
+              'sync.invalid_request',
+              'replayed clientCommitId carries changed operations',
+              JSON.stringify({
+                clientCommitId: push.clientCommitId,
+                opIndex: result.opIndex,
+              }),
+            );
+          }
           const target = schema.tables.get(operation.table)!;
-          const current = compileSchema(ctx.schema).tables.get(
-            operation.table,
-          )!;
+          const bitmapBytes = Math.ceil(target.columns.length / 8);
           return {
             ...result,
-            serverRow: projectRowPayload(current, target, result.serverRow),
+            serverRow: projectRowPayload(
+              currentSchema.tables.get(operation.table)!,
+              target,
+              result.serverRow,
+            ),
             conflictColumns: result.conflictColumns
-              .slice(0, Math.ceil(target.columns.length / 8))
+              .slice(0, bitmapBytes)
               .map((byte, i) =>
-                i === Math.ceil(target.columns.length / 8) - 1 &&
-                target.columns.length % 8 !== 0
+                i === bitmapBytes - 1 && target.columns.length % 8 !== 0
                   ? byte & ((1 << (target.columns.length % 8)) - 1)
                   : byte,
               ),

package/src/operations.ts

@@ -21,7 +21,11 @@ import {
 import { reportError, SyncError, syncError } from './errors';
 import { processPushOperationsWithTrace } from './push';
 import { compileSchema } from './schema';
-import { authorizeWrite, type ResolvedScopes } from './scopes';
+import {
+  authorizeWrite,
+  renderScopeValue,
+  type ResolvedScopes,
+} from './scopes';
 import type {
   AuthoritativeQueryRequest,
   AuthoritativeQueryResult,
@@ -534,11 +538,11 @@ function commandOperations(
       }
       return mutation.values[column.name] ?? null;
     });
-    const rowId = values[table.primaryKeyIndex];
-    if (typeof rowId !== 'string' || rowId.length === 0) {
+    const rowId = renderScopeValue(values[table.primaryKeyIndex]);
+    if (rowId === undefined) {
       throw syncError(
         'operation.invalid_request',
-        'command upsert requires a non-empty string primary key',
+        'command upsert requires a non-empty primary key',
       );
     }
     return {

package/src/push.ts

@@ -503,6 +503,7 @@ async function applyOperation(
         if (
           present[i] &&
           !crdtIndexes.has(i) &&
+          i !== table.primaryKeyIndex &&
           effectiveVersion(i) > op.baseVersion
         ) {
           marked.push(i);
@@ -978,7 +979,20 @@ async function enforceReferences(
   const operations: ValidateCommitOperation[] = [];
   const originByIndex: number[] = [];
 
+  const finalByRow = new Map<
+    string,
+    { readonly first: StagedWrite; readonly last: StagedWrite }
+  >();
   for (const write of staged) {
+    const rowKey = `${write.table.name}\u0000${write.rowId}`;
+    const existing = finalByRow.get(rowKey);
+    finalByRow.set(rowKey, {
+      first: existing?.first ?? write,
+      last: write,
+    });
+  }
+
+  for (const { last: write } of finalByRow.values()) {
     if (write.op !== 'upsert' || write.values === undefined) continue;
     for (const reference of write.table.references) {
       const value = write.values[reference.columnIndex];
@@ -1028,9 +1042,9 @@ async function enforceReferences(
     readonly rowId: string;
     readonly originOpIndex: number;
   }> = [];
-  for (const write of staged) {
-    if (write.op === 'delete' && write.stored !== undefined) {
-      schedule(write.table, write.rowId, write.opIndex, scheduled, queue);
+  for (const { first, last } of finalByRow.values()) {
+    if (last.op === 'delete' && first.stored !== undefined) {
+      schedule(last.table, last.rowId, last.opIndex, scheduled, queue);
     }
   }
 
@@ -1040,6 +1054,13 @@ async function enforceReferences(
     const key = `${item.table.name}\u0000${item.rowId}`;
     if (processed.has(key)) continue;
     processed.add(key);
+    const parentPkColumn = item.table.columns[item.table.primaryKeyIndex];
+    const parentKeyValue: RowValue =
+      parentPkColumn?.type === 'integer'
+        ? Number(item.rowId)
+        : parentPkColumn?.type === 'boolean'
+          ? item.rowId === 'true'
+          : item.rowId;
     for (const reference of item.table.referencedBy) {
       if (tx.scanRowsByIndex === undefined) {
         throw new Error(
@@ -1052,7 +1073,7 @@ async function enforceReferences(
         const page = await tx.scanRowsByIndex({
           table: reference.table,
           index: reference.index,
-          values: [item.rowId],
+          values: [parentKeyValue],
           afterRowId,
           limit: 1_000,
         });
@@ -1081,6 +1102,21 @@ async function enforceReferences(
         );
       }
       for (const childRow of children) {
+        if (reference.onDelete === 'CASCADE') {
+          if (
+            !schedule(
+              child,
+              childRow.rowId,
+              item.originOpIndex,
+              scheduled,
+              queue,
+            )
+          ) {
+            continue;
+          }
+        } else if (scheduled.has(`${child.name}\u0000${childRow.rowId}`)) {
+          continue;
+        }
         if (originByIndex.length >= cascadeLimit) {
           return {
             kind: 'terminate',
@@ -1091,11 +1127,6 @@ async function enforceReferences(
             ),
           };
         }
-        if (
-          !schedule(child, childRow.rowId, item.originOpIndex, scheduled, queue)
-        ) {
-          continue;
-        }
         const syntheticIndex = clientOpCount + originByIndex.length;
         const storedValues = decodeRow(child.columns, childRow.payload);
         if (reference.onDelete === 'CASCADE') {

package/src/realtime.ts

@@ -23,6 +23,7 @@ import {
   encodeMessage,
   encodePresenceError,
   encodePresenceFanout,
+  isSupportedProtocolWireVersion,
   MessageStreamScanner,
   PROTOCOL_WIRE_VERSION,
   type PresenceKind,
@@ -278,6 +279,8 @@ export class RealtimeSession {
   #registrationGeneration = 0;
   /** Generation of the most recent refresh whose result was applied. */
   #registrationApplied = 0;
+  /** Highest sequence that required a catch-up wake for this session. */
+  #wakeRequiredThroughSeq: number;
 
   constructor(
     hub: RealtimeHub,
@@ -301,6 +304,7 @@ export class RealtimeSession {
     this.cursor = cursor;
     this.lastKnownSeq = latestSeq;
     this.wakePending = cursor < latestSeq;
+    this.#wakeRequiredThroughSeq = cursor < latestSeq ? latestSeq : 0;
     this.registrations = registrations;
     this.openedAtMs = clock();
     this.#send = options.send;
@@ -336,9 +340,9 @@ export class RealtimeSession {
     // proves those commits no longer need socket notifications, so the next
     // notification must be adjacent to the acknowledged cursor.
     this.lastKnownSeq = Math.max(this.lastKnownSeq, this.cursor);
-    if (this.cursor >= this.lastKnownSeq) this.wakePending = false;
+    if (this.cursor >= this.#wakeRequiredThroughSeq) this.wakePending = false;
     // §8.2: acks update the client cursor record without an HTTP pull.
-    this.#persistCursor();
+    this.#persistCursor(cursor);
   }
 
   /**
@@ -571,7 +575,7 @@ export class RealtimeSession {
     try {
       const requestedWireVersion =
         (requestBytes[4] ?? 0) | ((requestBytes[5] ?? 0) << 8);
-      if (requestedWireVersion === 1 || requestedWireVersion === 2) {
+      if (isSupportedProtocolWireVersion(requestedWireVersion)) {
         this.wireVersion = requestedWireVersion;
       }
       let stream: AsyncIterable<Uint8Array> | undefined;
@@ -721,7 +725,7 @@ export class RealtimeSession {
     this.#hub.disconnect(this);
   }
 
-  #persistCursor(): void {
+  #persistCursor(cursor: number): void {
     // §8.2: start the write now and keep it on the control tail so `drain()`
     // can await it. Two acks may write concurrently: storage folds them with
     // `MAX(cursor, ?)`, so neither order loses the later cursor.
@@ -731,7 +735,7 @@ export class RealtimeSession {
         this.clientId,
         this.actorId,
         this.logEpoch,
-        this.cursor,
+        cursor,
         this.#clock(),
       );
     })();
@@ -767,6 +771,10 @@ export class RealtimeSession {
 
   sendWake(reason: WakeReason): void {
     this.wakePending = true;
+    this.#wakeRequiredThroughSeq = Math.max(
+      this.#wakeRequiredThroughSeq,
+      this.lastKnownSeq,
+    );
     this.#sendSafe(
       JSON.stringify({
         event: 'sync',
@@ -1121,6 +1129,12 @@ export class RealtimeHub {
       ...(this.#config.commitValidator !== undefined
         ? { commitValidator: this.#config.commitValidator }
         : {}),
+      ...(this.#config.reactionPlanner !== undefined
+        ? { reactionPlanner: this.#config.reactionPlanner }
+        : {}),
+      ...(this.#config.checkpoints !== undefined
+        ? { checkpoints: this.#config.checkpoints }
+        : {}),
       ...(this.#config.clock !== undefined
         ? { clock: this.#config.clock }
         : {}),
@@ -1148,6 +1162,9 @@ export class RealtimeHub {
       ...(this.#config.onError !== undefined
         ? { onError: this.#config.onError }
         : {}),
+      ...(this.#config.mapError !== undefined
+        ? { mapError: this.#config.mapError }
+        : {}),
       realtime: this,
     };
   }
@@ -1211,7 +1228,9 @@ export class RealtimeHub {
       this.#config.maxDeltaBytes ?? DEFAULT_MAX_DELTA_BYTES,
       storage,
       registry.logEpoch,
-      record?.wireVersion ?? PROTOCOL_WIRE_VERSION,
+      record !== undefined && isSupportedProtocolWireVersion(record.wireVersion)
+        ? record.wireVersion
+        : PROTOCOL_WIRE_VERSION,
       this.#config.events,
     );
     this.#sessions.add(session);

package/src/seed.ts

@@ -24,6 +24,7 @@ import { SyncError } from './errors';
 import type { SyncularServerEvent, SyncularServerEvents } from './events';
 import { composeEvents } from './events-ring';
 import { handleSyncRequest } from './handler';
+import { renderScopeValue } from './scopes';
 
 /** One app-shaped seed mutation — the same vocabulary as client mutations. */
 export type SeedMutation =
@@ -171,11 +172,11 @@ export async function seedMutations(
       (column) => (byColumn.get(column.name) ?? null) as RowValue,
     );
     const pkIndex = table.columns.findIndex((c) => c.name === table.primaryKey);
-    const rowId = values[pkIndex];
-    if (typeof rowId !== 'string' || rowId.length === 0) {
+    const rowId = renderScopeValue(values[pkIndex]);
+    if (rowId === undefined) {
       throw new SyncError(
         'sync.invalid_request',
-        `seedMutations: table ${table.name}: upsert requires a non-empty string primary key`,
+        `seedMutations: table ${table.name}: upsert requires a non-empty primary key`,
       );
     }
     return {