@abloatai/ablo 0.35.0 → 0.36.0

package/dist/BaseSyncedStore.d.ts

@@ -19,11 +19,13 @@ import type { Database, BootstrapResult } from './Database.js';
 import type { InstanceCache } from './InstanceCache.js';
 import { ModelRegistry } from './ModelRegistry.js';
 import { SyncWebSocket, type SyncDelta, type SyncGroupChangePayload, type GroupAddedPayload, type GroupRemovedPayload, type BootstrapHint, type BootstrapDataEvent, type PresenceUpdate, type EventMap, type DefaultCollaborationEvents, type SyncWebSocketEventMap } from './sync/SyncWebSocket.js';
-import { QueryProcessor } from './core/QueryProcessor.js';
+import { QueryProcessor } from './query/QueryProcessor.js';
 import { Model } from './Model.js';
+import type { RuntimeContext } from './RuntimeContext.js';
+import type { AbloPlugin, AppliedChange } from './transaction/plugin.js';
 import { ModelScope } from './InstanceCache.js';
 import type { Schema } from './transaction/schema/schema.js';
-import type { SyncStatus, LocalMutation } from './core/storeContract.js';
+import type { SyncStatus, LocalMutation } from './storeContract.js';
 import type { AuthCredentialSource } from './transaction/auth/credentialSource.js';
 import type { ModelData } from './transaction/types/modelData.js';
 import type { EnrichmentPlanEntry, ForeignKeyIndexSpec } from './sync/syncPlan.js';
@@ -75,7 +77,7 @@ export interface SyncedStoreConfig {
      */
     foreignKeyIndexes?: readonly ForeignKeyIndexSpec[];
 }
-export type { SyncStatus } from './core/storeContract.js';
+export type { SyncStatus } from './storeContract.js';
 /** User context for initialization */
 export interface UserContext {
     userId: string;
@@ -162,6 +164,10 @@ export { deriveSyncPlanFromSchema } from './sync/syncPlan.js';
  */
 export declare class BaseSyncedStore<TCollaboration extends EventMap<TCollaboration> = DefaultCollaborationEvents, TSchema extends Schema = Schema> {
     syncStatus: SyncStatus;
+    /** The owning client's runtime; the module-global bridge when constructed directly. */
+    protected readonly runtime: RuntimeContext;
+    /** The installed plugins the delta pipeline dispatches stage handlers to. */
+    protected readonly stagePlugins: readonly AbloPlugin[];
     protected readonly syncClient: SyncClient;
     protected readonly database: Database;
     protected readonly objectPool: InstanceCache;
@@ -307,6 +313,14 @@ export declare class BaseSyncedStore<TCollaboration extends EventMap<TCollaborat
         url?: string;
         /** Shared bearer credential source for every auth-aware transport. */
         auth?: AuthCredentialSource;
+        /** The owning client's runtime. Defaults to the module-global bridge. */
+        runtime?: RuntimeContext;
+        /**
+         * The installed plugins, whose declared stage handlers the delta
+         * pipeline dispatches. Empty on direct construction — the store's own
+         * apply is then the whole pipeline.
+         */
+        stagePlugins?: readonly AbloPlugin[];
     }, config?: SyncedStoreConfig);
     /**
      * Register foreign-key indexes for constant-time lookups.
@@ -411,7 +425,7 @@ export declare class BaseSyncedStore<TCollaboration extends EventMap<TCollaborat
     waitForConfirmation(modelName: string, modelId: string): Promise<void>;
     /**
      * Observe the LOCAL mutation stream for undo recording (see
-     * {@link import('./core/storeContract.js').LocalMutation}). Taps the
+     * {@link import('./storeContract.js').LocalMutation}). Taps the
      * MutationQueue's `transaction:created` event — fired once per local
      * create/update/delete/archive with `previousData` already captured.
      * Remote/collaborator deltas apply via `applyDeltaBatchToPool` and never
@@ -649,6 +663,12 @@ export declare class BaseSyncedStore<TCollaboration extends EventMap<TCollaborat
      *  read the live host fields). */
     private _deltaPipelineContext;
     private get deltaPipelineContext();
+    /**
+     * Lands persisted changes in the in-memory pool, with this store's
+     * relation enrichment bound. The one apply path: the pipeline's bridge
+     * (no plugins installed) and the `humans()` apply handler both call it.
+     */
+    applyChangesToPool(changes: readonly AppliedChange[]): void;
     /** Get fields that represent meaningful state for deduplication. Override for model-specific fields. */
     protected getStateFields(_modelName: string): string[];
     /** Deduplicate deltas to the same entity — keep meaningful state transitions only */

package/dist/BaseSyncedStore.js

@@ -19,9 +19,9 @@ import { resolveParticipantSyncGroups, } from './sync/participants.js';
 import { ModelRegistry } from './ModelRegistry.js';
 import { PropertyType } from './transaction/types/index.js';
 import { SyncWebSocket, } from './sync/SyncWebSocket.js';
-import { QueryProcessor } from './core/QueryProcessor.js';
+import { QueryProcessor } from './query/QueryProcessor.js';
 import { Model, rowAsModel } from './Model.js';
-import { getContext } from './context.js';
+import { globalRuntime } from './context.js';
 import { AbloSessionError, isAccessCredentialExpiryCloseReason } from './transaction/errors.js';
 import { ModelScope } from './InstanceCache.js';
 import { LazyReferenceCollection } from './LazyReferenceCollection.js';
@@ -84,6 +84,10 @@ export class BaseSyncedStore {
         isSessionError: false,
     };
     // ── Injected dependencies ──
+    /** The owning client's runtime; the module-global bridge when constructed directly. */
+    runtime;
+    /** The installed plugins the delta pipeline dispatches stage handlers to. */
+    stagePlugins;
     syncClient;
     database;
     objectPool;
@@ -203,7 +207,7 @@ export class BaseSyncedStore {
                     this.hydratedGroups.add(g);
             }
             catch (err) {
-                getContext().logger.debug('[BaseSyncedStore] scoped hydrate failed', {
+                this.runtime.logger.debug('[BaseSyncedStore] scoped hydrate failed', {
                     syncGroups: need,
                     error: err instanceof Error ? err.message : String(err),
                 });
@@ -280,6 +284,8 @@ export class BaseSyncedStore {
     modelTypesHydrated = new Set();
     modelTypeHydrationInFlight = new Map();
     constructor(dependencies, config = {}) {
+        this.runtime = dependencies.runtime ?? globalRuntime;
+        this.stagePlugins = dependencies.stagePlugins ?? [];
         this.syncClient = dependencies.syncClient;
         this.database = dependencies.database;
         this.objectPool = dependencies.objectPool;
@@ -516,7 +522,7 @@ export class BaseSyncedStore {
     }
     /**
      * Observe the LOCAL mutation stream for undo recording (see
-     * {@link import('./core/storeContract.js').LocalMutation}). Taps the
+     * {@link import('./storeContract.js').LocalMutation}). Taps the
      * MutationQueue's `transaction:created` event — fired once per local
      * create/update/delete/archive with `previousData` already captured.
      * Remote/collaborator deltas apply via `applyDeltaBatchToPool` and never
@@ -563,18 +569,18 @@ export class BaseSyncedStore {
                 // negation false-positives every server-side bootstrap (e.g. the
                 // server-side agent.run dispatch path through `connectAgent`).
                 if (typeof navigator !== 'undefined' && navigator.onLine === false) {
-                    getContext().observability.breadcrumb(`Bootstrap attempt ${attempt} skipped - offline`, 'sync.bootstrap', 'warning');
+                    this.runtime.observability.breadcrumb(`Bootstrap attempt ${attempt} skipped - offline`, 'sync.bootstrap', 'warning');
                     throw new AbloConnectionError('Bootstrap skipped - device is offline', {
                         code: 'bootstrap_offline',
                     });
                 }
                 try {
-                    getContext().logger.info(`[BaseSyncedStore] Bootstrap attempt ${attempt}/${BOOTSTRAP_CONFIG.MAX_RETRY_ATTEMPTS}`);
+                    this.runtime.logger.info(`[BaseSyncedStore] Bootstrap attempt ${attempt}/${BOOTSTRAP_CONFIG.MAX_RETRY_ATTEMPTS}`);
                     const result = (await Promise.race([
                         bootstrapFn(),
                         this.createBootstrapTimeout(attempt),
                     ]));
-                    getContext().logger.info('[BaseSyncedStore] Bootstrap completed successfully', { attempt });
+                    this.runtime.logger.info('[BaseSyncedStore] Bootstrap completed successfully', { attempt });
                     return result;
                 }
                 catch (error) {
@@ -587,12 +593,12 @@ export class BaseSyncedStore {
                     if (AbloSessionError.isSessionError(error))
                         throw error;
                     if (isNetworkError && typeof navigator !== 'undefined' && navigator.onLine === false) {
-                        getContext().observability.captureBootstrapFailure(error, { type: 'network-offline' });
+                        this.runtime.observability.captureBootstrapFailure(error, { type: 'network-offline' });
                         throw error;
                     }
-                    getContext().observability.breadcrumb(`Bootstrap attempt ${attempt} failed`, 'sync.bootstrap', 'warning', { isTimeout, isNetworkError, willRetry: attempt < BOOTSTRAP_CONFIG.MAX_RETRY_ATTEMPTS });
+                    this.runtime.observability.breadcrumb(`Bootstrap attempt ${attempt} failed`, 'sync.bootstrap', 'warning', { isTimeout, isNetworkError, willRetry: attempt < BOOTSTRAP_CONFIG.MAX_RETRY_ATTEMPTS });
                     if (isTimeout && attempt < BOOTSTRAP_CONFIG.MAX_RETRY_ATTEMPTS) {
-                        getContext().logger.info('[BaseSyncedStore] Resetting state before bootstrap retry');
+                        this.runtime.logger.info('[BaseSyncedStore] Resetting state before bootstrap retry');
                         this.resetBootstrapState();
                         await new Promise((resolve) => setTimeout(resolve, BOOTSTRAP_CONFIG.RETRY_DELAY_MS));
                     }
@@ -666,10 +672,10 @@ export class BaseSyncedStore {
             // is stale — clear it so re-entered groups backfill again.
             this.hydratedGroups.clear();
             this.hydratingGroups.clear();
-            getContext().logger.info('[BaseSyncedStore] Bootstrap state reset complete');
+            this.runtime.logger.info('[BaseSyncedStore] Bootstrap state reset complete');
         }
         catch {
-            getContext().observability.breadcrumb('Error resetting bootstrap state', 'sync.bootstrap', 'warning');
+            this.runtime.observability.breadcrumb('Error resetting bootstrap state', 'sync.bootstrap', 'warning');
         }
     }
     // ── Reconnection ─────────────────────────────────────────────────────────
@@ -698,7 +704,7 @@ export class BaseSyncedStore {
             return 'success';
         }
         catch (error) {
-            getContext().observability.captureBootstrapFailure(error, { type: 'connection-store-reconnect' });
+            this.runtime.observability.captureBootstrapFailure(error, { type: 'connection-store-reconnect' });
             if (AbloSessionError.isSessionError(error)) {
                 this.syncWebSocket.setSessionErrorDetected();
                 this.syncWebSocket.disconnect();
@@ -717,13 +723,13 @@ export class BaseSyncedStore {
                     const hydratedSize = this.objectPool.size;
                     if (hydratedSize > 0) {
                         this.dataReady = true;
-                        getContext().logger.info('[BaseSyncedStore] Hydrated from local fallback', {
+                        this.runtime.logger.info('[BaseSyncedStore] Hydrated from local fallback', {
                             objectPoolSize: hydratedSize,
                         });
                     }
                 }
                 catch (fallbackError) {
-                    getContext().logger.debug('[BaseSyncedStore] Local fallback failed', {
+                    this.runtime.logger.debug('[BaseSyncedStore] Local fallback failed', {
                         error: fallbackError.message,
                     });
                 }
@@ -792,6 +798,7 @@ export class BaseSyncedStore {
     /** Narrow context the group-change leaf talks back through. */
     groupChangeContext() {
         return {
+            runtime: this.runtime,
             database: this.database,
             objectPool: this.objectPool,
             getSubscribedSyncGroups: () => this.syncWebSocket.getSyncGroups(),
@@ -861,6 +868,7 @@ export class BaseSyncedStore {
     poolContext() {
         const store = this;
         return {
+            runtime: this.runtime,
             applyDeltaBatchToPool: (results) => {
                 this.syncClient.applyDeltaBatchToPool(results, (name, data) => this.enrichRelations(name, data));
             },
@@ -901,8 +909,8 @@ export class BaseSyncedStore {
                 hasLocalData = this.objectPool.size > 0;
             }
             catch (hydrateError) {
-                getContext().logger.debug('[sync-engine] IDB hydration failed', { error: hydrateError });
-                getContext().observability.captureBootstrapFailure(hydrateError, { type: 'hydration-from-idb' });
+                this.runtime.logger.debug('[sync-engine] IDB hydration failed', { error: hydrateError });
+                this.runtime.observability.captureBootstrapFailure(hydrateError, { type: 'hydration-from-idb' });
             }
             // Get sync baseline for WebSocket
             const lastSyncId = (yield this.database.getLastSyncId());
@@ -925,7 +933,7 @@ export class BaseSyncedStore {
             // delta flow works regardless of this branch.
             const requirements = (yield this.database.requiredBootstrap());
             if (context.bootstrapMode === 'none') {
-                getContext().logger.info('[BaseSyncedStore] Bootstrap skipped (bootstrapMode=none)', { kind: context.kind ?? 'user' });
+                this.runtime.logger.info('[BaseSyncedStore] Bootstrap skipped (bootstrapMode=none)', { kind: context.kind ?? 'user' });
                 // `setupWebSocketSync` above creates the SyncWebSocket and
                 // initiates the upgrade, but it does NOT await the 'connected'
                 // event — it returns synchronously after wiring listeners.
@@ -952,7 +960,7 @@ export class BaseSyncedStore {
                     // delta-queue replay in withDeltaQueuing's finally (and the error
                     // handler itself), which would otherwise vanish unhandled.
                     void this.performBackgroundBootstrap(requirements, context, signal).catch((error) => {
-                        getContext().observability.captureBootstrapFailure(error, {
+                        this.runtime.observability.captureBootstrapFailure(error, {
                             type: 'background-orchestration',
                         });
                     });
@@ -984,7 +992,7 @@ export class BaseSyncedStore {
                 return { success: false, error: error };
             }
             const isSession = AbloSessionError.isSessionError(error);
-            getContext().observability.captureBootstrapFailure(error, { type: 'initialize' });
+            this.runtime.observability.captureBootstrapFailure(error, { type: 'initialize' });
             if (isSession) {
                 this.syncWebSocket.setSessionErrorDetected();
                 this.syncWebSocket.disconnect();
@@ -1021,11 +1029,11 @@ export class BaseSyncedStore {
                 this.updateSyncStatus({ state: 'idle', progress: 100 });
             }
             catch (error) {
-                getContext().logger.debug('[sync-engine] Background bootstrap failed', {
+                this.runtime.logger.debug('[sync-engine] Background bootstrap failed', {
                     error: error instanceof Error ? error.message : String(error),
                     cause: error,
                 });
-                getContext().observability.captureBootstrapFailure(error, { type: 'background' });
+                this.runtime.observability.captureBootstrapFailure(error, { type: 'background' });
                 if (AbloSessionError.isSessionError(error)) {
                     this.syncWebSocket.setSessionErrorDetected();
                     this.syncWebSocket.disconnect();
@@ -1210,7 +1218,7 @@ export class BaseSyncedStore {
                     return;
                 resolved = true;
                 unsubscribe();
-                getContext().logger.debug(`[BaseSyncedStore] waitForWebSocketConnected timed out after ${timeoutMs}ms — initialize() will return but the next mutation may race the upgrade.`);
+                this.runtime.logger.debug(`[BaseSyncedStore] waitForWebSocketConnected timed out after ${timeoutMs}ms — initialize() will return but the next mutation may race the upgrade.`);
                 resolve(false);
             }, timeoutMs);
         });
@@ -1227,7 +1235,7 @@ export class BaseSyncedStore {
      */
     setupWebSocketSync(context, lastSyncId) {
         if (!context.userId || !context.organizationId) {
-            getContext().observability.breadcrumb('Cannot setup WebSocket sync without user context', 'sync.websocket', 'warning');
+            this.runtime.observability.breadcrumb('Cannot setup WebSocket sync without user context', 'sync.websocket', 'warning');
             return;
         }
         if (context.kind)
@@ -1280,7 +1288,7 @@ export class BaseSyncedStore {
             this.updateSyncStatus({ state: 'offline', offlineSince: new Date() });
         });
         const onReconnecting = this.syncWebSocket.subscribe('reconnecting', ({ attempt, delay }) => {
-            getContext().logger.info('[BaseSyncedStore] WebSocket reconnecting', { attempt, delay });
+            this.runtime.logger.info('[BaseSyncedStore] WebSocket reconnecting', { attempt, delay });
             this.updateSyncStatus({ state: 'reconnecting' });
         });
         // Delta events → feed into processing pipeline
@@ -1313,7 +1321,7 @@ export class BaseSyncedStore {
         // Terminal session loss (revocation / the login itself is gone): notify,
         // route the FSM to its terminal state, and clear local data.
         const handleTerminalSessionError = (error) => {
-            getContext().observability.captureWebSocketError({ context: 'session-error', error: error.message });
+            this.runtime.observability.captureWebSocketError({ context: 'session-error', error: error.message });
             this.onConnectionEvent?.('WS_SESSION_ERROR');
             for (const listener of this.sessionErrorListeners) {
                 try {
@@ -1326,8 +1334,8 @@ export class BaseSyncedStore {
             // When auth is revoked, locally cached data must not persist on disk.
             this.database.clear({ includeWriteJournal: true }).catch((clearErr) => {
                 // consumer register: session ended, but cached data may remain on disk
-                getContext().logger.error('Your session ended, but some locally cached data could not be cleared from this device.');
-                getContext().logger.debug('[BaseSyncedStore] Failed to clear database on session error', clearErr);
+                this.runtime.logger.error('Your session ended, but some locally cached data could not be cleared from this device.');
+                this.runtime.logger.debug('[BaseSyncedStore] Failed to clear database on session error', clearErr);
             });
             this.objectPool.clear();
         };
@@ -1342,7 +1350,7 @@ export class BaseSyncedStore {
             // through to the terminal path. Without this branch, every credential
             // TTL elapse wedged the socket behind the write-once session latch.
             if (AbloSessionError.isSessionError(error) && isAccessCredentialExpiryCloseReason(error.message)) {
-                getContext().observability.breadcrumb('WebSocket closed for expired access credential — re-minting', 'sync.websocket', 'warning');
+                this.runtime.observability.breadcrumb('WebSocket closed for expired access credential — re-minting', 'sync.websocket', 'warning');
                 // Un-latch BEFORE the async mint so the FSM's own recovery
                 // (probe → refreshing_credential → reconnect) is never blocked on
                 // our .then() ordering.
@@ -1390,8 +1398,8 @@ export class BaseSyncedStore {
         });
         const onReconnectFailed = this.syncWebSocket.subscribe('reconnect_failed', ({ attempts }) => {
             // consumer register: reconnection exhausted — the app is now offline
-            getContext().logger.warn('Lost connection to the sync service and could not reconnect. Your app is now offline; changes will sync once the connection is restored.');
-            getContext().logger.debug('[BaseSyncedStore] WebSocket reconnection gave up', { attempts });
+            this.runtime.logger.warn('Lost connection to the sync service and could not reconnect. Your app is now offline; changes will sync once the connection is restored.');
+            this.runtime.logger.debug('[BaseSyncedStore] WebSocket reconnection gave up', { attempts });
             this.updateSyncStatus({ state: 'reconnecting' });
         });
         this.disposers.push(onConnected, onDisconnected, onReconnecting, onDelta, onDeltaBatch, onBootstrapRequired, onBootstrapData, onPresenceUpdate, onError, onSessionError, onHandshakeFailed, onReconnectFailed, () => { this.areaOfInterest.dispose(); });
@@ -1513,6 +1521,8 @@ export class BaseSyncedStore {
             return this._deltaPipelineContext;
         const store = this;
         this._deltaPipelineContext = {
+            runtime: this.runtime,
+            stagePlugins: this.stagePlugins,
             // Shared pipeline state, backed by the host fields.
             get pendingDeltas() { return store.pendingDeltas; },
             set pendingDeltas(deltas) { store.pendingDeltas = deltas; },
@@ -1530,9 +1540,7 @@ export class BaseSyncedStore {
             advancePersisted: (syncId) => { this.syncClient.position.advancePersisted(syncId); },
             // Persistence + pool writes.
             processDeltaBatch: (deltas) => this.database.processDeltaBatch(deltas),
-            applyDeltaBatchToPool: (results) => {
-                this.syncClient.applyDeltaBatchToPool(results, (name, data) => this.enrichRelations(name, data));
-            },
+            applyDeltaBatchToPool: (results) => { this.applyChangesToPool(results); },
             acknowledge: (syncId) => { this.syncWebSocket.acknowledge(syncId); },
             get objectPool() { return store.objectPool; },
             // Dynamic-dispatch hooks — protected override points on this class.
@@ -1551,6 +1559,14 @@ export class BaseSyncedStore {
         };
         return this._deltaPipelineContext;
     }
+    /**
+     * Lands persisted changes in the in-memory pool, with this store's
+     * relation enrichment bound. The one apply path: the pipeline's bridge
+     * (no plugins installed) and the `humans()` apply handler both call it.
+     */
+    applyChangesToPool(changes) {
+        this.syncClient.applyDeltaBatchToPool(changes, (name, data) => this.enrichRelations(name, data));
+    }
     /** Get fields that represent meaningful state for deduplication. Override for model-specific fields. */
     getStateFields(_modelName) {
         return ['status', 'state', 'isActive'];
@@ -1663,7 +1679,7 @@ export class BaseSyncedStore {
             }
         }
         if (totalCancelled > 0) {
-            getContext().logger.info('[BaseSyncedStore] Cascade cancelled orphaned transactions', {
+            this.runtime.logger.info('[BaseSyncedStore] Cascade cancelled orphaned transactions', {
                 parentModel: parentModelName,
                 parentId: parentId.slice(0, 12),
                 totalCancelled,
@@ -1843,13 +1859,13 @@ export class BaseSyncedStore {
     }
     /** Error handler for fire-and-forget flushPendingDeltas calls */
     handleFlushError = (error) => {
-        getContext().observability.captureMutationFailure({
+        this.runtime.observability.captureMutationFailure({
             context: 'flush-pending-deltas',
             modelName: 'batch',
             modelId: 'batch',
             error: error instanceof Error ? error : new Error(String(error)),
         });
-        getContext().logger.debug('[BaseSyncedStore] Delta flush error', {
+        this.runtime.logger.debug('[BaseSyncedStore] Delta flush error', {
             error: error instanceof Error ? error.message : String(error),
         });
     };

package/dist/Database.d.ts

@@ -5,9 +5,11 @@
  * server. {@link BaseSyncedStore} drives it, and {@link InstanceCache} holds the
  * in-memory mirror of what this class persists.
  */
-import { type DatabaseInfo, type WorkspaceMetadata } from './core/DatabaseManager.js';
+import { type DatabaseInfo, type WorkspaceMetadata } from './stores/DatabaseManager.js';
 import { ModelRegistry } from './ModelRegistry.js';
 import { LoadStrategy } from './transaction/types/index.js';
+import type { RuntimeContext } from './RuntimeContext.js';
+import type { AppliedChange } from './transaction/plugin.js';
 import type { BootstrapFetcher, BootstrapData } from './sync/BootstrapFetcher.js';
 import { InMemoryObjectStore } from './adapters/inMemoryStorage.js';
 import type { SyncDeltaAction } from './transaction/wire/delta.js';
@@ -68,12 +70,7 @@ export interface BootstrapResult {
      * was disconnected — without this, DELETE deltas persist to IDB but
      * ghost entities linger in the pool until a full reload.
      */
-    deltaResults?: {
-        action: 'add' | 'update' | 'remove' | 'archive' | 'verify';
-        modelName: string;
-        modelId: string;
-        data?: ModelData | null;
-    }[];
+    deltaResults?: AppliedChange[];
 }
 export declare class Database {
     private databaseManager;
@@ -115,12 +112,14 @@ export declare class Database {
      *   new Database(registry, bootstrap, { inMemory: true })
      */
     private readonly inMemory;
+    private readonly runtime;
     /** In-memory stores used when inMemory=true. Keyed by model name. */
     private inMemoryStores;
     /** In-memory workspace metadata when inMemory=true. */
     private inMemoryMetadata;
     constructor(modelRegistry: ModelRegistry, bootstrapHelper: BootstrapFetcher, options?: {
         inMemory?: boolean;
+        runtime?: RuntimeContext;
     });
     /**
      * Get store for a model, or `undefined` if no store exists.
@@ -196,12 +195,7 @@ export declare class Database {
         modelName: string;
         modelId: string;
         data: ModelData | null;
-    }): Promise<{
-        action: 'add' | 'update' | 'remove' | 'archive' | 'verify';
-        modelName: string;
-        modelId: string;
-        data?: ModelData | null;
-    }>;
+    }): Promise<AppliedChange>;
     /**
      * Apply many deltas to the local store in as few IndexedDB transactions as
      * possible. Deltas are grouped by store, and each store's writes commit in a
@@ -240,13 +234,7 @@ export declare class Database {
          */
         transactionId?: string;
     }[]): Promise<{
-        results: {
-            action: 'add' | 'update' | 'remove' | 'archive' | 'verify';
-            modelName: string;
-            modelId: string;
-            data?: ModelData | null;
-            transactionId?: string;
-        }[];
+        results: AppliedChange[];
         /**
          * Highest syncId whose IDB store transaction actually committed in this
          * batch. The runtime delta cursor (WS `lastSyncId`, server-side