@abloatai/ablo 0.25.0 → 0.27.0

package/dist/core/DatabaseManager.js

@@ -1,11 +1,9 @@
 /**
- * Ablo Sync Engine - Database Manager
- *
- * Manages the two-tier database architecture:
- * 1. ablo_databases - Metadata about workspace databases
- * 2. ablo_(hash) - Workspace-specific data storage
- *
- * Follows Ablo's architecture for database management.
+ * Manages the client-side IndexedDB databases the sync engine keeps in the
+ * browser. There are two tiers. A single registry database, `ablo_databases`,
+ * records metadata about every workspace database. Each user-and-workspace pair
+ * then gets its own data database, named `ablo_<hash>`, that holds the synced
+ * rows. {@link DatabaseManager} creates, versions, and deletes both tiers.
  */
 import { getContext } from '../context.js';
 import { openIDBWithTimeout, deleteIDBWithTimeout, IDBOpenTimeoutError, } from './openIDBWithTimeout.js';
@@ -90,7 +88,7 @@ export class DatabaseManager {
         else if (existingInfo) {
             schemaVersion = existingInfo.schemaVersion || 1;
         }
-        // DEBUG: Log all existing databases for this user to detect duplicates
+        // Record the existing databases for this user so duplicates can be detected.
         const allUserDatabases = await this.getDatabasesForUser(userId);
         const allIndexedDBs = (await indexedDB.databases?.()) || [];
         const abloDatabases = allIndexedDBs.filter((db) => db.name?.startsWith('ablo_'));
@@ -107,7 +105,7 @@ export class DatabaseManager {
             schemaHash,
             schemaVersion,
             userVersion,
-            createdAt: existingInfo?.createdAt || new Date(),
+            createdAt: existingInfo?.createdAt ?? new Date(),
             updatedAt: new Date(),
         };
     }
@@ -117,7 +115,7 @@ export class DatabaseManager {
     generateDatabaseName(userId, workspaceId, userVersion = 1) {
         // Combine userId, workspaceId, and userVersion for unique database
         const combined = `${userId}:${workspaceId}:${userVersion}`;
-        // Generate hash similar to Linear's approach
+        // Hash the combined key into a compact, deterministic identifier.
         let hash = 0;
         for (let i = 0; i < combined.length; i++) {
             hash = (hash << 5) - hash + combined.charCodeAt(i);
@@ -143,8 +141,8 @@ export class DatabaseManager {
             tx.oncomplete = () => {
                 resolve();
             };
-            tx.onerror = () => reject(tx.error);
-            request.onerror = () => reject(request.error);
+            tx.onerror = () => { reject(tx.error); };
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
@@ -157,8 +155,8 @@ export class DatabaseManager {
             const tx = this.metaDb.transaction(['databases'], 'readonly');
             const store = tx.objectStore('databases');
             const request = store.get(name);
-            request.onsuccess = () => resolve(request.result || null);
-            request.onerror = () => reject(request.error);
+            request.onsuccess = () => { resolve(request.result ?? null); };
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
@@ -172,8 +170,8 @@ export class DatabaseManager {
             const store = tx.objectStore('databases');
             const index = store.index('userId');
             const request = index.getAll(userId);
-            request.onsuccess = () => resolve(request.result || []);
-            request.onerror = () => reject(request.error);
+            request.onsuccess = () => { resolve(request.result || []); };
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
@@ -185,13 +183,12 @@ export class DatabaseManager {
                 onUpgrade: (request, event) => {
                     const db = request.result;
                     const tx = event.target.transaction;
-                    // Per jakearchibald/idb's "Transaction Lifetime Management":
-                    // only IDB-request awaits keep an upgrade transaction alive; any
-                    // non-IDB await (fetch, timer, etc.) commits it prematurely and
-                    // later ops throw `TransactionInactiveError`. StoreManager.createStores
-                    // (src/core/StoreManager.ts:93) is only synchronous createObjectStore
-                    // / createIndex calls wrapped in an `async` keyword, so firing it
-                    // without awaiting is safe and matches the VCS-slot semantics.
+                    // IndexedDB rule: only awaits on IndexedDB requests keep an upgrade
+                    // transaction alive. Any other await — a fetch, a timer — commits the
+                    // transaction early, and later operations then throw
+                    // `TransactionInactiveError`. StoreManager.createStores runs only
+                    // synchronous createObjectStore / createIndex calls under an `async`
+                    // keyword, so calling it without awaiting is safe here.
                     if (createStoresFn && tx) {
                         try {
                             void createStoresFn(db, tx).catch((err) => {
@@ -231,18 +228,19 @@ export class DatabaseManager {
                     return;
                 }
                 const meta = {
-                    lastSyncId: data.lastSyncId || 0,
-                    firstSyncId: data.firstSyncId || 0,
-                    backendDatabaseVersion: data.backendDatabaseVersion || 1,
-                    subscribedSyncGroups: data.subscribedSyncGroups || [],
+                    lastSyncId: data.lastSyncId ?? 0,
+                    firstSyncId: data.firstSyncId ?? 0,
+                    backendDatabaseVersion: data.backendDatabaseVersion ?? 1,
+                    subscribedSyncGroups: data.subscribedSyncGroups ?? [],
                     updatedAt: data.updatedAt ? new Date(data.updatedAt) : new Date(),
                     schemaHash: data.schemaHash,
                     syncGroups: data.syncGroups,
-                    versions: data.versions || undefined,
+                    // Older persisted records may still carry an extra `versions` key
+                    // that is no longer used; it is tolerated by simply not reading it here.
                 };
                 resolve(meta);
             };
-            request.onerror = () => reject(request.error);
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
@@ -253,9 +251,9 @@ export class DatabaseManager {
             const tx = db.transaction(['__meta'], 'readwrite');
             const store = tx.objectStore('__meta');
             const request = store.put(metadata, 'metadata');
-            tx.oncomplete = () => resolve();
-            tx.onerror = () => reject(tx.error);
-            request.onerror = () => reject(request.error);
+            tx.oncomplete = () => { resolve(); };
+            tx.onerror = () => { reject(tx.error); };
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
@@ -270,7 +268,7 @@ export class DatabaseManager {
                 const data = request.result;
                 resolve(data?.persisted === true);
             };
-            request.onerror = () => reject(request.error);
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
@@ -287,9 +285,9 @@ export class DatabaseManager {
                 updatedAt: new Date().toISOString(),
             };
             const request = store.put(persistenceData, modelName);
-            tx.oncomplete = () => resolve();
-            tx.onerror = () => reject(tx.error);
-            request.onerror = () => reject(request.error);
+            tx.oncomplete = () => { resolve(); };
+            tx.onerror = () => { reject(tx.error); };
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
@@ -312,7 +310,7 @@ export class DatabaseManager {
                 }
                 resolve(states);
             };
-            request.onerror = () => reject(request.error);
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
@@ -362,10 +360,10 @@ export class DatabaseManager {
                 const schemaVersions = {};
                 for (const db of databases) {
                     // Count by user
-                    databasesByUser[db.userId] = (databasesByUser[db.userId] || 0) + 1;
+                    databasesByUser[db.userId] = (databasesByUser[db.userId] ?? 0) + 1;
                     // Count schema versions
                     const versionKey = `v${db.schemaVersion}`;
-                    schemaVersions[versionKey] = (schemaVersions[versionKey] || 0) + 1;
+                    schemaVersions[versionKey] = (schemaVersions[versionKey] ?? 0) + 1;
                 }
                 resolve({
                     metaDatabaseSize: databases.length,
@@ -374,7 +372,7 @@ export class DatabaseManager {
                     schemaVersions,
                 });
             };
-            request.onerror = () => reject(request.error);
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**

package/dist/core/QueryProcessor.d.ts

@@ -1,15 +1,13 @@
 /**
- * QueryProcessor - Centralized query processing for the sync engine
- *
- * Responsibilities:
- * - Complex filtering, sorting, and pagination logic
- * - Query optimization and caching strategies
- * - Predicate evaluation and result processing
- *
- * This extracts query processing logic from SyncedStore for proper separation of concerns
+ * Runs in-memory queries over a set of models — filtering by predicate,
+ * sorting, paginating, and caching the results. A caller hands
+ * {@link QueryProcessor} the candidate models and the query options, and it
+ * returns a {@link QueryResult}. It keeps two caches: a string-keyed cache for
+ * plain queries, and a structural-identity cache for predicate queries, whose
+ * closures cannot be turned into a stable string key.
  */
 import type { Model } from '../Model.js';
-import type { ModelScope } from '../ObjectPool.js';
+import type { ModelScope } from '../InstanceCache.js';
 export interface QueryOptions<T extends Model> {
     predicate?: (model: T) => boolean;
     /** Stable key to distinguish different predicates for the same model type.

package/dist/core/QueryProcessor.js

@@ -1,20 +1,17 @@
 /**
- * QueryProcessor - Centralized query processing for the sync engine
- *
- * Responsibilities:
- * - Complex filtering, sorting, and pagination logic
- * - Query optimization and caching strategies
- * - Predicate evaluation and result processing
- *
- * This extracts query processing logic from SyncedStore for proper separation of concerns
+ * Runs in-memory queries over a set of models — filtering by predicate,
+ * sorting, paginating, and caching the results. A caller hands
+ * {@link QueryProcessor} the candidate models and the query options, and it
+ * returns a {@link QueryResult}. It keeps two caches: a string-keyed cache for
+ * plain queries, and a structural-identity cache for predicate queries, whose
+ * closures cannot be turned into a stable string key.
  */
 /**
- * Optimized in-memory cache implementation
- *
- * 2025 Best Practice: O(1) invalidation by model type instead of O(n) regex matching
- * - Maintains a reverse index from model type to cache keys
- * - Invalidation by model type is O(k) where k = keys for that model type
- * - No regex compilation or full cache iteration needed
+ * The default in-memory cache. It keeps a reverse index from model type to the
+ * cache keys for that type, so invalidating one model type costs work
+ * proportional to that type's keys rather than a scan of the whole cache. A
+ * regex fallback still covers the rare pattern that is not a plain model-type
+ * match.
  */
 class BasicQueryCache {
     cache = new Map();
@@ -48,9 +45,8 @@ class BasicQueryCache {
             return;
         }
         // Fast path: Check if pattern is a simple model type match like ".*ModelType.*"
-        const simpleMatch = pattern.match(/^\.\*(\w+)\.\*$/);
-        if (simpleMatch) {
-            const modelType = simpleMatch[1];
+        const modelType = /^\.\*(\w+)\.\*$/.exec(pattern)?.[1];
+        if (modelType !== undefined) {
             const keysToDelete = this.modelTypeIndex.get(modelType);
             if (keysToDelete) {
                 for (const key of keysToDelete) {
@@ -88,20 +84,19 @@ class BasicQueryCache {
      * Cache key format: "operation:ModelType:options"
      */
     extractModelType(key) {
-        const parts = key.split(':');
-        return parts.length >= 2 ? parts[1] : null;
+        // A missing second segment reads as undefined, so `?? null` yields null.
+        return key.split(':')[1] ?? null;
     }
 }
 export class QueryProcessor {
     cache;
     enableCache;
-    // Stable-reference cache for predicate queries.
-    // String-based cache keys can't represent closures, so we use a separate
-    // identity-based cache that compares result model IDs. This follows the same
-    // principle as MobX's comparer.structural — return the previous reference
-    // when the structural content hasn't changed.
-    // Key: deterministic portion of query (modelName + serializable options)
-    // Value: previous result + its ID fingerprint
+    // Stable-reference cache for predicate queries. A string cache key cannot
+    // capture a closure, so predicate queries use a separate identity-based
+    // cache keyed on the deterministic part of the query (model name plus
+    // serializable options). Each entry stores the previous result and a
+    // fingerprint of its model ids; when the ids are unchanged, the processor
+    // returns the previous array reference so observers do not re-render.
     predicateResultCache = new Map();
     constructor(config = {}) {
         this.enableCache = config.enableCache ?? true;
@@ -137,10 +132,9 @@ export class QueryProcessor {
             hasMore: offset + limit < total,
             fromCache: false,
         };
-        // For predicate queries: use structural identity comparison
-        // Return the previous array reference if model IDs haven't changed.
-        // This is the query-layer equivalent of MobX's comparer.structural —
-        // observers won't re-render when the result is structurally identical.
+        // For predicate queries: compare by structural identity. Return the
+        // previous array reference when the model ids are unchanged, so observers
+        // don't re-render on a structurally identical result.
         if (options.predicate && this.enableCache) {
             const ids = data.map((m) => m.id).join(',');
             const cached = this.predicateResultCache.get(cacheKey);
@@ -151,7 +145,7 @@ export class QueryProcessor {
             // New result — store for future comparison
             this.predicateResultCache.set(cacheKey, { ids, result });
         }
-        // For non-predicate queries: use string-based cache as before
+        // For non-predicate queries: use the string-based cache.
         if (!options.predicate && this.enableCache) {
             this.cache.set(cacheKey, result);
         }
@@ -229,9 +223,8 @@ export class QueryProcessor {
         this.cache.invalidate(pattern);
         // Also invalidate predicate result cache for this model type
         if (pattern) {
-            const simpleMatch = pattern.match(/^\.\*(\w+)\.\*$/);
-            if (simpleMatch) {
-                const modelType = simpleMatch[1];
+            const modelType = /^\.\*(\w+)\.\*$/.exec(pattern)?.[1];
+            if (modelType !== undefined) {
                 for (const key of this.predicateResultCache.keys()) {
                     if (key.includes(modelType)) {
                         this.predicateResultCache.delete(key);

package/dist/core/QueryView.d.ts

@@ -9,10 +9,22 @@
  * directly and receive granular updates (splice/push, never replacement).
  */
 import { type IObservableArray } from 'mobx';
+import { type Model } from '../Model.js';
 import { ModelScope } from '../types/index.js';
-import type { ObjectPool } from '../ObjectPool.js';
 import type { ViewRegistry } from './ViewRegistry.js';
-import type { IncrementalView } from './query-utils.js';
+import type { IncrementalView } from './queryUtils.js';
+/**
+ * The slice of the object pool that a {@link QueryView} reads. It is a minimal
+ * structural interface rather than the concrete pool class, which lets a query
+ * view avoid importing the pool and so breaks what would otherwise be an import
+ * cycle — the pool imports {@link QueryView} to construct one. The concrete
+ * pool satisfies this interface structurally.
+ */
+export interface QueryViewPool {
+    hasForeignKeyIndex(typename: string, fieldName: string): boolean;
+    getByForeignKey(modelName: string, fieldName: string, fieldValue: string): Model[];
+    getByTypeName(modelName: string, scope?: ModelScope): Model[];
+}
 export interface QueryViewOptions<T> {
     where?: Partial<T>;
     filter?: (entity: T) => boolean;
@@ -20,8 +32,8 @@ export interface QueryViewOptions<T> {
     order?: 'asc' | 'desc';
     limit?: number;
     offset?: number;
-    /** Lifecycle filter — `live` (default), `archived`, or `all`. Named `state`
-     *  (GitHub's open/closed/all precedent) so it doesn't collide with the
+    /** Lifecycle filter — `live` (the default), `archived`, or `all`. It is
+     *  named `state` rather than `scope` so it does not collide with the
      *  sync-group `scope`. */
     state?: ModelScope;
 }
@@ -47,7 +59,7 @@ export declare class QueryView<T extends Record<string, unknown>> implements Inc
     private readonly fkField;
     private readonly fkValue;
     private disposed;
-    constructor(typename: string, pool: ObjectPool, registry: ViewRegistry, options?: QueryViewOptions<T>);
+    constructor(typename: string, pool: QueryViewPool, registry: ViewRegistry, options?: QueryViewOptions<T>);
     private initialScan;
     handleAdded(model: Record<string, unknown>): void;
     handleUpdated(model: Record<string, unknown>): void;

package/dist/core/QueryView.js

@@ -11,7 +11,7 @@
 import { observable, runInAction } from 'mobx';
 import { modelAsRow } from '../Model.js';
 import { ModelScope } from '../types/index.js';
-import { compareValues, binaryInsertionIndex, findIndexById, } from './query-utils.js';
+import { compareValues, binaryInsertionIndex, findIndexById, } from './queryUtils.js';
 // ---------------------------------------------------------------------------
 // QueryView
 // ---------------------------------------------------------------------------
@@ -54,10 +54,9 @@ export class QueryView {
         // Check for FK-index optimization: single-field where with an indexed FK
         this.fkField = null;
         this.fkValue = null;
-        if (this.whereEntries &&
-            this.whereEntries.length === 1 &&
-            typeof this.whereEntries[0][1] === 'string') {
-            const [field, value] = this.whereEntries[0];
+        const soleWhereEntry = this.whereEntries && this.whereEntries.length === 1 ? this.whereEntries[0] : undefined;
+        if (soleWhereEntry && typeof soleWhereEntry[1] === 'string') {
+            const [field, value] = soleWhereEntry;
             if (pool.hasForeignKeyIndex(typename, field)) {
                 this.fkField = field;
                 this.fkValue = value;
@@ -120,7 +119,7 @@ export class QueryView {
         if (this.disposed)
             return;
         const entity = model;
-        const id = entity['id'];
+        const id = entity.id;
         const idx = id !== undefined ? this.findIndexById(id) : -1;
         const matchesNow = this.matchesFilter(entity);
         runInAction(() => {
@@ -169,7 +168,7 @@ export class QueryView {
     // -----------------------------------------------------------------------
     /** Check whether an entity passes both `where` and `filter`. */
     matchesFilter(entity) {
-        // Note: scope is tracked per-entry in the ObjectPool, not on the model.
+        // Note: scope is tracked per-entry in the InstanceCache, not on the model.
         // The initial scan handles scope via getByTypeName(typename, scope).
         // Incremental notifications from the pool are scope-appropriate since
         // add/upsert/remove reflect the pool's authoritative scope tracking.

package/dist/core/StoreManager.d.ts

@@ -1,9 +1,10 @@
 /**
- * Linear Sync Engine - Store Manager
- *
- * Manages all ObjectStore instances for registered models.
- * Creates appropriate store types based on model load strategies.
- * Follows Linear's architecture with 80+ ObjectStore instances.
+ * Manages the {@link ObjectStore} instances the sync engine keeps in the
+ * browser — one per registered model — alongside the single
+ * {@link SyncActionStore} for pending changes. It creates each store from the
+ * model's metadata, tracks readiness, and provisions the underlying IndexedDB
+ * object stores. A model's load strategy (instant, lazy, or partial) decides
+ * how and when its data is loaded.
  */
 import { ModelRegistry } from '../ModelRegistry.js';
 import { ObjectStore } from '../stores/ObjectStore.js';
@@ -63,15 +64,12 @@ export declare class StoreManager {
         totalStores: number;
     }>;
     /**
-     * Check if ANY data store has at least one record.
-     *
-     * This is the Zero-style cache-validity check: if the stores are empty,
-     * the sync cursor (lastSyncId) is invalid regardless of what the metadata
-     * says. The cursor and the data must be co-located — no data means no
-     * cursor, which means full bootstrap.
-     *
-     * Samples up to 3 stores to avoid a full scan. If any store has records,
-     * returns true (we have cached data worth preserving).
+     * Reports whether any data store holds at least one record. This is a
+     * cache-validity check: if the stores are empty, the sync cursor
+     * (`lastSyncId`) is meaningless no matter what the metadata says, because the
+     * cursor and the data must travel together — no data means no cursor, which
+     * forces a full bootstrap. To stay cheap it samples up to three stores rather
+     * than scanning them all, and returns true as soon as one has records.
      */
     hasAnyData(): Promise<boolean>;
     /**
@@ -120,12 +118,12 @@ export declare class StoreManager {
             notReady: number;
         };
         totalRecords: number;
-        storeDetails: Array<{
+        storeDetails: {
             modelName: string;
             storeName: string;
             strategy: LoadStrategy;
             ready: boolean;
             count: number;
-        }>;
+        }[];
     }>;
 }

package/dist/core/StoreManager.js

@@ -1,10 +1,12 @@
 /**
- * Linear Sync Engine - Store Manager
- *
- * Manages all ObjectStore instances for registered models.
- * Creates appropriate store types based on model load strategies.
- * Follows Linear's architecture with 80+ ObjectStore instances.
+ * Manages the {@link ObjectStore} instances the sync engine keeps in the
+ * browser — one per registered model — alongside the single
+ * {@link SyncActionStore} for pending changes. It creates each store from the
+ * model's metadata, tracks readiness, and provisions the underlying IndexedDB
+ * object stores. A model's load strategy (instant, lazy, or partial) decides
+ * how and when its data is loaded.
  */
+import { ModelRegistry } from '../ModelRegistry.js';
 import { ObjectStore } from '../stores/ObjectStore.js';
 import { SyncActionStore } from '../stores/SyncActionStore.js';
 import { LoadStrategy } from '../types/index.js';
@@ -69,7 +71,7 @@ export class StoreManager {
         }
         // Use model name directly as store name
         const storeName = modelName;
-        // Create ObjectStore (MVP: simplified - use single store type for all strategies)
+        // Create the ObjectStore. One store type currently serves every load strategy.
         const store = new ObjectStore(this.db, modelName, storeName, metadata);
         this.stores.set(modelName, store);
     }
@@ -121,7 +123,7 @@ export class StoreManager {
         }
         // Create __meta table for model persistence state and database metadata
         if (!db.objectStoreNames.contains('__meta')) {
-            const metaStore = db.createObjectStore('__meta');
+            db.createObjectStore('__meta');
             getContext().logger.debug('Created __meta table');
         }
         // Create __transactions table for unsent transactions
@@ -183,22 +185,22 @@ export class StoreManager {
         };
     }
     /**
-     * Check if ANY data store has at least one record.
-     *
-     * This is the Zero-style cache-validity check: if the stores are empty,
-     * the sync cursor (lastSyncId) is invalid regardless of what the metadata
-     * says. The cursor and the data must be co-located — no data means no
-     * cursor, which means full bootstrap.
-     *
-     * Samples up to 3 stores to avoid a full scan. If any store has records,
-     * returns true (we have cached data worth preserving).
+     * Reports whether any data store holds at least one record. This is a
+     * cache-validity check: if the stores are empty, the sync cursor
+     * (`lastSyncId`) is meaningless no matter what the metadata says, because the
+     * cursor and the data must travel together — no data means no cursor, which
+     * forces a full bootstrap. To stay cheap it samples up to three stores rather
+     * than scanning them all, and returns true as soon as one has records.
      */
     async hasAnyData() {
         const storeEntries = Array.from(this.stores);
         // Sample a few stores — don't check all 30+ if the first one has data
         const samplesToCheck = Math.min(storeEntries.length, 3);
         for (let i = 0; i < samplesToCheck; i++) {
-            const [, store] = storeEntries[i];
+            const entry = storeEntries[i];
+            if (!entry)
+                break;
+            const [, store] = entry;
             try {
                 const count = await store.count();
                 if (count > 0)
@@ -277,8 +279,8 @@ export class StoreManager {
      * Clear all stores
      */
     async clearAllStores() {
-        // Lifecycle chatter (logout / identity switch / reset) — NOT a warning.
-        // `debug` so it's silent under the default `warn` threshold.
+        // Lifecycle chatter (logout / identity switch / reset), not a warning.
+        // Logged at `debug` so it stays silent under the default `warn` threshold.
         getContext().logger.debug('Clearing all stores');
         const promises = Array.from(this.stores.values()).map((store) => store.clear());
         await Promise.all(promises);
@@ -293,12 +295,11 @@ export class StoreManager {
         for (const store of this.stores.values()) {
             store.markAsClosing();
         }
-        // SyncActionStore is a standalone store (does NOT extend ObjectStore)
-        // and has no markAsClosing equivalent. The previous `(syncactionStore
-        // as any).markAsClosing?.()` was a silent no-op disguised as a real
-        // call — the optional chain swallowed the missing method. If
-        // closing-state coordination is needed for sync actions, add it
-        // explicitly to SyncActionStore rather than reintroducing the cast.
+        // SyncActionStore is a standalone store that does not extend ObjectStore
+        // and has no markAsClosing equivalent, so it is intentionally skipped here.
+        // If closing-state coordination is ever needed for sync actions, add it
+        // explicitly to SyncActionStore rather than casting to reach a method that
+        // may not exist.
         getContext().logger.debug('All stores marked as closing');
     }
     /**

package/dist/core/ViewRegistry.d.ts

@@ -1,20 +1,20 @@
 /**
  * ViewRegistry — tracks active QueryViews per typename.
  *
- * When the ObjectPool mutates a model, it calls notifyAdded / notifyUpdated /
+ * When the InstanceCache mutates a model, it calls notifyAdded / notifyUpdated /
  * notifyRemoved on the registry, which fans the event out to every active
  * QueryView subscribed to that typename.
  */
 import { type Model } from '../Model.js';
-import type { IncrementalView } from './query-utils.js';
+import type { IncrementalView } from './queryUtils.js';
 export declare class ViewRegistry {
     private views;
     register(typename: string, view: IncrementalView): void;
     unregister(typename: string, view: IncrementalView): void;
-    /** Called by ObjectPool after a model is added to the pool. */
+    /** Called by InstanceCache after a model is added to the pool. */
     notifyAdded(typename: string, model: Model): void;
-    /** Called by ObjectPool after a model is updated in the pool. */
+    /** Called by InstanceCache after a model is updated in the pool. */
     notifyUpdated(typename: string, model: Model): void;
-    /** Called by ObjectPool after a model is removed from the pool. */
+    /** Called by InstanceCache after a model is removed from the pool. */
     notifyRemoved(typename: string, modelId: string): void;
 }

package/dist/core/ViewRegistry.js

@@ -1,7 +1,7 @@
 /**
  * ViewRegistry — tracks active QueryViews per typename.
  *
- * When the ObjectPool mutates a model, it calls notifyAdded / notifyUpdated /
+ * When the InstanceCache mutates a model, it calls notifyAdded / notifyUpdated /
  * notifyRemoved on the registry, which fans the event out to every active
  * QueryView subscribed to that typename.
  */
@@ -25,7 +25,7 @@ export class ViewRegistry {
             this.views.delete(typename);
         }
     }
-    /** Called by ObjectPool after a model is added to the pool. */
+    /** Called by InstanceCache after a model is added to the pool. */
     notifyAdded(typename, model) {
         const set = this.views.get(typename);
         if (!set)
@@ -34,7 +34,7 @@ export class ViewRegistry {
             view.handleAdded(modelAsRow(model));
         }
     }
-    /** Called by ObjectPool after a model is updated in the pool. */
+    /** Called by InstanceCache after a model is updated in the pool. */
     notifyUpdated(typename, model) {
         const set = this.views.get(typename);
         if (!set)
@@ -43,7 +43,7 @@ export class ViewRegistry {
             view.handleUpdated(modelAsRow(model));
         }
     }
-    /** Called by ObjectPool after a model is removed from the pool. */
+    /** Called by InstanceCache after a model is removed from the pool. */
     notifyRemoved(typename, modelId) {
         const set = this.views.get(typename);
         if (!set)