@abloatai/ablo 0.35.0 → 0.36.0

package/dist/Model.d.ts

@@ -246,9 +246,16 @@ export declare abstract class Model {
      * written, `onWrite(key, oldValue, newValue)` is invoked with the value
      * captured immediately before assignment. `applyChanges` passes a hook
      * that records the change in `modifiedProperties`; `updateFromData`
-     * passes none (hydration must not generate outbound mutations). This
-     * is the single source of mutation tracking now that the `mobx-setup`
-     * `observe()` bridge has been removed (one write path: the SDK proxy).
+     * passes none (hydration must not generate outbound mutations).
+     *
+     * This is not the ONLY tracking path. `mobxSetup`'s `observe()` bridge is
+     * live and forwards a DIRECT assignment (`layer.position = next`) to
+     * `propertyChanged` as well — product code writes model fields directly in
+     * plenty of places (keyboard nudge, formatting, AI tools), and those writes
+     * have to reach the server and the undo stream too. The two paths compose:
+     * a direct write establishes the first-old-wins baseline, and a later
+     * `applyChanges` carrying the value the model already holds is a no-op that
+     * leaves that baseline intact.
      */
     private assignFieldsFromData;
     /**
@@ -260,10 +267,13 @@ export declare abstract class Model {
      * brand-new outbound mutation and the record would echo forever. For a
      * local user edit, use `applyChanges` instead.
      *
-     * Suppression is belt-and-suspenders: we pass no `onWrite` hook AND
-     * clear/restore `modifiedProperties` around the assignment, so any
-     * remaining `mobx-setup` `observe()` side-channel writes are discarded
-     * too. (The clear/restore is a harmless no-op once that bridge is gone.)
+     * Suppression takes two forms and BOTH are load-bearing: we pass no
+     * `onWrite` hook, and we clear/restore `modifiedProperties` around the
+     * assignment. The second is what catches `mobxSetup`'s `observe()` bridge,
+     * which fires on the assignment itself and would otherwise record an
+     * inbound delta as a local edit — queueing an outbound mutation that echoes
+     * forever, and putting a collaborator's change on your undo stack. Do not
+     * remove it while that bridge exists (`mobxSetup.M1`).
      */
     updateFromData(data: ModelData): void;
     /**

package/dist/Model.js

@@ -428,9 +428,16 @@ export class Model {
      * written, `onWrite(key, oldValue, newValue)` is invoked with the value
      * captured immediately before assignment. `applyChanges` passes a hook
      * that records the change in `modifiedProperties`; `updateFromData`
-     * passes none (hydration must not generate outbound mutations). This
-     * is the single source of mutation tracking now that the `mobx-setup`
-     * `observe()` bridge has been removed (one write path: the SDK proxy).
+     * passes none (hydration must not generate outbound mutations).
+     *
+     * This is not the ONLY tracking path. `mobxSetup`'s `observe()` bridge is
+     * live and forwards a DIRECT assignment (`layer.position = next`) to
+     * `propertyChanged` as well — product code writes model fields directly in
+     * plenty of places (keyboard nudge, formatting, AI tools), and those writes
+     * have to reach the server and the undo stream too. The two paths compose:
+     * a direct write establishes the first-old-wins baseline, and a later
+     * `applyChanges` carrying the value the model already holds is a no-op that
+     * leaves that baseline intact.
      */
     assignFieldsFromData(data, onWrite) {
         // Update properties with safety checks for read-only/computed accessors
@@ -489,10 +496,13 @@ export class Model {
      * brand-new outbound mutation and the record would echo forever. For a
      * local user edit, use `applyChanges` instead.
      *
-     * Suppression is belt-and-suspenders: we pass no `onWrite` hook AND
-     * clear/restore `modifiedProperties` around the assignment, so any
-     * remaining `mobx-setup` `observe()` side-channel writes are discarded
-     * too. (The clear/restore is a harmless no-op once that bridge is gone.)
+     * Suppression takes two forms and BOTH are load-bearing: we pass no
+     * `onWrite` hook, and we clear/restore `modifiedProperties` around the
+     * assignment. The second is what catches `mobxSetup`'s `observe()` bridge,
+     * which fires on the assignment itself and would otherwise record an
+     * inbound delta as a local edit — queueing an outbound mutation that echoes
+     * forever, and putting a collaborator's change on your undo stack. Do not
+     * remove it while that bridge exists (`mobxSetup.M1`).
      */
     updateFromData(data) {
         if (this.isDisposed) {

package/dist/ModelRegistry.d.ts

@@ -8,6 +8,7 @@
  * another model that is registered later.
  */
 import { type ModelMetadata, type PropertyMetadata, type ReferenceMetadata, LoadStrategy } from './transaction/types/index.js';
+import type { RuntimeContext } from './RuntimeContext.js';
 import type { Model } from './Model.js';
 import type { ConcreteModelConstructor } from './BaseSyncedStore.js';
 /**
@@ -61,6 +62,8 @@ export interface BackReferenceMetadata {
 interface RegistryConfig {
     validateOnRegister?: boolean;
     allowLateReferences?: boolean;
+    /** The owning client's runtime. Defaults to the module-global bridge. */
+    runtime?: RuntimeContext;
 }
 /** Set the active ModelRegistry instance (called by createSyncEngine) */
 export declare function setActiveRegistry(registry: ModelRegistry): void;
@@ -80,6 +83,7 @@ export declare class ModelRegistry {
     private backReferences;
     private schemaHash?;
     private config;
+    private readonly runtime;
     private registeredModels;
     private pendingHashUpdate;
     constructor(config?: RegistryConfig);

package/dist/ModelRegistry.js

@@ -9,7 +9,7 @@
  */
 // Removed Node.js crypto import for browser compatibility
 import { PropertyType, LoadStrategy, } from './transaction/types/index.js';
-import { getContext } from './context.js';
+import { globalRuntime } from './context.js';
 import { AbloValidationError } from './transaction/errors.js';
 /**
  * Module-level active registry. Set by createSyncEngine so that Model instances
@@ -51,6 +51,7 @@ export class ModelRegistry {
     backReferences = new Map();
     schemaHash;
     config;
+    runtime;
     registeredModels = new Set();
     pendingHashUpdate = false;
     constructor(config = {}) {
@@ -58,6 +59,7 @@ export class ModelRegistry {
             validateOnRegister: config.validateOnRegister ?? true,
             allowLateReferences: config.allowLateReferences ?? true,
         };
+        this.runtime = config.runtime ?? globalRuntime;
     }
     validateModelConstructor(name, constructor) {
         if (typeof constructor !== 'function') {
@@ -71,7 +73,7 @@ export class ModelRegistry {
         const required = ['updateFromData', 'toJSON', 'getModelName'];
         for (const method of required) {
             if (typeof prototype[method] !== 'function') {
-                getContext().logger.debug('Model missing required method', name, { method });
+                this.runtime.logger.debug('Model missing required method', name, { method });
             }
         }
     }
@@ -99,7 +101,7 @@ export class ModelRegistry {
             this.pendingReferences.set(targetName, pending);
         }
         pending.push({ modelName, propertyName, metadata });
-        getContext().logger.debug('Reference deferred', `${modelName}.${propertyName}`, { targetModel: targetName });
+        this.runtime.logger.debug('Reference deferred', `${modelName}.${propertyName}`, { targetModel: targetName });
     }
     resolvePendingReferences(targetModelName) {
         const pending = this.pendingReferences.get(targetModelName);
@@ -108,12 +110,12 @@ export class ModelRegistry {
         for (const ref of pending) {
             try {
                 this.completeReferenceRegistration(ref.modelName, ref.propertyName, ref.metadata);
-                getContext().logger.debug('Reference resolved', `${ref.modelName}.${ref.propertyName}`, {
+                this.runtime.logger.debug('Reference resolved', `${ref.modelName}.${ref.propertyName}`, {
                     targetModel: targetModelName,
                 });
             }
             catch (error) {
-                getContext().observability.breadcrumb(`Failed to resolve reference ${ref.modelName}.${ref.propertyName}`, 'sync.database', 'error', {
+                this.runtime.observability.breadcrumb(`Failed to resolve reference ${ref.modelName}.${ref.propertyName}`, 'sync.database', 'error', {
                     error: error instanceof Error ? error.message : String(error),
                 });
             }
@@ -154,10 +156,10 @@ export class ModelRegistry {
         }
         // Check for duplicate
         if (this.models.has(name)) {
-            getContext().logger.debug('Model already registered, skipping', name);
+            this.runtime.logger.debug('Model already registered, skipping', name);
             return;
         }
-        getContext().logger.debug('Registering model', name);
+        this.runtime.logger.debug('Registering model', name);
         // Register. The one cast in this file: input is any Model-subclass
         // constructor (validated above); registered classes are concrete
         // subclasses constructible with `data?` and carrying Model's statics —
@@ -180,7 +182,7 @@ export class ModelRegistry {
         this.resolvePendingReferences(name);
         // Invalidate schema hash
         this.schemaHash = undefined;
-        getContext().logger.debug('Model registered', name, metadata);
+        this.runtime.logger.debug('Model registered', name, metadata);
     }
     /**
      * Register property with validation
@@ -201,7 +203,7 @@ export class ModelRegistry {
         if (existing) {
             if (this.arePropertiesCompatible(existing, metadata)) {
                 // Properties are compatible, skip re-registration
-                getContext().logger.debug('Property already registered (compatible)', `${modelName}.${propertyName}`);
+                this.runtime.logger.debug('Property already registered (compatible)', `${modelName}.${propertyName}`);
                 return;
             }
             else {
@@ -210,7 +212,7 @@ export class ModelRegistry {
         }
         props.set(propertyName, metadata);
         this.schemaHash = undefined;
-        getContext().logger.debug('Property registered', `${modelName}.${propertyName}`, metadata);
+        this.runtime.logger.debug('Property registered', `${modelName}.${propertyName}`, metadata);
     }
     /**
      * Register reference with lazy resolution
@@ -265,7 +267,7 @@ export class ModelRegistry {
         }
         // Reverse lookup (parent → children) is derived on demand by
         // `getChildModels`, which scans this map.
-        getContext().logger.debug('BackReference registered', `${childModelName} -> ${metadata.parentModel}`, {
+        this.runtime.logger.debug('BackReference registered', `${childModelName} -> ${metadata.parentModel}`, {
             foreignKey: metadata.foreignKey,
             cascadeDelete: metadata.cascadeDelete,
         });
@@ -365,7 +367,7 @@ export class ModelRegistry {
         const sorted = JSON.stringify(schema, Object.keys(schema).sort());
         // Create hash - browser-compatible simple hash
         this.schemaHash = this.simpleHash(sorted);
-        getContext().logger.debug('Schema hash updated', this.schemaHash);
+        this.runtime.logger.debug('Schema hash updated', this.schemaHash);
         return this.schemaHash;
     }
     /**
@@ -410,10 +412,10 @@ export class ModelRegistry {
         }
         const isValid = errors.length === 0;
         if (isValid) {
-            getContext().logger.info('All model references are valid');
+            this.runtime.logger.info('All model references are valid');
         }
         else {
-            getContext().observability.breadcrumb('Reference validation failed', 'sync.database', 'error');
+            this.runtime.observability.breadcrumb('Reference validation failed', 'sync.database', 'error');
         }
         return {
             valid: isValid,
@@ -458,7 +460,7 @@ export class ModelRegistry {
         this.constructorToModelName.clear();
         this.schemaHash = undefined;
         this.pendingHashUpdate = false;
-        getContext().logger.info('ModelRegistry cleared');
+        this.runtime.logger.info('ModelRegistry cleared');
     }
     /**
      * Static wrapper for backward compatibility

package/dist/NetworkMonitor.d.ts

@@ -6,10 +6,12 @@
  * firing, so returning to the tab emits a recovery signal the store can act on.
  */
 import { EventEmitter } from 'events';
+import type { RuntimeContext } from './RuntimeContext.js';
 export declare class NetworkMonitor extends EventEmitter {
+    private readonly runtime;
     private isOnline;
     private lastOnlineCheck;
-    constructor();
+    constructor(runtime?: RuntimeContext);
     private handleOnline;
     private handleOffline;
     /**

package/dist/NetworkMonitor.js

@@ -6,15 +6,17 @@
  * firing, so returning to the tab emits a recovery signal the store can act on.
  */
 import { EventEmitter } from 'events';
-import { getContext } from './context.js';
+import { globalRuntime } from './context.js';
 export class NetworkMonitor extends EventEmitter {
+    runtime;
     // Only `navigator.onLine === false` means offline. Node 18+ exposes a global
     // `navigator` with `onLine === undefined`, so the naive `navigator.onLine`
     // would seed `false` (offline) on every server client — start optimistic.
     isOnline = !(typeof navigator !== 'undefined' && navigator.onLine === false);
     lastOnlineCheck = new Date();
-    constructor() {
+    constructor(runtime = globalRuntime) {
         super();
+        this.runtime = runtime;
         this.setupListeners();
     }
     handleOnline = () => {
@@ -22,7 +24,7 @@ export class NetworkMonitor extends EventEmitter {
         this.isOnline = true;
         this.lastOnlineCheck = new Date();
         if (wasOffline) {
-            getContext().logger.info('Network connection restored');
+            this.runtime.logger.info('Network connection restored');
             this.emit('online');
         }
     };
@@ -32,7 +34,7 @@ export class NetworkMonitor extends EventEmitter {
         if (wasOnline) {
             // Symmetric with 'Network connection restored' (info) — expected,
             // transient connectivity state, not an actionable warning.
-            getContext().logger.info('Network connection lost');
+            this.runtime.logger.info('Network connection lost');
             this.emit('offline');
         }
     };
@@ -49,7 +51,7 @@ export class NetworkMonitor extends EventEmitter {
         this.isOnline = navigator.onLine;
         this.lastOnlineCheck = new Date();
         if (this.isOnline) {
-            getContext().logger.info('Tab became visible with network available — emitting visibility_online');
+            this.runtime.logger.info('Tab became visible with network available — emitting visibility_online');
             this.emit('visibility_online');
         }
     };

package/dist/SyncClient.d.ts

@@ -9,6 +9,8 @@
  */
 import { InstanceCache } from './InstanceCache.js';
 import { Model } from './Model.js';
+import type { AppliedChange } from './transaction/plugin.js';
+import type { RuntimeContext } from './RuntimeContext.js';
 import { EventEmitter } from 'events';
 import { MutationQueue } from './transactions/mutations/MutationQueue.js';
 import { type CommitLatencySample } from './transactions/mutations/commitLatency.js';
@@ -42,6 +44,7 @@ export interface RehydrationStats {
     elapsedMs: number;
 }
 export declare class SyncClient extends EventEmitter {
+    private readonly runtime;
     private objectPool;
     private database;
     private get mutationExecutor();
@@ -77,7 +80,7 @@ export declare class SyncClient extends EventEmitter {
      * responses, and snapshots and claims read `readFloor`.
      */
     readonly position: LogPosition;
-    constructor(objectPool: InstanceCache, database: Database, commitOutbox?: DurableWriteStore, commitOutboxNamespace?: string);
+    constructor(objectPool: InstanceCache, database: Database, commitOutbox?: DurableWriteStore, commitOutboxNamespace?: string, runtime?: RuntimeContext);
     /**
      * Setup network monitoring handlers
      */
@@ -508,20 +511,7 @@ export declare class SyncClient extends EventEmitter {
      * consumers; `Ablo` is the public surface.
      */
     getMutationQueue(): MutationQueue;
-    applyDeltaBatchToPool(dbResults: {
-        action: string;
-        modelName: string;
-        modelId: string;
-        data?: Record<string, unknown> | null;
-        /**
-         * Server-stamped transaction id, echoing the client's commit op
-         * id. Used by echo detection to recognize "this is the
-         * confirmation of a mutation I've already applied locally."
-         * Optional because system-emitted deltas (sync_group changes,
-         * schema-derived deltas, etc.) don't have a client transaction.
-         */
-        transactionId?: string;
-    }[], enrichRelations: (modelName: string, data: Record<string, unknown>) => Record<string, unknown>): void;
+    applyDeltaBatchToPool(dbResults: readonly AppliedChange[], enrichRelations: (modelName: string, data: Record<string, unknown>) => Record<string, unknown>): void;
     /**
      * Apply bootstrap data to the InstanceCache with ghost removal.
      * Owns: model creation, batch upsert, ghost detection + removal.