@syncular/client 0.15.44 → 0.15.46

package/dist/remote.js

@@ -0,0 +1,441 @@
+/**
+ * Database-less SSP2 producer (§6.10). It prepares and sends ordinary commits
+ * through the existing push path without creating a local replica or outbox.
+ */
+import { decodeMessage, decodeRemoteOperationResponse, decodeRemoteOperationRealtimeMessage, encodeMessage, encodeRemoteOperationRequest, encodeRemoteOperationRealtimeMessage, encodeRow, PROTOCOL_WIRE_VERSION, } from '@syncular/core';
+import { encryptRowValues } from './encryption.js';
+import { ClientSyncError } from './errors.js';
+import { compileClientSchema, recordToRowValues, } from './schema.js';
+export function remoteCommand(id) {
+    if (id.length === 0)
+        throw invalid('remote command id must be non-empty');
+    return { id };
+}
+function invalid(message) {
+    return new ClientSyncError('sync.invalid_request', message);
+}
+function operationResponse(bytes) {
+    let response;
+    try {
+        response = decodeRemoteOperationResponse(bytes);
+    }
+    catch {
+        throw new ClientSyncError('client.invalid_host_response', 'remote operation response is malformed');
+    }
+    if (typeof response !== 'object' ||
+        response === null ||
+        Array.isArray(response)) {
+        throw new ClientSyncError('client.invalid_host_response', 'remote operation response is malformed');
+    }
+    if (response.revision !== 1) {
+        throw new ClientSyncError('client.invalid_host_response', 'remote operation response has an unsupported revision');
+    }
+    if (response.kind === 'error' &&
+        (typeof response.code !== 'string' ||
+            typeof response.message !== 'string' ||
+            typeof response.retryable !== 'boolean')) {
+        throw new ClientSyncError('client.invalid_host_response', 'remote operation error response is malformed');
+    }
+    if (response.kind === 'query' &&
+        (typeof response.operationId !== 'string' ||
+            !Array.isArray(response.rows) ||
+            response.rows.some((row) => typeof row !== 'object' || row === null || Array.isArray(row)) ||
+            !Number.isSafeInteger(response.maxCommitSeq) ||
+            response.maxCommitSeq < 0)) {
+        throw new ClientSyncError('client.invalid_host_response', 'remote query response is malformed');
+    }
+    if (response.kind === 'command' &&
+        (typeof response.operationId !== 'string' ||
+            typeof response.requestId !== 'string' ||
+            !['applied', 'cached', 'rejected'].includes(response.status) ||
+            !Array.isArray(response.results) ||
+            (response.commitSeq !== undefined &&
+                (!Number.isSafeInteger(response.commitSeq) || response.commitSeq < 1)))) {
+        throw new ClientSyncError('client.invalid_host_response', 'remote command response is malformed');
+    }
+    if (response.kind !== 'error' &&
+        response.kind !== 'query' &&
+        response.kind !== 'command') {
+        throw new ClientSyncError('client.invalid_host_response', 'remote operation response has an unknown kind');
+    }
+    return response;
+}
+export class SyncRemoteClient {
+    #schema;
+    #clientId;
+    #transport;
+    #operations;
+    #operationRealtime;
+    #operationSocket;
+    #operationSocketPromise;
+    #operationSocketGeneration = 0;
+    #watches = new Map();
+    #encryption;
+    constructor(config) {
+        if (config.clientId.length === 0) {
+            throw invalid('SyncRemoteClient clientId must be non-empty');
+        }
+        this.#schema =
+            config.schema === undefined
+                ? undefined
+                : compileClientSchema(config.schema);
+        this.#clientId = config.clientId;
+        this.#transport = config.transport;
+        this.#operations = config.operations;
+        this.#operationRealtime = config.operationRealtime;
+        this.#encryption = config.encryption;
+    }
+    async prepareCommit(input) {
+        const schema = this.#schema;
+        if (schema === undefined) {
+            throw new ClientSyncError('client.remote_schema_unconfigured', 'SyncRemoteClient needs a schema to prepare ordinary commits');
+        }
+        if (input.requestId.length === 0) {
+            throw invalid('remote commit requestId must be non-empty');
+        }
+        if (input.mutations.length === 0) {
+            throw new ClientSyncError('sync.empty_commit', 'a remote commit must carry at least one mutation (§6.1)');
+        }
+        const operations = [];
+        for (const mutation of input.mutations) {
+            const table = schema.tables.get(mutation.table);
+            if (table === undefined) {
+                throw invalid('remote commit targets an unknown table');
+            }
+            if (mutation.op === 'delete') {
+                if (mutation.rowId.length === 0) {
+                    throw invalid('remote delete rowId must be non-empty');
+                }
+                operations.push({
+                    table: mutation.table,
+                    rowId: mutation.rowId,
+                    op: 'delete',
+                    ...(mutation.baseVersion !== undefined
+                        ? { baseVersion: mutation.baseVersion }
+                        : {}),
+                });
+                continue;
+            }
+            let values = recordToRowValues(table, mutation.values);
+            const rowId = values[table.primaryKeyIndex];
+            if (typeof rowId !== 'string' || rowId.length === 0) {
+                throw invalid('remote upsert requires a non-empty string primary key');
+            }
+            if (this.#encryption !== undefined && table.hasEncryptedColumns) {
+                values = await encryptRowValues(this.#encryption, table, rowId, values);
+            }
+            operations.push({
+                table: mutation.table,
+                rowId,
+                op: 'upsert',
+                ...(mutation.baseVersion !== undefined
+                    ? { baseVersion: mutation.baseVersion }
+                    : {}),
+                payload: encodeRow(table.columns, values),
+            });
+        }
+        return {
+            requestId: input.requestId,
+            bytes: encodeMessage({
+                wireVersion: PROTOCOL_WIRE_VERSION,
+                msgKind: 'request',
+                frames: [
+                    {
+                        type: 'REQ_HEADER',
+                        clientId: this.#clientId,
+                        schemaVersion: schema.version,
+                    },
+                    {
+                        type: 'PUSH_COMMIT',
+                        clientCommitId: input.requestId,
+                        operations,
+                    },
+                ],
+            }),
+        };
+    }
+    async sendCommit(prepared) {
+        if (this.#transport === undefined) {
+            throw new ClientSyncError('client.remote_sync_unconfigured', 'SyncRemoteClient has no sync transport for ordinary commits');
+        }
+        const response = decodeMessage(await this.#transport(prepared.bytes));
+        if (response.msgKind !== 'response') {
+            throw new ClientSyncError('client.invalid_host_response', 'remote commit transport returned a non-response SSP2 message');
+        }
+        const error = response.frames.find((frame) => frame.type === 'ERROR');
+        if (error?.type === 'ERROR') {
+            throw new ClientSyncError(error.code, error.message, error.retryable);
+        }
+        const result = response.frames.find((frame) => frame.type === 'PUSH_RESULT' &&
+            frame.clientCommitId === prepared.requestId);
+        if (result === undefined) {
+            throw new ClientSyncError('client.invalid_host_response', 'remote commit response carried no matching PUSH_RESULT');
+        }
+        const details = response.frames.find((frame) => frame.type === 'PUSH_RESULT_DETAILS' &&
+            frame.clientCommitId === prepared.requestId);
+        const detailsByIndex = new Map(details?.entries.map((entry) => [entry.opIndex, entry.details]) ?? []);
+        return {
+            requestId: prepared.requestId,
+            status: result.status,
+            ...(result.commitSeq !== undefined
+                ? { commitSeq: result.commitSeq }
+                : {}),
+            results: result.results.map((operation) => {
+                if (operation.status !== 'error')
+                    return operation;
+                const operationDetails = detailsByIndex.get(operation.opIndex);
+                return operationDetails === undefined
+                    ? operation
+                    : { ...operation, details: operationDetails };
+            }),
+        };
+    }
+    async commit(input) {
+        return this.sendCommit(await this.prepareCommit(input));
+    }
+    async query(descriptor, params) {
+        if (this.#operations === undefined) {
+            throw new ClientSyncError('client.remote_operations_unconfigured', 'SyncRemoteClient has no remote operation transport');
+        }
+        const response = operationResponse(await this.#operations(encodeRemoteOperationRequest({
+            revision: 1,
+            kind: 'query',
+            clientId: this.#clientId,
+            operationId: descriptor.id,
+            params: params ?? null,
+        })));
+        if (response.kind === 'error') {
+            throw new ClientSyncError(response.code, response.message, response.retryable);
+        }
+        if (response.kind !== 'query' || response.operationId !== descriptor.id) {
+            throw new ClientSyncError('client.invalid_host_response', 'remote query returned a mismatched response');
+        }
+        try {
+            return {
+                rows: response.rows.map((row) => descriptor.mapRow(row)),
+                maxCommitSeq: response.maxCommitSeq,
+            };
+        }
+        catch {
+            throw new ClientSyncError('client.invalid_host_response', 'remote query row is malformed');
+        }
+    }
+    async command(descriptor, requestId, input) {
+        if (this.#operations === undefined) {
+            throw new ClientSyncError('client.remote_operations_unconfigured', 'SyncRemoteClient has no remote operation transport');
+        }
+        if (requestId.length === 0) {
+            throw invalid('remote command requestId must be non-empty');
+        }
+        const response = operationResponse(await this.#operations(encodeRemoteOperationRequest({
+            revision: 1,
+            kind: 'command',
+            clientId: this.#clientId,
+            operationId: descriptor.id,
+            requestId,
+            params: input ?? null,
+        })));
+        if (response.kind === 'error') {
+            throw new ClientSyncError(response.code, response.message, response.retryable);
+        }
+        if (response.kind !== 'command' ||
+            response.operationId !== descriptor.id ||
+            response.requestId !== requestId) {
+            throw new ClientSyncError('client.invalid_host_response', 'remote command returned a mismatched response');
+        }
+        return {
+            requestId,
+            status: response.status,
+            ...(response.commitSeq !== undefined
+                ? { commitSeq: response.commitSeq }
+                : {}),
+            results: response.results,
+        };
+    }
+    async watch(descriptor, params, handlers) {
+        if (this.#operationRealtime === undefined) {
+            throw new ClientSyncError('client.remote_realtime_unconfigured', 'SyncRemoteClient has no remote operation realtime connector');
+        }
+        const watchId = crypto.randomUUID();
+        this.#watches.set(watchId, {
+            operationId: descriptor.id,
+            mapRow: descriptor.mapRow,
+            handlers: handlers,
+        });
+        let socket;
+        try {
+            socket = await this.#operationRealtimeSocket();
+        }
+        catch (error) {
+            this.#watches.delete(watchId);
+            throw error;
+        }
+        if (!this.#watches.has(watchId)) {
+            throw new ClientSyncError('client.remote_realtime_cancelled', 'remote operation watch was cancelled before registration');
+        }
+        try {
+            socket.send(encodeRemoteOperationRealtimeMessage({
+                revision: 1,
+                kind: 'watch',
+                watchId,
+                clientId: this.#clientId,
+                operationId: descriptor.id,
+                params: params ?? null,
+            }));
+        }
+        catch {
+            const error = new ClientSyncError('client.remote_realtime_closed', 'remote operation realtime connection closed while registering a watch', true);
+            this.#disconnectOperationRealtime(this.#operationSocketGeneration, error, true);
+            throw error;
+        }
+        return () => {
+            if (!this.#watches.delete(watchId))
+                return;
+            try {
+                this.#operationSocket?.send(encodeRemoteOperationRealtimeMessage({
+                    revision: 1,
+                    kind: 'unwatch',
+                    watchId,
+                }));
+            }
+            catch {
+                this.#disconnectOperationRealtime(this.#operationSocketGeneration, new ClientSyncError('client.remote_realtime_closed', 'remote operation realtime connection closed while removing a watch', true), true);
+            }
+        };
+    }
+    async #operationRealtimeSocket() {
+        if (this.#operationSocket !== undefined)
+            return this.#operationSocket;
+        if (this.#operationSocketPromise !== undefined) {
+            return this.#operationSocketPromise;
+        }
+        const connector = this.#operationRealtime;
+        if (connector === undefined) {
+            throw new ClientSyncError('client.remote_realtime_unconfigured', 'SyncRemoteClient has no remote operation realtime connector');
+        }
+        const generation = this.#operationSocketGeneration;
+        const pending = Promise.resolve(connector({
+            onMessage: (bytes) => {
+                if (generation !== this.#operationSocketGeneration)
+                    return;
+                let message;
+                try {
+                    message = decodeRemoteOperationRealtimeMessage(bytes);
+                    if (typeof message !== 'object' ||
+                        message === null ||
+                        message.revision !== 1 ||
+                        (message.kind !== 'snapshot' && message.kind !== 'watch_error') ||
+                        typeof message.watchId !== 'string') {
+                        throw new Error('invalid remote operation realtime message');
+                    }
+                }
+                catch {
+                    this.#disconnectOperationRealtime(generation, new ClientSyncError('client.invalid_host_response', 'remote operation realtime message is malformed'), true);
+                    return;
+                }
+                const watch = this.#watches.get(message.watchId);
+                if (watch === undefined)
+                    return;
+                if (message.kind === 'watch_error') {
+                    if (typeof message.code !== 'string' ||
+                        typeof message.message !== 'string' ||
+                        typeof message.retryable !== 'boolean') {
+                        this.#disconnectOperationRealtime(generation, new ClientSyncError('client.invalid_host_response', 'remote operation watch error is malformed'), true);
+                        return;
+                    }
+                    try {
+                        watch.handlers.onError?.(new ClientSyncError(message.code, message.message, message.retryable));
+                    }
+                    catch {
+                        // An observer cannot alter the connection lifecycle.
+                    }
+                    return;
+                }
+                if (message.operationId !== watch.operationId ||
+                    !Array.isArray(message.rows) ||
+                    message.rows.some((row) => typeof row !== 'object' || row === null || Array.isArray(row)) ||
+                    !Number.isSafeInteger(message.maxCommitSeq) ||
+                    message.maxCommitSeq < 0) {
+                    this.#disconnectOperationRealtime(generation, new ClientSyncError('client.invalid_host_response', 'remote operation watch snapshot is malformed'), true);
+                    return;
+                }
+                let rows;
+                try {
+                    rows = message.rows.map(watch.mapRow);
+                }
+                catch {
+                    try {
+                        watch.handlers.onError?.(new ClientSyncError('client.invalid_host_response', 'remote operation watch row is malformed'));
+                    }
+                    catch {
+                        // An observer cannot alter the connection lifecycle.
+                    }
+                    return;
+                }
+                try {
+                    watch.handlers.onSnapshot({
+                        rows,
+                        maxCommitSeq: message.maxCommitSeq,
+                    });
+                }
+                catch {
+                    // An observer cannot alter the connection lifecycle.
+                }
+            },
+            onClose: () => {
+                this.#disconnectOperationRealtime(generation, new ClientSyncError('client.remote_realtime_closed', 'remote operation realtime connection closed', true), false);
+            },
+        }))
+            .then((socket) => {
+            if (generation !== this.#operationSocketGeneration) {
+                try {
+                    socket.close();
+                }
+                catch {
+                    // The cancelled socket cannot affect the replacement generation.
+                }
+                throw new ClientSyncError('client.remote_realtime_cancelled', 'remote operation realtime connection was cancelled');
+            }
+            this.#operationSocket = socket;
+            return socket;
+        })
+            .finally(() => {
+            if (this.#operationSocketPromise === pending) {
+                this.#operationSocketPromise = undefined;
+            }
+        });
+        this.#operationSocketPromise = pending;
+        return pending;
+    }
+    #disconnectOperationRealtime(generation, error, closeSocket) {
+        if (generation !== this.#operationSocketGeneration)
+            return;
+        this.#operationSocketGeneration += 1;
+        const socket = this.#operationSocket;
+        this.#operationSocket = undefined;
+        this.#operationSocketPromise = undefined;
+        const watches = [...this.#watches.values()];
+        this.#watches.clear();
+        if (closeSocket) {
+            try {
+                socket?.close();
+            }
+            catch {
+                // Local state is already disconnected.
+            }
+        }
+        if (error === undefined)
+            return;
+        for (const watch of watches) {
+            try {
+                watch.handlers.onError?.(error);
+            }
+            catch {
+                // An observer cannot alter the connection lifecycle.
+            }
+        }
+    }
+    close() {
+        this.#disconnectOperationRealtime(this.#operationSocketGeneration, undefined, true);
+    }
+}

package/dist/schema.d.ts

@@ -1,6 +1,6 @@
 /**
  * Client schema IR (SPEC.md §2.4, §3.1) — the same shape the server
- * compiles, hand-written until codegen (B5) emits it. Drives local table
+ * compiles and is emitted by codegen. Drives local table
  * DDL, the generated row codec, mutation helpers, and the §3.3 purge
  * mapping (scope variable → local column).
  */
@@ -17,7 +17,7 @@ export interface ClientIndexSpec {
     readonly columns: readonly string[];
     readonly unique: boolean;
 }
-/** One client-local contentful FTS5 projection (RFC 0005). */
+/** One client-local contentful FTS5 projection. */
 export interface ClientFtsIndexSpec {
     readonly name: string;
     readonly columns: readonly string[];
@@ -58,7 +58,7 @@ export interface CompiledClientTable {
     /**
      * Scope variable → the pattern's literal prefix (§3.1). A stored-scope
      * value `v` for this variable has scope key `prefix:v` — the invalidation
-     * vocabulary (TODO 3.1 / DESIGN-eviction I2) and the delta-routing key.
+     * vocabulary and the delta-routing key.
      */
     readonly scopePrefixByVariable: ReadonlyMap<string, string>;
     /** Local secondary indexes to create on the mirror table (declaration

package/dist/sql-tag.d.ts

@@ -1,6 +1,6 @@
 /**
  * The `sql` tagged template — the raw tier's composition helper
- * (DESIGN-queries.md I4). Structural injection safety: an interpolated
+ * Structural injection safety: an interpolated
  * value can only ever become a `?` bind parameter; SQL text can only enter
  * through the literal template, `sql.ident()` (allowlist-gated) or a loud
  * `sql.raw()`. This helper is deliberately dumb plumbing and stays that

package/dist/transport.d.ts

@@ -1,11 +1,22 @@
 /**
- * Transport seams (REVISE B3): request/response bytes, segment download,
+ * Transport seams: request/response bytes, segment download,
  * and the realtime attach surface matching §8's client side. Tests use
  * loopback implementations that call the server library directly — the
  * loopback doctrine; HTTP/WebSocket bindings live in `./http`.
  */
 /** One combined push+pull round trip: SSP2 request bytes → response bytes. */
 export type SyncTransport = (request: Uint8Array) => Promise<Uint8Array>;
+/** One registered authoritative query or command request. */
+export type RemoteOperationTransport = (request: Uint8Array) => Promise<Uint8Array>;
+export interface RemoteOperationRealtimeHandlers {
+    onMessage(bytes: Uint8Array): void;
+    onClose?(): void;
+}
+export interface RemoteOperationRealtimeSocket {
+    send(bytes: Uint8Array): void;
+    close(): void;
+}
+export type RemoteOperationRealtimeConnector = (handlers: RemoteOperationRealtimeHandlers) => RemoteOperationRealtimeSocket | Promise<RemoteOperationRealtimeSocket>;
 export interface SegmentFetchRequest {
     readonly segmentId: string;
     readonly table: string;

package/dist/transport.js

@@ -1,5 +1,5 @@
 /**
- * Transport seams (REVISE B3): request/response bytes, segment download,
+ * Transport seams: request/response bytes, segment download,
  * and the realtime attach surface matching §8's client side. Tests use
  * loopback implementations that call the server library directly — the
  * loopback doctrine; HTTP/WebSocket bindings live in `./http`.

package/dist/wasm-database.d.ts

@@ -3,7 +3,7 @@ import { type ClientDatabase } from './database.js';
  * EXPLICIT ephemeral mode: an in-memory sqlite-wasm database. For tests,
  * demos and SSR only — nothing persists. The persistent mode is
  * `openPersistentWasmDatabase` inside a worker; there is no fallback from
- * one to the other (Direction decision 2).
+ * one to the other.
  */
 export declare function openWasmDatabase(): Promise<ClientDatabase>;
 export interface PersistentWasmDatabaseOptions {
@@ -18,13 +18,15 @@ export interface PersistentWasmDatabaseOptions {
     readonly initialCapacity?: number;
 }
 /**
- * THE persistent browser mode: a named database on OPFS via the
+ * THE reload-persistent browser mode: a named database on OPFS via the
  * `opfs-sahpool` VFS. Worker-context only — not because SAHPool requires
  * it (it uses `FileSystemSyncAccessHandle`, no `Atomics.wait`, and could
  * technically run on the main thread), but because the persistent mode IS
- * whole-core-in-a-worker (REVISE Direction decision 2, 2026-07-03) and
+ * whole-core-in-a-worker and
  * this factory enforces that decision. No COOP/COEP headers required.
  *
- * Support floor: no OPFS → a loud `ClientSyncError`, never a fallback.
+ * Support floor: no OPFS → a loud `ClientSyncError`, never a fallback. This
+ * factory cannot request eviction-resistant origin storage because that API
+ * belongs to the page's Window context.
  */
 export declare function openPersistentWasmDatabase(name: string, options?: PersistentWasmDatabaseOptions): Promise<ClientDatabase>;

package/dist/wasm-database.js

@@ -1,8 +1,8 @@
 /**
- * `ClientDatabase` on @sqlite.org/sqlite-wasm (Direction decision 2,
- * 2026-07-03). Two modes, no ladder between them:
+ * `ClientDatabase` on @sqlite.org/sqlite-wasm. Two modes, no ladder between
+ * them:
  *
- * - `openPersistentWasmDatabase(name)` — THE persistent browser mode:
+ * - `openPersistentWasmDatabase(name)` — THE reload-persistent browser mode:
  *   OPFS via the `opfs-sahpool` VFS, restricted to Web Worker contexts
  *   because the whole client core runs in a worker by design. SAHPool
  *   needs **no COOP/COEP headers and no SharedArrayBuffer** (it is built
@@ -10,7 +10,10 @@
  *   proxy — the COOP/COEP requirement documented by sqlite-wasm applies
  *   only to `oo1.OpfsDb`, which this binding no longer uses). Browsers
  *   without OPFS are unsupported (support floor ~2023+): the factory
- *   fails loud. Never IndexedDB, never a silent in-memory fallback.
+ *   fails loud. Never IndexedDB, never a silent in-memory fallback. The
+ *   browser's separate origin-eviction policy is exposed from the root package
+ *   by `checkBrowserStoragePersistence` and
+ *   `requestBrowserStoragePersistence`.
  * - `openWasmDatabase()` — EXPLICIT ephemeral: an in-memory database for
  *   tests, demos and SSR. Nothing survives a reload, on purpose.
  *
@@ -106,7 +109,7 @@ function initSqlite3() {
  * EXPLICIT ephemeral mode: an in-memory sqlite-wasm database. For tests,
  * demos and SSR only — nothing persists. The persistent mode is
  * `openPersistentWasmDatabase` inside a worker; there is no fallback from
- * one to the other (Direction decision 2).
+ * one to the other.
  */
 export async function openWasmDatabase() {
     const sqlite3 = await initSqlite3();
@@ -133,14 +136,16 @@ function opfsSahPoolError(error, directory) {
         `or rename the directory. Underlying error: ${detail}`, true);
 }
 /**
- * THE persistent browser mode: a named database on OPFS via the
+ * THE reload-persistent browser mode: a named database on OPFS via the
  * `opfs-sahpool` VFS. Worker-context only — not because SAHPool requires
  * it (it uses `FileSystemSyncAccessHandle`, no `Atomics.wait`, and could
  * technically run on the main thread), but because the persistent mode IS
- * whole-core-in-a-worker (REVISE Direction decision 2, 2026-07-03) and
+ * whole-core-in-a-worker and
  * this factory enforces that decision. No COOP/COEP headers required.
  *
- * Support floor: no OPFS → a loud `ClientSyncError`, never a fallback.
+ * Support floor: no OPFS → a loud `ClientSyncError`, never a fallback. This
+ * factory cannot request eviction-resistant origin storage because that API
+ * belongs to the page's Window context.
  */
 export async function openPersistentWasmDatabase(name, options) {
     if (!/^[A-Za-z0-9._-]+$/.test(name)) {

package/dist/window.d.ts

@@ -1,5 +1,5 @@
 /**
- * Windowed subscriptions (SPEC.md §4.8 / DESIGN-eviction.md W1).
+ * Windowed subscriptions (SPEC.md §4.8).
  *
  * A window is a partial local replica keyed by scope VALUES: the client
  * holds rows for a chosen set of units (one scope value each) of a window

package/dist/window.js

@@ -1,5 +1,5 @@
 /**
- * Windowed subscriptions (SPEC.md §4.8 / DESIGN-eviction.md W1).
+ * Windowed subscriptions (SPEC.md §4.8).
  *
  * A window is a partial local replica keyed by scope VALUES: the client
  * holds rows for a chosen set of units (one scope value each) of a window

package/dist/worker-entry.js

@@ -1,5 +1,5 @@
 /**
- * Worker-side bootstrap (Direction decision 2): constructs the WHOLE
+ * Worker-side bootstrap: constructs the WHOLE
  * client core — SyncClient + transports + realtime + SQLite — inside the
  * worker and serves the `worker-protocol` RPC over postMessage.
  *

package/dist/worker-host.d.ts

@@ -1,6 +1,6 @@
 /**
- * Main-thread side of the worker mode (Direction decision 2) and the
- * multi-tab topology (TODO 3.2, REVISE B3).
+ * Main-thread side of the worker mode and the
+ * multi-tab topology.
  *
  * `createSyncClientHandle` acquires the Web Locks leader lock and, when it
  * wins, spawns the worker running the WHOLE core — so exactly one core runs
@@ -8,7 +8,7 @@
  * holding the lock). The returned {@link SyncClientHandle} is a thin, fully
  * async proxy over the `worker-protocol` RPC.
  *
- * Multi-tab is the DEFAULT (RFC 0002 §2.4 — the follower path is
+ * Multi-tab is the DEFAULT. The follower path is
  * conformance-covered): a tab that LOSES the election becomes a FOLLOWER
  * (`role === 'follower'`) that proxies every call to the leader tab over a
  * BroadcastChannel (see `multi-tab.ts`). When the leader tab closes, its
@@ -86,7 +86,7 @@ export interface SyncClientHandleConfig {
     /** Shared by default; isolated derives the database/lock/channel tuple. */
     readonly replica?: BrowserReplicaMode;
     /**
-     * Multi-tab followers (TODO 3.2). On by default: a tab that loses the
+     * Multi-tab followers. On by default: a tab that loses the
      * leader election becomes a FOLLOWER that proxies to the leader over a
      * BroadcastChannel, and contests + promotes when the leader closes. Set
      * false for the single-tab contract — the loser is a dead
@@ -172,7 +172,7 @@ export declare class SyncClientHandle {
     /** @internal — dispatch a worker/relayed event to handle-local listeners. */
     __dispatchEvent(event: SyncWorkerEvent): void;
     /**
-     * TODO 3.1 / I1: subscribe to fine-grained invalidation — the identical
+     * Subscribe to fine-grained invalidation. The identical
      * surface as `SyncClient.onInvalidate`, so React bindings target one
      * interface across direct, worker-leader, and follower modes. Returns an
      * unsubscribe function.

package/dist/worker-host.js

@@ -98,7 +98,7 @@ export class SyncClientHandle {
         this.#diagnostics = internals.diagnostics;
         this.#roleListeners = internals.roleListeners ?? new Set();
         this.#leadershipListeners = internals.leadershipListeners ?? new Set();
-        // RFC 0002 §3.2: console introspection — a no-op outside a dev page.
+        // Console introspection is a no-op outside a dev page.
         this.#devtoolsUnregister = registerDevtools({
             kind: 'handle',
             ref: this,
@@ -181,7 +181,7 @@ export class SyncClientHandle {
         }
     }
     /**
-     * TODO 3.1 / I1: subscribe to fine-grained invalidation — the identical
+     * Subscribe to fine-grained invalidation. The identical
      * surface as `SyncClient.onInvalidate`, so React bindings target one
      * interface across direct, worker-leader, and follower modes. Returns an
      * unsubscribe function.