@abloatai/ablo 0.25.0 → 0.27.0

package/dist/ModelRegistry.js

@@ -1,13 +1,11 @@
 /**
- * ModelRegistry - Type-safe model metadata management
- *
- * Key improvements:
- * - Instance-based for better testing
- * - Validation at registration
- * - Lazy reference resolution
- * - Crypto-based schema hashing
- * - Comprehensive error reporting
- * - Best practices from Linear Sync Engine
+ * ModelRegistry is the source of truth for model metadata: which model classes
+ * exist, the properties and references declared on each, the back-references
+ * used for cascade handling, and a stable hash of the whole schema.
+ * {@link Model} instances resolve their metadata through the active registry,
+ * and {@link InstanceCache} uses it to map between model names and constructor
+ * classes. References resolve lazily, so a model may declare a reference to
+ * another model that is registered later.
  */
 // Removed Node.js crypto import for browser compatibility
 import { PropertyType, LoadStrategy, } from './types/index.js';
@@ -43,17 +41,17 @@ export class ModelRegistry {
     properties = new Map();
     references = new Map();
     pendingReferences = new Map();
-    // 🔧 PROPER FIX: Static mapping from constructor to model name
+    // Maps a constructor back to its model name. Keyed as `unknown` on purpose:
+    // lookups arrive both as `this.constructor` (a Function) and as typed model
+    // classes, and both are accepted without a cast.
     constructorToModelName = new Map();
-    // LINEAR PATTERN: BackReferences for cascade-aware transaction handling.
-    // Maps childModelName → BackReferenceMetadata[] (which parent models
-    // own this child). The inverse direction (parentModelName → children)
-    // is derived on demand by `getChildModels`, populated only here.
+    // Back-references for cascade-aware transaction handling. Maps a child model
+    // name to the parent models it references. The inverse direction (parent to
+    // children) is derived on demand by `getChildModels`; it is populated here.
     backReferences = new Map();
     schemaHash;
     config;
     registeredModels = new Set();
-    batchMode = false;
     pendingHashUpdate = false;
     constructor(config = {}) {
         this.config = {
@@ -65,13 +63,14 @@ export class ModelRegistry {
         if (typeof constructor !== 'function') {
             throw new AbloValidationError(`Model ${name} constructor must be a function`, { code: 'registry_invalid_constructor' });
         }
-        if (!constructor.prototype) {
+        const prototype = constructor.prototype;
+        if (!prototype || typeof prototype !== 'object') {
             throw new AbloValidationError(`Model ${name} constructor must have a prototype`, { code: 'registry_invalid_constructor' });
         }
         // Check for required methods
         const required = ['updateFromData', 'toJSON', 'getModelName'];
         for (const method of required) {
-            if (typeof constructor.prototype[method] !== 'function') {
+            if (typeof prototype[method] !== 'function') {
                 getContext().logger.debug('Model missing required method', name, { method });
             }
         }
@@ -159,10 +158,14 @@ export class ModelRegistry {
             return;
         }
         getContext().logger.debug('Registering model', name);
-        // Register
-        this.models.set(name, constructor);
+        // Register. The one cast in this file: input is any Model-subclass
+        // constructor (validated above); registered classes are concrete
+        // subclasses constructible with `data?` and carrying Model's statics —
+        // the shape `RegisteredModelClass` names for every read site.
+        const modelClass = constructor;
+        this.models.set(name, modelClass);
         this.modelMetadata.set(name, metadata);
-        // 🔧 PROPER FIX: Create reverse mapping from constructor to model name
+        // Record the reverse mapping from constructor to model name
         this.constructorToModelName.set(constructor, name);
         // Initialize property maps
         if (!this.properties.has(name)) {
@@ -239,13 +242,14 @@ export class ModelRegistry {
         this.completeReferenceRegistration(modelName, propertyName, metadata);
     }
     /**
-     * LINEAR PATTERN: Register a back-reference for cascade-aware transaction handling
+     * Register a back-reference for cascade-aware transaction handling.
      *
-     * When a parent model is deleted, the TransactionQueue will cancel pending
-     * transactions for all child models that have a backReference to that parent.
+     * When a parent model is deleted, the transaction queue cancels pending
+     * transactions for every child model that declares a back-reference to that
+     * parent.
      *
-     * @param childModelName - The model that has a FK to the parent (e.g., 'Slide')
-     * @param metadata - BackReference configuration
+     * @param childModelName - The model that holds a foreign key to the parent (e.g., 'Slide')
+     * @param metadata - The back-reference configuration
      */
     registerBackReference(childModelName, metadata) {
         // Add to instance map
@@ -291,7 +295,6 @@ export class ModelRegistry {
         return Array.from(this.models.keys());
     }
     /** Get model constructor by name */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     getModelByName(name) {
         return this.models.get(name);
     }
@@ -339,7 +342,9 @@ export class ModelRegistry {
         return children;
     }
     /**
-     * Calculate schema hash using crypto
+     * Compute a stable hash of the registered schema — model names, property
+     * types, and their indexed and optional flags. Memoized until the schema
+     * changes.
      */
     getSchemaHash() {
         if (this.schemaHash)
@@ -422,7 +427,6 @@ export class ModelRegistry {
      * Start batch registration mode to optimize performance
      */
     startBatch() {
-        this.batchMode = true;
         this.pendingHashUpdate = false;
     }
     /**
@@ -432,7 +436,6 @@ export class ModelRegistry {
      * End batch registration mode and update schema hash if needed
      */
     endBatch() {
-        this.batchMode = false;
         if (this.pendingHashUpdate) {
             this.getSchemaHash(); // This will recalculate if needed
             this.pendingHashUpdate = false;
@@ -454,7 +457,6 @@ export class ModelRegistry {
         this.backReferences.clear();
         this.constructorToModelName.clear();
         this.schemaHash = undefined;
-        this.batchMode = false;
         this.pendingHashUpdate = false;
         getContext().logger.info('ModelRegistry cleared');
     }

package/dist/NetworkMonitor.d.ts

@@ -1,10 +1,9 @@
 /**
- * NetworkMonitor - Network connectivity tracking with visibility awareness
- *
- * Monitors online/offline state using browser events AND visibility changes.
- * When a tab becomes visible after being hidden (e.g., laptop sleep/wake),
- * the WebSocket may have silently died without triggering online/offline events.
- * The visibility handler detects this and emits 'online' to trigger recovery.
+ * NetworkMonitor tracks network connectivity and reports it through events.
+ * It listens to the browser's online and offline events, and it also watches
+ * for a tab becoming visible again: after a laptop sleep/wake or a long spell
+ * in the background, the WebSocket can die silently without an offline event
+ * firing, so returning to the tab emits a recovery signal the store can act on.
  */
 import { EventEmitter } from 'events';
 export declare class NetworkMonitor extends EventEmitter {

package/dist/NetworkMonitor.js

@@ -1,10 +1,9 @@
 /**
- * NetworkMonitor - Network connectivity tracking with visibility awareness
- *
- * Monitors online/offline state using browser events AND visibility changes.
- * When a tab becomes visible after being hidden (e.g., laptop sleep/wake),
- * the WebSocket may have silently died without triggering online/offline events.
- * The visibility handler detects this and emits 'online' to trigger recovery.
+ * NetworkMonitor tracks network connectivity and reports it through events.
+ * It listens to the browser's online and offline events, and it also watches
+ * for a tab becoming visible again: after a laptop sleep/wake or a long spell
+ * in the background, the WebSocket can die silently without an offline event
+ * firing, so returning to the tab emits a recovery signal the store can act on.
  */
 import { EventEmitter } from 'events';
 import { getContext } from './context.js';
@@ -18,7 +17,7 @@ export class NetworkMonitor extends EventEmitter {
         super();
         this.setupListeners();
     }
-    handleOnline = async () => {
+    handleOnline = () => {
         const wasOffline = !this.isOnline;
         this.isOnline = true;
         this.lastOnlineCheck = new Date();

package/dist/SyncClient.d.ts

@@ -1,17 +1,17 @@
 /**
- * SyncClient - Mutation and offline queue manager
- *
- * Responsibilities:
- * - Handle model mutations (create, update, delete, archive)
- * - Manage offline mutation queue with persistence
- * - Send mutations to server via API client
- * - Handle conflict resolution for local changes
+ * Applies model mutations and manages the offline write queue. The
+ * SyncClient turns local create, update, delete, and archive calls into
+ * optimistic changes, holds them while the client is offline, sends them to
+ * the server when connectivity returns, and resolves conflicts when the
+ * server's version of a row disagrees with the local one. It sits between the
+ * reactive object pool and the {@link TransactionQueue} that delivers writes
+ * over the network.
  */
-import { ObjectPool } from './ObjectPool.js';
+import { InstanceCache } from './InstanceCache.js';
 import { Model } from './Model.js';
 import { EventEmitter } from 'events';
 import { TransactionQueue } from './transactions/TransactionQueue.js';
-import { type OptimisticEchoMetrics } from './transactions/OptimisticEchoTracker.js';
+import { type UnconfirmedWritesMetrics } from './transactions/UnconfirmedWrites.js';
 import type { Database } from './Database.js';
 import type { WriteOptions } from './interfaces/index.js';
 import { SyncPosition } from './sync/syncPosition.js';
@@ -50,33 +50,29 @@ export declare class SyncClient extends EventEmitter {
     private organizationId;
     private pendingMutations;
     /**
-     * Tracks transaction ids the client has optimistically applied but
-     * the server has not yet confirmed. The receive path consults it
-     * to recognize delta echoes of own mutations and suppress the
-     * (otherwise-redundant) pool mutation — the IDB write still runs
-     * because the delta is the authoritative version of the row.
+     * Tracks the ids of transactions the client has applied optimistically but
+     * the server has not yet confirmed. When a delta arrives, the receive path
+     * consults this set to recognize the echo of the client's own mutation and
+     * skip the now-redundant pool update; the IndexedDB write still runs,
+     * because the delta is the authoritative version of the row. Without this
+     * discriminator, an optimistically applied delete followed by a
+     * server-confirmed create echo would resurrect the row for the window
+     * between the two confirmations.
      *
-     * The receive-layer discriminator named in
-     * `apps/sync-server/docs/OPTIMISTIC_RECONCILIATION.md`. Without
-     * it, an optimistically-applied DELETE followed by a
-     * server-confirming CREATE echo resurrects the row for the window
-     * between the two confirmations (the chart-delete flicker).
-     *
-     * Bounded with FIFO eviction; observability via `getEchoMetrics()`.
+     * The set is bounded with first-in-first-out eviction, and
+     * {@link SyncClient.getEchoMetrics} exposes its counters.
      */
     private readonly echoTracker;
     private connectionState;
-    private offlineSince?;
-    private maxRetries;
     private isDisposed;
     /**
-     * THE client's place in the global delta order — the one canonical
-     * instance (see `sync/syncPosition.ts`). The store advances
-     * `applied`/`persisted` as deltas land; the queue advances `acked` on
-     * commit responses; snapshots/claims read `readFloor`.
+     * The client's position in the global delta order, held as the single
+     * canonical {@link SyncPosition} instance. The store advances `applied` and
+     * `persisted` as deltas land, the queue advances `acked` on commit
+     * responses, and snapshots and claims read `readFloor`.
      */
     readonly position: SyncPosition;
-    constructor(objectPool: ObjectPool, database: Database);
+    constructor(objectPool: InstanceCache, database: Database);
     /**
      * Setup network monitoring handlers
      */
@@ -104,19 +100,23 @@ export declare class SyncClient extends EventEmitter {
      */
     private setupTransactionRollbackHandling;
     /**
-     * Forward reconciliation requests from TransactionQueue to the sync layer.
-     * When delta confirmation times out, TransactionQueue emits 'reconciliation:needed'
-     * instead of rolling back — following the Replicache/PowerSync pattern of never
-     * destroying optimistic state that the server may have committed.
+     * Forward reconciliation requests from the {@link TransactionQueue} to the
+     * sync layer. When delta confirmation times out, the queue emits
+     * `reconciliation:needed` instead of rolling back, so optimistic state the
+     * server may already have committed is never destroyed.
      */
     private setupReconciliationForwarding;
     /**
-     * LINEAR PATTERN: Persist unconfirmed transactions to IndexedDB.
-     * When delta confirmation retries exhaust, the transaction data is cached in IDB
-     * so it survives tab close. On next session, WebSocket reconnect + delta catch-up
-     * will deliver the missing deltas and naturally confirm the transaction.
+     * Persist unconfirmed transactions to IndexedDB. When delta-confirmation
+     * retries are exhausted, the transaction is cached so it survives a tab
+     * close. On the next session, a WebSocket reconnect and delta catch-up
+     * deliver the missing deltas and confirm the transaction.
      */
     private setupAwaitingTransactionPersistence;
+    /** Persist an unconfirmed transaction to IndexedDB (never rejects — failures are captured). */
+    private persistAwaitingTransaction;
+    /** Drop the persisted awaiting-row once confirmed (never rejects). */
+    private removeAwaitingTransaction;
     /**
      * Initialize sync client with authentication
      */
@@ -131,7 +131,7 @@ export declare class SyncClient extends EventEmitter {
      * Self-healing helper for individual model records.
      *
      * Two registry-driven repair passes run on every row hydrated from
-     * IDB or merged from a delta:
+     * IndexedDB or merged from a delta:
      *
      * 1. **Auto-fill** — for each `autoFill` rule the consumer's schema
      *    declares on this model, copy the corresponding identity value
@@ -152,12 +152,12 @@ export declare class SyncClient extends EventEmitter {
         healed: boolean;
     } | null;
     /**
-     * Hydrate ObjectPool with data from Database
+     * Hydrate InstanceCache with data from Database
      * Called after bootstrap is complete
      */
     hydrateFromDatabase(): Promise<void>;
     /**
-     * Re-hydrate ObjectPool from IndexedDB when the pool already has data.
+     * Re-hydrate InstanceCache from IndexedDB when the pool already has data.
      *
      * Unlike hydrateFromDatabase() (which uses addBatch and skips existing IDs),
      * this method properly:
@@ -168,13 +168,14 @@ export declare class SyncClient extends EventEmitter {
      */
     rehydrateFromDatabase(): Promise<RehydrationStats>;
     /**
-     * Mutate model optimistically and queue for server sync.
-     * IndexedDB is only updated when server confirms via delta packet.
-     *
-     * CRITICAL: Changes are captured BEFORE poolAction to prevent data loss.
-     * The captured changes are frozen and passed to queueMutation.
+     * Apply a mutation to a model optimistically and queue it for server sync.
+     * IndexedDB is updated only once the server confirms the change with a delta
+     * packet.
      *
-     * @see src/sync-engine/types/TrackableModel.ts for change capture pattern
+     * A model's changes are captured before the pool action runs, because a pool
+     * operation such as an upsert can clear the model's local change set;
+     * capturing first ensures those changes are never lost. The captured set is
+     * frozen and handed to {@link queueMutation}.
      */
     private mutate;
     private pendingChangedTypes;
@@ -206,8 +207,9 @@ export declare class SyncClient extends EventEmitter {
      */
     private clearPendingMutationsForModel;
     /**
-     * Upload file and create attachment (UPLOAD operation)
-     * Uses Linear-style pattern with immediate URL generation
+     * Upload a file and create its attachment record. The upload runs through
+     * the {@link TransactionQueue}, and a model is built from the server's
+     * response and added to the pool.
      */
     uploadFile(file: File, options: {
         id: string;
@@ -235,16 +237,17 @@ export declare class SyncClient extends EventEmitter {
     /** Archive model (ARCHIVE) - works offline */
     archive(model: Model): void;
     /**
-     * Append a mutation and schedule its sync work.
+     * Append a mutation to the pending queue and schedule its sync work.
      *
-     * IDB persistence and the server push are deferred to a microtask so N
-     * pushes inside the same tick collapse into ONE IDB serialization + ONE
-     * process call. Without the deferral, queueing 100 mutations (paste,
-     * PPTX import, AI sandbox layer creation) reserializes the entire
-     * growing queue 100× — O(N²) `model.toJSON()`.
+     * IndexedDB persistence and the server push are deferred to a microtask, so
+     * many pushes within the same tick collapse into a single serialization and
+     * a single process call. Without the deferral, queueing a hundred mutations
+     * at once — a large paste, a document import, bulk layer creation — would
+     * reserialize the whole growing queue a hundred times, an O(N²) cost in
+     * `model.toJSON()`.
      *
-     * @param mutation.capturedChanges - Pre-captured changes (frozen), used
-     *   to avoid re-reading changes after pool ops that might clear them.
+     * @param mutation.capturedChanges - Pre-captured, frozen changes, used to
+     *   avoid re-reading a model after pool operations that might clear them.
      */
     private queueMutation;
     private syncScheduled;
@@ -254,7 +257,13 @@ export declare class SyncClient extends EventEmitter {
      */
     private persistMutationQueue;
     /**
-     * Restore mutation queue from IndexedDB
+     * Restore the mutation queue from IndexedDB.
+     *
+     * The persisted record was written by an earlier session, possibly by an
+     * older build of the SDK, so each entry is validated as it is replayed:
+     * corrupt entries are dropped and logged at debug level, and a failure is
+     * never swallowed silently, because the survival of offline writes must be
+     * observable.
      */
     private restoreMutationQueue;
     /**
@@ -272,16 +281,16 @@ export declare class SyncClient extends EventEmitter {
      */
     private stageMutation;
     /**
-     * Resolve conflicts between local and server data
-     * Used when processing deltas from WebSocket
-     *
-     * CRITICAL: Always respects certain server states (deletes, deactivations)
-     * even when there are local changes, to maintain data consistency.
+     * Resolve a conflict between the local model and incoming server data,
+     * called while processing deltas from the WebSocket. Certain server states,
+     * such as deletions and deactivations, always take precedence even when the
+     * local model has unsynced changes, so the two sides stay consistent.
      */
-    resolveConflicts(localModel: Model, serverData: any): Model;
+    resolveConflicts(localModel: Model, serverData: Record<string, unknown>): Model;
     /**
-     * Extract critical state fields from server data
-     * These are states that must always be respected, even with local changes
+     * Extract the critical state fields from server data. These are the states
+     * that must be honored even when the local model has unsynced changes. The
+     * conflict resolver reads exactly these fields and no others.
      */
     private extractCriticalState;
     /**
@@ -334,26 +343,26 @@ export declare class SyncClient extends EventEmitter {
      */
     dispose(): void;
     /**
-     * LINEAR PATTERN: Notify TransactionQueue of incoming delta for sync ID threshold confirmation.
-     * Transactions are confirmed when any delta with id >= their lastSyncId threshold arrives.
-     * @param syncId - The sync ID of the received delta
+     * Notify the {@link TransactionQueue} of an incoming delta so it can confirm
+     * transactions by sync-id threshold. A transaction is confirmed once any
+     * delta with an id at or beyond its `lastSyncId` threshold arrives.
+     * @param syncId - The sync id of the received delta.
      */
     onDeltaReceived(syncId: number): void;
     /**
-     * LINEAR PATTERN: Cancel transactions for orphaned child entities
-     *
-     * Called by SyncedStore when a DELETE delta arrives for a parent entity.
-     * Cancels pending transactions for children that reference the deleted parent.
+     * Cancel pending transactions for child entities orphaned by a parent's
+     * deletion. The store calls this when a delete delta arrives for a parent,
+     * cancelling any queued writes on children that reference it.
      *
-     * @param childModelName - The child model type (e.g., 'SlideLayer')
-     * @param foreignKey - The FK property name (e.g., 'slideId')
-     * @param parentId - The deleted parent's ID
-     * @returns Number of transactions cancelled
+     * @param childModelName - The child model type (for example, `SlideLayer`).
+     * @param foreignKey - The foreign-key property name (for example, `slideId`).
+     * @param parentId - The id of the deleted parent.
+     * @returns The number of transactions cancelled.
      */
     cancelTransactionsByForeignKey(childModelName: string, foreignKey: string, parentId: string): number;
     /**
-     * Wait for a transaction to be confirmed via delta echo (Linear pattern)
-     * Delegates to TransactionQueue which already handles timeouts
+     * Wait for a transaction to be confirmed by its delta echo. Delegates to the
+     * {@link TransactionQueue}, which handles the confirmation timeout.
      */
     waitForDeltaConfirmation(transactionId: string): Promise<void>;
     /**
@@ -363,12 +372,12 @@ export declare class SyncClient extends EventEmitter {
     /**
      * Get sync statistics. Return type is inferred from the literal so
      * the call site sees the actual shape — `connectionState` narrowed
-     * to its three states, `objectPoolStats` typed by `ObjectPool.getStats`.
+     * to its three states, `objectPoolStats` typed by `InstanceCache.getStats`.
      */
     getSyncStats(): {
         connectionState: 'connected' | 'disconnected' | 'connecting';
         pendingMutations: number;
-        objectPoolStats: ReturnType<ObjectPool['getStats']>;
+        objectPoolStats: ReturnType<InstanceCache['getStats']>;
     };
     /**
      * Get pending transaction count from TransactionQueue
@@ -386,10 +395,10 @@ export declare class SyncClient extends EventEmitter {
      * can render typed UI (toast keyed by `AbloError.type`, route-level
      * "this entity reverted" boundaries, telemetry).
      *
-     * Distinct from `onTransactionEvent('failed', cb)`, which exists only
-     * for the legacy parameterless `pendingChanges` counter and intentionally
-     * drops the payload. The two coexist — keep the counter callback fast
-     * and the typed listener for user-visible surfaces.
+     * Distinct from `onTransactionEvent('failed', cb)`, which serves the
+     * parameterless `pendingChanges` counter and intentionally drops the
+     * payload. The two coexist: the counter callback stays lightweight, while
+     * this typed listener drives user-visible surfaces.
      */
     onMutationFailure(listener: (payload: {
         transaction: import('./transactions/TransactionQueue.js').Transaction;
@@ -397,15 +406,16 @@ export declare class SyncClient extends EventEmitter {
         permanent?: boolean;
     }) => void): () => void;
     /**
-     * Subscribe to LOCAL transaction creation with the full {@link Transaction}
+     * Subscribe to local transaction creation with the full {@link Transaction}
      * payload (`type`, `modelName`, `modelId`, `data`, `previousData`). This is
-     * the feed `BaseSyncedStore.subscribeLocalMutations` taps for undo recording.
+     * the feed the store's local-mutation subscription taps for undo recording.
      *
-     * MUST subscribe to the TransactionQueue's emitter directly — that is the
-     * ONLY emitter that fires `transaction:created`. SyncClient's own emitter
-     * (reached via `subscribe()`) never re-broadcasts it, so routing undo through
-     * `subscribe('transaction:created')` silently records nothing. Mirrors
-     * `onMutationFailure`, which taps the queue for the same reason.
+     * It subscribes to the {@link TransactionQueue}'s emitter directly, since
+     * that is the only emitter that fires `transaction:created`. The SyncClient's
+     * own emitter (reached through {@link subscribe}) never rebroadcasts that
+     * event, so routing undo through `subscribe('transaction:created')` would
+     * record nothing. {@link onMutationFailure} taps the queue for the same
+     * reason.
      */
     onLocalTransaction(listener: (tx: import('./transactions/TransactionQueue.js').Transaction) => void): () => void;
     /**
@@ -454,9 +464,9 @@ export declare class SyncClient extends EventEmitter {
     unassignEntity(entityType: string, entityId: string): Promise<void>;
     reassignEntity(entityType: string, entityId: string, assigneeType: string, assigneeId: string, id?: string): Promise<void>;
     /**
-     * Apply a batch of delta results from Database to the ObjectPool.
+     * Apply a batch of delta results from Database to the InstanceCache.
      * Owns: model creation, upsert, remove, archive, conflict resolution.
-     * Returns: nothing — ObjectPool is updated in place.
+     * Returns: nothing — InstanceCache is updated in place.
      */
     /**
      * Mark a local transaction as optimistically applied. The matching
@@ -472,17 +482,17 @@ export declare class SyncClient extends EventEmitter {
      * — a sustained `evictions > 0` rate or `rollbacks` spike is a
      * health signal worth alerting on.
      */
-    getEchoMetrics(): Readonly<OptimisticEchoMetrics>;
+    getEchoMetrics(): Readonly<UnconfirmedWritesMetrics>;
     /**
-     * Package-internal accessor for the TransactionQueue. Used by
-     * `Ablo.commits.create()` to route raw multi-op envelopes through the
-     * same retry-on-reconnect lane as the Model proxy path, and by tests
-     * to exercise the queue ↔ markTransactionPending wiring on the real
-     * instance the SyncClient subscribes to. NOT re-exported to SDK
-     * consumers — `Ablo` itself is the public surface.
+     * Package-internal accessor for the {@link TransactionQueue}. Used by
+     * `Ablo.commits.create()` to route raw multi-operation envelopes through the
+     * same retry-on-reconnect lane as the model proxy path, and by tests to
+     * exercise the queue's interaction with {@link markTransactionPending} on the
+     * real instance the SyncClient subscribes to. It is not re-exported to SDK
+     * consumers; `Ablo` is the public surface.
      */
     getTransactionQueue(): TransactionQueue;
-    applyDeltaBatchToPool(dbResults: Array<{
+    applyDeltaBatchToPool(dbResults: {
         action: string;
         modelName: string;
         modelId: string;
@@ -495,9 +505,9 @@ export declare class SyncClient extends EventEmitter {
          * schema-derived deltas, etc.) don't have a client transaction.
          */
         transactionId?: string;
-    }>, enrichRelations: (modelName: string, data: Record<string, unknown>) => Record<string, unknown>): void;
+    }[], enrichRelations: (modelName: string, data: Record<string, unknown>) => Record<string, unknown>): void;
     /**
-     * Apply bootstrap data to the ObjectPool with ghost removal.
+     * Apply bootstrap data to the InstanceCache with ghost removal.
      * Owns: model creation, batch upsert, ghost detection + removal.
      */
     applyBootstrapDataToPool(bootstrapData: {
@@ -505,13 +515,13 @@ export declare class SyncClient extends EventEmitter {
         failedModels?: string[];
     }, protectedIds?: ReadonlySet<string>, options?: {
         /**
-         * SCOPED backfill (P4 hydrate-on-enter): the snapshot covers only the
-         * groups just entered, NOT the whole type. Two behaviors change to keep
-         * it from corrupting the pool:
-         *   - upsert is version-guarded ({@link ObjectPool.upsertIfNewer}) so a
-         *     concurrent live delta isn't clobbered back to the snapshot version;
-         *   - ghost removal is SKIPPED — a subset snapshot must never evict rows
-         *     of the same type that belong to other (unhydrated) groups.
+         * Scoped backfill for the hydrate-on-enter path: the snapshot covers only
+         * the groups just entered, not the whole model type. Two behaviors change
+         * so the subset cannot corrupt the pool. First, the upsert is
+         * version-guarded ({@link InstanceCache.upsertIfNewer}) so a concurrent live
+         * delta is not clobbered back to the snapshot version. Second, ghost
+         * removal is skipped, because a subset snapshot must never evict rows of
+         * the same type that belong to other, unhydrated groups.
          */
         scoped?: boolean;
     }): {