@abloatai/ablo 0.35.0 → 0.36.0

package/dist/{core → stores}/StoreManager.js

@@ -7,8 +7,8 @@
  * when its data is loaded.
  */
 import { ModelRegistry } from '../ModelRegistry.js';
-import { ObjectStore } from '../stores/ObjectStore.js';
-import { SyncActionStore } from '../stores/SyncActionStore.js';
+import { ObjectStore } from './ObjectStore.js';
+import { SyncActionStore } from './SyncActionStore.js';
 import { LoadStrategy } from '../transaction/types/index.js';
 import { AbloValidationError } from '../transaction/errors.js';
 /**
@@ -21,6 +21,7 @@ import { AbloValidationError } from '../transaction/errors.js';
  * - Handles store-specific optimizations based on load strategies
  */
 export class StoreManager {
+    runtime;
     stores = new Map();
     /** Strict-durability wrapper for the client write journal and commit outbox. */
     transactionStore = null;
@@ -28,7 +29,8 @@ export class StoreManager {
     db = null;
     isInitialized = false;
     modelRegistry;
-    constructor(modelRegistry) {
+    constructor(modelRegistry, runtime = globalRuntime) {
+        this.runtime = runtime;
         this.modelRegistry = modelRegistry;
     }
     /**
@@ -38,10 +40,10 @@ export class StoreManager {
         this.db = db;
         if (this.isInitialized) {
             // Idempotent re-entry — harmless, nothing for the consumer to act on → debug.
-            getContext().logger.debug('StoreManager already initialized');
+            this.runtime.logger.debug('StoreManager already initialized');
             return;
         }
-        getContext().logger.info('Initializing ObjectStore instances for all models');
+        this.runtime.logger.info('Initializing ObjectStore instances for all models');
         const startTime = performance.now();
         // Get all registered models
         const allModels = this.modelRegistry.getRegisteredModelNames();
@@ -55,11 +57,11 @@ export class StoreManager {
         // mode.
         this.transactionStore = new ObjectStore(this.db, '__transactions', '__transactions', { loadStrategy: LoadStrategy.instant }, 'strict');
         // Initialize SyncactionStore
-        this.syncactionStore = new SyncActionStore(this.db);
+        this.syncactionStore = new SyncActionStore(this.db, this.runtime);
         await this.syncactionStore.initialize();
         this.isInitialized = true;
         const duration = performance.now() - startTime;
-        getContext().logger.info('Initialized ObjectStores and SyncactionStore', {
+        this.runtime.logger.info('Initialized ObjectStores and SyncactionStore', {
             count: this.stores.size,
             ms: duration.toFixed(2),
         });
@@ -84,14 +86,14 @@ export class StoreManager {
      * Create stores (tables) in IndexedDB
      */
     async createStores(db) {
-        getContext().logger.info('Creating tables for all registered models');
+        this.runtime.logger.info('Creating tables for all registered models');
         for (const modelName of this.modelRegistry.getRegisteredModelNames()) {
             const storeName = modelName;
             // Skip if store already exists
             if (db.objectStoreNames.contains(storeName)) {
                 continue;
             }
-            getContext().logger.debug('Creating table', { storeName, modelName });
+            this.runtime.logger.debug('Creating table', { storeName, modelName });
             // Create object store with id as keyPath
             const store = db.createObjectStore(storeName, { keyPath: 'id' });
             // Create indexes for indexed properties
@@ -99,12 +101,12 @@ export class StoreManager {
             for (const propName of indexedProperties) {
                 try {
                     store.createIndex(propName, propName, { unique: false });
-                    getContext().logger.debug('Created index', { store: storeName, prop: propName });
+                    this.runtime.logger.debug('Created index', { store: storeName, prop: propName });
                 }
                 catch (error) {
                     // Internal IndexedDB index setup — a miss only affects local query
                     // speed and isn't consumer-actionable → debug.
-                    getContext().logger.debug('Failed to create index', { store: storeName, prop: propName, error });
+                    this.runtime.logger.debug('Failed to create index', { store: storeName, prop: propName, error });
                 }
             }
         }
@@ -119,12 +121,12 @@ export class StoreManager {
         if (!db.objectStoreNames.contains('sync_action_table')) {
             const syncActionStore = db.createObjectStore('sync_action_table', { keyPath: 'id' });
             syncActionStore.createIndex('syncId', 'id');
-            getContext().logger.debug('Created sync_action_table');
+            this.runtime.logger.debug('Created sync_action_table');
         }
         // Create __meta table for model persistence state and database metadata
         if (!db.objectStoreNames.contains('__meta')) {
             db.createObjectStore('__meta');
-            getContext().logger.debug('Created __meta table');
+            this.runtime.logger.debug('Created __meta table');
         }
         // Create __transactions table for unsent transactions
         if (!db.objectStoreNames.contains('__transactions')) {
@@ -135,7 +137,7 @@ export class StoreManager {
             // Create indexes for transaction queries
             transactionStore.createIndex('timestamp', 'timestamp');
             transactionStore.createIndex('status', 'status');
-            getContext().logger.debug('Created __transactions table');
+            this.runtime.logger.debug('Created __transactions table');
         }
     }
     /**
@@ -175,7 +177,7 @@ export class StoreManager {
             }
         }
         const allReady = notReadyStores.length === 0;
-        getContext().logger.debug('Store readiness', {
+        this.runtime.logger.debug('Store readiness', {
             ready: readyStores.length,
             total: this.stores.size,
             notReady: notReadyStores,
@@ -232,10 +234,10 @@ export class StoreManager {
      * Perform maintenance on all stores
      */
     async performMaintenance() {
-        getContext().logger.info('Performing maintenance on all stores');
+        this.runtime.logger.info('Performing maintenance on all stores');
         const promises = Array.from(this.stores.values()).map((store) => store.performMaintenance());
         await Promise.all(promises);
-        getContext().logger.info('Store maintenance completed');
+        this.runtime.logger.info('Store maintenance completed');
     }
     /**
      * Clear all stores
@@ -243,17 +245,17 @@ export class StoreManager {
     async clearAllStores() {
         // 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');
+        this.runtime.logger.debug('Clearing all stores');
         const promises = Array.from(this.stores.values()).map((store) => store.clear());
         await Promise.all(promises);
-        getContext().logger.info('All stores cleared');
+        this.runtime.logger.info('All stores cleared');
     }
     /**
      * Mark all stores as closing to prevent new operations
      * Called before database connection is closed
      */
     markAllStoresAsClosing() {
-        getContext().logger.debug('Marking all stores as closing');
+        this.runtime.logger.debug('Marking all stores as closing');
         for (const store of this.stores.values()) {
             store.markAsClosing();
         }
@@ -263,7 +265,7 @@ export class StoreManager {
         // 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');
+        this.runtime.logger.debug('All stores marked as closing');
     }
     /**
      * Get comprehensive statistics
@@ -299,4 +301,4 @@ export class StoreManager {
         };
     }
 }
-import { getContext } from '../context.js';
+import { globalRuntime } from '../context.js';

package/dist/stores/SyncActionStore.d.ts

@@ -2,6 +2,7 @@
  * A local, IndexedDB-backed store for the sync actions (change deltas) the
  * server sends. See {@link SyncActionStore}.
  */
+import type { RuntimeContext } from '../RuntimeContext.js';
 import { type SyncAction } from './syncAction.js';
 /**
  * Stores the sync actions (the change deltas) the server sends, keyed by
@@ -11,11 +12,12 @@ import { type SyncAction } from './syncAction.js';
  * replayed while resolving a conflict.
  */
 export declare class SyncActionStore {
+    private readonly runtime;
     private db;
     private storeName;
     private lastAppliedSyncId;
     private pendingActions;
-    constructor(db: IDBDatabase);
+    constructor(db: IDBDatabase, runtime?: RuntimeContext);
     /**
      * Initialize store (create if needed)
      */

package/dist/stores/SyncActionStore.js

@@ -3,7 +3,7 @@
  * server sends. See {@link SyncActionStore}.
  */
 // Uses native IndexedDB for maximum performance
-import { getContext } from '../context.js';
+import { globalRuntime } from '../context.js';
 import { syncActionSchema } from './syncAction.js';
 /**
  * The validation boundary for rows read back from the store. A row may have
@@ -14,10 +14,10 @@ import { syncActionSchema } from './syncAction.js';
  * than replayed as a malformed delta.
  */
 /** Parse one stored row into a SyncAction, or `null` (dropped + logged). */
-function toSyncAction(row) {
+function toSyncAction(row, runtime) {
     const parsed = syncActionSchema.safeParse(row);
     if (!parsed.success) {
-        getContext().logger.debug('[SyncActionStore] Dropping malformed stored sync action', {
+        runtime.logger.debug('[SyncActionStore] Dropping malformed stored sync action', {
             issues: parsed.error.issues.map((i) => i.path.join('.')).join(', '),
         });
         return null;
@@ -32,11 +32,13 @@ function toSyncAction(row) {
  * replayed while resolving a conflict.
  */
 export class SyncActionStore {
+    runtime;
     db;
     storeName = 'sync_action_table';
     lastAppliedSyncId = 0;
     pendingActions = new Map();
-    constructor(db) {
+    constructor(db, runtime = globalRuntime) {
+        this.runtime = runtime;
         this.db = db;
     }
     /**
@@ -121,7 +123,7 @@ export class SyncActionStore {
                     resolve(undefined);
                     return;
                 }
-                resolve(toSyncAction(data) ?? undefined);
+                resolve(toSyncAction(data, this.runtime) ?? undefined);
             };
             request.onerror = () => { reject(request.error); };
         });
@@ -139,7 +141,7 @@ export class SyncActionStore {
             request.onsuccess = () => {
                 const allData = request.result;
                 const actions = allData
-                    .map(toSyncAction)
+                    .map((row) => toSyncAction(row, this.runtime))
                     .filter((action) => action !== null);
                 resolve(actions);
             };
@@ -488,7 +490,7 @@ export class SyncActionStore {
                     try {
                         await this.updateLastSyncId(this.lastAppliedSyncId);
                         const result = actionsToRewind
-                            .map(toSyncAction)
+                            .map((row) => toSyncAction(row, this.runtime))
                             .filter((action) => action !== null);
                         resolve(result);
                     }

package/dist/sync/BootstrapFetcher.d.ts

@@ -94,11 +94,15 @@ export interface BootstrapOptions {
      * {@link BootstrapFetcher.setAuthToken}.
      */
     getAuthToken?: AuthTokenGetter;
+    /** The owning client's runtime. Defaults to the module-global bridge. */
+    runtime?: RuntimeContext;
 }
+import type { RuntimeContext } from '../RuntimeContext.js';
 import { type AuthTokenGetter } from '../transaction/auth/credentialSource.js';
 import { type ValidatedServerDelta } from './schemas.js';
 export declare class BootstrapFetcher {
     private options;
+    private readonly runtime;
     /**
      * Every in-flight request's controller, tagged with the lane it belongs to. A
      * registry rather than a single field because a chunked cold start runs

package/dist/sync/BootstrapFetcher.js

@@ -6,11 +6,11 @@
  * cached snapshot when the device is offline. {@link BootstrapData} is the
  * shape it returns; {@link BootstrapOptions} configures it.
  */
-import { getContext } from '../context.js';
+import { globalRuntime } from '../context.js';
 import { AbloError, AbloSessionError, AbloConnectionError, translateHttpError, toAbloError, isRetryableCode } from '../transaction/errors.js';
 import { withAuthHeaders } from '../transaction/auth/credentialSource.js';
 import { classifySchemaDrift, describeSchemaDrift, } from './schemaDrift.js';
-// SyncObservability replaced by getContext().observability
+// SyncObservability replaced by this.runtime.observability
 import { parseBootstrapResponse } from './schemas.js';
 /**
  * Rows per page for the chunked cold-start bootstrap. Matches the server's
@@ -67,6 +67,7 @@ function classifyRequestFailure(error, controller, diedMessage) {
 }
 export class BootstrapFetcher {
     options;
+    runtime;
     /**
      * Every in-flight request's controller, tagged with the lane it belongs to. A
      * registry rather than a single field because a chunked cold start runs
@@ -139,14 +140,14 @@ export class BootstrapFetcher {
     warnOnSchemaDrift(serverHash) {
         if (this.schemaDriftWarned || !serverHash)
             return;
-        const clientHash = getContext().config.expectedSchemaHash;
+        const clientHash = this.runtime.config.expectedSchemaHash;
         if (!clientHash || clientHash === serverHash)
             return;
         // A projection (`selectModels`/`omitModels`) hashes its subset, which never
         // equals the full schema a server runs — so it also carries the source
         // schema's hash. Matching that means the client is a faithful subset of the
         // deployed schema: current, not drifted. Only warn when neither matches.
-        const sourceHash = getContext().config.expectedSourceSchemaHash;
+        const sourceHash = this.runtime.config.expectedSourceSchemaHash;
         if (sourceHash && sourceHash === serverHash)
             return;
         this.schemaDriftWarned = true;
@@ -158,7 +159,7 @@ export class BootstrapFetcher {
         // from the server's per-model surface before speaking; fall back to the
         // hash message only when that surface is unavailable (older server,
         // network hiccup). Fire-and-forget: never blocks or fails the bootstrap.
-        const clientModels = getContext().config.expectedModelHashes;
+        const clientModels = this.runtime.config.expectedModelHashes;
         if (clientModels && Object.keys(clientModels).length > 0) {
             void this.resolveSemanticDrift(clientModels, clientHash, serverHash, where);
             return;
@@ -188,7 +189,7 @@ export class BootstrapFetcher {
             if (finding.kind === 'aligned')
                 return; // additive server lead — not this client's concern
             if (finding.kind !== 'unknown') {
-                getContext().logger.warn(describeSchemaDrift(finding, where), {
+                this.runtime.logger.warn(describeSchemaDrift(finding, where), {
                     clientSchemaHash: clientHash,
                     serverSchemaHash: serverHash,
                     serverUrl: this.baseUrl,
@@ -210,7 +211,7 @@ export class BootstrapFetcher {
         // `[Ablo]` namespace — consumers wiring their own logger (pino, etc.) lose
         // that prefix, and a drift warning that reads like the app's own log is
         // worse than none. The brand tells them at a glance who is talking.
-        getContext().logger.warn(`Ablo: Schema drift — the schema this client was built with (${clientHash}) is not the ` +
+        this.runtime.logger.warn(`Ablo: Schema drift — the schema this client was built with (${clientHash}) is not the ` +
             `one active on the server it connected to (${serverHash} at ${where}). Until they match, ` +
             `operations that depend on the difference will fail later with an opaque database error. ` +
             `This is usually one of three things. The schema may have been pushed to a different ` +
@@ -227,6 +228,7 @@ export class BootstrapFetcher {
         });
     }
     constructor(options) {
+        this.runtime = options.runtime ?? globalRuntime;
         // Defaults are spread first; the explicit `baseUrl` then takes precedence,
         // resolved from `options.baseUrl` or the localhost fallback. Callers pass
         // the full base URL, including the `/api` prefix.
@@ -299,7 +301,7 @@ export class BootstrapFetcher {
         const key = this.flightKey(lastSyncId);
         const joined = this.flights.get(key);
         if (joined) {
-            getContext().logger.debug('Joining the bootstrap already in flight', { key });
+            this.runtime.logger.debug('Joining the bootstrap already in flight', { key });
             return joined;
         }
         // A request for something else genuinely does supersede: the running one is
@@ -372,14 +374,14 @@ export class BootstrapFetcher {
                 ? this.loadCachedBootstrap(this.options.cacheScope)
                 : null;
             if (cached) {
-                getContext().logger.info('Using cached bootstrap (offline)');
+                this.runtime.logger.info('Using cached bootstrap (offline)');
                 return cached;
             }
             throw new AbloConnectionError('Offline and no cached bootstrap available', {
                 code: 'bootstrap_offline_no_cache',
             });
         }
-        getContext().logger.info('Fetching fresh bootstrap data', { url });
+        this.runtime.logger.info('Fetching fresh bootstrap data', { url });
         const lane = syncGroupsOverride ? 'scoped' : 'bootstrap';
         // Chunk a COLD start by model: each instant model is its own request, so
         // one giant model can't make the whole snapshot undeliverable, and a
@@ -397,7 +399,7 @@ export class BootstrapFetcher {
             const data = chunked
                 ? await this.fetchChunkedBootstrap(instantModels, this.options.syncGroups)
                 : await this.fetchWithRetries(url, lane);
-            getContext().logger.info('Bootstrap data fetched', {
+            this.runtime.logger.info('Bootstrap data fetched', {
                 type: data.type,
                 lastSyncId: data.lastSyncId,
                 chunked,
@@ -429,7 +431,7 @@ export class BootstrapFetcher {
                 ? this.loadCachedBootstrap(this.options.cacheScope)
                 : null;
             if (cached) {
-                getContext().observability.breadcrumb('Bootstrap cache fallback', 'sync.bootstrap', 'warning', {
+                this.runtime.observability.breadcrumb('Bootstrap cache fallback', 'sync.bootstrap', 'warning', {
                     error: ablo.message,
                 });
                 return cached;
@@ -452,7 +454,7 @@ export class BootstrapFetcher {
             catch (error) {
                 // SessionError should NOT be retried - the session is invalid and needs re-authentication
                 if (AbloSessionError.isSessionError(error)) {
-                    getContext().observability.breadcrumb('Bootstrap session error - redirecting to sign-in', 'sync.bootstrap', 'warning', {
+                    this.runtime.observability.breadcrumb('Bootstrap session error - redirecting to sign-in', 'sync.bootstrap', 'warning', {
                         statusCode: (error).statusCode,
                     });
                     throw error;
@@ -465,11 +467,11 @@ export class BootstrapFetcher {
                 // unclassified error with no code) flow through to the retry/backoff.
                 const ablo = toAbloError(error);
                 if (ablo.code && !isRetryableCode(ablo.code)) {
-                    getContext().observability.breadcrumb('Bootstrap non-retryable error — failing fast', 'sync.bootstrap', 'warning', { code: ablo.code, httpStatus: ablo.httpStatus });
+                    this.runtime.observability.breadcrumb('Bootstrap non-retryable error — failing fast', 'sync.bootstrap', 'warning', { code: ablo.code, httpStatus: ablo.httpStatus });
                     throw ablo;
                 }
                 lastError = error;
-                getContext().observability.breadcrumb('Bootstrap fetch failed', 'sync.bootstrap', 'warning', {
+                this.runtime.observability.breadcrumb('Bootstrap fetch failed', 'sync.bootstrap', 'warning', {
                     attempt: attempt + 1,
                 });
                 if (attempt < this.options.maxRetries - 1) {
@@ -490,7 +492,7 @@ export class BootstrapFetcher {
      * and cancels its siblings.
      */
     async fetchChunkedBootstrap(models, syncGroups) {
-        getContext().logger.info('Bootstrap chunked by model', {
+        this.runtime.logger.info('Bootstrap chunked by model', {
             models: models.length,
         });
         const queue = [...models];
@@ -587,7 +589,7 @@ export class BootstrapFetcher {
         const etag = res.headers.get('ETag');
         if (res.status === 304) {
             // Log for telemetry
-            getContext().logger.info('[Bootstrap] 304 Not Modified - using cached data');
+            this.runtime.logger.info('[Bootstrap] 304 Not Modified - using cached data');
             return { notModified: true, etag };
         }
         if (!res.ok) {
@@ -621,7 +623,7 @@ export class BootstrapFetcher {
             }
             throw translated;
         }
-        const data = parseBootstrapResponse(await this.readJsonWithStallGuard(res, controller));
+        const data = parseBootstrapResponse(await this.readJsonWithStallGuard(res, controller), this.runtime);
         this.warnOnSchemaDrift(data.schemaHash);
         // Persist payload for offline
         try {
@@ -633,7 +635,7 @@ export class BootstrapFetcher {
             // Offline persistence is best-effort; a failed cache write must not
             // block returning the freshly fetched data.
         }
-        getContext().logger.info('[Bootstrap] 200 OK - received new data');
+        this.runtime.logger.info('[Bootstrap] 200 OK - received new data');
         return { notModified: false, data, etag };
     }
     /**
@@ -667,7 +669,7 @@ export class BootstrapFetcher {
         const armStallTimer = () => {
             clearTimeout(stallTimer);
             stallTimer = setTimeout(() => {
-                getContext().observability.breadcrumb('Bootstrap download stalled', 'sync.bootstrap', 'warning', { receivedBytes, stallTimeoutMs: this.options.stallTimeout });
+                this.runtime.observability.breadcrumb('Bootstrap download stalled', 'sync.bootstrap', 'warning', { receivedBytes, stallTimeoutMs: this.options.stallTimeout });
                 const stallError = new AbloConnectionError(`Bootstrap download stalled: no data received for ${this.options.stallTimeout}ms (${receivedBytes} bytes arrived before the stream went quiet)`, { code: 'bootstrap_fetch_timeout' });
                 stallReject?.(stallError);
                 // Then tear the transfer down: abort frees the socket under real
@@ -723,7 +725,7 @@ export class BootstrapFetcher {
     }
     async fetchOnceWith(url, controller) {
         const timeoutId = setTimeout(() => {
-            getContext().observability.breadcrumb('Bootstrap fetch timeout', 'sync.bootstrap', 'warning', {
+            this.runtime.observability.breadcrumb('Bootstrap fetch timeout', 'sync.bootstrap', 'warning', {
                 timeoutMs: this.options.fetchTimeout,
             });
             controller.abort(new AbloConnectionError(`Bootstrap fetch timed out after ${this.options.fetchTimeout}ms waiting for the server to respond`, { code: 'bootstrap_fetch_timeout' }));
@@ -771,7 +773,7 @@ export class BootstrapFetcher {
             }
             throw translated;
         }
-        const data = parseBootstrapResponse(await this.readJsonWithStallGuard(response, controller));
+        const data = parseBootstrapResponse(await this.readJsonWithStallGuard(response, controller), this.runtime);
         this.warnOnSchemaDrift(data.schemaHash);
         // Offline caching happens in `fetchBootstrap` on the assembled result —
         // caching here would let a single-model chunk overwrite the full snapshot.
@@ -848,11 +850,11 @@ export class BootstrapFetcher {
             }
             keysToRemove.forEach((key) => {
                 localStorage.removeItem(key);
-                getContext().logger.debug('Cleared cache key', { key });
+                this.runtime.logger.debug('Cleared cache key', { key });
             });
         }
         catch (error) {
-            getContext().logger.debug('Failed to clear cache', { error });
+            this.runtime.logger.debug('Failed to clear cache', { error });
         }
     }
     // Cache helpers for offline bootstrap
@@ -866,7 +868,7 @@ export class BootstrapFetcher {
             localStorage.setItem(this.getBootstrapCacheKey(orgId), JSON.stringify(data));
         }
         catch (e) {
-            getContext().logger.debug('Failed to cache bootstrap payload', {
+            this.runtime.logger.debug('Failed to cache bootstrap payload', {
                 error: e instanceof Error ? e.message : String(e),
             });
         }
@@ -918,7 +920,7 @@ export class BootstrapFetcher {
             return body.status === 'healthy';
         }
         catch {
-            getContext().observability.breadcrumb('Health check failed', 'sync.bootstrap', 'warning');
+            this.runtime.observability.breadcrumb('Health check failed', 'sync.bootstrap', 'warning');
             return false;
         }
     }

package/dist/sync/OnDemandLoader.d.ts

@@ -24,6 +24,7 @@ import type { InstanceCache } from '../InstanceCache.js';
 import type { Database } from '../Database.js';
 import type { Model } from '../Model.js';
 import type { ModelRegistry } from '../ModelRegistry.js';
+import type { RuntimeContext } from '../RuntimeContext.js';
 import type { RecoveryClass } from '../transaction/errorCodes.js';
 import type { LoadWhere, WhereClause } from '../query/types.js';
 import type { Schema } from '../transaction/schema/schema.js';
@@ -41,6 +42,8 @@ export interface OnDemandLoaderOptions {
     readonly getAuthToken?: () => string | null;
     /** @deprecated Use `getAuthToken`. */
     readonly getCapabilityToken?: () => string | null;
+    /** The owning client's runtime. Defaults to the module-global bridge. */
+    readonly runtime?: RuntimeContext;
 }
 export interface FetchOptions<T> {
     /**

package/dist/sync/OnDemandLoader.js

@@ -432,6 +432,7 @@ export class OnDemandLoader {
             baseUrl: this.opts.baseUrl,
             getAuthToken: this.authTokenProvider ?? undefined,
             recoverCredential: this.credentialRecovery ?? undefined,
+            runtime: this.opts.runtime,
         }, { queries: [query] });
         const rows = Array.isArray(result.results[0]) ? result.results[0] : [];
         // Normalize: wire rows lack `__typename` when the server elides it.

package/dist/sync/bootstrapApply.d.ts

@@ -13,6 +13,7 @@
  * stale local copies the server no longer reports — are performed by the sync
  * client behind that interface.
  */
+import type { RuntimeContext } from '../RuntimeContext.js';
 import type { BootstrapResult } from '../Database.js';
 import type { SyncDelta } from './SyncWebSocket.js';
 /** Counts describing what applying a bootstrap changed in the pool: entities
@@ -32,6 +33,8 @@ export interface RehydrationStats {
  * takes effect through this interface.
  */
 export interface PoolContext {
+    /** The owning client's runtime. Defaults to the module-global bridge. */
+    readonly runtime?: RuntimeContext;
     /** Applies persisted delta results to the in-memory pool, with the host's relation enrichment bound. */
     applyDeltaBatchToPool(results: NonNullable<BootstrapResult['deltaResults']>): void;
     /** Writes bootstrap data into the pool: creates models, heals partial rows, upserts, and removes stale local copies the server no longer reports. */

package/dist/sync/bootstrapApply.js

@@ -13,7 +13,7 @@
  * stale local copies the server no longer reports — are performed by the sync
  * client behind that interface.
  */
-import { getContext } from '../context.js';
+import { globalRuntime } from '../context.js';
 /**
  * Applies a bootstrap result to the in-memory pool and returns what changed.
  * A full bootstrap creates, heals, and upserts models and removes stale local
@@ -42,7 +42,7 @@ export function applyBootstrapToPool(ctx, bootstrapResult, protectedIds) {
     // Creates models, heals partial rows, upserts, and removes stale local copies.
     const stats = ctx.applyBootstrapDataToPool(bootstrapData, protectedIds);
     const elapsedMs = Math.round((typeof performance !== 'undefined' ? performance.now() : Date.now()) - start);
-    getContext().logger.info('[BaseSyncedStore] Bootstrap applied', {
+    (ctx.runtime ?? globalRuntime).logger.info('[BaseSyncedStore] Bootstrap applied', {
         ...stats, elapsedMs, poolSize: ctx.getPoolSize(),
     });
     return { ...stats, elapsedMs };

package/dist/sync/deltaPipeline.d.ts

@@ -10,18 +10,12 @@
  * point lives on the store and drives this pipeline through {@link enqueueDelta}
  * and {@link flushPendingDeltas}.
  */
+import type { RuntimeContext } from '../RuntimeContext.js';
 import { ModelScope } from '../InstanceCache.js';
 import type { Model } from '../Model.js';
-import type { ModelData } from '../transaction/types/modelData.js';
 import type { SyncDelta } from './SyncWebSocket.js';
-/** One applied-delta result from the persistence layer's batch write, forwarded to the pool. */
-interface DeltaDbResult {
-    action: 'add' | 'update' | 'remove' | 'archive' | 'verify';
-    modelName: string;
-    modelId: string;
-    data?: ModelData | null;
-    transactionId?: string;
-}
+import type { ModelData } from '../transaction/types/modelData.js';
+import { type AbloPlugin, type AppliedChange } from '../transaction/plugin.js';
 /**
  * What the pipeline needs back from the surrounding store: the shared mutable
  * pipeline state (backed by the store's own fields through accessors), narrow
@@ -29,6 +23,14 @@ interface DeltaDbResult {
  * subclass's overrides continue to take effect.
  */
 export interface DeltaPipelineContext {
+    /** The owning client's runtime. Defaults to the module-global bridge. */
+    readonly runtime?: RuntimeContext;
+    /**
+     * The installed plugins, whose declared stage handlers this pipeline
+     * dispatches at each boundary. Empty (or absent) on directly-constructed
+     * stores, where the store's own apply is the whole pipeline.
+     */
+    readonly stagePlugins?: readonly AbloPlugin[];
     pendingDeltas: SyncDelta[];
     batchTimer: ReturnType<typeof setTimeout> | null;
     /** Queue for deltas arriving during an active bootstrap; null when none. */
@@ -52,11 +54,11 @@ export interface DeltaPipelineContext {
         data: ModelData | null;
         transactionId?: string;
     }[]): Promise<{
-        results: DeltaDbResult[];
+        results: AppliedChange[];
         persistedSyncId: number;
     }>;
     /** Applies persisted delta results to the in-memory pool, with the host's relation enrichment bound. */
-    applyDeltaBatchToPool(results: DeltaDbResult[]): void;
+    applyDeltaBatchToPool(results: AppliedChange[]): void;
     /** Acknowledges a sync id back to the server; a no-op when the socket is down. */
     acknowledge(syncId: number): void;
     readonly objectPool: {
@@ -110,4 +112,3 @@ export declare function scheduleDeltaFlush(ctx: DeltaPipelineContext): void;
  * and advances the acknowledgement cursor once the store write has committed.
  */
 export declare function flushPendingDeltas(ctx: DeltaPipelineContext): Promise<void>;
-export {};