@abloatai/ablo 0.35.0 → 0.36.0

package/dist/SyncClient.js

@@ -14,7 +14,7 @@ import { Model } from './Model.js';
 import { snapshotJsonValue } from './transaction/utils/json.js';
 // ModelRegistry instance accessed via this.objectPool.registry
 import { LoadStrategy } from './transaction/types/index.js';
-import { getContext } from './context.js';
+import { globalRuntime } from './context.js';
 import { AbloAuthenticationError, AbloError, AbloValidationError } from './transaction/errors.js';
 import { EventEmitter } from 'events';
 import { NetworkMonitor } from './NetworkMonitor.js';
@@ -67,9 +67,10 @@ function toEpochMs(value) {
     return 0;
 }
 export class SyncClient extends EventEmitter {
+    runtime;
     objectPool;
     database;
-    get mutationExecutor() { return getContext().mutationExecutor; }
+    get mutationExecutor() { return this.runtime.mutationExecutor; }
     networkMonitor;
     /**
      * @internal — test seam, stripped from the published declarations by
@@ -111,15 +112,17 @@ export class SyncClient extends EventEmitter {
      * responses, and snapshots and claims read `readFloor`.
      */
     position = new LogPosition();
-    constructor(objectPool, database, commitOutbox = new DatabaseCommitOutboxStore(database), commitOutboxNamespace = 'default') {
+    constructor(objectPool, database, commitOutbox = new DatabaseCommitOutboxStore(database), commitOutboxNamespace = 'default', runtime = globalRuntime) {
         super();
+        this.runtime = runtime;
         this.objectPool = objectPool;
         this.database = database;
         this.commitOutboxNamespace = commitOutboxNamespace;
-        this.networkMonitor = new NetworkMonitor();
+        this.networkMonitor = new NetworkMonitor(this.runtime);
         // Initialize MutationQueue with proper configuration
         this.mutationQueue = new MutationQueue({
             position: this.position,
+            runtime: this.runtime,
             maxBatchSize: 50, // Larger batches keep the batch count low for bulk operations
             // A short delay keeps writes responsive; coalescing still groups them
             batchDelay: 150,
@@ -203,7 +206,7 @@ export class SyncClient extends EventEmitter {
         // losing a failed reconnect flush silently.
         this.networkMonitor.on('online', () => {
             void this.handleReconnection().catch((error) => {
-                getContext().observability.captureMutationFailure({
+                this.runtime.observability.captureMutationFailure({
                     context: 'network-online-reconnection',
                     error: error instanceof Error ? error : new Error(String(error)),
                 });
@@ -211,7 +214,7 @@ export class SyncClient extends EventEmitter {
         });
         this.networkMonitor.on('offline', () => {
             void this.handleDisconnection().catch((error) => {
-                getContext().observability.captureMutationFailure({
+                this.runtime.observability.captureMutationFailure({
                     context: 'network-offline-handler',
                     error: error instanceof Error ? error : new Error(String(error)),
                 });
@@ -261,7 +264,7 @@ export class SyncClient extends EventEmitter {
             // rejected write — keep it at `debug` so the rollback mechanics are
             // available when debugging but don't double the console noise.
             const abloErr = error instanceof AbloError ? error : undefined;
-            getContext().logger.debug('[SyncClient.rollback]', {
+            this.runtime.logger.debug('[SyncClient.rollback]', {
                 txType: transaction.type,
                 modelName: transaction.modelName,
                 modelId: transaction.modelId.slice(0, 12),
@@ -272,7 +275,7 @@ export class SyncClient extends EventEmitter {
                 requestId: abloErr?.requestId,
                 message: error?.message,
             });
-            getContext().observability.captureRollback({
+            this.runtime.observability.captureRollback({
                 transactionType: transaction.type,
                 modelName: transaction.modelName,
                 modelId: transaction.modelId,
@@ -291,7 +294,7 @@ export class SyncClient extends EventEmitter {
                     // DELETE "not found" rollback: the entity doesn't exist on the server.
                     // Instead of restoring a ghost entity, remove it locally too.
                     // Both sides agree: this entity should not exist.
-                    getContext().observability.breadcrumb('DELETE rolled back with "not found" - removing ghost entity', 'sync.conflict', 'info', {
+                    this.runtime.observability.breadcrumb('DELETE rolled back with "not found" - removing ghost entity', 'sync.conflict', 'info', {
                         modelId: transaction.modelId,
                         modelName: transaction.modelName,
                     });
@@ -309,7 +312,7 @@ export class SyncClient extends EventEmitter {
                         // design (can't revive the private isDisposed flag), so keep this
                         // at `debug` instead of emitting a second `warn` that reads as a
                         // distinct failure in the console.
-                        getContext().logger.debug('[SyncClient] Rollback skipped restore (model already disposed)', {
+                        this.runtime.logger.debug('[SyncClient] Rollback skipped restore (model already disposed)', {
                             modelId: transaction.modelId,
                             modelName: transaction.modelName,
                             reason,
@@ -336,7 +339,7 @@ export class SyncClient extends EventEmitter {
                 });
             }
             catch (error) {
-                getContext().observability.captureMutationFailure({
+                this.runtime.observability.captureMutationFailure({
                     context: 'rollback-failed',
                     transactionId: transaction.id,
                     modelName: transaction.modelName,
@@ -354,7 +357,7 @@ export class SyncClient extends EventEmitter {
      */
     setupReconciliationForwarding() {
         this.mutationQueue.on('reconciliation:needed', (event) => {
-            getContext().observability.captureReconciliation({
+            this.runtime.observability.captureReconciliation({
                 reason: event.reason,
                 model: event.model,
                 modelId: event.modelId,
@@ -415,14 +418,14 @@ export class SyncClient extends EventEmitter {
                     operationType: event.operationType,
                 },
             });
-            getContext().observability.breadcrumb('Persisted unconfirmed transaction to IDB', 'sync.transaction', 'info', {
+            this.runtime.observability.breadcrumb('Persisted unconfirmed transaction to IDB', 'sync.transaction', 'info', {
                 txId: event.txId,
                 model: event.model,
                 modelId: event.modelId,
             });
         }
         catch (error) {
-            getContext().observability.captureMutationFailure({
+            this.runtime.observability.captureMutationFailure({
                 context: 'persist-awaiting-transaction',
                 modelName: event.model,
                 modelId: event.modelId,
@@ -447,7 +450,7 @@ export class SyncClient extends EventEmitter {
     async initialize(userId, organizationId) {
         this.userId = userId;
         this.organizationId = organizationId;
-        getContext().observability.setContext(userId, organizationId);
+        this.runtime.observability.setContext(userId, organizationId);
         this.mutationQueue.setCommitOutboxScope({
             organizationId,
             participantId: userId,
@@ -470,7 +473,7 @@ export class SyncClient extends EventEmitter {
         // reports online by default. NetworkMonitor drives the ongoing
         // online/offline transitions below — this read is only the initial
         // snapshot taken when identity is set.
-        if (getContext().onlineStatus.isOnline()) {
+        if (this.runtime.onlineStatus.isOnline()) {
             this.setConnectionState('connected');
         }
         else {
@@ -523,7 +526,7 @@ export class SyncClient extends EventEmitter {
                 const replacement = rule.from === 'organizationId' ? this.organizationId : this.userId;
                 if (!replacement)
                     continue;
-                getContext().observability.captureSelfHealing({
+                this.runtime.observability.captureSelfHealing({
                     modelName: modelType,
                     modelId: idPrefix,
                     field: rule.field,
@@ -537,7 +540,7 @@ export class SyncClient extends EventEmitter {
             for (const field of meta.requiredFields) {
                 if (result[field])
                     continue;
-                getContext().observability.captureSelfHealing({
+                this.runtime.observability.captureSelfHealing({
                     modelName: modelType,
                     modelId: idPrefix,
                     field,
@@ -600,7 +603,7 @@ export class SyncClient extends EventEmitter {
                 allModelsToAdd.push(...modelsForType);
                 // Persist healed records back to IndexedDB (fire-and-forget, non-blocking)
                 if (recordsToHeal.length > 0 && this.database) {
-                    getContext().logger.info(`[SyncClient.hydrate] Persisting ${recordsToHeal.length} healed ${modelType} records to IndexedDB`);
+                    this.runtime.logger.info(`[SyncClient.hydrate] Persisting ${recordsToHeal.length} healed ${modelType} records to IndexedDB`);
                     // Use fire-and-forget to not block hydration.
                     // void is safe: the handler's body is fully try/catch'd.
                     void Promise.resolve().then(async () => {
@@ -608,10 +611,10 @@ export class SyncClient extends EventEmitter {
                             for (const { id, data } of recordsToHeal) {
                                 await this.database.putRecord(modelType, id, data);
                             }
-                            getContext().logger.info(`[SyncClient.hydrate] Successfully healed ${recordsToHeal.length} ${modelType} records`);
+                            this.runtime.logger.info(`[SyncClient.hydrate] Successfully healed ${recordsToHeal.length} ${modelType} records`);
                         }
                         catch (err) {
-                            getContext().observability.captureMutationFailure({
+                            this.runtime.observability.captureMutationFailure({
                                 context: 'persist-healed-records',
                                 modelName: modelType,
                                 error: err instanceof Error ? err : new Error(String(err)),
@@ -629,7 +632,7 @@ export class SyncClient extends EventEmitter {
                 });
             }
             catch (error) {
-                getContext().observability.captureBootstrapFailure(error, { type: `hydrate-${modelType}` });
+                this.runtime.observability.captureBootstrapFailure(error, { type: `hydrate-${modelType}` });
             }
         }
         // Phase 2: Single MobX action — add ALL models across all types at once.
@@ -638,7 +641,7 @@ export class SyncClient extends EventEmitter {
         const addEnd = typeof performance !== 'undefined' ? performance.now() : Date.now();
         // Log per-type perf after the batched add (so logs still show per-type breakdown)
         for (const entry of perTypePerfLogs) {
-            getContext().logger.debug('hydrate:type', parseFloat(entry.fetchMs) + parseFloat(entry.createMs), {
+            this.runtime.logger.debug('hydrate:type', parseFloat(entry.fetchMs) + parseFloat(entry.createMs), {
                 type: entry.type,
                 fetched: entry.fetched,
                 added: entry.added,
@@ -647,7 +650,7 @@ export class SyncClient extends EventEmitter {
             });
         }
         const totalEnd = typeof performance !== 'undefined' ? performance.now() : Date.now();
-        getContext().logger.debug('hydrate:total', totalEnd - totalStart, {
+        this.runtime.logger.debug('hydrate:total', totalEnd - totalStart, {
             totalModels: totalAdded,
             addBatchMs: (addEnd - addStart).toFixed(2),
         });
@@ -655,7 +658,7 @@ export class SyncClient extends EventEmitter {
         try {
             const preseededTypes = this.objectPool.registry.getRegisteredModelNames();
             const stats = this.objectPool.getStats();
-            getContext().logger.info('startup_summary', {
+            this.runtime.logger.info('startup_summary', {
                 typesPreseeded: preseededTypes.length,
                 poolSize: stats.size,
                 typeCounts: stats.typeCounts,
@@ -736,7 +739,7 @@ export class SyncClient extends EventEmitter {
                         }
                     }
                     catch (error) {
-                        getContext().observability.breadcrumb('Model creation failed during rehydration', 'sync.bootstrap', 'warning', {
+                        this.runtime.observability.breadcrumb('Model creation failed during rehydration', 'sync.bootstrap', 'warning', {
                             modelType,
                             modelId: recordId?.slice(0, 8) ?? 'unknown',
                             error: error instanceof Error ? error.message : String(error),
@@ -746,7 +749,7 @@ export class SyncClient extends EventEmitter {
                 }
             }
             catch (error) {
-                getContext().observability.captureBootstrapFailure(error, { type: `rehydrate-${modelType}` });
+                this.runtime.observability.captureBootstrapFailure(error, { type: `rehydrate-${modelType}` });
             }
         }
         // ── Phase 2: Upsert batch (single MobX action) ──
@@ -785,12 +788,12 @@ export class SyncClient extends EventEmitter {
             healed: healedCount,
             elapsedMs,
         };
-        getContext().logger.info('[SyncClient.rehydrate] Complete', {
+        this.runtime.logger.info('[SyncClient.rehydrate] Complete', {
             ...stats,
             poolSize: this.objectPool.size,
             ghostIds: ghostIds.length > 0 ? ghostIds.slice(0, 5).map((id) => id.slice(0, 8)) : [],
         });
-        getContext().observability.breadcrumb('Rehydration complete', 'sync.bootstrap', 'info', {
+        this.runtime.observability.breadcrumb('Rehydration complete', 'sync.bootstrap', 'info', {
             added: stats.added,
             updated: stats.updated,
             removed: stats.removed,
@@ -882,7 +885,7 @@ export class SyncClient extends EventEmitter {
      * (e.g. freshly constructed cell models from a bulk document decomposition).
      */
     updateWithChanges(model, changes) {
-        getContext().logger.debug(`SyncClient.updateWithChanges`, {
+        this.runtime.logger.debug(`SyncClient.updateWithChanges`, {
             modelId: model.id,
             modelType: model.getModelName(),
         });
@@ -928,7 +931,7 @@ export class SyncClient extends EventEmitter {
         this.pendingMutations = this.pendingMutations.filter((m) => m.model.id !== modelId);
         const afterCount = this.pendingMutations.length;
         if (beforeCount !== afterCount) {
-            getContext().logger.debug('[SyncClient.clearPendingMutationsForModel] Cleared pending mutations', {
+            this.runtime.logger.debug('[SyncClient.clearPendingMutationsForModel] Cleared pending mutations', {
                 modelId,
                 clearedCount: beforeCount - afterCount,
                 remainingCount: afterCount,
@@ -988,7 +991,7 @@ export class SyncClient extends EventEmitter {
             return null;
         }
         catch (error) {
-            getContext().observability.captureMutationFailure({
+            this.runtime.observability.captureMutationFailure({
                 context: 'file-upload',
                 error: error instanceof Error ? error : new Error(String(error)),
             });
@@ -1187,9 +1190,9 @@ export class SyncClient extends EventEmitter {
             : (cb) => Promise.resolve().then(cb);
         schedule(() => {
             this.syncScheduled = false;
-            if (getContext().onlineStatus.isOnline()) {
+            if (this.runtime.onlineStatus.isOnline()) {
                 this.processPendingMutations().catch((err) => {
-                    getContext().observability.breadcrumb('Background sync failed', 'sync.transaction', 'warning', { error: err instanceof Error ? err.message : String(err) });
+                    this.runtime.observability.breadcrumb('Background sync failed', 'sync.transaction', 'warning', { error: err instanceof Error ? err.message : String(err) });
                 });
             }
         });
@@ -1248,7 +1251,7 @@ export class SyncClient extends EventEmitter {
             const restore = async (mutation, migrateLegacy, legacyMutationId) => {
                 const parsed = persistedMutationSchema.safeParse(mutation);
                 if (!parsed.success) {
-                    getContext().logger.debug('[SyncClient] Dropping malformed persisted mutation', {
+                    this.runtime.logger.debug('[SyncClient] Dropping malformed persisted mutation', {
                         issues: parsed.error.issues.map((i) => i.path.join('.')).join(', '),
                     });
                     return;
@@ -1260,7 +1263,7 @@ export class SyncClient extends EventEmitter {
                 const age = Date.now() - writtenAt;
                 if (!(age < PENDING_MUTATION_REPLAY_WINDOW_MS)) {
                     heldForReview += 1;
-                    getContext().logger.warn('A saved local write is older than the server idempotency window and was held for review.');
+                    this.runtime.logger.warn('A saved local write is older than the server idempotency window and was held for review.');
                     return;
                 }
                 const mutationId = parsed.data.mutationId ?? legacyMutationId ?? `mutation_${uuid()}`;
@@ -1304,7 +1307,7 @@ export class SyncClient extends EventEmitter {
                         await restore(legacy.data.mutation, true);
                         continue;
                     }
-                    getContext().logger.debug('[SyncClient] Dropping malformed pending mutation record', {
+                    this.runtime.logger.debug('[SyncClient] Dropping malformed pending mutation record', {
                         rowId: row.id,
                     });
                     continue;
@@ -1312,7 +1315,7 @@ export class SyncClient extends EventEmitter {
                 if (parsed.data.scope.organizationId !== this.organizationId ||
                     parsed.data.scope.participantId !== this.userId ||
                     parsed.data.scope.namespace !== this.commitOutboxNamespace) {
-                    getContext().logger.warn('A saved local write belongs to a different account or server and was held for review.');
+                    this.runtime.logger.warn('A saved local write belongs to a different account or server and was held for review.');
                     continue;
                 }
                 await restore(parsed.data.mutation, false);
@@ -1334,10 +1337,10 @@ export class SyncClient extends EventEmitter {
             // A restore failure means queued offline writes did NOT rehydrate.
             // Self-healing is impossible here (the record may be unreadable), but
             // the failure must be visible for diagnosis instead of silent loss.
-            getContext().logger.debug('[SyncClient] Failed to restore offline mutation queue', {
+            this.runtime.logger.debug('[SyncClient] Failed to restore offline mutation queue', {
                 error: error instanceof Error ? error.message : String(error),
             });
-            getContext().observability.captureMutationFailure({
+            this.runtime.observability.captureMutationFailure({
                 context: 'restore-mutation-queue',
                 error: error instanceof Error ? error : String(error),
             });
@@ -1367,14 +1370,14 @@ export class SyncClient extends EventEmitter {
             // identity, which surfaces downstream as "writes never confirm"; we do
             // NOT name internal wiring (`SyncClient.initialize`) here because that
             // method isn't part of the @abloatai/ablo surface a reader could act on.
-            getContext().logger.debug('[sync] writes waiting for identity (user/org not set yet) — queued, will retry', {
+            this.runtime.logger.debug('[sync] writes waiting for identity (user/org not set yet) — queued, will retry', {
                 pending: this.pendingMutations.length,
                 userId: this.userId,
                 organizationId: this.organizationId,
             });
             return;
         }
-        if (!getContext().onlineStatus.isOnline())
+        if (!this.runtime.onlineStatus.isOnline())
             return; // Skip if offline
         if (this.isDisposed)
             return; // Skip if disposed
@@ -1419,7 +1422,7 @@ export class SyncClient extends EventEmitter {
             this.stagedMutationIds.delete(mutation.mutationId);
             this.pendingMutations = this.pendingMutations.filter((pending) => pending.mutationId !== mutation.mutationId);
             mutation.rejectStaged?.(outcome.reason);
-            getContext().observability.captureMutationFailure({
+            this.runtime.observability.captureMutationFailure({
                 context: 'persist-pending-mutation',
                 error: outcome.reason instanceof Error
                     ? outcome.reason
@@ -1451,7 +1454,7 @@ export class SyncClient extends EventEmitter {
         // apply, store add). That means the write never entered the queue, so
         // capture it instead of dropping it silently.
         const captureStagingFailure = (error) => {
-            getContext().observability.captureMutationFailure({
+            this.runtime.observability.captureMutationFailure({
                 context: `stage-mutation-${mutation.type}`,
                 modelName: mutation.model.getModelName(),
                 modelId: mutation.model.id,
@@ -1484,7 +1487,7 @@ export class SyncClient extends EventEmitter {
                 : new Date(localModel.updatedAt).getTime()
             : 0;
         const serverUpdatedAt = toEpochMs(serverData.updatedAt);
-        getContext().logger.debug('Conflict resolution', {
+        this.runtime.logger.debug('Conflict resolution', {
             modelId: localModel.id,
             modelType: localModel.getModelName(),
             hasLocalChanges,
@@ -1498,7 +1501,7 @@ export class SyncClient extends EventEmitter {
         const criticalServerStates = this.extractCriticalState(serverData);
         const shouldForceAcceptServer = this.hasCriticalStateChange(criticalServerStates);
         if (shouldForceAcceptServer) {
-            getContext().logger.debug('Accepting server update - critical state change detected', {
+            this.runtime.logger.debug('Accepting server update - critical state change detected', {
                 modelId: localModel.id,
                 criticalStates: criticalServerStates,
             });
@@ -1512,7 +1515,7 @@ export class SyncClient extends EventEmitter {
         // Keep locally changed fields; apply server for the rest.
         if (hasLocalChanges) {
             const localChanges = localModel.getChanges();
-            getContext().logger.debug('Merging server update with local dirty fields', {
+            this.runtime.logger.debug('Merging server update with local dirty fields', {
                 modelId: localModel.id,
                 keptFields: Object.keys(localChanges || {}),
             });
@@ -1531,7 +1534,7 @@ export class SyncClient extends EventEmitter {
         // No local changes: fall back to LWW to converge
         // Accept server regardless of timestamp equality to stay in sync
         const acceptReason = serverUpdatedAt > localUpdatedAt ? 'server is newer' : 'no local changes';
-        getContext().logger.debug(`Accepting server update - ${acceptReason}`);
+        this.runtime.logger.debug(`Accepting server update - ${acceptReason}`);
         localModel.updateFromData(serverData);
         localModel.clearChanges();
         localModel.markAsSynced();
@@ -1575,7 +1578,7 @@ export class SyncClient extends EventEmitter {
      * Handle network reconnection
      */
     async handleReconnection() {
-        getContext().observability.breadcrumb('Network reconnected', 'sync.offline');
+        this.runtime.observability.breadcrumb('Network reconnected', 'sync.offline');
         this.emit('sync:reconnecting');
         try {
             // Prefer a single batch flush for pending mutations (fast path)
@@ -1589,7 +1592,7 @@ export class SyncClient extends EventEmitter {
             this.emit('sync:reconnected');
         }
         catch (error) {
-            getContext().observability.captureMutationFailure({
+            this.runtime.observability.captureMutationFailure({
                 context: 'reconnection-sync',
                 error: error instanceof Error ? error : new Error(String(error)),
             });
@@ -1600,7 +1603,7 @@ export class SyncClient extends EventEmitter {
      * Handle network disconnection
      */
     async handleDisconnection() {
-        getContext().observability.breadcrumb('Network disconnected', 'sync.offline');
+        this.runtime.observability.breadcrumb('Network disconnected', 'sync.offline');
         this.setConnectionState('disconnected');
         this.emit('sync:offline');
     }
@@ -1622,8 +1625,8 @@ export class SyncClient extends EventEmitter {
         const oldState = this.connectionState;
         this.connectionState = state;
         if (oldState !== state) {
-            getContext().observability.setConnectionState(state);
-            getContext().observability.breadcrumb(`Connection: ${oldState} → ${state}`, 'sync.websocket');
+            this.runtime.observability.setConnectionState(state);
+            this.runtime.observability.breadcrumb(`Connection: ${oldState} → ${state}`, 'sync.websocket');
             if (state === 'connected') {
                 this.emit('connection:established');
                 this.mutationQueue.setConnectionState('connected');
@@ -1666,7 +1669,7 @@ export class SyncClient extends EventEmitter {
                     observer.onSync(event);
                 }
                 catch (error) {
-                    getContext().observability.breadcrumb('Observer error', 'sync.transaction', 'error', {
+                    this.runtime.observability.breadcrumb('Observer error', 'sync.transaction', 'error', {
                         error: error instanceof Error ? error.message : String(error),
                     });
                 }
@@ -1689,7 +1692,7 @@ export class SyncClient extends EventEmitter {
         // WebSocket itself was ready. Always kick both durable lanes on the real
         // socket event, even when the high-level state did not change.
         void this.mutationQueue.flushOfflineQueue().catch((error) => {
-            getContext().observability.captureMutationFailure({
+            this.runtime.observability.captureMutationFailure({
                 context: 'restore-commit-outbox',
                 error: error instanceof Error ? error : new Error(String(error)),
             });
@@ -1720,7 +1723,7 @@ export class SyncClient extends EventEmitter {
             this.mutationQueue.onDeltaReceived(syncId, transactionId, correlationId);
         }
         catch (e) {
-            getContext().observability.breadcrumb('Failed to notify delta received', 'sync.transaction', 'warning', {
+            this.runtime.observability.breadcrumb('Failed to notify delta received', 'sync.transaction', 'warning', {
                 syncId,
                 transactionId,
                 correlationId,
@@ -2071,7 +2074,7 @@ export class SyncClient extends EventEmitter {
                     // fall-through.
                     // Self-healing: the next catch-up poll / reconnect re-fetches and
                     // re-applies this delta, so it's forensic, not consumer-actionable → debug.
-                    getContext().logger.debug('[SyncClient.applyDeltaBatchToPool] skipping pool op for unpersisted delta', {
+                    this.runtime.logger.debug('[SyncClient.applyDeltaBatchToPool] skipping pool op for unpersisted delta', {
                         modelName,
                         modelId: modelId.slice(0, 12),
                     });

package/dist/client/Ablo.js

@@ -35,10 +35,10 @@ import { createAbloHttpClient, } from '../transaction/transport/httpClient.js';
 import { layerPluginSurface, resolvePlugins, } from '../transaction/plugin.js';
 import { noopLogger } from '../transaction/logger.js';
 import { humans } from './humans.js';
+import { kStoreCluster } from './storeCluster.js';
 import { createCoreClient } from './coreClient.js';
 import { buildReactiveEngine } from './reactiveEngine.js';
 import { resolveClientPrelude } from './clientPrelude.js';
-import { createDefaultMutationExecutor } from './wsMutationExecutor.js';
 export function Ablo(options) {
     if (options.transport === 'http') {
         // Capabilities are declared above transport (ADR 0016): the plugin list
@@ -63,11 +63,15 @@ export function Ablo(options) {
     //    `connect()`, and `deferConnect` keeps even that closed until the store
     //    has seeded identity and read scope during `ready()` — the late-bound
     //    values (`kind`, the credential, `syncGroups`, the resume cursor) are
-    //    seeded there, not here. Built only for the reactive path: the core
-    //    client (`plugins: []`) constructs its own feed, and no plugin runs on
-    //    that path to read this one.
+    //    seeded there, not here. Whether to build it is read off what the
+    //    listed plugins DECLARE — a plugin that requires a duplex transport
+    //    gets one to attach to — never off a plugin's name; interrogating the
+    //    assembly by id is the context's `hasPlugin`, a capability for
+    //    plugins, not a dispatch key for this root. The empty list builds
+    //    nothing here: the core client (`plugins: []`) constructs its own
+    //    feed, and no plugin runs on that path to read this one.
     const pluginList = options.plugins ?? [humans()];
-    const transport = pluginList.some((plugin) => plugin.id === 'humans')
+    const transport = pluginList.some((plugin) => plugin.requires?.duplex === true)
         ? new SyncWebSocket({
             baseUrl: url,
             kind,
@@ -77,19 +81,15 @@ export function Ablo(options) {
             deferConnect: true,
         })
         : null;
-    //    The default mutation executor sends `{ type: 'commit', ... }` over
-    //    that connection; before it opens, sends reject with the diagnosed
-    //    not-ready error and the MutationQueue owns the retry. Caller-supplied
-    //    executors are still honored for advanced cases (test mocks,
-    //    alternative transports).
-    const executor = internalOptions.mutationExecutor ?? createDefaultMutationExecutor(() => transport);
     // Resolve the capability list before anything heavy is constructed
     // (ADR 0016). The two configuration gates — a duplicate id, a transport
     // mismatch — fire here, while the stack still points at the caller's own
     // setup. With no list given, the reactive materialiser is installed:
     // today's default client. (Flipping the bare default to the stateless core
     // is the mirror-flip step, decided with the published version identity —
-    // not here.)
+    // not here.) The context carries the host's resolved values — url,
+    // credential source, identity — so `humans().init` constructs the store
+    // cluster right here, during resolution.
     const installedPlugins = resolvePlugins(pluginList, { duplex: true }, {
         logger,
         observability: internalOptions.observability,
@@ -99,6 +99,8 @@ export function Ablo(options) {
         ...(transport ? { transport } : {}),
         participant: { id: participantId, kind },
         syncGroups: internalOptions.syncGroups ?? [],
+        url,
+        auth: authCredentials,
     });
     const humansSurface = installedPlugins.humans;
     if (!humansSurface) {
@@ -132,18 +134,27 @@ export function Ablo(options) {
         // 'humans', which is exactly the condition the transport was built under.
         throw new AbloValidationError('The reactive client was selected but no connection was constructed.', { code: 'invalid_options', param: 'plugins' });
     }
-    // The reactive engine is the humans() capability: everything from here on
-    // — runtime context, store, streams, model proxies, resources — builds in
-    // `./reactiveEngine.ts`, fed the prelude plus the plugin's contribution
-    // (the presence stream). The host owns construction; plugins declare and
-    // contribute. A plugin surface that hands back a whole-client constructor
-    // inverts that relationship — tried and rejected (ADR 0016, follow-up 3b).
+    const cluster = humansSurface[kStoreCluster];
+    if (!cluster) {
+        // Unreachable on this path: the context above carries everything the
+        // cluster needs (connection, url, credential source, schema). A missing
+        // cluster means the context and the plugin disagree — say so rather
+        // than building a client with no store.
+        throw new AbloValidationError('The reactive client was selected but no store was constructed.', { code: 'invalid_options', param: 'plugins' });
+    }
+    // The reactive engine is the humans() capability: `init` constructed the
+    // store cluster (runtime, component graph, store) from the widened
+    // context; what remains here builds in `./reactiveEngine.ts`, fed the
+    // prelude plus the plugin's contributions. The host owns assembly;
+    // plugins declare and construct their own parts. A plugin surface that
+    // hands back a whole-client constructor inverts that relationship —
+    // tried and rejected (ADR 0016, follow-up 3b).
     return layerPluginSurface(buildReactiveEngine({
         ...prelude,
         options,
-        executor,
         transport,
         presence: humansSurface.presence,
+        cluster,
         createSibling: (siblingOptions) => Ablo(siblingOptions),
     }), installedPlugins);
 }

package/dist/client/createInternalComponents.d.ts

@@ -17,6 +17,7 @@ import type { AuthCredentialSource } from '../transaction/auth/credentialSource.
 import type { Schema, SchemaRecord } from '../transaction/schema/schema.js';
 import { type AbloPersistence } from '../transaction/persistence.js';
 import type { DurableWriteStore, DurableWritesConfig } from '../transactions/mutations/durableWriteStore.js';
+import type { RuntimeContext } from '../RuntimeContext.js';
 export interface InternalComponentsInput<S extends SchemaRecord> {
     readonly schema: Schema<S>;
     /** The WebSocket URL. Used to derive the bootstrap HTTP base URL when the
@@ -34,6 +35,9 @@ export interface InternalComponentsInput<S extends SchemaRecord> {
         readonly commitOutbox?: DurableWriteStore;
     };
     readonly auth?: AuthCredentialSource;
+    /** The owning client's runtime, threaded into every component built here.
+     *  Defaults to the module-global bridge for direct construction. */
+    readonly runtime?: RuntimeContext;
 }
 export interface InternalComponents {
     readonly modelRegistry: ModelRegistry;

package/dist/client/createInternalComponents.js

@@ -16,17 +16,20 @@ import { BootstrapFetcher } from '../sync/BootstrapFetcher.js';
 import { loadsAtBootstrap } from '../transaction/schema/loadStrategy.js';
 import { resolveBootstrapBaseUrl } from '../transaction/auth/apiKey.js';
 import { shouldUseInMemoryPersistence } from '../transaction/persistence.js';
+import { globalRuntime } from '../context.js';
 import { resolveDurableWrites } from '../transaction/durableWrites.js';
 export function createInternalComponents(input) {
     const { schema, url, options, auth } = input;
+    const runtime = input.runtime ?? globalRuntime;
     // The registry is created here, but model registration happens in the caller,
     // which owns the schema-to-class translation.
     const modelRegistry = new ModelRegistry({
         validateOnRegister: false,
         allowLateReferences: true,
+        runtime,
     });
     setActiveRegistry(modelRegistry);
-    const objectPool = new InstanceCache({ maxSize: options.maxPoolSize ?? 10000 }, modelRegistry);
+    const objectPool = new InstanceCache({ maxSize: options.maxPoolSize ?? 10000, runtime }, modelRegistry);
     const bootstrapBaseUrl = resolveBootstrapBaseUrl({
         url,
         bootstrapBaseUrl: options.bootstrapBaseUrl,
@@ -36,15 +39,17 @@ export function createInternalComponents(input) {
         syncGroups: options.syncGroups,
         instantModels: deriveInstantModels(schema),
         getAuthToken: auth?.getAuthToken,
+        runtime,
     });
     const database = new Database(modelRegistry, bootstrapHelper, {
         // By default there is no browser-local durable store unless the caller asks
         // for one. Node and edge runtimes always use the in-memory store because
         // IndexedDB is unavailable there.
         inMemory: shouldUseInMemoryPersistence(options),
+        runtime,
     });
     const durableWrites = resolveDurableWrites(options);
-    const syncClient = new SyncClient(objectPool, database, durableWrites.store, durableWrites.namespace ?? url);
+    const syncClient = new SyncClient(objectPool, database, durableWrites.store, durableWrites.namespace ?? url, runtime);
     // Lazy-load lane: hydrates the object pool and IndexedDB on demand for
     // entities not in scope at bootstrap (`load: 'lazy'` models, or an entity
     // reached by deep link before the pool warmed up). Single-flight, with
@@ -56,6 +61,7 @@ export function createInternalComponents(input) {
         schema,
         baseUrl: bootstrapBaseUrl,
         getAuthToken: auth?.getAuthToken,
+        runtime,
     });
     // Drop the lazy-lane hydration ledger on reconnect. While connected, the
     // WebSocket delta stream keeps hydrated rows fresh so repeat reads serve