@abloatai/ablo 0.35.0 → 0.36.0

package/dist/Database.js

@@ -5,11 +5,11 @@
  * server. {@link BaseSyncedStore} drives it, and {@link InstanceCache} holds the
  * in-memory mirror of what this class persists.
  */
-import { DatabaseManager } from './core/DatabaseManager.js';
-import { StoreManager } from './core/StoreManager.js';
+import { DatabaseManager } from './stores/DatabaseManager.js';
+import { StoreManager } from './stores/StoreManager.js';
 import { ModelRegistry } from './ModelRegistry.js';
 import { LoadStrategy } from './transaction/types/index.js';
-import { getContext } from './context.js';
+import { globalRuntime } from './context.js';
 import { AbloConnectionError, AbloValidationError } from './transaction/errors.js';
 import { InMemoryObjectStore } from './adapters/inMemoryStorage.js';
 import { logPositionSchema } from './transaction/logPosition.js';
@@ -110,7 +110,7 @@ export class Database {
     /** Essential fields that must be preserved during partial UPDATE merges.
      * Sourced from SyncEngineConfig.essentialFields — consumers define their own. */
     get essentialFields() {
-        return getContext().config.essentialFields;
+        return this.runtime.config.essentialFields;
     }
     /**
      * When true, all IndexedDB operations are replaced with in-memory Maps.
@@ -121,13 +121,15 @@ export class Database {
      *   new Database(registry, bootstrap, { inMemory: true })
      */
     inMemory;
+    runtime;
     /** In-memory stores used when inMemory=true. Keyed by model name. */
     inMemoryStores = new Map();
     /** In-memory workspace metadata when inMemory=true. */
     inMemoryMetadata = null;
     constructor(modelRegistry, bootstrapHelper, options) {
-        this.databaseManager = new DatabaseManager();
-        this.storeManager = new StoreManager(modelRegistry);
+        this.runtime = options?.runtime ?? globalRuntime;
+        this.databaseManager = new DatabaseManager(this.runtime);
+        this.storeManager = new StoreManager(modelRegistry, this.runtime);
         this.modelRegistry = modelRegistry;
         this.bootstrapHelper = bootstrapHelper;
         this.inMemory = options?.inMemory ?? false;
@@ -149,7 +151,7 @@ export class Database {
             ? this.inMemoryStores.get(modelName)
             : this.storeManager.getStore(modelName);
         if (!store && context) {
-            getContext().observability.breadcrumb(`Store not found for model: ${modelName}`, 'sync.database', 'warning', { context });
+            this.runtime.observability.breadcrumb(`Store not found for model: ${modelName}`, 'sync.database', 'warning', { context });
         }
         return store;
     }
@@ -170,7 +172,7 @@ export class Database {
         const requiredFields = this.essentialFields[modelName] ?? [];
         const preserved = requiredFields.filter((field) => existing[field] !== undefined && delta[field] === undefined);
         if (preserved.length > 0) {
-            getContext().logger.debug('[Database] UPDATE merged - preserved fields', {
+            this.runtime.logger.debug('[Database] UPDATE merged - preserved fields', {
                 modelName,
                 modelId: modelId.slice(0, 12),
                 deltaFields: Object.keys(delta),
@@ -188,7 +190,7 @@ export class Database {
         // Creates InMemoryObjectStore instances for all registered models.
         // Bootstrap via HTTP still works; only local persistence is skipped.
         if (this.inMemory) {
-            getContext().logger.debug('Opening in-memory database (headless mode)');
+            this.runtime.logger.debug('Opening in-memory database (headless mode)');
             const allModels = this.modelRegistry.getRegisteredModelNames();
             for (const modelName of allModels) {
                 const storeName = `store_${modelName.toLowerCase()}`;
@@ -196,11 +198,11 @@ export class Database {
             }
             // Create a __transactions store for the offline queue
             this.inMemoryStores.set('__transactions', new InMemoryObjectStore('__transactions', '__transactions'));
-            getContext().logger.info(`In-memory database opened: ${this.inMemoryStores.size} stores`);
+            this.runtime.logger.info(`In-memory database opened: ${this.inMemoryStores.size} stores`);
             return;
         }
         // ── Browser mode: IndexedDB (existing behavior, unchanged) ───
-        getContext().logger.debug('Opening IndexedDB database');
+        this.runtime.logger.debug('Opening IndexedDB database');
         // Initialize meta database
         await this.databaseManager.initializeMetaDatabase();
         // Calculate database info
@@ -214,7 +216,7 @@ export class Database {
         // Initialize stores
         await this.storeManager.initializeStores(this.workspaceDb);
         const readiness = await this.storeManager.checkReadinessOfStores();
-        getContext().logger.info(`Database opened: ${this.currentDbInfo.name} (${readiness.readyStores.length}/${readiness.totalStores} stores ready)`);
+        this.runtime.logger.info(`Database opened: ${this.currentDbInfo.name} (${readiness.readyStores.length}/${readiness.totalStores} stores ready)`);
     }
     /**
      * Shrink a record before persisting it. Drops `undefined` fields, empty
@@ -277,7 +279,7 @@ export class Database {
      */
     markRequiresFullBootstrap() {
         this._forceFullBootstrap = true;
-        getContext().logger.info('[Database] Marked for forced full bootstrap (sync group change)');
+        this.runtime.logger.info('[Database] Marked for forced full bootstrap (sync group change)');
     }
     /**
      * Smart bootstrap requirements based on data freshness
@@ -309,7 +311,7 @@ export class Database {
             this._forceFullBootstrap = false;
             const instantModels = this.modelRegistry.getModelsByLoadStrategy(LoadStrategy.instant);
             const lazyModels = this.modelRegistry.getModelsByLoadStrategy(LoadStrategy.lazy);
-            getContext().logger.info('[Database.requiredBootstrap] Forced FULL bootstrap (sync group change)');
+            this.runtime.logger.info('[Database.requiredBootstrap] Forced FULL bootstrap (sync group change)');
             return {
                 type: 'full',
                 modelsToLoad: [...instantModels, ...lazyModels],
@@ -348,7 +350,7 @@ export class Database {
         // we've confirmed the data it refers to actually exists in the stores.
         const lastSyncId = dataExists ? metadataLastSyncId : 0;
         // Log the resolved database state for diagnostics.
-        getContext().logger.debug('[Database.requiredBootstrap] State check', {
+        this.runtime.logger.debug('[Database.requiredBootstrap] State check', {
             readinessReady: readiness.ready,
             hasMetadata: !!metadata,
             metadataLastSyncId,
@@ -365,13 +367,13 @@ export class Database {
         if (offline && hasLocalData) {
             // Offline with data - use local bootstrap (only option when offline)
             type = 'local';
-            getContext().logger.info('Offline detected with local data - using local bootstrap');
+            this.runtime.logger.info('Offline detected with local data - using local bootstrap');
         }
         else {
             // The server is the source of truth: always use a full bootstrap
             // when online.
             type = 'full';
-            getContext().logger.info('Full bootstrap - server is source of truth', {
+            this.runtime.logger.info('Full bootstrap - server is source of truth', {
                 reason: offline ? 'offline_no_data' : 'server_authoritative',
                 hasLocalData,
                 lastSyncId,
@@ -396,12 +398,12 @@ export class Database {
      *  shrinkage check. Caller supplies the complete list, not just
      *  team-derived groups. */
     syncGroups, onProgress) {
-        getContext().logger.debug('Starting bootstrap fetch', {
+        this.runtime.logger.debug('Starting bootstrap fetch', {
             type: requirements.type,
             lastSyncId: requirements.lastSyncId,
             modelsToLoad: requirements.modelsToLoad,
         });
-        getContext().logger.info('Database: Starting bootstrap from Go server', {
+        this.runtime.logger.info('Database: Starting bootstrap from Go server', {
             type: requirements.type,
             syncGroups,
             modelsToLoad: requirements.modelsToLoad,
@@ -410,12 +412,12 @@ export class Database {
             // Fetch before any destructive operation, so a failed network
             // request can't leave the local store empty.
             const startTime = typeof performance !== 'undefined' ? performance.now() : Date.now();
-            getContext().logger.info('Fetching bootstrap data from server (before clearing local data)', {
+            this.runtime.logger.info('Fetching bootstrap data from server (before clearing local data)', {
                 type: requirements.type,
                 lastSyncId: requirements.lastSyncId,
             });
             const bootstrapData = await this.bootstrapHelper.fetchBootstrap(requirements.lastSyncId);
-            getContext().logger.debug('Received bootstrap response', {
+            this.runtime.logger.debug('Received bootstrap response', {
                 type: bootstrapData.type,
                 lastSyncId: bootstrapData.lastSyncId,
                 hasModels: !!bootstrapData.models,
@@ -431,7 +433,7 @@ export class Database {
             // Handle partial bootstrap (delta batch)
             if (bootstrapData.type === 'partial') {
                 const deltas = bootstrapData.deltas ?? [];
-                getContext().logger.info('Processing partial bootstrap with delta batch', {
+                this.runtime.logger.info('Processing partial bootstrap with delta batch', {
                     deltaCount: deltas.length,
                     fromSyncId: requirements.lastSyncId,
                     toSyncId: bootstrapData.lastSyncId,
@@ -471,7 +473,7 @@ export class Database {
                     updatedAt: new Date(),
                 });
                 const elapsed = (typeof performance !== 'undefined' ? performance.now() : Date.now()) - startTime;
-                getContext().logger.info(`Partial bootstrap complete in ${elapsed.toFixed(2)}ms`, {
+                this.runtime.logger.info(`Partial bootstrap complete in ${elapsed.toFixed(2)}ms`, {
                     deltasApplied,
                     lastSyncId: bootstrapData.lastSyncId,
                 });
@@ -488,21 +490,21 @@ export class Database {
             for (const [modelName, modelData] of Object.entries(bootstrapData.models)) {
                 // Handle null, undefined, or non-array data
                 if (!modelData) {
-                    getContext().observability.breadcrumb(`No data received for ${modelName}`, 'sync.bootstrap', 'warning');
+                    this.runtime.observability.breadcrumb(`No data received for ${modelName}`, 'sync.bootstrap', 'warning');
                     continue;
                 }
                 if (!Array.isArray(modelData)) {
-                    getContext().observability.breadcrumb(`Skipping non-array data for ${modelName}`, 'sync.bootstrap', 'warning');
+                    this.runtime.observability.breadcrumb(`Skipping non-array data for ${modelName}`, 'sync.bootstrap', 'warning');
                     continue;
                 }
                 // Skip empty arrays silently (expected for some models)
                 if (modelData.length === 0) {
-                    getContext().logger.debug(`No ${modelName} items to store (empty array)`);
+                    this.runtime.logger.debug(`No ${modelName} items to store (empty array)`);
                     continue;
                 }
                 const store = this.getStore(modelName, 'bootstrap');
                 if (!store) {
-                    getContext().logger.debug(`[Bootstrap] NO IDB STORE for ${modelName} — ${modelData.length} items DROPPED`);
+                    this.runtime.logger.debug(`[Bootstrap] NO IDB STORE for ${modelName} — ${modelData.length} items DROPPED`);
                     continue;
                 }
                 let writeErrors = 0;
@@ -520,7 +522,7 @@ export class Database {
                     }
                     catch (error) {
                         writeErrors++;
-                        getContext().observability.breadcrumb(`Failed to store ${modelName} item`, 'sync.database', 'error', {
+                        this.runtime.observability.breadcrumb(`Failed to store ${modelName} item`, 'sync.database', 'error', {
                             error: error instanceof Error ? error.message : String(error),
                         });
                     }
@@ -530,7 +532,7 @@ export class Database {
                 // against. Counted and surfaced here so a partial does not read as a
                 // clean bootstrap.
                 if (writeErrors > 0) {
-                    getContext().observability.breadcrumb(`Stored ${modelName} with ${writeErrors} of ${modelData.length} items dropped`, 'sync.database', 'warning');
+                    this.runtime.observability.breadcrumb(`Stored ${modelName} with ${writeErrors} of ${modelData.length} items dropped`, 'sync.database', 'warning');
                 }
                 // Mark model as persisted after successful write
                 try {
@@ -548,8 +550,8 @@ export class Database {
                 updatedAt: new Date(),
             });
             const elapsed = (typeof performance !== 'undefined' ? performance.now() : Date.now()) - startTime;
-            getContext().logger.info(`Bootstrap complete: ${modelsLoaded} items loaded, ${modelsStored} stored to IndexedDB in ${elapsed.toFixed(2)}ms`);
-            getContext().analytics?.capture('bootstrap_success', {
+            this.runtime.logger.info(`Bootstrap complete: ${modelsLoaded} items loaded, ${modelsStored} stored to IndexedDB in ${elapsed.toFixed(2)}ms`);
+            this.runtime.analytics?.capture('bootstrap_success', {
                 responseTime: elapsed,
                 modelsLoaded,
             });
@@ -557,12 +559,12 @@ export class Database {
         }
         catch (error) {
             // Comprehensive error logging for bootstrap failures
-            getContext().observability.captureBootstrapFailure(error, {
+            this.runtime.observability.captureBootstrapFailure(error, {
                 type: requirements.type,
                 navigatorOnline: typeof navigator !== 'undefined' ? navigator.onLine : undefined,
             });
             // Track bootstrap failure telemetry
-            getContext().analytics?.capture('bootstrap_failed', {
+            this.runtime.analytics?.capture('bootstrap_failed', {
                 bootstrapType: requirements.type,
                 lastSyncId: requirements.lastSyncId,
                 errorMessage: error instanceof Error ? error.message : String(error),
@@ -617,7 +619,7 @@ export class Database {
             // newly created, it was newly visible. We fall through to the 'I' case
             // after a debug trace so the two can be disambiguated in logs.
             case 'C':
-                getContext().observability.breadcrumb('Applying covering delta (gained permission)', 'sync.database', 'info', { modelName, modelId: modelId.slice(0, 12) });
+                this.runtime.observability.breadcrumb('Applying covering delta (gained permission)', 'sync.database', 'info', { modelName, modelId: modelId.slice(0, 12) });
             // falls through
             case 'I': {
                 // Skip when the delta payload was empty/null. IDB rejects
@@ -635,7 +637,7 @@ export class Database {
                     }
                 }
                 catch (err) {
-                    getContext().observability.breadcrumb(`IndexedDB put failed for ${modelName}:${modelId}`, 'sync.database', 'error', {
+                    this.runtime.observability.breadcrumb(`IndexedDB put failed for ${modelName}:${modelId}`, 'sync.database', 'error', {
                         error: err instanceof Error ? err.message : String(err),
                     });
                     throw err; // Re-throw to see the actual error
@@ -650,7 +652,7 @@ export class Database {
                 // building a record from partial update data would corrupt it
                 // (missing reportId, and so on).
                 if (!existing) {
-                    getContext().observability.breadcrumb('Skipping UPDATE delta - no existing record to merge with', 'sync.database', 'warning', {
+                    this.runtime.observability.breadcrumb('Skipping UPDATE delta - no existing record to merge with', 'sync.database', 'warning', {
                         modelName,
                         modelId: modelId.slice(0, 12),
                     });
@@ -671,7 +673,7 @@ export class Database {
                     }
                 }
                 catch (err) {
-                    getContext().observability.breadcrumb(`IndexedDB put failed for ${modelName}:${modelId}`, 'sync.database', 'error', {
+                    this.runtime.observability.breadcrumb(`IndexedDB put failed for ${modelName}:${modelId}`, 'sync.database', 'error', {
                         error: err instanceof Error ? err.message : String(err),
                     });
                     throw err;
@@ -688,7 +690,7 @@ export class Database {
                     }
                 }
                 catch (err) {
-                    getContext().observability.breadcrumb(`IndexedDB delete failed for ${modelName}:${modelId}`, 'sync.database', 'error', {
+                    this.runtime.observability.breadcrumb(`IndexedDB delete failed for ${modelName}:${modelId}`, 'sync.database', 'error', {
                         error: err instanceof Error ? err.message : String(err),
                     });
                     // Surface failure so caller does not mutate InstanceCache inconsistently
@@ -706,7 +708,7 @@ export class Database {
                     }
                 }
                 catch (err) {
-                    getContext().observability.breadcrumb(`IndexedDB archive put failed for ${modelName}:${modelId}`, 'sync.database', 'error', {
+                    this.runtime.observability.breadcrumb(`IndexedDB archive put failed for ${modelName}:${modelId}`, 'sync.database', 'error', {
                         error: err instanceof Error ? err.message : String(err),
                     });
                     throw err;
@@ -722,7 +724,7 @@ export class Database {
             // queue), we return a no-op verify rather than crashing the engine.
             case 'G':
             case 'S':
-                getContext().observability.breadcrumb(`Group membership delta (${actionType}) reached processDelta — should be handled upstream`, 'sync.database', 'warning', { modelName, modelId: modelId.slice(0, 12), actionType });
+                this.runtime.observability.breadcrumb(`Group membership delta (${actionType}) reached processDelta — should be handled upstream`, 'sync.database', 'warning', { modelName, modelId: modelId.slice(0, 12), actionType });
                 return { action: 'verify', modelName, modelId, data: null };
             default: {
                 // The switch above is exhaustive over the declared action types, so
@@ -808,7 +810,7 @@ export class Database {
             }
         }
         if (deleteSyncIds.size > 0) {
-            getContext().logger.debug('[Database.processDeltaBatch] Built DELETE index for conflict resolution', {
+            this.runtime.logger.debug('[Database.processDeltaBatch] Built DELETE index for conflict resolution', {
                 deleteCount: deleteSyncIds.size,
                 totalDeltas: deltas.length,
             });
@@ -850,7 +852,7 @@ export class Database {
                     const deltaSyncId = delta.syncId ?? 0;
                     if (deleteSyncId >= deltaSyncId) {
                         // DELETE has equal or higher syncId - skip this UPDATE/INSERT
-                        getContext().logger.debug('[Database.processDeltaBatch] Skipping stale delta (DELETE wins)', {
+                        this.runtime.logger.debug('[Database.processDeltaBatch] Skipping stale delta (DELETE wins)', {
                             modelName: delta.modelName,
                             modelId: delta.modelId.slice(0, 12),
                             actionType: delta.actionType,
@@ -877,7 +879,7 @@ export class Database {
             deltasByStore.get(delta.modelName).push({ idx, delta });
         });
         if (skippedDueToConflict > 0) {
-            getContext().logger.info('[Database.processDeltaBatch] Conflict resolution summary', {
+            this.runtime.logger.info('[Database.processDeltaBatch] Conflict resolution summary', {
                 skippedDueToConflict,
                 totalDeltas: deltas.length,
                 deleteCount: deleteSyncIds.size,
@@ -908,7 +910,7 @@ export class Database {
                         }
                     }
                     catch {
-                        getContext().observability.breadcrumb(`Batch read failed for ${modelName}, falling back to individual reads`, 'sync.database', 'warning');
+                        this.runtime.observability.breadcrumb(`Batch read failed for ${modelName}, falling back to individual reads`, 'sync.database', 'warning');
                         // Fallback: mark all as missing for self-healing
                         for (const id of updateIds) {
                             missingIds.add(id);
@@ -920,7 +922,7 @@ export class Database {
                 // so its delta is skipped).
                 const failedToFetch = new Set();
                 if (missingIds.size > 0) {
-                    getContext().logger.info(`[Database.processDeltaBatch] Found ${missingIds.size} missing records for ${modelName}, fetching from server...`);
+                    this.runtime.logger.info(`[Database.processDeltaBatch] Found ${missingIds.size} missing records for ${modelName}, fetching from server...`);
                     // Fetch sequentially to avoid overwhelming server
                     for (const id of missingIds) {
                         try {
@@ -928,24 +930,24 @@ export class Database {
                             if (fetchedRecord) {
                                 const compacted = this.compactRecord(modelName, fetchedRecord);
                                 existingRecords.set(id, compacted);
-                                getContext().logger.debug(`[Database.processDeltaBatch] Successfully fetched missing record: ${modelName}:${id}`);
+                                this.runtime.logger.debug(`[Database.processDeltaBatch] Successfully fetched missing record: ${modelName}:${id}`);
                             }
                             else {
                                 // fetchEntity returns null for 404 — entity was deleted, skip the delta
                                 failedToFetch.add(id);
-                                getContext().logger.debug(`[Database.processDeltaBatch] Entity not found (deleted): ${modelName}:${id}`);
+                                this.runtime.logger.debug(`[Database.processDeltaBatch] Entity not found (deleted): ${modelName}:${id}`);
                             }
                         }
                         catch (error) {
                             // Unexpected error (5xx, network failure) — mark for skipping and report
                             failedToFetch.add(id);
-                            getContext().observability.breadcrumb(`Failed to fetch missing record ${modelName}:${id}`, 'sync.database', 'warning', {
+                            this.runtime.observability.breadcrumb(`Failed to fetch missing record ${modelName}:${id}`, 'sync.database', 'warning', {
                                 error: error instanceof Error ? error.message : String(error),
                             });
                         }
                     }
                     if (failedToFetch.size > 0) {
-                        getContext().logger.info(`[Database.processDeltaBatch] Skipping ${failedToFetch.size} stale UPDATE deltas for deleted entities`, {
+                        this.runtime.logger.info(`[Database.processDeltaBatch] Skipping ${failedToFetch.size} stale UPDATE deltas for deleted entities`, {
                             modelName,
                             failedCount: failedToFetch.size,
                             totalMissing: missingIds.size,
@@ -997,7 +999,7 @@ export class Database {
                             // store nor fetchable from the server (a 404), it was deleted,
                             // so skip it rather than create an incomplete record.
                             if (!existing && failedToFetch.has(modelId)) {
-                                getContext().logger.debug('[Database.processDeltaBatch] Skipping UPDATE for deleted entity', {
+                                this.runtime.logger.debug('[Database.processDeltaBatch] Skipping UPDATE for deleted entity', {
                                     modelName,
                                     modelId: modelId.slice(0, 12),
                                 });
@@ -1008,7 +1010,7 @@ export class Database {
                             // building a record from partial update data would corrupt it
                             // (missing reportId, and so on).
                             if (!existing) {
-                                getContext().observability.breadcrumb('Batch: Skipping UPDATE delta - no existing record', 'sync.database', 'warning', {
+                                this.runtime.observability.breadcrumb('Batch: Skipping UPDATE delta - no existing record', 'sync.database', 'warning', {
                                     modelName,
                                     modelId: modelId.slice(0, 12),
                                 });
@@ -1084,7 +1086,7 @@ export class Database {
                 // `DataError`, `AbortError`) so we can find what's wrong with
                 // the `compacted` payload shape or store schema.
                 const idbErr = err instanceof Error ? err : new Error(String(err));
-                getContext().logger.debug('[Database.processDeltaBatch] store tx FAILED', {
+                this.runtime.logger.debug('[Database.processDeltaBatch] store tx FAILED', {
                     modelName,
                     storeDeltasCount: storeDeltas.length,
                     errorName: idbErr.name,
@@ -1097,7 +1099,7 @@ export class Database {
                             : typeof delta.data,
                     })),
                 });
-                getContext().observability.captureMutationFailure({
+                this.runtime.observability.captureMutationFailure({
                     context: 'batch-indexeddb-operation',
                     modelName,
                     error: idbErr,
@@ -1123,7 +1125,7 @@ export class Database {
                 await this.updateWorkspaceMetadata({ lastSyncId: highestPersistedSyncId });
             }
             catch (err) {
-                getContext().observability.breadcrumb('Failed to update metadata after batch', 'sync.database', 'error', {
+                this.runtime.observability.breadcrumb('Failed to update metadata after batch', 'sync.database', 'error', {
                     error: err instanceof Error ? err.message : String(err),
                 });
             }
@@ -1133,7 +1135,7 @@ export class Database {
             // persisted" signal loud when it actually happens. If this fires
             // repeatedly on the same sync IDs, a specific row is un-writable
             // (validation? compact issue?) and needs fixing at that layer.
-            getContext().logger.debug('[Database.processDeltaBatch] cursor withheld due to failed store tx', {
+            this.runtime.logger.debug('[Database.processDeltaBatch] cursor withheld due to failed store tx', {
                 seen: highestSyncId,
                 persisted: highestPersistedSyncId,
                 gap: highestSyncId - highestPersistedSyncId,
@@ -1153,7 +1155,7 @@ export class Database {
     async putRecord(modelName, id, data) {
         const store = this.getStore(modelName, 'putRecord');
         if (!store) {
-            getContext().observability.breadcrumb(`Store not found for putRecord: ${modelName}`, 'sync.database', 'warning');
+            this.runtime.observability.breadcrumb(`Store not found for putRecord: ${modelName}`, 'sync.database', 'warning');
             return;
         }
         const compacted = this.compactRecord(modelName, data);
@@ -1196,7 +1198,7 @@ export class Database {
         // Graceful degradation: skip if database is closing or not open
         // This prevents "Database not opened" errors during React Strict Mode cleanup
         if (!this.workspaceDb || this.isClosing) {
-            getContext().observability.breadcrumb('updateWorkspaceMetadata: Database not open or closing', 'sync.database', 'warning', {
+            this.runtime.observability.breadcrumb('updateWorkspaceMetadata: Database not open or closing', 'sync.database', 'warning', {
                 hasDb: !!this.workspaceDb,
                 isClosing: this.isClosing,
             });
@@ -1488,13 +1490,13 @@ export class Database {
         }
         await this.databaseManager.close();
         this.currentDbInfo = null;
-        getContext().logger.debug('Database closed');
+        this.runtime.logger.debug('Database closed');
     }
     async clear(options = {}) {
         await this.storeManager.clearAllStores();
         if (options.includeWriteJournal) {
             await this.transactionStore.clear();
         }
-        getContext().logger.info('All stores cleared');
+        this.runtime.logger.info('All stores cleared');
     }
 }

package/dist/InstanceCache.d.ts

@@ -8,9 +8,10 @@
  */
 import { Model } from './Model.js';
 import { ModelRegistry } from './ModelRegistry.js';
+import type { RuntimeContext } from './RuntimeContext.js';
 import { ModelScope } from './transaction/types/index.js';
-import { ViewRegistry } from './core/ViewRegistry.js';
-import { QueryView, type QueryViewOptions } from './core/QueryView.js';
+import { ViewRegistry } from './views/ViewRegistry.js';
+import { QueryView, type QueryViewOptions } from './views/QueryView.js';
 /** Constructor type for Model subclasses - uses abstract to handle variance */
 type ModelConstructor<T extends Model> = abstract new (...args: never[]) => T;
 export { ModelScope };
@@ -19,6 +20,8 @@ interface PoolConfig {
     maxAge?: number;
     gcInterval?: number;
     useWeakRefs?: boolean;
+    /** The owning client's runtime. Defaults to the module-global bridge. */
+    runtime?: RuntimeContext;
 }
 interface DeltaInfo {
     action?: string;
@@ -38,6 +41,7 @@ export declare class InstanceCache {
     private foreignKeyConfig;
     private metrics;
     private config;
+    private readonly runtime;
     private gcTimer?;
     readonly registry: ModelRegistry;
     readonly viewRegistry: ViewRegistry;

package/dist/InstanceCache.js

@@ -9,11 +9,11 @@
 import { makeObservable, observable, action, computed, runInAction } from 'mobx';
 import { Model } from './Model.js';
 import { ModelRegistry } from './ModelRegistry.js';
-import { getContext } from './context.js';
+import { globalRuntime } from './context.js';
 import { AbloValidationError } from './transaction/errors.js';
 import { ModelScope } from './transaction/types/index.js';
-import { ViewRegistry } from './core/ViewRegistry.js';
-import { QueryView } from './core/QueryView.js';
+import { ViewRegistry } from './views/ViewRegistry.js';
+import { QueryView } from './views/QueryView.js';
 // Re-exported so `import { ModelScope } from './InstanceCache.js'` resolves
 export { ModelScope };
 /**
@@ -51,6 +51,7 @@ export class InstanceCache {
     };
     // Configuration
     config;
+    runtime;
     gcTimer;
     // ModelRegistry instance — single source of truth for model metadata
     registry;
@@ -106,6 +107,7 @@ export class InstanceCache {
             gcInterval: config.gcInterval ?? 60000, // 1 minute
             useWeakRefs: config.useWeakRefs ?? true,
         };
+        this.runtime = config.runtime ?? globalRuntime;
         // Store the model registry reference
         if (!modelRegistry) {
             throw new AbloValidationError('InstanceCache requires ModelRegistry for production-safe model name lookup', { code: 'pool_registry_missing' });
@@ -264,7 +266,7 @@ export class InstanceCache {
                     (history.lastAction === 'U' || history.lastAction === 'D')) {
                     // Internal delta-ordering anomaly that reconciles on the next
                     // catch-up — forensic, not consumer-actionable → debug.
-                    getContext().logger.debug(`InstanceCache.add() SUSPICIOUS: INSERT after ${history.lastAction}`, { modelType, id, syncId: deltaInfo.syncId });
+                    this.runtime.logger.debug(`InstanceCache.add() SUSPICIOUS: INSERT after ${history.lastAction}`, { modelType, id, syncId: deltaInfo.syncId });
                 }
             }
             // Update delta history
@@ -539,7 +541,7 @@ export class InstanceCache {
                     // This is expected during migration from hand-coded → dynamic models.
                 }
                 catch (e) {
-                    getContext().observability.breadcrumb(`Failed to create fallback instance for ${modelClass.name}`, 'sync.database', 'error', {
+                    this.runtime.observability.breadcrumb(`Failed to create fallback instance for ${modelClass.name}`, 'sync.database', 'error', {
                         error: e instanceof Error ? e.message : String(e),
                     });
                     return [];
@@ -647,8 +649,8 @@ export class InstanceCache {
             if (modelName === 'Unknown') {
                 // Malformed row with no type marker — dropped, but nothing the consumer
                 // can act on (the actionable schema-drift case is handled below) → debug.
-                getContext().logger.debug('InstanceCache.createFromData: No model identifier found', { data });
-                getContext().modelDebugLogger?.logError('Unknown', 'CREATE', 'No model identifier found', data);
+                this.runtime.logger.debug('InstanceCache.createFromData: No model identifier found', { data });
+                this.runtime.modelDebugLogger?.logError('Unknown', 'CREATE', 'No model identifier found', data);
                 return null;
             }
             if (opts?.strict) {
@@ -661,9 +663,9 @@ export class InstanceCache {
             // Genuinely actionable and NOT self-healing: a model the server is sending
             // isn't in your schema, so these rows are silently skipped. Keep at warn,
             // consumer register (their model name + the `ablo status` fix); forensics ride debug.
-            getContext().logger.warn(`Received data for "${modelName}", which isn't in your schema — these rows will be skipped. Run \`ablo status\` to compare your local schema with the server.`);
-            getContext().logger.debug(`InstanceCache.createFromData: No constructor found for model "${modelName}"`, { data });
-            getContext().modelDebugLogger?.logError(modelName, 'CREATE', `No constructor found for model "${modelName}"`, data);
+            this.runtime.logger.warn(`Received data for "${modelName}", which isn't in your schema — these rows will be skipped. Run \`ablo status\` to compare your local schema with the server.`);
+            this.runtime.logger.debug(`InstanceCache.createFromData: No constructor found for model "${modelName}"`, { data });
+            this.runtime.modelDebugLogger?.logError(modelName, 'CREATE', `No constructor found for model "${modelName}"`, data);
             return null;
         }
         // If the model already exists, update it in place instead of creating a
@@ -680,7 +682,7 @@ export class InstanceCache {
             // Don't return existing, create new model (will use composite key for storage)
         }
         // Log model creation attempt
-        getContext().modelDebugLogger?.logCreation(modelName, data, Constructor);
+        this.runtime.modelDebugLogger?.logCreation(modelName, data, Constructor);
         try {
             // Pass data directly to constructor for Prisma-first models
             const model = new Constructor(data);
@@ -690,14 +692,14 @@ export class InstanceCache {
             const errorMessage = error instanceof Error ? error.message : String(error);
             // Internal construction failure — captured via observability below and
             // re-fetched on resync; the stack is forensic → debug.
-            getContext().logger.debug(`[InstanceCache.createFromData] FAILED ${modelName}`, { errorMessage, stack: error instanceof Error ? error.stack : undefined });
-            getContext().observability.captureMutationFailure({
+            this.runtime.logger.debug(`[InstanceCache.createFromData] FAILED ${modelName}`, { errorMessage, stack: error instanceof Error ? error.stack : undefined });
+            this.runtime.observability.captureMutationFailure({
                 context: 'createFromData',
                 modelName,
                 modelId: data.id,
                 error: errorMessage,
             });
-            getContext().modelDebugLogger?.logError(modelName, 'CREATE', errorMessage, {
+            this.runtime.modelDebugLogger?.logError(modelName, 'CREATE', errorMessage, {
                 data,
                 constructor: Constructor.name,
             });
@@ -904,7 +906,7 @@ export class InstanceCache {
                 }
             }
             if (skippedObserved > 0) {
-                getContext().logger.debug(`[InstanceCache GC] Skipped ${skippedObserved} models with active React observers`);
+                this.runtime.logger.debug(`[InstanceCache GC] Skipped ${skippedObserved} models with active React observers`);
             }
             // Also clean up old tracking data
             this.clearDeltaHistory();
@@ -1046,7 +1048,7 @@ export class InstanceCache {
             // has dangling refs (legacy orphan deltas, pending CREATE
             // transactions, etc.). Noisy at warn level, useful during
             // investigation.
-            getContext().logger.debug('[InstanceCache.getByForeignKey] ROWS DROPPED', {
+            this.runtime.logger.debug('[InstanceCache.getByForeignKey] ROWS DROPPED', {
                 modelName,
                 fieldName,
                 fieldValue,