@syncular/client 0.30.13 → 0.30.15

package/dist/previous-version.js

@@ -1,7 +1,7 @@
 import { ClientSyncError } from './errors.js';
 import { INVALID_HOST_RESPONSE_CODE } from './local-rebootstrap.js';
 import { fromSqlValue, jsonToRowValue, localColumnType, quoteIdent, rowValueToJson, } from './schema.js';
-import { getMeta, setMeta } from './state.js';
+import { getMeta, setMeta, META_TABLE } from './state.js';
 /** `_syncular_meta` key holding the persisted {@link LocalSchemaDescriptor}. */
 const LOCAL_SCHEMA_DESCRIPTOR_KEY = 'localSchemaDescriptor';
 /**
@@ -441,7 +441,7 @@ export function writePreviousVersionRefusal(db, reason, measurement) {
 }
 /** Delete the durable refusal. Part of the orphan sweep and of a successful capture. */
 export function clearPreviousVersionRefusal(db) {
-    db.exec('DELETE FROM _syncular_meta WHERE key=?', [
+    db.exec(`DELETE FROM ${META_TABLE} WHERE key=?`, [
         PREVIOUS_VERSION_CONTEXT_KEY,
     ]);
 }
@@ -575,7 +575,7 @@ export function writePreviousVersionAudit(db, audit) {
 }
 /** Delete the advisory audit. Part of a discard, never of a normal bump. */
 export function clearPreviousVersionAudit(db) {
-    db.exec('DELETE FROM _syncular_meta WHERE key=?', [
+    db.exec(`DELETE FROM ${META_TABLE} WHERE key=?`, [
         PREVIOUS_VERSION_AUDIT_KEY,
     ]);
 }

package/dist/schema.d.ts

@@ -93,6 +93,7 @@ export declare const OPTIMISTIC_VERSION = -1;
  * pass through this filter.
  */
 export declare function stripSyncColumns(rows: SqlRow[]): SqlRow[];
+export declare function hasUniqueIndex(table: CompiledClientTable): boolean;
 export declare function matchesLocalScopes(table: CompiledClientTable, scopes: Readonly<Record<string, readonly string[]>>, values: Readonly<Record<string, JsonRowValue>>): boolean;
 export declare function quoteIdent(name: string): string;
 /**

package/dist/schema.js

@@ -1,3 +1,9 @@
+import { BLOB_COMMIT_REFS } from './blob.js';
+import { PENDING_EVICTIONS } from './window.js';
+import { WINDOWS_TABLE } from './window.js';
+import { OUTBOX_TABLE, OUTBOX_IMAGES } from './outbox.js';
+import { OUTCOMES_TABLE } from './outcomes.js';
+import { SUBSCRIPTIONS_TABLE, META_TABLE } from './state.js';
 import { ensureFailedOverlaySchema } from './failed-overlay.js';
 import { invalidRequest } from './errors.js';
 import { snakeToCamel } from './naming.js';
@@ -156,6 +162,9 @@ export function stripSyncColumns(rows) {
         return copy;
     });
 }
+export function hasUniqueIndex(table) {
+    return table.indexes.some((index) => index.unique);
+}
 export function matchesLocalScopes(table, scopes, values) {
     const entries = Object.entries(scopes);
     return (entries.length > 0 &&
@@ -361,34 +370,34 @@ export function ensureLocalBookkeepingSchema(db) {
     db.transaction(() => {
         ensureFailedOverlaySchema(db);
         const createTable = (name, columns) => db.exec(`CREATE TABLE IF NOT EXISTS ${name}(${columns})`);
-        createTable('_syncular_meta', 'key TEXT PRIMARY KEY,value TEXT NOT NULL');
-        createTable('_syncular_blob_commit_refs', 'commit_id TEXT NOT NULL,blob_id TEXT NOT NULL,PRIMARY KEY(commit_id,blob_id)');
-        db.exec('CREATE INDEX IF NOT EXISTS _syncular_blob_commit_refs_body ON _syncular_blob_commit_refs(blob_id)');
-        db.exec("INSERT OR IGNORE INTO _syncular_meta(key,value)VALUES('localRevision','0')");
-        createTable('_syncular_outbox', 'seq INTEGER PRIMARY KEY AUTOINCREMENT,client_commit_id TEXT NOT NULL UNIQUE,created_at_ms INTEGER NOT NULL,operations TEXT NOT NULL');
-        createTable('_syncular_outbox_before_images', 'client_commit_id TEXT NOT NULL,op_index INTEGER NOT NULL,existed INTEGER NOT NULL CHECK(existed IN (0,1)),sync_version INTEGER,values_json TEXT,PRIMARY KEY(client_commit_id,op_index)');
+        createTable(META_TABLE, 'key TEXT PRIMARY KEY,value TEXT NOT NULL');
+        createTable(BLOB_COMMIT_REFS, 'commit_id TEXT NOT NULL,blob_id TEXT NOT NULL,PRIMARY KEY(commit_id,blob_id)');
+        db.exec(`CREATE INDEX IF NOT EXISTS ${BLOB_COMMIT_REFS}_body ON ${BLOB_COMMIT_REFS}(blob_id)`);
+        db.exec(`INSERT OR IGNORE INTO ${META_TABLE}(key,value)VALUES('localRevision','0')`);
+        createTable(OUTBOX_TABLE, 'seq INTEGER PRIMARY KEY AUTOINCREMENT,client_commit_id TEXT NOT NULL UNIQUE,created_at_ms INTEGER NOT NULL,operations TEXT NOT NULL');
+        createTable(OUTBOX_IMAGES, 'client_commit_id TEXT NOT NULL,op_index INTEGER NOT NULL,existed INTEGER NOT NULL CHECK(existed IN (0,1)),sync_version INTEGER,values_json TEXT,PRIMARY KEY(client_commit_id,op_index)');
         if (!db
-            .query('PRAGMA table_info(_syncular_outbox_before_images)')
+            .query(`PRAGMA table_info(${OUTBOX_IMAGES})`)
             .some((row) => row.name === 'delivery_seq'))
-            db.exec('ALTER TABLE _syncular_outbox_before_images ADD COLUMN delivery_seq INTEGER');
-        createTable('_syncular_commit_outcomes', "seq INTEGER PRIMARY KEY AUTOINCREMENT,client_commit_id TEXT NOT NULL UNIQUE,status TEXT NOT NULL CHECK(status IN ('applied','cached','conflict','rejected')),recorded_at_ms INTEGER NOT NULL,results TEXT NOT NULL,operations TEXT,resolution TEXT NOT NULL DEFAULT 'active' CHECK(resolution IN ('active','resolved_keep_server','superseded','dismissed')),resolved_at_ms INTEGER,replacement_client_commit_id TEXT");
+            db.exec(`ALTER TABLE ${OUTBOX_IMAGES} ADD COLUMN delivery_seq INTEGER`);
+        createTable(OUTCOMES_TABLE, "seq INTEGER PRIMARY KEY AUTOINCREMENT,client_commit_id TEXT NOT NULL UNIQUE,status TEXT NOT NULL CHECK(status IN ('applied','cached','conflict','rejected')),recorded_at_ms INTEGER NOT NULL,results TEXT NOT NULL,operations TEXT,resolution TEXT NOT NULL DEFAULT 'active' CHECK(resolution IN ('active','resolved_keep_server','superseded','dismissed')),resolved_at_ms INTEGER,replacement_client_commit_id TEXT");
         // Outcomes created before durable aggregate recovery retain no commit
         // envelope. New failed outcomes store it in the protected client DB.
         try {
-            db.exec('ALTER TABLE _syncular_commit_outcomes ADD COLUMN operations TEXT');
+            db.exec(`ALTER TABLE ${OUTCOMES_TABLE} ADD COLUMN operations TEXT`);
         }
         catch {
             // column already exists — the CREATE above included it
         }
-        db.exec('CREATE INDEX IF NOT EXISTS _syncular_commit_outcomes_resolution_seq ON _syncular_commit_outcomes(resolution,seq)');
-        createTable('_syncular_subscriptions', "id TEXT PRIMARY KEY,tbl TEXT NOT NULL,requested_scopes TEXT NOT NULL,params TEXT,cursor INTEGER NOT NULL DEFAULT -1,bootstrap_state TEXT,effective_scopes TEXT,status TEXT NOT NULL DEFAULT 'active',reason_code TEXT");
+        db.exec(`CREATE INDEX IF NOT EXISTS ${OUTCOMES_TABLE}_resolution_seq ON ${OUTCOMES_TABLE}(resolution,seq)`);
+        createTable(SUBSCRIPTIONS_TABLE, "id TEXT PRIMARY KEY,tbl TEXT NOT NULL,requested_scopes TEXT NOT NULL,params TEXT,cursor INTEGER NOT NULL DEFAULT -1,bootstrap_state TEXT,effective_scopes TEXT,status TEXT NOT NULL DEFAULT 'active',reason_code TEXT");
         // §4.8 window registry: which units (scope values) of a window base are
         // live locally — the completeness oracle (I3) and the shrink driver
         // (a unit's omission from the next pull unregisters it, §4.1).
-        createTable('_syncular_windows', 'base TEXT NOT NULL,unit TEXT NOT NULL,sub_id TEXT NOT NULL,PRIMARY KEY(base,unit)');
+        createTable(WINDOWS_TABLE, 'base TEXT NOT NULL,unit TEXT NOT NULL,sub_id TEXT NOT NULL,PRIMARY KEY(base,unit)');
         // §4.8 E1: units that left the window but still had outbox-pinned rows.
         // Retried when the outbox drains; cancelled if the unit re-enters.
-        createTable('_syncular_window_pending_evict', 'sub_id TEXT PRIMARY KEY,tbl TEXT NOT NULL,effective_scopes TEXT NOT NULL');
+        createTable(PENDING_EVICTIONS, 'sub_id TEXT PRIMARY KEY,tbl TEXT NOT NULL,effective_scopes TEXT NOT NULL');
     });
 }
 /** Create both application and protected bookkeeping tables. */

package/dist/state.d.ts

@@ -1,3 +1,5 @@
+export declare const META_TABLE = "_syncular_meta";
+export declare const SUBSCRIPTIONS_TABLE = "_syncular_subscriptions";
 /**
  * Durable client sync state: per-subscription cursor, bootstrap resume
  * token (round-tripped opaquely, §4.7), and the last-echoed effective

package/dist/state.js

@@ -1,3 +1,7 @@
+export const META_TABLE = '_syncular_meta';
+import { PENDING_EVICTIONS } from './window.js';
+import { WINDOWS_TABLE } from './window.js';
+export const SUBSCRIPTIONS_TABLE = '_syncular_subscriptions';
 export const LOCAL_REVISION_KEY = 'localRevision';
 const MAX_U64 = 18446744073709551615n;
 function rowToRecord(row) {
@@ -23,17 +27,17 @@ function rowToRecord(row) {
 }
 export function loadSubscriptions(db) {
     return db
-        .query('SELECT * FROM _syncular_subscriptions ORDER BY rowid ASC')
+        .query(`SELECT * FROM ${SUBSCRIPTIONS_TABLE} ORDER BY rowid ASC`)
         .map(rowToRecord);
 }
 export function getSubscription(db, id) {
-    const row = db.query('SELECT * FROM _syncular_subscriptions WHERE id=?', [
+    const row = db.query(`SELECT * FROM ${SUBSCRIPTIONS_TABLE} WHERE id=?`, [
         id,
     ])[0];
     return row === undefined ? undefined : rowToRecord(row);
 }
 export function saveSubscription(db, record) {
-    db.exec('INSERT OR REPLACE INTO _syncular_subscriptions(id,tbl,requested_scopes,params,cursor,bootstrap_state,effective_scopes,status,reason_code)VALUES(?,?,?,?,?,?,?,?,?)', [
+    db.exec(`INSERT OR REPLACE INTO ${SUBSCRIPTIONS_TABLE}(id,tbl,requested_scopes,params,cursor,bootstrap_state,effective_scopes,status,reason_code)VALUES(?,?,?,?,?,?,?,?,?)`, [
         record.id,
         record.table,
         JSON.stringify(record.scopes),
@@ -48,7 +52,7 @@ export function saveSubscription(db, record) {
     ]);
 }
 export function deleteSubscription(db, id) {
-    db.exec('DELETE FROM _syncular_subscriptions WHERE id=?', [id]);
+    db.exec(`DELETE FROM ${SUBSCRIPTIONS_TABLE} WHERE id=?`, [id]);
 }
 /**
  * §7.4.3 reset: keep compatible subscription REGISTRATIONS (id, table,
@@ -58,7 +62,7 @@ export function deleteSubscription(db, id) {
  * subscriptions the app still wants. Caller owns the transaction.
  */
 export function resetSubscriptionsForBump(db) {
-    db.exec("UPDATE _syncular_subscriptions SET cursor=-1,bootstrap_state=NULL,effective_scopes=NULL,status='active',reason_code=NULL");
+    db.exec(`UPDATE ${SUBSCRIPTIONS_TABLE} SET cursor=-1,bootstrap_state=NULL,effective_scopes=NULL,status='active',reason_code=NULL`);
 }
 /** Persist declarations separately from the previous-version row descriptor. */
 export function saveSubscriptionScopeSchema(db, schema) {
@@ -108,7 +112,7 @@ export function pruneUnknownSubscriptions(db, subscriptions, schema, bump = fals
         .map((record) => record.id));
     // Shrinking a pinned window already removed its registration. Its deferred
     // eviction still carries the old scope declaration and needs the same fence.
-    for (const row of db.query('SELECT sub_id,tbl,effective_scopes FROM _syncular_window_pending_evict')) {
+    for (const row of db.query(`SELECT sub_id,tbl,effective_scopes FROM ${PENDING_EVICTIONS}`)) {
         if (!compatible({
             table: String(row.tbl),
             scopes: JSON.parse(String(row.effective_scopes)),
@@ -119,23 +123,19 @@ export function pruneUnknownSubscriptions(db, subscriptions, schema, bump = fals
         return retained;
     db.transaction(() => {
         for (const id of staleIds) {
-            db.exec('DELETE FROM _syncular_windows WHERE sub_id=?', [id]);
-            db.exec('DELETE FROM _syncular_window_pending_evict WHERE sub_id=?', [
-                id,
-            ]);
-            db.exec('DELETE FROM _syncular_subscriptions WHERE id=?', [id]);
+            db.exec(`DELETE FROM ${WINDOWS_TABLE} WHERE sub_id=?`, [id]);
+            db.exec(`DELETE FROM ${PENDING_EVICTIONS} WHERE sub_id=?`, [id]);
+            db.exec(`DELETE FROM ${SUBSCRIPTIONS_TABLE} WHERE id=?`, [id]);
         }
     });
     return retained;
 }
 export function getMeta(db, key) {
-    const row = db.query('SELECT value FROM _syncular_meta WHERE key=?', [
-        key,
-    ])[0];
+    const row = db.query(`SELECT value FROM ${META_TABLE} WHERE key=?`, [key])[0];
     return row === undefined ? undefined : row.value;
 }
 export function setMeta(db, key, value) {
-    db.exec('INSERT OR REPLACE INTO _syncular_meta(key,value)VALUES(?,?)', [
+    db.exec(`INSERT OR REPLACE INTO ${META_TABLE}(key,value)VALUES(?,?)`, [
         key,
         value,
     ]);

package/dist/window.d.ts

@@ -1,3 +1,5 @@
+export declare const PENDING_EVICTIONS = "_syncular_window_pending_evict";
+export declare const WINDOWS_TABLE = "_syncular_windows";
 /**
  * Windowed subscriptions (SPEC.md §4.8).
  *

package/dist/window.js

@@ -1,3 +1,5 @@
+export const PENDING_EVICTIONS = '_syncular_window_pending_evict';
+export const WINDOWS_TABLE = '_syncular_windows';
 /**
  * Windowed subscriptions (SPEC.md §4.8).
  *
@@ -88,12 +90,12 @@ export async function deriveSubId(base, unit) {
 /** Live units for a base, ordered by unit value. */
 export function loadWindowUnits(db, baseKey) {
     return db
-        .query('SELECT unit, sub_id FROM _syncular_windows WHERE base = ? ORDER BY unit ASC', [baseKey])
+        .query(`SELECT unit,sub_id FROM ${WINDOWS_TABLE} WHERE base=? ORDER BY unit`, [baseKey])
         .map((row) => ({ unit: row.unit, subId: row.sub_id }));
 }
 /** Registry lookup used to emit exact completion changes for a sub id. */
 export function getWindowUnitBySubId(db, subId) {
-    const row = db.query(`SELECT base, unit, sub_id FROM _syncular_windows
+    const row = db.query(`SELECT base, unit, sub_id FROM ${WINDOWS_TABLE}
       WHERE sub_id = ? LIMIT 1`, [subId])[0];
     return row === undefined
         ? undefined
@@ -104,30 +106,31 @@ export function getWindowUnitBySubId(db, subId) {
         };
 }
 export function insertWindowUnit(db, baseKey, unit, subId) {
-    db.exec('INSERT OR REPLACE INTO _syncular_windows(base, unit, sub_id) VALUES (?, ?, ?)', [baseKey, unit, subId]);
+    db.exec(`INSERT OR REPLACE INTO ${WINDOWS_TABLE}(base,unit,sub_id)VALUES(?,?,?)`, [baseKey, unit, subId]);
 }
 export function deleteWindowUnit(db, baseKey, unit) {
-    db.exec('DELETE FROM _syncular_windows WHERE base = ? AND unit = ?', [
+    db.exec(`DELETE FROM ${WINDOWS_TABLE} WHERE base=? AND unit=?`, [
         baseKey,
         unit,
     ]);
 }
 /** Is a single scope value windowed-in for this base? (the oracle, I3) */
 export function isUnitLive(db, baseKey, unit) {
-    return (db.query('SELECT 1 FROM _syncular_windows WHERE base = ? AND unit = ? LIMIT 1', [baseKey, unit]).length > 0);
+    return (db.query(`SELECT 1 FROM ${WINDOWS_TABLE} WHERE base=? AND unit=? LIMIT 1`, [
+        baseKey,
+        unit,
+    ]).length > 0);
 }
 export function savePendingEviction(db, subId, table, effective) {
-    db.exec(`INSERT OR REPLACE INTO _syncular_window_pending_evict(sub_id, tbl, effective_scopes)
+    db.exec(`INSERT OR REPLACE INTO ${PENDING_EVICTIONS}(sub_id, tbl, effective_scopes)
        VALUES (?, ?, ?)`, [subId, table, JSON.stringify(effective)]);
 }
 export function deletePendingEviction(db, subId) {
-    db.exec('DELETE FROM _syncular_window_pending_evict WHERE sub_id = ?', [
-        subId,
-    ]);
+    db.exec(`DELETE FROM ${PENDING_EVICTIONS} WHERE sub_id = ?`, [subId]);
 }
 export function loadPendingEvictions(db) {
     return db
-        .query('SELECT sub_id, tbl, effective_scopes FROM _syncular_window_pending_evict')
+        .query(`SELECT sub_id, tbl, effective_scopes FROM ${PENDING_EVICTIONS}`)
         .map((row) => ({
         subId: row.sub_id,
         table: row.tbl,

package/dist/worker-entry.js

@@ -13,6 +13,7 @@
  * RPC-driven and auto-driven sync rounds serialize on one queue because
  * the core owns exactly one loop.
  */
+import { defineAuthorityReads } from './authority.js';
 import { SyncClient } from './client.js';
 import { withClientDiagnosticsHost, } from './diagnostics.js';
 import { encryptionConfigFromKeyring } from './encryption.js';
@@ -233,6 +234,9 @@ export function startSyncWorker(overrides = {}) {
             ...(config.encryption !== undefined
                 ? { encryption: encryptionConfigFromKeyring(config.encryption) }
                 : {}),
+            ...(config.authorityReads !== undefined
+                ? { authorityReads: defineAuthorityReads(config.authorityReads) }
+                : {}),
             ...(config.securityPreflight !== undefined
                 ? { securityPreflight: config.securityPreflight }
                 : {}),
@@ -342,6 +346,7 @@ export function startSyncWorker(overrides = {}) {
             return serializedSync(() => running.syncUntilIdle(maxRounds));
         },
         query: (sql, params) => requireClient().query(sql, params),
+        authoritySnapshot: () => requireClient().authoritySnapshot(),
         querySnapshot: (spec) => requireClient().querySnapshot(spec),
         localRevision: () => requireClient().localRevision,
         statusSnapshot: () => requireClient().statusSnapshot(),
@@ -420,6 +425,8 @@ export function startSyncWorker(overrides = {}) {
         'previousVersionDiscard',
     ]);
     async function dispatch(message) {
+        if (message.method === 'authoritySnapshot' && message.args.length)
+            throw new ClientSyncError('client.authority_read_forbidden', 'authoritySnapshot accepts no arguments');
         const method = api[message.method];
         const invoke = () => method.apply(api, message.args);
         if (syncChainMethods.has(message.method)) {

package/dist/worker-host.d.ts

@@ -83,6 +83,8 @@ export interface SyncClientHandleConfig {
     readonly headers?: Readonly<Record<string, string>>;
     /** Structured-clone-safe E2EE keyring installed only in the leader worker. */
     readonly encryption?: EncryptionKeyringConfig;
+    /** Fixed plain authority reads permitted before security activation. */
+    readonly authorityReads?: import('./authority.js').AuthorityReadPolicy;
     /** Open the worker-owned replica behind the fail-closed security gate. */
     readonly securityPreflight?: boolean;
     readonly transportEnabled?: boolean;
@@ -244,6 +246,7 @@ export declare class SyncClientHandle implements PromiseMethods<WorkerApi> {
     sync(): Promise<SyncSummary>;
     syncUntilIdle(maxRounds?: number): Promise<SyncSummary>;
     query(sql: string, params?: readonly SqlValue[]): Promise<SqlRow[]>;
+    authoritySnapshot(): Promise<import('./authority.js').AuthoritySnapshot>;
     querySnapshot<Row = SqlRow>(spec: QueryReadSpec): Promise<QuerySnapshot<Row>>;
     localRevision(): Promise<LocalRevision>;
     statusSnapshot(): Promise<SyncStatusSnapshot>;

package/dist/worker-host.js

@@ -332,6 +332,11 @@ export class SyncClientHandle {
     query(sql, params) {
         return this.#call('query', [sql, params]);
     }
+    authoritySnapshot() {
+        if (arguments.length)
+            throw new ClientSyncError('client.authority_read_forbidden', 'authoritySnapshot accepts no arguments');
+        return this.#call('authoritySnapshot', []);
+    }
     querySnapshot(spec) {
         return this.#call('querySnapshot', [spec]);
     }
@@ -569,6 +574,9 @@ function buildInitConfig(config, headers = config.headers) {
         ...(config.transportEnabled !== undefined
             ? { transportEnabled: config.transportEnabled }
             : {}),
+        ...(config.authorityReads !== undefined
+            ? { authorityReads: config.authorityReads.declarations }
+            : {}),
         ...(config.securityPreflight !== undefined
             ? { securityPreflight: config.securityPreflight }
             : {}),

package/dist/worker-protocol.d.ts

@@ -77,6 +77,7 @@ export interface WorkerInitConfig {
     /** Portable raw keyring installed inside the worker-owned client core. */
     readonly encryption?: EncryptionKeyringConfig;
     /** Open the worker-owned replica behind the fail-closed security gate. */
+    readonly authorityReads?: readonly import('./authority.js').AuthorityReadDeclaration[];
     readonly securityPreflight?: boolean;
     readonly transportEnabled?: boolean;
     readonly clientId?: string;
@@ -138,6 +139,7 @@ export interface WorkerApi extends Omit<ClientSnapshotMethods, 'querySnapshot'>
     sync(): Promise<SyncSummary>;
     syncUntilIdle(maxRounds?: number): Promise<SyncSummary>;
     query(sql: string, params?: readonly SqlValue[]): SqlRow[];
+    authoritySnapshot(): import('./authority.js').AuthoritySnapshot;
     querySnapshot(spec: QueryReadSpec): QuerySnapshot;
     localRevision(): LocalRevision;
     pendingCommits(): OutboxCommit[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/client",
-  "version": "0.30.13",
+  "version": "0.30.15",
   "description": "Syncular TypeScript client core — offline-first sync over SQLite (WASM/OPFS, Bun, Node)",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -89,10 +89,10 @@
   },
   "dependencies": {
     "@sqlite.org/sqlite-wasm": "^3.53.0-build1",
-    "@syncular/core": "0.30.13"
+    "@syncular/core": "0.30.15"
   },
   "devDependencies": {
-    "@syncular/server": "0.30.13",
+    "@syncular/server": "0.30.15",
     "playwright": "1.63.0",
     "@electric-sql/pglite": "^0.5.4"
   }

package/src/apply.ts

@@ -1,4 +1,6 @@
-import { RETAINED_ROWS } from './failed-overlay';
+import { hasUniqueIndex } from './schema';
+import { OUTBOX_TABLE, OUTBOX_IMAGES, countOutbox } from './outbox';
+import { RETAINED_ROWS, type OverlayScope } from './failed-overlay';
 import { retainedBaseWrite, restoreFailedBases } from './failed-overlay';
 /**
  * Local application of server data: `COMMIT` frames (§4.5), rows segments
@@ -28,7 +30,7 @@ import {
 } from './schema';
 
 /** Lets the client wrap the physical write in its revision transaction. */
-export type ApplyTransaction = <T>(fn: () => T) => T;
+export type ApplyTransaction = (fn: () => OverlayScope) => unknown;
 
 function upsertSql(table: CompiledClientTable): string {
   const names = [
@@ -96,8 +98,7 @@ export async function applyCommitFrame(
   schema: CompiledClientSchema,
   frame: CommitFrame,
   encryption?: EncryptionConfig,
-  transaction: (fn: () => readonly string[] | undefined) => unknown = (fn) =>
-    db.transaction(fn),
+  transaction: (fn: () => OverlayScope) => unknown = (fn) => db.transaction(fn),
 ): Promise<void> {
   type Resolved =
     | { op: 'delete'; table: CompiledClientTable; rowId: string }
@@ -142,18 +143,18 @@ export async function applyCommitFrame(
     });
   }
   transaction(() => {
-    const rowKeys = frame.tables.some((name) =>
-      schema.tables.get(name)?.indexes.some((index) => index.unique),
-    )
-      ? undefined
-      : frame.changes.map((change) =>
-          JSON.stringify([frame.tables[change.tableIndex], change.rowId]),
-        );
-    restoreFailedBases(db, schema, false, rowKeys);
+    const scope = resolved.map((change, index) =>
+      JSON.stringify(
+        hasUniqueIndex(change.table)
+          ? [change.table.name]
+          : [change.table.name, frame.changes[index]!.rowId],
+      ),
+    );
+    restoreFailedBases(db, schema, scope);
     for (const [index, change] of resolved.entries()) {
       const rowId = frame.changes[index]!.rowId;
       db.exec(
-        "UPDATE _syncular_outbox_before_images SET delivery_seq=MAX(COALESCE(delivery_seq,0),?) WHERE (client_commit_id,op_index) IN(SELECT client_commit_id,json_each.key FROM _syncular_outbox,json_each(operations) WHERE json_extract(value,'$.table')=? AND json_extract(value,'$.rowId')=?)",
+        `UPDATE ${OUTBOX_IMAGES} SET delivery_seq=MAX(COALESCE(delivery_seq,0),?) WHERE (client_commit_id,op_index) IN(SELECT client_commit_id,json_each.key FROM ${OUTBOX_TABLE},json_each(operations) WHERE json_extract(value,'$.table')=? AND json_extract(value,'$.rowId')=?)`,
         [frame.commitSeq, change.table.name, rowId],
       );
       db.exec(
@@ -166,7 +167,7 @@ export async function applyCommitFrame(
         upsertLocalRow(db, change.table, change.values, change.rowVersion);
       }
     }
-    return rowKeys;
+    return scope;
   });
 }
 
@@ -238,6 +239,41 @@ export function localScopePredicate(
   return { sql, params };
 }
 
+function scopedRows(
+  db: ClientDatabase,
+  table: CompiledClientTable,
+  scope: ReturnType<typeof localScopePredicate>,
+) {
+  return scope
+    ? db.query(
+        `SELECT ${quoteIdent(table.primaryKey)} AS id FROM ${quoteIdent(table.name)} WHERE ${scope.sql}`,
+        scope.params,
+      )
+    : [];
+}
+
+function bootstrapScope(
+  db: ClientDatabase,
+  table: CompiledClientTable,
+  effective: ScopeMap,
+): string[] {
+  const rows = scopedRows(db, table, localScopePredicate(table, effective));
+  rows.push(
+    ...db
+      .query(`SELECT id,base,intent FROM ${RETAINED_ROWS} WHERE tbl=?`, [
+        table.name,
+      ])
+      .filter((row) =>
+        [row.base, row.intent].some(
+          (json) =>
+            json !== null &&
+            matchesLocalScopes(table, effective, JSON.parse(json as string)),
+        ),
+      ),
+  );
+  return rows.map((row) => JSON.stringify([table.name, String(row.id)]));
+}
+
 export function deleteScopedRows(
   db: ClientDatabase,
   table: CompiledClientTable,
@@ -246,10 +282,7 @@ export function deleteScopedRows(
   const scope = localScopePredicate(table, effective);
   if (!scope) return;
   const { sql, params } = scope;
-  for (const row of db.query(
-    `SELECT ${quoteIdent(table.primaryKey)} AS id FROM ${quoteIdent(table.name)} WHERE ${sql}`,
-    params,
-  )) {
+  for (const row of scopedRows(db, table, scope)) {
     retainedBaseWrite(db, table, String(row.id));
   }
   db.exec(`DELETE FROM ${quoteIdent(table.name)} WHERE ${sql}`, params);
@@ -451,8 +484,31 @@ export async function applySqliteSegment(
         predicates.push(`${primaryKey} <= ?`);
         params.push(boundary);
       }
+      const replay =
+        countOutbox(db) ||
+        db.query(`SELECT 1 FROM ${RETAINED_ROWS} WHERE tbl=? LIMIT 1`, [
+          table.name,
+        ]).length;
+      const rows = replay
+        ? db.query(
+            `SELECT * FROM ${source} WHERE ${predicates.join(' AND ') || 'true'}`,
+            params,
+          )
+        : [];
       (options.transaction ?? ((fn) => db.transaction(fn)))(() => {
-        restoreFailedBases(db, schema);
+        const scope = !replay
+          ? []
+          : hasUniqueIndex(table)
+            ? [JSON.stringify([table.name])]
+            : [
+                ...(after === undefined && options.clearFirst
+                  ? bootstrapScope(db, table, options.effective)
+                  : []),
+                ...rows.map((row) =>
+                  JSON.stringify([table.name, String(row[table.primaryKey])]),
+                ),
+              ];
+        const protectedRows = restoreFailedBases(db, schema, scope);
         if (after === undefined && options.clearFirst)
           deleteScopedRows(db, table, options.effective);
         db.exec(
@@ -460,23 +516,22 @@ export async function applySqliteSegment(
           params,
         );
         applied += Number(db.query('SELECT changes()AS n')[0]?.n ?? 0);
-        for (const row of db.query(
-          `SELECT * FROM ${source} WHERE ${predicates.join(' AND ') || 'true'}`,
-          params,
-        )) {
-          retainedBaseWrite(
-            db,
-            table,
-            String(row[table.primaryKey]),
-            Object.fromEntries(
-              table.columns.map((column) => [
-                column.name,
-                rowValueToJson(row[column.name] as RowValue),
-              ]),
-            ),
-            Number(row._syncular_version),
-          );
-        }
+        if (protectedRows)
+          for (const row of rows) {
+            retainedBaseWrite(
+              db,
+              table,
+              String(row[table.primaryKey]),
+              Object.fromEntries(
+                table.columns.map((column) => [
+                  column.name,
+                  rowValueToJson(row[column.name] as RowValue),
+                ]),
+              ),
+              Number(row._syncular_version),
+            );
+          }
+        return scope;
       });
       options.onProgress?.(applied);
       await yieldToHost();
@@ -537,7 +592,20 @@ export async function applyRowsSegment(
     first = false;
     if (!clearThisBlock && rows.length === 0) continue;
     (options.transaction ?? ((fn) => db.transaction(fn)))(() => {
-      const protectedRows = restoreFailedBases(db, schema);
+      const scope: OverlayScope = hasUniqueIndex(table)
+        ? [JSON.stringify([table.name])]
+        : [
+            ...(clearThisBlock
+              ? bootstrapScope(db, table, options.effective)
+              : []),
+            ...rows.map((row) =>
+              JSON.stringify([
+                table.name,
+                String(row.values[table.primaryKeyIndex]),
+              ]),
+            ),
+          ];
+      const protectedRows = restoreFailedBases(db, schema, scope);
       if (clearThisBlock) {
         deleteScopedRows(db, table, options.effective);
       }
@@ -546,6 +614,7 @@ export async function applyRowsSegment(
         applied += 1;
         if (applied % 1024 === 0) options.onProgress?.(applied);
       }
+      return scope;
     });
     options.onProgress?.(applied);
     await yieldToHost();