@syncular/server 0.8.0 → 0.10.0

package/README.md

@@ -60,6 +60,119 @@ done by a binding of the core or by in-database fanout — a relay would add a
 hop, a second protocol surface, and a managed dependency for zero capability
 the core lacks.
 
+## Write validators and recovery metadata
+
+`validators` is the server-authoritative seam for row business rules that
+scope grants cannot express. A validator runs after row decode and scope
+authorization, inside the commit transaction, for HTTP and WebSocket sync
+rounds alike. Throw `ValidationRejection` for a deliberate host rejection:
+
+```ts
+import {
+  ValidationRejection,
+  type SyncServerConfig,
+} from '@syncular/server';
+
+const config: SyncServerConfig = {
+  schema,
+  storage,
+  segments,
+  resolveScopes,
+  validators: {
+    surgeries: ({ row }) => {
+      if (typeof row?.duration_minutes === 'number' && row.duration_minutes < 5) {
+        throw new ValidationRejection(
+          'surgery.duration_too_short',
+          'diagnostic only',
+          {
+            fieldPaths: ['duration_minutes'],
+            reason: 'below_minimum',
+            requiredAction: 'edit_fields',
+            references: { minimum_minutes: '5' },
+          },
+        );
+      }
+    },
+  },
+};
+```
+
+The third argument is optional. When supplied, Syncular validates and
+normalizes a bounded `RejectionDetails` object and persists it with the
+idempotency result. Its values replicate to the authorized client, so include
+only non-sensitive identifiers that the host explicitly approves for recovery
+UI. Unknown members, free-form tokens, malformed paths, and over-limit data
+fail at construction. Diagnostic prose stays in `message`; apps should map
+the stable code/details to localized copy instead of displaying that message.
+
+Validators are per-operation. A validator must not mutate the row it receives.
+
+For a multi-row or multi-table invariant, install `commitValidator`. It runs
+once after every operation is staged in the same transaction, and can inspect
+both the decoded sibling operations and final candidate state:
+
+```ts
+import {
+  CommitValidationRejection,
+  type SyncServerConfig,
+} from '@syncular/server';
+
+const config: SyncServerConfig = {
+  schema,
+  storage,
+  segments,
+  resolveScopes,
+  commitValidator: ({ operations }) => {
+    const transition = operations.find(
+      (operation) =>
+        operation.table === 'surgeries' &&
+        operation.row !== undefined &&
+        operation.stored !== undefined &&
+        operation.row.status !== operation.stored.status,
+    );
+    if (transition === undefined) return;
+
+    const hasEvent = operations.some(
+      (operation) =>
+        operation.table === 'surgery_status_events' &&
+        operation.row?.surgery_id === transition.rowId &&
+        operation.row?.status === transition.row?.status,
+    );
+    if (!hasEvent) {
+      throw new CommitValidationRejection(
+        transition.opIndex,
+        'surgery.status_event_required',
+        'diagnostic only',
+        {
+          fieldPaths: ['status'],
+          reason: 'missing_sibling_operation',
+          requiredAction: 'repair_aggregate',
+        },
+      );
+    }
+  },
+};
+```
+
+The callback also receives `read.getRow()` and bounded `read.scanRows()` APIs.
+Those reads see the final candidate state, including staged sibling upserts and
+deletes. Syncular serializes the partition before any operation read so two
+aggregate validators cannot both accept mutually invalid candidates. It also
+re-checks idempotency after taking that lock and persists a rejected outcome
+while the lock is retained, so overlapping duplicate deliveries cannot rerun
+the callback.
+
+SQLite and PostgreSQL provide that serialization directly. D1 does not expose
+an interactive lock: `D1ServerStorage` fails closed unless it is constructed
+inside an external per-partition coordinator with
+`{ commitValidationSerialized: true }` (normally one Durable Object per
+partition). Do not set that assertion on a stateless Worker. Custom storages
+must implement both the transaction lock and candidate scan seam.
+
+Whole-commit validation checks a client-proposed commit; it does not grant
+authority. Privileged operations such as connecting facilities still belong in
+explicit server-authoritative commands.
+
 ## Structured events (the ops seam)
 
 One optional interface, `SyncularServerEvents`, carries every

package/dist/context.d.ts

@@ -14,7 +14,7 @@ import type { SegmentStore } from './segment-store.js';
 import type { BlobPresignConfig, BlobUploadPresignConfig, SegmentUrlConfig } from './signed-url.js';
 import type { SqliteImageBuilder } from './sqlite-image.js';
 import type { ServerStorage, StoredCommit } from './storage.js';
-import type { ValidatorRegistry } from './validate.js';
+import type { CommitValidator, ValidatorRegistry } from './validate.js';
 /** SSP2 body content type (§1.1). */
 export declare const SSP2_CONTENT_TYPE = "application/vnd.syncular.sync.v2";
 export interface ResolveScopesArgs {
@@ -94,6 +94,13 @@ export interface SyncServerConfig {
      * process, never on the wire.
      */
     readonly validators?: ValidatorRegistry;
+    /**
+     * §6.8 whole-commit validator. When present, the storage serializes this
+     * partition before operation reads/writes, then invokes the callback once
+     * over every staged decoded operation and candidate-state reader before
+     * commit-log/idempotency append. A throw rolls back the complete commit.
+     */
+    readonly commitValidator?: CommitValidator;
     readonly resolveScopes: ResolveScopes;
     /**
      * §7.3 auth leases. Absent ⇒ the feature is off: no `LEASE` frame is

package/dist/d1-storage.d.ts

@@ -13,9 +13,18 @@ export interface D1Database {
     batch(statements: D1PreparedStatement[]): Promise<unknown[]>;
     exec(query: string): Promise<unknown>;
 }
+export interface D1ServerStorageOptions {
+    /**
+     * Assert that all writes for a partition reach this storage serially.
+     * Required for §6.8 because D1 exposes no interactive transaction lock.
+     * Set this only inside a per-partition Durable Object or equivalent
+     * coordinator; the default fails closed when a commit validator is used.
+     */
+    readonly commitValidationSerialized?: boolean;
+}
 export declare class D1ServerStorage implements ServerStorage {
     #private;
-    constructor(db: D1Database);
+    constructor(db: D1Database, options?: D1ServerStorageOptions);
     /** Apply the schema DDL (idempotent). Call once before use. */
     migrate(): Promise<void>;
     /** Resolve a table's compiled schema; row operations require `ensureSchema`. */

package/dist/frame-bytes.js

@@ -39,6 +39,21 @@ function wrapperFor(frame) {
         case 'ERROR':
         case 'UNKNOWN':
             return { frames: [STUB_HEADER, frame], index: 1 };
+        case 'PUSH_RESULT_DETAILS': {
+            const result = {
+                type: 'PUSH_RESULT',
+                clientCommitId: frame.clientCommitId,
+                status: 'rejected',
+                results: frame.entries.map((entry) => ({
+                    opIndex: entry.opIndex,
+                    status: 'error',
+                    code: 'sync.constraint_violation',
+                    message: '',
+                    retryable: false,
+                })),
+            };
+            return { frames: [STUB_HEADER, result, frame], index: 2 };
+        }
         case 'SUB_START':
             return { frames: [STUB_HEADER, frame, STUB_SUB_END], index: 1 };
         case 'SUB_END':

package/dist/handler.js

@@ -187,6 +187,18 @@ async function planRequest(request, ctx, schema) {
         leaseToEmit,
     };
 }
+function pushResultDetailsFrame(frame) {
+    const entries = frame.results.flatMap((result) => result.status === 'error' && result.details !== undefined
+        ? [{ opIndex: result.opIndex, details: result.details }]
+        : []);
+    return entries.length === 0
+        ? undefined
+        : {
+            type: 'PUSH_RESULT_DETAILS',
+            clientCommitId: frame.clientCommitId,
+            entries,
+        };
+}
 function emitPushEvent(events, ctx, clientId, push, frame) {
     const base = {
         atMs: clockOf(ctx)(),
@@ -269,6 +281,9 @@ async function* streamResponse(plan, ctx, schema, report) {
                 emitPushEvent(events, ctx, plan.header.clientId, push, frame);
             }
             yield encodeResponseFrame(frame);
+            const details = pushResultDetailsFrame(frame);
+            if (details !== undefined)
+                yield encodeResponseFrame(details);
         }
         // Pull half (§4): subscriptions echoed in request order.
         const cursors = [];

package/dist/postgres-storage.js

@@ -107,6 +107,7 @@ function serializePushResult(result) {
                     code: record.code,
                     message: record.message,
                     retryable: record.retryable,
+                    ...(record.details !== undefined ? { details: record.details } : {}),
                 };
             }
             return { opIndex: record.opIndex, status: record.status };
@@ -133,6 +134,7 @@ function deserializePushResult(value) {
                 code: record.code ?? '',
                 message: record.message ?? '',
                 retryable: record.retryable ?? false,
+                ...(record.details !== undefined ? { details: record.details } : {}),
             };
         }
         return { opIndex: record.opIndex, status: 'applied' };
@@ -223,6 +225,7 @@ class PostgresTransaction {
     #partition;
     #resolveTable;
     #open = true;
+    #commitValidationSavepoint = false;
     /** Resolves/rejects the `transaction(fn)` wrapper (see `begin`). */
     #resolve;
     #reject;
@@ -241,6 +244,65 @@ class PostgresTransaction {
         this.#assertOpen();
         return getRowOn(this.#client, this.#resolveTable(table), this.#partition, rowId);
     }
+    async scanRows(query) {
+        this.#assertOpen();
+        const variables = Object.keys(query.scopeFilter).sort();
+        const firstVariable = variables[0];
+        if (firstVariable === undefined)
+            return [];
+        const firstValues = query.scopeFilter[firstVariable] ?? [];
+        if (firstValues.length === 0)
+            return [];
+        const sql = scanRowPageSql(this.#resolveTable(query.table), firstValues.length, 'postgres');
+        const rows = [];
+        let afterRowId = query.afterRowId ?? '';
+        const batchSize = Math.max(64, query.limit);
+        while (rows.length < query.limit) {
+            const { rows: records } = await this.#client.query(sql, [
+                this.#partition,
+                query.table,
+                firstVariable,
+                ...firstValues,
+                afterRowId,
+                batchSize,
+            ]);
+            if (records.length === 0)
+                break;
+            for (const record of records) {
+                afterRowId = record.row_id;
+                if (record.payload === null || record.payload === undefined)
+                    continue;
+                const stored = toStoredRow(record);
+                if (!matchesEffective(stored.scopes, query.scopeFilter))
+                    continue;
+                rows.push(stored);
+                if (rows.length >= query.limit)
+                    break;
+            }
+            if (records.length < batchSize)
+                break;
+        }
+        return rows;
+    }
+    async lockPartitionForCommitValidation() {
+        this.#assertOpen();
+        await this.#client.query(`INSERT INTO sync_partitions(partition, max_commit_seq) VALUES ($1, 0)
+       ON CONFLICT (partition) DO NOTHING`, [this.#partition]);
+        await this.#client.query('SELECT max_commit_seq FROM sync_partitions WHERE partition=$1 FOR UPDATE', [this.#partition]);
+        await this.#client.query('SAVEPOINT syncular_commit_validation_candidate');
+        this.#commitValidationSavepoint = true;
+    }
+    async commitRejectedPushResult(clientId, clientCommitId, result) {
+        this.#assertOpen();
+        if (!this.#commitValidationSavepoint) {
+            throw new Error('whole-commit rejection requires its validation savepoint');
+        }
+        await this.#client.query('ROLLBACK TO SAVEPOINT syncular_commit_validation_candidate');
+        await this.#client.query('RELEASE SAVEPOINT syncular_commit_validation_candidate');
+        this.#commitValidationSavepoint = false;
+        await this.putPushResult(clientId, clientCommitId, result);
+        await this.commit();
+    }
     async upsertRow(table, row) {
         this.#assertOpen();
         await writeRowOn(this.#client, this.#resolveTable(table), this.#partition, row);

package/dist/push.js

@@ -21,7 +21,7 @@ import { decodeRow, encodeRow, parseBlobRef, } from '@syncular/core';
 import { clockOf } from './context.js';
 import { SyncError } from './errors.js';
 import { authorizeWrite, renderScopeValue, storedScopesForRow } from './scopes.js';
-import { toValidateRow, ValidationRejection } from './validate.js';
+import { CommitValidationRejection, toValidateRow, ValidationRejection, } from './validate.js';
 /**
  * Extract the blobIds a decoded row references through its `blob_ref`
  * columns (§5.9.4), skipping NULLs. Malformed BlobRefs already failed at
@@ -36,10 +36,17 @@ function blobIdsInRow(table, values) {
     }
     return ids;
 }
-function errorRecord(opIndex, code, message, retryable = false) {
+function errorRecord(opIndex, code, message, retryable = false, details) {
     return {
         kind: 'terminate',
-        record: { opIndex, status: 'error', code, message, retryable },
+        record: {
+            opIndex,
+            status: 'error',
+            code,
+            message,
+            retryable,
+            ...(details !== undefined ? { details } : {}),
+        },
     };
 }
 function conflictRecord(opIndex, serverVersion, serverRow) {
@@ -83,7 +90,7 @@ async function runValidator(validators, table, op, rowId, values, storedValues,
     }
     catch (error) {
         if (error instanceof ValidationRejection) {
-            return errorRecord(opIndex, error.code, error.message);
+            return errorRecord(opIndex, error.code, error.message, false, error.details);
         }
         // §6.7: a non-ValidationRejection throw is still a rejection, mapped to
         // the generic server-side constraint code (§10.2) — the validator's
@@ -142,7 +149,18 @@ async function applyOperation(tx, schema, resolved, op, opIndex, blobCtx, crdtMe
     if (op.op === 'delete') {
         if (stored === undefined) {
             // Deleting an absent row is applied (idempotent, §6.2); no change.
-            return { kind: 'applied', change: undefined };
+            return {
+                kind: 'applied',
+                change: undefined,
+                operation: {
+                    opIndex,
+                    op: 'delete',
+                    table: table.name,
+                    rowId: op.rowId,
+                    row: undefined,
+                    stored: undefined,
+                },
+            };
         }
         if (!authorizeWrite(table, stored.scopes, resolved)) {
             return errorRecord(opIndex, 'sync.forbidden', 'delete denied by scope authorization (§3.4)');
@@ -154,7 +172,8 @@ async function applyOperation(tx, schema, resolved, op, opIndex, blobCtx, crdtMe
         // §6.7: validate the delete against the stored row (row = undefined,
         // stored = the row about to be removed). Only reached for an existing
         // row — an absent-row delete is an idempotent no-op above.
-        const deleteReject = await runValidator(validators, table, 'delete', op.rowId, undefined, decodeRow(table.columns, stored.payload), opIndex, partition, actorId);
+        const storedValues = decodeRow(table.columns, stored.payload);
+        const deleteReject = await runValidator(validators, table, 'delete', op.rowId, undefined, storedValues, opIndex, partition, actorId);
         if (deleteReject !== undefined)
             return deleteReject;
         await tx.deleteRow(op.table, op.rowId);
@@ -166,6 +185,15 @@ async function applyOperation(tx, schema, resolved, op, opIndex, blobCtx, crdtMe
                 op: 'delete',
                 scopes: stored.scopes,
             },
+            operation: {
+                opIndex,
+                op: 'delete',
+                table: table.name,
+                rowId: op.rowId,
+                row: undefined,
+                stored: toValidateRow(table.columns, storedValues),
+                storedServerVersion: stored.serverVersion,
+            },
         };
     }
     // upsert — payload presence is enforced by the envelope codec (§6.1).
@@ -246,6 +274,16 @@ async function applyOperation(tx, schema, resolved, op, opIndex, blobCtx, crdtMe
                 scopes: stored.scopes,
                 payload: newPayload,
             },
+            operation: {
+                opIndex,
+                op: 'upsert',
+                table: table.name,
+                rowId: op.rowId,
+                row: toValidateRow(table.columns, values),
+                stored: toValidateRow(table.columns, storedValues),
+                storedServerVersion: stored.serverVersion,
+                nextServerVersion: newVersion,
+            },
         };
     }
     // Insert path: no stored row.
@@ -302,6 +340,15 @@ async function applyOperation(tx, schema, resolved, op, opIndex, blobCtx, crdtMe
             scopes: extracted.scopes,
             payload: insertPayload,
         },
+        operation: {
+            opIndex,
+            op: 'upsert',
+            table: table.name,
+            rowId: op.rowId,
+            row: toValidateRow(table.columns, values),
+            stored: undefined,
+            nextServerVersion: 1,
+        },
     };
 }
 /**
@@ -339,6 +386,73 @@ function missingScopeVariable(table, scopes) {
     }
     return undefined;
 }
+function commitValidationReader(tx, schema) {
+    const tableFor = (name) => {
+        const table = schema.tables.get(name);
+        if (table === undefined) {
+            throw new Error(`commit validator requested unknown table ${JSON.stringify(name)}`);
+        }
+        return table;
+    };
+    return {
+        getRow: async (tableName, rowId) => {
+            const table = tableFor(tableName);
+            const stored = await tx.getRow(tableName, rowId);
+            if (stored === undefined)
+                return undefined;
+            return {
+                row: toValidateRow(table.columns, decodeRow(table.columns, stored.payload)),
+                serverVersion: stored.serverVersion,
+            };
+        },
+        scanRows: async ({ table: tableName, scopeFilter, afterRowId = null, limit = 100, }) => {
+            const table = tableFor(tableName);
+            if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1_000) {
+                throw new Error('commit validator scan limit must be an integer from 1 to 1,000');
+            }
+            if (tx.scanRows === undefined) {
+                throw new Error('storage transaction does not support commit-validator scans');
+            }
+            const rows = await tx.scanRows({
+                table: tableName,
+                scopeFilter,
+                afterRowId,
+                limit,
+            });
+            return rows.map((stored) => ({
+                row: toValidateRow(table.columns, decodeRow(table.columns, stored.payload)),
+                serverVersion: stored.serverVersion,
+            }));
+        },
+    };
+}
+async function runCommitValidator(validator, tx, schema, clientId, clientCommitId, actorId, partition, operations) {
+    if (validator === undefined)
+        return undefined;
+    try {
+        await validator({
+            clientId,
+            clientCommitId,
+            actorId,
+            partition,
+            operations,
+            read: commitValidationReader(tx, schema),
+        });
+    }
+    catch (error) {
+        if (error instanceof CommitValidationRejection) {
+            if (error.opIndex >= operations.length) {
+                return errorRecord(0, 'sync.constraint_violation', `commit validator rejection names unavailable opIndex ${error.opIndex}`);
+            }
+            return errorRecord(error.opIndex, error.code, error.message, false, error.details);
+        }
+        if (error instanceof ValidationRejection) {
+            return errorRecord(operations[0]?.opIndex ?? 0, error.code, error.message, false, error.details);
+        }
+        return errorRecord(operations[0]?.opIndex ?? 0, 'sync.constraint_violation', `whole-commit validator threw: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return undefined;
+}
 function resultFrame(clientCommitId, stored, replay) {
     const status = stored.status === 'applied' ? (replay ? 'cached' : 'applied') : 'rejected';
     return {
@@ -351,6 +465,22 @@ function resultFrame(clientCommitId, stored, replay) {
         results: [...stored.results],
     };
 }
+function idempotencyCacheMissFrame(clientCommitId, error) {
+    return {
+        type: 'PUSH_RESULT',
+        clientCommitId,
+        status: 'rejected',
+        results: [
+            {
+                opIndex: 0,
+                status: 'error',
+                code: 'sync.idempotency_cache_miss',
+                message: error.message,
+                retryable: true,
+            },
+        ],
+    };
+}
 /**
  * Process one `PUSH_COMMIT` frame: idempotency replay (§2.3), sequential
  * atomic apply (§6.4), realtime notification for applied commits.
@@ -366,20 +496,7 @@ export async function processPushCommit(ctx, schema, resolved, clientId, frame)
             error.code === 'sync.idempotency_cache_miss') {
             // §6.3: answer the retryable cache-miss for this commit rather than
             // re-applying. Not persisted — a retry may find a readable record.
-            return {
-                type: 'PUSH_RESULT',
-                clientCommitId: frame.clientCommitId,
-                status: 'rejected',
-                results: [
-                    {
-                        opIndex: 0,
-                        status: 'error',
-                        code: 'sync.idempotency_cache_miss',
-                        message: error.message,
-                        retryable: true,
-                    },
-                ],
-            };
+            return idempotencyCacheMissFrame(frame.clientCommitId, error);
         }
         throw error;
     }
@@ -390,10 +507,38 @@ export async function processPushCommit(ctx, schema, resolved, clientId, frame)
     const blobCtx = { store: ctx.blobs, partition };
     const crdtMergers = ctx.crdtMergers;
     const validators = ctx.validators;
+    const commitValidator = ctx.commitValidator;
     const tx = await storage.begin(partition);
+    const commitRejectedPushResult = tx.commitRejectedPushResult?.bind(tx);
     try {
+        if (commitValidator !== undefined) {
+            if (tx.lockPartitionForCommitValidation === undefined ||
+                commitRejectedPushResult === undefined) {
+                throw new Error('storage transaction does not support atomic whole-commit validation finalization');
+            }
+            await tx.lockPartitionForCommitValidation();
+            // The optimistic lookup above may have raced another request for the
+            // same idempotency key. Re-check after acquiring partition serialization
+            // so a concurrent duplicate never reruns the aggregate validator.
+            try {
+                const serializedPersisted = await storage.getPushResult(partition, clientId, frame.clientCommitId);
+                if (serializedPersisted !== undefined) {
+                    await tx.rollback();
+                    return resultFrame(frame.clientCommitId, serializedPersisted, true);
+                }
+            }
+            catch (error) {
+                if (error instanceof SyncError &&
+                    error.code === 'sync.idempotency_cache_miss') {
+                    await tx.rollback();
+                    return idempotencyCacheMissFrame(frame.clientCommitId, error);
+                }
+                throw error;
+            }
+        }
         const results = [];
         const changes = [];
+        const validatedOperations = [];
         let terminated;
         for (let opIndex = 0; opIndex < frame.operations.length; opIndex++) {
             const op = frame.operations[opIndex];
@@ -405,25 +550,43 @@ export async function processPushCommit(ctx, schema, resolved, clientId, frame)
                 break;
             }
             results.push({ opIndex, status: 'applied' });
+            validatedOperations.push(outcome.operation);
             if (outcome.change !== undefined)
                 changes.push(outcome.change);
         }
+        if (terminated === undefined) {
+            const commitReject = await runCommitValidator(commitValidator, tx, schema, clientId, frame.clientCommitId, ctx.actorId, partition, validatedOperations);
+            if (commitReject?.kind === 'terminate') {
+                terminated = commitReject.record;
+            }
+        }
         if (terminated !== undefined) {
             // §6.3 rejected: only the terminating operation's record; §6.4:
             // every write of the commit rolls back.
-            await tx.rollback();
             const stored = {
                 status: 'rejected',
                 results: [terminated],
             };
-            const rejectionTx = await storage.begin(partition);
-            try {
-                await rejectionTx.putPushResult(clientId, frame.clientCommitId, stored);
-                await rejectionTx.commit();
+            if (commitValidator !== undefined) {
+                // Discard candidate rows and persist the rejection while retaining the
+                // same partition lock. This closes the duplicate-request race between
+                // rollback and the durable idempotency outcome.
+                if (commitRejectedPushResult === undefined) {
+                    throw new Error('storage transaction lost whole-commit rejection finalization support');
+                }
+                await commitRejectedPushResult(clientId, frame.clientCommitId, stored);
             }
-            catch (error) {
-                await rejectionTx.rollback();
-                throw error;
+            else {
+                await tx.rollback();
+                const rejectionTx = await storage.begin(partition);
+                try {
+                    await rejectionTx.putPushResult(clientId, frame.clientCommitId, stored);
+                    await rejectionTx.commit();
+                }
+                catch (error) {
+                    await rejectionTx.rollback();
+                    throw error;
+                }
             }
             return resultFrame(frame.clientCommitId, stored, false);
         }

package/dist/realtime.d.ts

@@ -20,10 +20,15 @@ import type { ServerSchema } from './schema.js';
 import type { SegmentStore } from './segment-store.js';
 import type { SegmentUrlConfig } from './signed-url.js';
 import type { ServerStorage, StoredCommit } from './storage.js';
+import type { CommitValidator, ValidatorRegistry } from './validate.js';
 export interface RealtimeHubConfig {
     readonly schema: ServerSchema;
     readonly storage: ServerStorage;
     readonly resolveScopes: ResolveScopes;
+    /** §6.7 validators used by sync rounds carried over this socket. */
+    readonly validators?: ValidatorRegistry;
+    /** §6.8 whole-commit validator shared with HTTP sync rounds. */
+    readonly commitValidator?: CommitValidator;
     readonly clock?: () => number;
     /** Deltas larger than this become `delta-too-large` wake-ups (§8.2). */
     readonly maxDeltaBytes?: number;

package/dist/realtime.js

@@ -716,6 +716,12 @@ export class RealtimeHub {
             storage: this.#config.storage,
             segments,
             resolveScopes: this.#config.resolveScopes,
+            ...(this.#config.validators !== undefined
+                ? { validators: this.#config.validators }
+                : {}),
+            ...(this.#config.commitValidator !== undefined
+                ? { commitValidator: this.#config.commitValidator }
+                : {}),
             ...(this.#config.clock !== undefined
                 ? { clock: this.#config.clock }
                 : {}),

package/dist/sqlite-dialect.js

@@ -111,6 +111,7 @@ export function serializePushResult(result) {
                     code: record.code,
                     message: record.message,
                     retryable: record.retryable,
+                    ...(record.details !== undefined ? { details: record.details } : {}),
                 };
             }
             return { opIndex: record.opIndex, status: record.status };
@@ -137,6 +138,7 @@ export function deserializePushResult(text) {
                 code: record.code ?? '',
                 message: record.message ?? '',
                 retryable: record.retryable ?? false,
+                ...(record.details !== undefined ? { details: record.details } : {}),
             };
         }
         return { opIndex: record.opIndex, status: 'applied' };