@syncular/client 0.30.12 → 0.30.14

package/dist/apply.d.ts

@@ -1,3 +1,4 @@
+import { type OverlayScope } from './failed-overlay.js';
 /**
  * Local application of server data: `COMMIT` frames (§4.5), rows segments
  * (§5.2, §5.6), and the scope-matched delete shared by the §3.3 purge
@@ -8,7 +9,7 @@ import type { ClientDatabase } from './database.js';
 import type { EncryptionConfig } from './encryption.js';
 import { type CompiledClientSchema, type CompiledClientTable } from './schema.js';
 /** Lets the client wrap the physical write in its revision transaction. */
-export type ApplyTransaction = <T>(fn: () => T) => T;
+export type ApplyTransaction = (fn: () => OverlayScope) => unknown;
 export declare function upsertLocalRow(db: ClientDatabase, table: CompiledClientTable, values: readonly RowValue[], syncVersion: number, serverWrite?: boolean): void;
 export declare function deleteLocalRow(db: ClientDatabase, table: CompiledClientTable, rowId: string, serverWrite?: boolean): void;
 /**
@@ -23,7 +24,7 @@ export declare function deleteLocalRow(db: ClientDatabase, table: CompiledClient
  * (`client.decrypt_failed`) aborts before any local write, so the commit
  * never half-applies.
  */
-export declare function applyCommitFrame(db: ClientDatabase, schema: CompiledClientSchema, frame: CommitFrame, encryption?: EncryptionConfig, transaction?: (fn: () => readonly string[] | undefined) => unknown): Promise<void>;
+export declare function applyCommitFrame(db: ClientDatabase, schema: CompiledClientSchema, frame: CommitFrame, encryption?: EncryptionConfig, transaction?: (fn: () => OverlayScope) => unknown): Promise<void>;
 /**
  * §5.2: the segment's column table must match the generated schema for
  * (table, schemaVersion) — order, names, types, nullability. A mismatch is

package/dist/apply.js

@@ -1,3 +1,5 @@
+import { hasUniqueIndex } from './schema.js';
+import { OUTBOX_TABLE, OUTBOX_IMAGES, countOutbox } from './outbox.js';
 import { RETAINED_ROWS } from './failed-overlay.js';
 import { retainedBaseWrite, restoreFailedBases } from './failed-overlay.js';
 /**
@@ -76,13 +78,13 @@ export async function applyCommitFrame(db, schema, frame, encryption, transactio
         });
     }
     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')=?)", [frame.commitSeq, change.table.name, rowId]);
+            db.exec(`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(`DELETE FROM ${RETAINED_ROWS} WHERE tbl=? AND id=? AND commit_seq<=?`, [change.table.name, rowId, frame.commitSeq]);
             if (change.op === 'delete') {
                 deleteLocalRow(db, change.table, change.rowId);
@@ -91,7 +93,7 @@ export async function applyCommitFrame(db, schema, frame, encryption, transactio
                 upsertLocalRow(db, change.table, change.values, change.rowVersion);
             }
         }
-        return rowKeys;
+        return scope;
     });
 }
 /**
@@ -147,12 +149,27 @@ export function localScopePredicate(table, effective) {
         .join(' AND ');
     return { sql, params };
 }
+function scopedRows(db, table, scope) {
+    return scope
+        ? db.query(`SELECT ${quoteIdent(table.primaryKey)} AS id FROM ${quoteIdent(table.name)} WHERE ${scope.sql}`, scope.params)
+        : [];
+}
+function bootstrapScope(db, table, effective) {
+    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)))));
+    return rows.map((row) => JSON.stringify([table.name, String(row.id)]));
+}
 export function deleteScopedRows(db, table, effective) {
     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);
@@ -287,18 +304,37 @@ export async function applySqliteSegment(db, schema, table, bytes, descriptor, o
                 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(`INSERT INTO ${quoteIdent(table.name)}(${insertNames.join(', ')})SELECT ${[...names, quoteIdent('_syncular_version')].join(', ')} FROM ${source} WHERE ${predicates.join(' AND ') || 'true'} ON CONFLICT(${primaryKey})DO UPDATE SET ${updates}`, 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]),
-                    ])), 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]),
+                        ])), Number(row._syncular_version));
+                    }
+                return scope;
             });
             options.onProgress?.(applied);
             await yieldToHost();
@@ -347,7 +383,18 @@ export async function applyRowsSegment(db, schema, table, segment, options, encr
         if (!clearThisBlock && rows.length === 0)
             continue;
         (options.transaction ?? ((fn) => db.transaction(fn)))(() => {
-            const protectedRows = restoreFailedBases(db, schema);
+            const scope = 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);
             }
@@ -357,6 +404,7 @@ export async function applyRowsSegment(db, schema, table, segment, options, encr
                 if (applied % 1024 === 0)
                     options.onProgress?.(applied);
             }
+            return scope;
         });
         options.onProgress?.(applied);
         await yieldToHost();

package/dist/blob.d.ts

@@ -1,3 +1,4 @@
+export declare const BLOB_COMMIT_REFS = "_syncular_blob_commit_refs";
 /**
  * Client-side blob cache + transport (SPEC.md §5.9.7).
  *

package/dist/blob.js

@@ -1,3 +1,4 @@
+export const BLOB_COMMIT_REFS = '_syncular_blob_commit_refs';
 /**
  * Client-side blob cache + transport (SPEC.md §5.9.7).
  *
@@ -70,7 +71,7 @@ export function enforceBlobCacheCap(db, schema, maxBytes) {
     if (total <= maxBytes)
         return [];
     // Oldest eligible body first, with blob ID as a stable tie.
-    const candidates = db.query(`SELECT blob_id,byte_length FROM _syncular_blobs WHERE blob_id NOT IN(SELECT blob_id FROM _syncular_blob_uploads)AND blob_id NOT IN(SELECT blob_id FROM _syncular_blob_commit_refs)AND blob_id NOT IN(${visibleBlobIdsSql(schema)})ORDER BY created_at_ms ASC,blob_id ASC`);
+    const candidates = db.query(`SELECT blob_id,byte_length FROM _syncular_blobs WHERE blob_id NOT IN(SELECT blob_id FROM _syncular_blob_uploads)AND blob_id NOT IN(SELECT blob_id FROM ${BLOB_COMMIT_REFS})AND blob_id NOT IN(${visibleBlobIdsSql(schema)})ORDER BY created_at_ms ASC,blob_id ASC`);
     const evicted = [];
     db.transaction(() => {
         for (const row of candidates) {
@@ -86,7 +87,7 @@ export function enforceBlobCacheCap(db, schema, maxBytes) {
 }
 export function listPendingUploads(db) {
     return db
-        .query('SELECT blob_id,media_type FROM(SELECT blob_id,media_type,created_at_ms FROM _syncular_blob_uploads UNION ALL SELECT DISTINCT r.blob_id,b.media_type,9223372036854775807 AS created_at_ms FROM _syncular_blob_commit_refs r LEFT JOIN _syncular_blobs b ON b.blob_id=r.blob_id WHERE NOT EXISTS(SELECT 1 FROM _syncular_blob_uploads u WHERE u.blob_id=r.blob_id))ORDER BY created_at_ms,blob_id')
+        .query(`SELECT blob_id,media_type FROM(SELECT blob_id,media_type,created_at_ms FROM _syncular_blob_uploads UNION ALL SELECT DISTINCT r.blob_id,b.media_type,9223372036854775807 AS created_at_ms FROM ${BLOB_COMMIT_REFS} r LEFT JOIN _syncular_blobs b ON b.blob_id=r.blob_id WHERE NOT EXISTS(SELECT 1 FROM _syncular_blob_uploads u WHERE u.blob_id=r.blob_id))ORDER BY created_at_ms,blob_id`)
         .map((row) => {
         if (typeof row.blob_id !== 'string' ||
             (row.media_type !== null && typeof row.media_type !== 'string')) {
@@ -138,6 +139,6 @@ function visibleBlobIdsSql(schema) {
         : selects.join(' UNION ');
 }
 export function deleteUnreferencedCachedBlobs(db, schema) {
-    db.exec(`DELETE FROM _syncular_blobs WHERE blob_id NOT IN(SELECT blob_id FROM _syncular_blob_uploads)AND blob_id NOT IN(SELECT blob_id FROM _syncular_blob_commit_refs)AND blob_id NOT IN(${visibleBlobIdsSql(schema)})`);
+    db.exec(`DELETE FROM _syncular_blobs WHERE blob_id NOT IN(SELECT blob_id FROM _syncular_blob_uploads)AND blob_id NOT IN(SELECT blob_id FROM ${BLOB_COMMIT_REFS})AND blob_id NOT IN(${visibleBlobIdsSql(schema)})`);
 }
 export { parseBlobRef, serializeBlobRef };

package/dist/client.d.ts

@@ -104,6 +104,7 @@ export interface SyncClientLimits {
     readonly outcomeRetentionMaxEntries?: number;
 }
 export interface SyncClientConfig {
+    readonly transportEnabled?: boolean;
     /** Keep rejected/conflicting local intent visible until explicit resolution. */
     readonly retainFailedCommits?: boolean;
     readonly database: ClientDatabase;
@@ -295,6 +296,8 @@ export declare class SyncClient {
     /** Acquire leadership, create local tables, resolve the clientId. */
     start(): Promise<void>;
     close(): Promise<void>;
+    /** Host-owned transport policy; the local replica remains available. */
+    setTransportEnabled(enabled: boolean): void;
     /** Current fail-closed local-replica security state. */
     securityLifecycle(): SecurityLifecycle;
     /**