@abloatai/humans 0.60.0 → 0.61.0

package/dist/local/sync/schemas.d.ts

@@ -20,10 +20,10 @@ export declare const ServerDeltaSchema: z.ZodObject<{
     id: z.ZodNumber;
     data: z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
     actionType: z.ZodEnum<{
-        A: "A";
         I: "I";
         U: "U";
         D: "D";
+        A: "A";
         V: "V";
         C: "C";
         G: "G";
@@ -44,10 +44,10 @@ export declare const BootstrapResponseSchema: z.ZodObject<{
         id: z.ZodNumber;
         data: z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
         actionType: z.ZodEnum<{
-            A: "A";
             I: "I";
             U: "U";
             D: "D";
+            A: "A";
             V: "V";
             C: "C";
             G: "G";

package/dist/local/transactions/localMutation.js

@@ -16,9 +16,9 @@ export function createLocalMutationPort(emit) {
     };
     return {
         updates,
-        applyCreate: (model, transaction) => track('optimistic:create', model, transaction),
-        applyUpdate: (model, transaction) => track('optimistic:update', model, transaction),
-        applyDelete: (model, transaction) => track('optimistic:delete', model, transaction),
+        applyCreate: (model, transaction) => { track('optimistic:create', model, transaction); },
+        applyUpdate: (model, transaction) => { track('optimistic:update', model, transaction); },
+        applyDelete: (model, transaction) => { track('optimistic:delete', model, transaction); },
         rollback: (transaction, reason, error) => {
             const optimistic = updates.get(transaction.id);
             if (!optimistic)

package/dist/local/transactions/mutations/MutationQueue.d.ts

@@ -111,6 +111,7 @@ export declare class MutationQueue extends EventEmitter {
     private pendingPersistenceStages;
     private persistenceStageScheduled;
     private pendingDrainPromise;
+    private modelProcessingPromise;
     private executionQueue;
     private isProcessing;
     private processTimer?;
@@ -153,7 +154,6 @@ export declare class MutationQueue extends EventEmitter {
     private get failureHandlingContext();
     private get conflictResolutionContext();
     private get processingSchedulerContext();
-    private get pendingDrainContext();
     private get durableCommitRestoreContext();
     private get persistenceContext();
     private nextCommitSequence;
@@ -225,7 +225,6 @@ export declare class MutationQueue extends EventEmitter {
      */
     private scheduleReplicationLagTimeout;
     private takeNextExecutionBatch;
-    private takePendingDrainBatch;
     /**
      * Resolvers for per-transaction `confirmation` promises. Populated in
      * `attachConfirmation` at staging time, consumed by the constructor-time

package/dist/local/transactions/mutations/MutationQueue.js

@@ -34,9 +34,8 @@ import { enqueueTransaction } from './queueCoalescing.js';
 import { processBatch } from './batchProcessing.js';
 import { handleFailure } from './failureHandling.js';
 import { handleConflict as resolveConflict, isPermanentError as classifyPermanentError, isDefinitiveRejection as classifyDefinitiveRejection } from './failurePolicy.js';
-import { takeNextExecutionBatch as selectExecutionBatch, takePendingDrainBatch as selectPendingDrainBatch } from './executionSelection.js';
+import { takeNextExecutionBatch as selectExecutionBatch } from './executionSelection.js';
 import { scheduleProcessing as scheduleProcessingExternal } from './processingScheduler.js';
-import { drainPendingConfirmations, } from './pendingDrain.js';
 import { restoreDurableCommits as restoreDurableCommitsExternal } from './durableCommitRestore.js';
 export class MutationQueue extends EventEmitter {
     // Keep one hour of clock/network margin inside the server's 24-hour ledger.
@@ -70,6 +69,7 @@ export class MutationQueue extends EventEmitter {
     pendingPersistenceStages = [];
     persistenceStageScheduled = false;
     pendingDrainPromise = null;
+    modelProcessingPromise = null;
     executionQueue = [];
     isProcessing = false;
     processTimer;
@@ -303,32 +303,6 @@ export class MutationQueue extends EventEmitter {
             logger: this.runtime.logger,
         };
     }
-    get pendingDrainContext() {
-        return {
-            runtime: this.runtime,
-            config: { deltaConfirmationTimeout: this.config.deltaConfirmationTimeout },
-            store: this.store,
-            executionQueue: this.executionQueue,
-            optimisticUpdates: this.localMutationPort.updates,
-            assertDurableReplayOpen: () => { this.assertDurableReplayOpen(); },
-            processCommitLane: () => this.processCommitLane(),
-            takePendingDrainBatch: (pending) => this.takePendingDrainBatch(pending),
-            ensureCommitEnvelope: (batch) => this.ensureCommitEnvelope(batch),
-            ensureDerivedFields: (transaction) => { this.ensureDerivedFields(transaction); },
-            sourceMutationIdsFor: (batch) => this.sourceMutationIdsFor(batch),
-            sealDurableCommit: (input) => this.sealDurableCommit(input),
-            assertEnvelopeInsideReplayWindow: (envelope) => { this.assertEnvelopeInsideReplayWindow(envelope); },
-            parseMutationCommitResult: (value) => this.parseMutationCommitResult(value),
-            dispatchCommitBounded: (...args) => this.dispatchCommitBounded(...args),
-            persistDurableCommitAcceptance: (envelope, result) => this.persistDurableCommitAcceptance(envelope, result),
-            removeDurableCommit: (idempotencyKey) => this.removeDurableCommit(idempotencyKey),
-            scheduleReplicationLagTimeout: (transactionId, clientTxId, correlationId) => { this.scheduleReplicationLagTimeout(transactionId, clientTxId, correlationId); },
-            scheduleDeltaConfirmationTimeout: (transaction, timeoutMs) => { this.scheduleDeltaConfirmationTimeout(transaction, timeoutMs); },
-            enqueue: (transaction) => { this.enqueue(transaction); },
-            recentDeltaCorrelations: this.recentDeltaCorrelations,
-            emit: (event, payload) => this.emit(event, payload),
-        };
-    }
     get durableCommitRestoreContext() {
         return {
             config: this.config,
@@ -738,9 +712,6 @@ export class MutationQueue extends EventEmitter {
         this.executionQueue = selected.remaining;
         return selected.batch;
     }
-    takePendingDrainBatch(pending) {
-        return selectPendingDrainBatch(pending, this.config.maxBatchSize);
-    }
     /**
      * Resolvers for per-transaction `confirmation` promises. Populated in
      * `attachConfirmation` at staging time, consumed by the constructor-time
@@ -1004,25 +975,15 @@ export class MutationQueue extends EventEmitter {
         return this.pendingDrainPromise;
     }
     async drainPendingInternal() {
-        // The normal batch scheduler and the explicit/reconnect drain are two
-        // ways to drive the same durable queue. They must never seal the same
-        // staged source records concurrently: the first seal consumes those
-        // records, so the second would correctly reject them as already claimed.
-        //
-        // `isProcessing` is acquired synchronously before either path awaits,
-        // making it the queue-wide execution lock. If the normal lane already
-        // owns it, that lane will finish the pending work; callers waiting on a
-        // specific confirmation remain attached to the exact transaction.
-        if (this.isProcessing)
-            return;
-        this.isProcessing = true;
-        try {
-            await drainPendingConfirmations(this.pendingDrainContext);
-        }
-        finally {
-            this.isProcessing = false;
-            if (this.executionQueue.length > 0)
-                this.scheduleProcessing(true);
+        // Explicit flushes and reconnects are merely another trigger for the one
+        // model-mutation execution lane. A second sealing implementation can race
+        // the scheduled lane, consume its journal sources, and later dispatch the
+        // same transaction again. Move every staged row to the owned queue, then
+        // drive the normal lane until the queue has handed off all current work.
+        this.commitCreatedTransactions();
+        await this.processCommitLane();
+        while (this.executionQueue.length > 0 || this.modelProcessingPromise) {
+            await this.processBatch();
         }
     }
     async create(model, context, writeOptions, sourceMutationId) {
@@ -1055,7 +1016,20 @@ export class MutationQueue extends EventEmitter {
         scheduleProcessingExternal(this.processingSchedulerContext, immediate);
     }
     async processBatch() {
-        await processBatch(this.batchProcessingContext);
+        if (this.modelProcessingPromise) {
+            await this.modelProcessingPromise;
+            if (this.executionQueue.length > 0)
+                await this.processBatch();
+            return;
+        }
+        const processing = processBatch(this.batchProcessingContext);
+        const tracked = processing.finally(() => {
+            if (this.modelProcessingPromise === tracked) {
+                this.modelProcessingPromise = null;
+            }
+        });
+        this.modelProcessingPromise = tracked;
+        await tracked;
     }
     rememberDeltaCorrelation(correlationId, syncId) {
         // Refresh insertion order when a replay repeats the same correlation id.

package/dist/local/transactions/mutations/batchProcessing.js

@@ -64,16 +64,29 @@ export async function processBatch(ctx) {
             if (batchOps.length > 0) {
                 let dispatchStarted = false;
                 try {
-                    const durableEnvelope = await ctx.sealDurableCommit({
-                        idempotencyKey: commitIdempotencyKey,
-                        origin: 'model_batch',
-                        operations: batchOps.map(({ op }) => op),
-                        sourceMutationIds: ctx.sourceMutationIdsFor(batch),
-                        commitOptions: { reads: collectQueuedReads(batch) },
-                        createdAt: Math.min(...batch.map((transaction) => transaction.createdAt)),
-                        sealedAt: batch[0]?.commitEnvelope?.sealedAt ?? Date.now(),
-                        sequence: batch[0]?.commitEnvelope?.sequence,
-                    });
+                    let durableEnvelope = batch[0]?.durableEnvelope;
+                    if (durableEnvelope) {
+                        const mismatched = batch.some((transaction) => transaction.durableEnvelope?.idempotencyKey !==
+                            durableEnvelope?.idempotencyKey);
+                        if (mismatched || durableEnvelope.idempotencyKey !== commitIdempotencyKey) {
+                            throw new Error('Cannot replay a model batch with inconsistent durable envelopes');
+                        }
+                    }
+                    else {
+                        durableEnvelope = await ctx.sealDurableCommit({
+                            idempotencyKey: commitIdempotencyKey,
+                            origin: 'model_batch',
+                            operations: batchOps.map(({ op }) => op),
+                            sourceMutationIds: ctx.sourceMutationIdsFor(batch),
+                            commitOptions: { reads: collectQueuedReads(batch) },
+                            createdAt: Math.min(...batch.map((transaction) => transaction.createdAt)),
+                            sealedAt: batch[0]?.commitEnvelope?.sealedAt ?? Date.now(),
+                            sequence: batch[0]?.commitEnvelope?.sequence,
+                        });
+                        for (const transaction of batch) {
+                            transaction.durableEnvelope = durableEnvelope;
+                        }
+                    }
                     const operations = durableEnvelope.operations;
                     // Capture lastSyncId from the server response for threshold-based
                     // confirmation.

package/dist/local/transactions/mutations/commitPayload.d.ts

@@ -11,7 +11,7 @@
 import type { RuntimeContext } from '../../RuntimeContext.js';
 import { MutationOperationType } from '@abloatai/transaction/types';
 import type { MutationOptions, WriteOptions } from '../../interfaces/index.js';
-import type { CommitEnvelopeMember } from '@abloatai/transaction/commit';
+import type { CommitEnvelopeMember, DurableCommitEnvelope } from '@abloatai/transaction/commit';
 export interface UserContext {
     userId: string;
     organizationId: string;
@@ -69,6 +69,13 @@ export interface QueuedMutation {
      * re-batching its operations under a fresh key.
      */
     commitEnvelope?: CommitEnvelopeMember;
+    /**
+     * The exact durable request produced by the first successful local seal.
+     * Runtime retries dispatch this object directly. Asking the outbox to seal
+     * again is both unnecessary and unsafe after a concurrent authoritative
+     * completion has begun cleaning up the stored envelope.
+     */
+    durableEnvelope?: DurableCommitEnvelope;
     /** Pending-mutation journal entries atomically consumed by this envelope. */
     sourceMutationIds?: string[];
     /** Completed locally without a server operation; no sync echo will arrive. */

package/dist/local/transactions/mutations/commitTransport.js

@@ -95,7 +95,9 @@ export function dispatchCommitBounded(ctx, ...args) {
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
         return dispatched;
     return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new AbloConnectionError('The mutation transport did not acknowledge the commit in time; its outcome remains pending and is safe to retry.', { code: 'commit_no_result' })), timeoutMs);
+        const timer = setTimeout(() => {
+            reject(new AbloConnectionError('The mutation transport did not acknowledge the commit in time; its outcome remains pending and is safe to retry.', { code: 'commit_no_result' }));
+        }, timeoutMs);
         dispatched.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error instanceof Error ? error : new Error(String(error))); });
     });
 }

package/dist/local/transactions/mutations/executionSelection.d.ts

@@ -3,4 +3,3 @@ export declare function takeNextExecutionBatch(executionQueue: QueuedMutation[],
     batch: QueuedMutation[];
     remaining: QueuedMutation[];
 };
-export declare function takePendingDrainBatch(pending: QueuedMutation[], maxBatchSize: number): QueuedMutation[];

package/dist/local/transactions/mutations/executionSelection.js

@@ -1,6 +1,10 @@
 export function takeNextExecutionBatch(executionQueue, maxBatchSize) {
+    // Cancellation, delta confirmation, and failure settlement can all make a
+    // queued reference terminal before its scheduler callback runs. Terminal or
+    // currently executing rows have no authority to cross the dispatch boundary.
+    const pendingQueue = executionQueue.filter((tx) => tx.status === 'pending');
     const retryGroups = new Map();
-    for (const tx of executionQueue) {
+    for (const tx of pendingQueue) {
         const envelope = tx.commitEnvelope;
         if (!envelope)
             continue;
@@ -13,30 +17,18 @@ export function takeNextExecutionBatch(executionQueue, maxBatchSize) {
         const expectedCount = members[0]?.commitEnvelope?.operationCount;
         if (expectedCount === undefined || members.length !== expectedCount)
             continue;
-        const remaining = executionQueue.filter((tx) => tx.commitEnvelope?.idempotencyKey !== idempotencyKey);
+        const remaining = pendingQueue.filter((tx) => tx.commitEnvelope?.idempotencyKey !== idempotencyKey);
         members.sort((a, b) => (a.commitEnvelope?.operationIndex ?? 0) - (b.commitEnvelope?.operationIndex ?? 0));
         return { batch: members, remaining };
     }
-    const fresh = executionQueue.filter((tx) => !tx.commitEnvelope);
+    const fresh = pendingQueue.filter((tx) => !tx.commitEnvelope);
     const firstFresh = fresh[0];
     if (!firstFresh)
-        return { batch: [], remaining: executionQueue };
+        return { batch: [], remaining: pendingQueue };
     const explicitIndex = fresh.findIndex((tx) => typeof tx.writeOptions?.idempotencyKey === 'string');
     const selected = explicitIndex === 0
         ? [firstFresh]
         : fresh.slice(0, Math.min(maxBatchSize, explicitIndex > 0 ? explicitIndex : fresh.length));
     const selectedIds = new Set(selected.map((tx) => tx.id));
-    return { batch: selected, remaining: executionQueue.filter((tx) => !selectedIds.has(tx.id)) };
-}
-export function takePendingDrainBatch(pending, maxBatchSize) {
-    const first = pending[0];
-    if (!first)
-        return [];
-    const envelope = first.commitEnvelope;
-    if (envelope)
-        return pending.filter((tx) => tx.commitEnvelope?.idempotencyKey === envelope.idempotencyKey);
-    if (typeof first.writeOptions?.idempotencyKey === 'string')
-        return [first];
-    const explicitIndex = pending.findIndex((tx) => typeof tx.writeOptions?.idempotencyKey === 'string');
-    return pending.slice(0, Math.min(maxBatchSize, explicitIndex > 0 ? explicitIndex : pending.length));
+    return { batch: selected, remaining: pendingQueue.filter((tx) => !selectedIds.has(tx.id)) };
 }

package/dist/local/transactions/mutations/failureHandling.js

@@ -13,6 +13,15 @@ export function transientRetryDelayMs(error, attempt, retryBackoff) {
     return Math.floor(Math.random() * ceiling);
 }
 export async function handleFailure(ctx, transaction, error) {
+    // The dispatch owner may lose its acknowledgement while an authoritative
+    // delta concurrently completes the same transaction. Completion is
+    // terminal: a late catch path must not turn that row back into `pending`
+    // and schedule a second seal after its durable sources were cleaned up.
+    if (transaction.status === 'completed' ||
+        transaction.status === 'failed' ||
+        transaction.status === 'rolled_back' ||
+        transaction.status === 'awaiting_delta')
+        return;
     transaction.attempts++;
     // Check whether this is a permanent error that should not be retried.
     if (ctx.isPermanentError(error)) {

package/dist/local/transactions/mutations/localMutation.js

@@ -12,9 +12,9 @@ export function createLocalMutationPort(emitter) {
     const updates = new Map();
     return {
         updates,
-        applyCreate: (model, transaction) => applyOptimisticCreate(updates, emitter, model, transaction),
-        applyUpdate: (model, transaction) => applyOptimisticUpdate(updates, emitter, model, transaction),
-        applyDelete: (model, transaction) => applyOptimisticDelete(updates, emitter, model, transaction),
+        applyCreate: (model, transaction) => { applyOptimisticCreate(updates, emitter, model, transaction); },
+        applyUpdate: (model, transaction) => { applyOptimisticUpdate(updates, emitter, model, transaction); },
+        applyDelete: (model, transaction) => { applyOptimisticDelete(updates, emitter, model, transaction); },
         rollback: (transaction, reason, error) => rollbackOptimistic(updates, emitter, transaction, reason, error),
     };
 }

package/dist/local/transactions/mutations/queueCoalescing.js

@@ -1,6 +1,14 @@
 import { mergeUpdateData } from './coalesceRules.js';
 import { hasCommitCoalescingBarrier } from './commitPayload.js';
 export function enqueueTransaction(ctx, transaction) {
+    // Only the pending state may cross into the execution owner. A late timer,
+    // reconnect callback, or stale staging callback must not resurrect a row
+    // that is already executing or terminal, and repeated triggers must not put
+    // the same source mutation into the queue twice.
+    if (transaction.status !== 'pending')
+        return;
+    if (ctx.executionQueue.some((candidate) => candidate.id === transaction.id))
+        return;
     ctx.ensureDerivedFields(transaction);
     const modelKey = `${transaction.modelName}:${transaction.modelId}`;
     if (transaction.type === 'update' && transaction.attempts === 0 && !transaction.commitEnvelope) {

package/dist/react/useErrorListener.js

@@ -10,5 +10,5 @@ export function useErrorListener(listener) {
     }
     const listenerRef = useRef(listener);
     listenerRef.current = listener;
-    useEffect(() => context.subscribeError((error) => listenerRef.current(error)), [context]);
+    useEffect(() => context.subscribeError((error) => { listenerRef.current(error); }), [context]);
 }

package/dist/react/useMutationFailureListener.js

@@ -14,6 +14,6 @@ export function useMutationFailureListener(listener) {
         const engine = context.engine;
         if (!engine)
             return;
-        return engine.onMutationFailure((payload) => listenerRef.current(payload));
+        return engine.onMutationFailure((payload) => { listenerRef.current(payload); });
     }, [context, context.engine]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/humans",
-  "version": "0.60.0",
+  "version": "0.61.0",
   "description": "The optional human-facing local-state package for Ablo: presence, live queries, and React bindings.",
   "license": "Apache-2.0",
   "type": "module",
@@ -68,7 +68,7 @@
     "test:property": "jest --testPathPatterns=__tests__/property",
     "test:migrated-integration": "jest --testPathPatterns=__tests__/integration",
     "test:e2e": "E2E_TEST=true jest --config jest.e2e.config.ts",
-    "lint:eslint": "eslint . --cache",
+    "lint:eslint": "eslint . --cache --suppressions-location eslint-suppressions.json",
     "check:boundary": "node scripts/check-boundary.mjs",
     "test:integration": "npm run build && node scripts/check-package-integration.mjs",
     "lint:pkg": "publint"
@@ -84,7 +84,7 @@
     "directory": "packages/humans"
   },
   "dependencies": {
-    "@abloatai/transaction": "^0.60.0",
+    "@abloatai/transaction": "^0.61.0",
     "mobx": "^6.13.7",
     "uuid": "^11.1.0",
     "zod": "^4.4.3"
@@ -114,7 +114,6 @@
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "ts-jest": "^29.4.5",
-    "ts-node": "^10.9.2",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
     "ws": "^8.18.3"
   }

package/src/local/BaseSyncedStore.ts

@@ -1759,9 +1759,9 @@ export class BaseSyncedStore<
     const isCreate = !this.objectPool.get(model.id);
     if (isCreate) {
       model.updatedAt = new Date();
-      this.syncClient.add(model);
+      await this.syncClient.add(model);
     } else {
-      this.syncClient.update(model);
+      await this.syncClient.update(model);
     }
   }
 
@@ -1779,21 +1779,21 @@ export class BaseSyncedStore<
     const model = rowAsModel(entity);
     this.pendingDeletes.add(model.id);
     // SyncClient.delete handles: pool remove, transaction queue
-    this.syncClient.delete(model);
+    await this.syncClient.delete(model);
   }
 
   /** Archive a model. Accepts schema-inferred entity shapes (see `save`). */
   async archive<T extends { id: string; archivedAt?: Date | null }>(entity: T): Promise<void> {
     const model = rowAsModel(entity);
     model.archivedAt = new Date();
-    this.syncClient.archive(model);
+    await this.syncClient.archive(model);
   }
 
   /** Unarchive a model. Accepts schema-inferred entity shapes (see `save`). */
   async unarchive<T extends { id: string; archivedAt?: Date | null }>(entity: T): Promise<void> {
     const model = rowAsModel(entity);
     model.archivedAt = null;
-    this.syncClient.update(model);
+    await this.syncClient.update(model);
   }
 
 

package/src/local/Model.ts

@@ -416,7 +416,7 @@ export abstract class Model {
     const original = this.getOriginalSnapshot();
     for (const key of keys) {
       if (key === 'id') continue;
-      const mod = modified?.get(key);
+      const mod = modified.get(key);
       if (mod) {
         out[key] = mod.old;
       } else if (original && key in original) {
@@ -463,25 +463,23 @@ export abstract class Model {
     const modelName = this.getModelName();
     const properties = getActiveRegistry().getProperties(modelName);
 
-    if (properties) {
-      const json = this.toJSON();
-      for (const [propName, metadata] of properties) {
-        // Check required fields
-        if (!metadata.nullable && !metadata.optional) {
-          const value = json[propName];
-          if (value == null || value === '') {
-            errors.push(`${propName} is required`);
-          }
+    const json = this.toJSON();
+    for (const [propName, metadata] of properties) {
+      // Check required fields
+      if (!metadata.nullable && !metadata.optional) {
+        const value = json[propName];
+        if (value == null || value === '') {
+          errors.push(`${propName} is required`);
         }
+      }
 
-        // Run custom validation rules
-        const rules = this.validationRules[propName];
-        if (rules) {
-          const value = json[propName];
-          for (const rule of rules) {
-            const error = rule(value);
-            if (error) errors.push(error);
-          }
+      // Run custom validation rules
+      const rules = this.validationRules[propName];
+      if (rules) {
+        const value = json[propName];
+        for (const rule of rules) {
+          const error = rule(value);
+          if (error) errors.push(error);
         }
       }
     }
@@ -816,18 +814,16 @@ export abstract class Model {
       result.archivedAt = this.archivedAt?.toISOString() ?? null;
     }
 
-    if (properties) {
-      const self = this as Record<string, unknown>;
-      for (const [propName, metadata] of properties) {
-        // Skip certain types
-        if (metadata.type === 'ephemeralProperty') continue;
-        if (metadata.type === 'referenceModel') continue;
-        if (metadata.type === 'referenceCollection') continue;
-
-        const value = self[propName];
-        if (value !== undefined) {
-          result[propName] = value;
-        }
+    const self = this as Record<string, unknown>;
+    for (const [propName, metadata] of properties) {
+      // Skip certain types
+      if (metadata.type === 'ephemeralProperty') continue;
+      if (metadata.type === 'referenceModel') continue;
+      if (metadata.type === 'referenceCollection') continue;
+
+      const value = self[propName];
+      if (value !== undefined) {
+        result[propName] = value;
       }
     }
 
@@ -946,14 +942,12 @@ export abstract class Model {
       const modelName = this.getModelName();
       const properties = getActiveRegistry().getProperties(modelName);
 
-      if (properties) {
-        const self = this as Record<string, unknown>;
-        for (const [propName, metadata] of properties) {
-          if (metadata.type === 'referenceCollection') {
-            const collection = self[propName] as Disposable | undefined;
-            if (collection?.dispose) {
-              collection.dispose();
-            }
+      const self = this as Record<string, unknown>;
+      for (const [propName, metadata] of properties) {
+        if (metadata.type === 'referenceCollection') {
+          const collection = self[propName] as Disposable | undefined;
+          if (collection) {
+            collection.dispose();
           }
         }
       }
@@ -983,11 +977,9 @@ export abstract class Model {
     const modelName = this.getModelName();
     const properties = getActiveRegistry().getProperties(modelName);
 
-    if (properties) {
-      const json = this.toJSON();
-      for (const [propName] of properties) {
-        snapshot[propName] = json[propName];
-      }
+    const json = this.toJSON();
+    for (const [propName] of properties) {
+      snapshot[propName] = json[propName];
     }
 
     return snapshot;
@@ -1034,19 +1026,17 @@ export abstract class Model {
 
     const properties = getActiveRegistry().getProperties(this.getModelName());
     const self = this as Record<string, unknown>;
-    if (properties) {
-      for (const [propName, metadata] of properties) {
-        if (
-          metadata.type === 'ephemeralProperty' ||
-          metadata.type === 'referenceModel' ||
-          metadata.type === 'referenceCollection'
-        ) {
-          continue;
-        }
-        // Reading through the observable getter is the point: it subscribes the
-        // enclosing MobX reaction to this field.
-        snapshot[propName] = self[propName];
+    for (const [propName, metadata] of properties) {
+      if (
+        metadata.type === 'ephemeralProperty' ||
+        metadata.type === 'referenceModel' ||
+        metadata.type === 'referenceCollection'
+      ) {
+        continue;
       }
+      // Reading through the observable getter is the point: it subscribes the
+      // enclosing MobX reaction to this field.
+      snapshot[propName] = self[propName];
     }
 
     for (const name of this.getDerivedGetterNames()) {

package/src/local/NetworkMonitor.ts

@@ -14,6 +14,8 @@ export class NetworkMonitor extends EventEmitter {
   // 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.
+  // DOM types say `onLine` is boolean, but Node exposes it as undefined.
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-boolean-literal-compare
   private isOnline = !(typeof navigator !== 'undefined' && navigator.onLine === false);
   private lastOnlineCheck: Date = new Date();
 

package/src/local/RuntimeContext.ts

@@ -106,6 +106,8 @@ export const browserOnlineStatus: OnlineStatusProvider = {
     // signal. Don't use `!navigator.onLine`: Node 18+ exposes a global
     // `navigator` whose `onLine` is `undefined`, which `!` would read as offline —
     // wedging every Node/server client (agents, worker, MCP) into a false offline.
+    // DOM types say `onLine` is boolean, but Node exposes it as undefined.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-boolean-literal-compare
     return !(typeof navigator !== 'undefined' && navigator.onLine === false);
   },
 };