@abloatai/humans 0.38.0 → 0.39.0

package/dist/local/Model.js

@@ -31,6 +31,7 @@ export class ValidationError extends Error {
 }
 /** Shared frozen default for {@link Model.getDerivedGetterNames}. */
 const EMPTY_DERIVED_GETTERS = Object.freeze([]);
+const fieldWritePlans = new WeakMap();
 /**
  * The abstract base class every domain model extends. It holds the model's id
  * and timestamps, tracks in-place property changes for change detection and
@@ -54,6 +55,17 @@ export class Model {
     _isNew = true;
     /** Original data snapshot */
     _originalData;
+    /**
+     * Whether the persisted baseline needs recapturing. Hydration and ack land
+     * far more often than anything reads the baseline — an observer-only client
+     * reads it never — so each of those sites marks the snapshot stale and
+     * {@link getOriginalSnapshot} materializes it on first read. Correctness
+     * rests on the tracking invariant: every non-hydration write is recorded in
+     * `modifiedProperties` (first-old-wins), so between the stale mark and the
+     * read, untracked fields still hold exactly the values an eager capture
+     * would have recorded.
+     */
+    _originalDataStale = false;
     /** Sync status */
     syncStatus = 'pending';
     /** Timestamps */
@@ -208,7 +220,8 @@ export class Model {
      */
     markAsPersisted() {
         this._isNew = false;
-        this._originalData = this.captureSnapshot();
+        this._originalData = undefined;
+        this._originalDataStale = true;
     }
     /**
      * Check if this is a new model
@@ -230,6 +243,10 @@ export class Model {
      * last acknowledged state would already be the authoritative baseline.
      */
     getOriginalSnapshot() {
+        if (this._originalDataStale) {
+            this._originalData = this.captureSnapshot();
+            this._originalDataStale = false;
+        }
         return this._originalData;
     }
     /**
@@ -238,7 +255,8 @@ export class Model {
     clearChanges() {
         runInAction(() => {
             this.modifiedProperties.clear();
-            this._originalData = this.captureSnapshot();
+            this._originalData = undefined;
+            this._originalDataStale = true;
         });
     }
     /**
@@ -471,43 +489,39 @@ export class Model {
      * leaves that baseline intact.
      */
     assignFieldsFromData(data, onWrite) {
-        // Update properties with safety checks for read-only/computed accessors
-        for (const [key, raw] of Object.entries(data)) {
+        let plan = fieldWritePlans.get(this.constructor);
+        if (!plan) {
+            plan = new Map();
+            fieldWritePlans.set(this.constructor, plan);
+        }
+        for (const key in data) {
             if (key === 'id')
                 continue;
-            // Only attempt to set if the property exists on instance or prototype
-            if (!(this.hasOwnProperty(key) || key in this))
+            if (!Object.prototype.hasOwnProperty.call(data, key))
                 continue;
-            // Never assign to MobX computed properties (they may expose a setter that throws)
-            try {
-                if (isComputedProp(this, key)) {
-                    continue;
-                }
-            }
-            catch {
-                // If MobX internals are unavailable for some reason, fall back to descriptor checks below
+            const raw = data[key];
+            let disposition = plan.get(key);
+            if (disposition === undefined) {
+                disposition = this.resolveFieldDisposition(key);
+                plan.set(key, disposition);
             }
-            // Resolve property descriptor from own or prototype chain
-            const ownDesc = Object.getOwnPropertyDescriptor(this, key);
-            let desc = ownDesc;
-            if (!desc) {
-                let proto = Object.getPrototypeOf(this);
-                while (proto && proto !== Object.prototype && !desc) {
-                    desc = Object.getOwnPropertyDescriptor(proto, key);
-                    proto = Object.getPrototypeOf(proto);
-                }
+            if (disposition === 'skip-readonly')
+                continue;
+            if (disposition === 'skip-absent') {
+                // The plan was built from an instance that lacked this key. Re-resolve
+                // for this instance without touching the cache, so heterogeneous
+                // shapes stay correct at the cost of the slow path.
+                if (!(key in this))
+                    continue;
+                disposition = this.resolveFieldDisposition(key);
+                if (disposition === 'skip-readonly' || disposition === 'skip-absent')
+                    continue;
             }
-            // Determine writability: allow if data descriptor writable, or accessor with setter
-            const writable = desc
-                ? ('writable' in desc && !!desc.writable) ||
-                    ('set' in desc && typeof desc.set === 'function')
-                : true;
-            if (!writable) {
-                // Skip read-only accessor properties (getter-only)
+            else if (!(key in this)) {
                 continue;
             }
             // Handle date conversions
-            const value = (key === 'createdAt' || key === 'updatedAt' || key === 'archivedAt') && raw
+            const value = disposition === 'write-date' && raw
                 ? new Date(raw)
                 : raw;
             // Capture the pre-write value BEFORE assignment so trackers
@@ -518,6 +532,42 @@ export class Model {
             onWrite?.(key, oldValue, value);
         }
     }
+    /**
+     * The uncached decision for one key: existence on instance or prototype,
+     * never a MobX computed (its setter may throw), and writability resolved
+     * through the descriptor chain — a data descriptor's `writable` or an
+     * accessor's setter.
+     */
+    resolveFieldDisposition(key) {
+        if (!(key in this))
+            return 'skip-absent';
+        try {
+            if (isComputedProp(this, key)) {
+                return 'skip-readonly';
+            }
+        }
+        catch {
+            // If MobX internals are unavailable for some reason, fall back to descriptor checks below
+        }
+        const ownDesc = Object.getOwnPropertyDescriptor(this, key);
+        let desc = ownDesc;
+        if (!desc) {
+            let proto = Object.getPrototypeOf(this);
+            while (proto && proto !== Object.prototype && !desc) {
+                desc = Object.getOwnPropertyDescriptor(proto, key);
+                proto = Object.getPrototypeOf(proto);
+            }
+        }
+        const writable = desc
+            ? ('writable' in desc && !!desc.writable) ||
+                ('set' in desc && typeof desc.set === 'function')
+            : true;
+        if (!writable)
+            return 'skip-readonly';
+        return key === 'createdAt' || key === 'updatedAt' || key === 'archivedAt'
+            ? 'write-date'
+            : 'write';
+    }
     /**
      * Update from raw data (hydration)
      *
@@ -550,7 +600,8 @@ export class Model {
         });
         // Mark as persisted if updating existing model
         if (!this._isNew) {
-            this._originalData = this.captureSnapshot();
+            this._originalData = undefined;
+            this._originalDataStale = true;
         }
         this.didUpdate();
     }

package/dist/local/SyncClient.d.ts

@@ -275,10 +275,6 @@ export declare class SyncClient extends EventEmitter {
      * conflict resolver reads exactly these fields and no others.
      */
     private extractCriticalState;
-    /**
-     * Check if critical state changes exist that require forcing server state
-     */
-    private hasCriticalStateChange;
     /**
      * Handle network reconnection
      */
@@ -487,6 +483,7 @@ export declare class SyncClient extends EventEmitter {
      */
     getMutationQueue(): MutationQueue;
     applyDeltaBatchToPool(dbResults: readonly AppliedChange[], enrichRelations: (modelName: string, data: Record<string, unknown>) => Record<string, unknown>): void;
+    private applyDeltaBatchToPoolInAction;
     /**
      * Apply bootstrap data to the InstanceCache with ghost removal.
      * Owns: model creation, batch upsert, ghost detection + removal.

package/dist/local/SyncClient.js

@@ -1038,31 +1038,22 @@ export class SyncClient extends EventEmitter {
      * local model has unsynced changes, so the two sides stay consistent.
      */
     resolveConflicts(localModel, serverData) {
-        const hasLocalChanges = localModel.hasChanges;
-        // Safely get timestamp, handling both Date objects and strings
-        const localUpdatedAt = localModel.updatedAt
-            ? localModel.updatedAt instanceof Date
-                ? localModel.updatedAt.getTime()
-                : new Date(localModel.updatedAt).getTime()
-            : 0;
-        const serverUpdatedAt = toEpochMs(serverData.updatedAt);
-        this.runtime.logger.debug('Conflict resolution', {
-            modelId: localModel.id,
-            modelType: localModel.getModelName(),
-            hasLocalChanges,
-            localUpdatedAt: localModel.updatedAt?.toString(),
-            serverUpdatedAt: serverData.updatedAt,
-            localChanges: localModel.getChanges(),
-            serverState: this.extractCriticalState(serverData),
-        });
-        // PRIORITY 1: Check for critical server states that must be respected
-        // These states override any local changes to maintain data consistency
-        const criticalServerStates = this.extractCriticalState(serverData);
-        const shouldForceAcceptServer = this.hasCriticalStateChange(criticalServerStates);
+        // No entry-point debug here: this runs once per incoming update delta,
+        // and a debug call's payload is BUILT even when the logger discards it —
+        // a per-delta model scan on the apply hot path. The outcome branches
+        // below log the cases worth reading.
+        // PRIORITY 1: Check for critical server states that must be respected.
+        // These states override any local changes to maintain data consistency.
+        // Checked inline — the collected-object form (`extractCriticalState`)
+        // only materializes on the rare force-accept branch, for its log line.
+        const shouldForceAcceptServer = (serverData.deletedAt !== undefined && serverData.deletedAt !== null) ||
+            (serverData.archivedAt !== undefined && serverData.archivedAt !== null) ||
+            serverData.isActive === false ||
+            (serverData.unassignedAt !== undefined && serverData.unassignedAt !== null);
         if (shouldForceAcceptServer) {
             this.runtime.logger.debug('Accepting server update - critical state change detected', {
                 modelId: localModel.id,
-                criticalStates: criticalServerStates,
+                criticalStates: this.extractCriticalState(serverData),
             });
             // Force accept server state for critical changes
             localModel.updateFromData(serverData);
@@ -1072,7 +1063,7 @@ export class SyncClient extends EventEmitter {
         }
         // Local-first: if we have local dirty fields, merge by field.
         // Keep locally changed fields; apply server for the rest.
-        if (hasLocalChanges) {
+        if (localModel.hasChanges) {
             const localChanges = localModel.getChanges();
             this.runtime.logger.debug('Merging server update with local dirty fields', {
                 modelId: localModel.id,
@@ -1082,6 +1073,13 @@ export class SyncClient extends EventEmitter {
             const merged = { ...serverData, ...(localChanges || {}) };
             // Preserve the most recent updatedAt without clearing dirty flags
             if (serverData.updatedAt || localModel.updatedAt) {
+                // Safely get timestamp, handling both Date objects and strings
+                const localUpdatedAt = localModel.updatedAt
+                    ? localModel.updatedAt instanceof Date
+                        ? localModel.updatedAt.getTime()
+                        : new Date(localModel.updatedAt).getTime()
+                    : 0;
+                const serverUpdatedAt = toEpochMs(serverData.updatedAt);
                 const mergedUpdatedAt = new Date(Math.max(localUpdatedAt, serverUpdatedAt));
                 // updateFromData accepts Date or ISO string for dates
                 merged.updatedAt = mergedUpdatedAt;
@@ -1090,10 +1088,9 @@ export class SyncClient extends EventEmitter {
             // Intentionally DO NOT clearChanges here; pending tx will confirm and clear
             return localModel;
         }
-        // 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';
-        this.runtime.logger.debug(`Accepting server update - ${acceptReason}`);
+        // No local changes: fall back to LWW to converge. Accept server
+        // regardless of timestamp equality to stay in sync. Not logged — this is
+        // the common path for every collaborator update a client receives.
         localModel.updateFromData(serverData);
         localModel.clearChanges();
         localModel.markAsSynced();
@@ -1125,14 +1122,6 @@ export class SyncClient extends EventEmitter {
         }
         return critical;
     }
-    /**
-     * Check if critical state changes exist that require forcing server state
-     */
-    hasCriticalStateChange(criticalStates) {
-        // Any critical state present means we should force accept server
-        return (Object.keys(criticalStates).length > 0 &&
-            Object.values(criticalStates).some((v) => v !== null && v !== undefined));
-    }
     /**
      * Handle network reconnection
      */
@@ -1536,6 +1525,18 @@ export class SyncClient extends EventEmitter {
         return this.mutationQueue;
     }
     applyDeltaBatchToPool(dbResults, enrichRelations) {
+        // The WHOLE batch — conflict resolution and model mutation included, not
+        // just the pool bookkeeping at the end — runs in one MobX action.
+        // `resolveConflicts` writes model fields via `updateFromData`; when those
+        // writes ran before the action, every delta opened its own top-level
+        // action and flushed reactions at its boundary, so a large frame paid one
+        // reaction pass per delta and an observer could see a partially applied
+        // frame between them.
+        runInAction(() => {
+            this.applyDeltaBatchToPoolInAction(dbResults, enrichRelations);
+        });
+    }
+    applyDeltaBatchToPoolInAction(dbResults, enrichRelations) {
         const modelsToAdd = [];
         const modelsToUpsert = [];
         const idsToRemove = [];
@@ -1633,31 +1634,25 @@ export class SyncClient extends EventEmitter {
                     break;
             }
         }
-        // Reveal the whole frame in a single MobX action. `addBatch`,
-        // `upsertBatch`, `removeBatch`, and `updateScope` are each individually
-        // wrapped in an action, so calling them in sequence flushes reactions at
-        // every action boundary — a catch-up frame that adds, updates, and removes
-        // would fire every dependent reaction several times in a row, re-rendering
-        // and re-sorting on each. Wrapping them in one outer `runInAction` defers
-        // all reaction flushes to a single boundary, so dependents recompute
-        // exactly once regardless of how many models or operation kinds the frame
-        // touched. The app therefore never observes a partially applied frame.
-        runInAction(() => {
-            if (modelsToAdd.length > 0)
-                this.objectPool.addBatch(modelsToAdd, ModelScope.live);
-            if (modelsToUpsert.length > 0)
-                this.objectPool.upsertBatch(modelsToUpsert, ModelScope.live);
-            if (idsToRemove.length > 0)
-                this.objectPool.removeBatch(idsToRemove);
-            for (const id of idsToArchive)
-                this.objectPool.updateScope(id, ModelScope.archived);
-            // Emit changed model types so QueryProcessor can auto-invalidate.
-            // Kept inside the action so any observable query-cache state it
-            // flips is part of the same atomic reveal.
-            const changedTypes = new Set(dbResults.map(r => r.modelName));
-            if (changedTypes.size > 0)
-                this.emit('models:changed', changedTypes);
-        });
+        // Reveal the whole frame at one reaction boundary: the caller's single
+        // action covers the collection loop above and these batch pool writes, so
+        // dependents recompute exactly once regardless of how many models or
+        // operation kinds the frame touched, and the app never observes a
+        // partially applied frame.
+        if (modelsToAdd.length > 0)
+            this.objectPool.addBatch(modelsToAdd, ModelScope.live);
+        if (modelsToUpsert.length > 0)
+            this.objectPool.upsertBatch(modelsToUpsert, ModelScope.live);
+        if (idsToRemove.length > 0)
+            this.objectPool.removeBatch(idsToRemove);
+        for (const id of idsToArchive)
+            this.objectPool.updateScope(id, ModelScope.archived);
+        // Emit changed model types so QueryProcessor can auto-invalidate.
+        // Kept inside the action so any observable query-cache state it
+        // flips is part of the same atomic reveal.
+        const changedTypes = new Set(dbResults.map(r => r.modelName));
+        if (changedTypes.size > 0)
+            this.emit('models:changed', changedTypes);
     }
     /**
      * Apply bootstrap data to the InstanceCache with ghost removal.

package/dist/local/client/reactiveEngine.js

@@ -11,6 +11,7 @@
  * host-built core client with the per-model surface split — the cut's own
  * design step (docs/plans/package-split.md).
  */
+import { omittedModelError } from '@abloatai/transaction/schema/select';
 import { durableCommitOperationSchema, } from '@abloatai/transaction/transactions/settlement/commitEnvelope';
 import { AbloAuthenticationError, AbloConnectionError, AbloValidationError, claimedError } from '@abloatai/transaction/errors';
 import { batchFence, fenceTokenFor, modelTarget, streamTarget, subTarget, } from '@abloatai/transaction/coordination';
@@ -703,5 +704,22 @@ export function buildReactiveEngine(inputs) {
             });
         },
     };
+    // A model the schema projection left out answers with an error naming the
+    // model and the fix, not `undefined`. An app can compile against the full
+    // source schema while running a projection, so the type system never sees
+    // this gap; without the stub the caller crashes one property later with a
+    // bare TypeError ("reading 'local'") that names neither. Non-enumerable so
+    // spread, Object.keys, and JSON.stringify walk past the stubs untriggered.
+    for (const name of schema.omittedModels ?? []) {
+        if (name in engine)
+            continue;
+        Object.defineProperty(engine, name, {
+            get() {
+                throw omittedModelError(name);
+            },
+            enumerable: false,
+            configurable: true,
+        });
+    }
     return engine;
 }

package/dist/local/sync/SyncWebSocket.js

@@ -178,12 +178,9 @@ export class SyncWebSocket extends WsTransport {
         const delta = this.normalizeWireDelta(rawDelta);
         if (!delta)
             return;
-        getContext().logger.debug('Received delta', {
-            action: delta.actionType,
-            model: delta.modelName,
-            id: delta.modelId,
-            syncId: delta.id,
-        });
+        // No per-delta debug here: the payload object is built even when the
+        // logger discards it, and this runs at the full live wire rate. Dropped
+        // malformed deltas are still logged by `normalizeWireDelta`.
         // Do not advance `this.cursor.lastSyncId` on receipt. The runtime cursor
         // must stay consistent with what has been persisted locally; otherwise the
         // next `requestIncrementalSync()` (and the connect-time handshake) would

package/dist/local/sync/deltaPipeline.js

@@ -14,7 +14,7 @@ import { runInAction } from 'mobx';
 import { globalRuntime } from '../context.js';
 import { ModelScope } from '../InstanceCache.js';
 import { runStage, pluginsForStage, } from '../../plugin.js';
-import { observeDrainBatch, timeDrainStage, timeDrainStageAsync } from './drainProfile.js';
+import { observeDrainBatch, observeDrainAcknowledge, timeDrainStage, timeDrainStageAsync, openDrainBatchRow, closeDrainBatchRow, } from './drainProfile.js';
 /**
  * One drain per store. Incoming WebSocket frames may arrive while persistence
  * and pool application are awaiting. Without a single-flight guard every
@@ -295,6 +295,15 @@ function yieldToHost() {
     });
 }
 async function flushDeltaBatch(ctx, queuedDeltas) {
+    openDrainBatchRow(queuedDeltas.length);
+    try {
+        await flushDeltaBatchInner(ctx, queuedDeltas);
+    }
+    finally {
+        closeDrainBatchRow();
+    }
+}
+async function flushDeltaBatchInner(ctx, queuedDeltas) {
     const stagePlugins = ctx.stagePlugins ?? [];
     const deduplicatedDeltas = timeDrainStage('dedupe', () => ctx.deduplicateDeltas(queuedDeltas));
     observeDrainBatch(queuedDeltas.length, deduplicatedDeltas.length);
@@ -372,6 +381,7 @@ async function flushDeltaBatch(ctx, queuedDeltas) {
         timeDrainStage('acknowledge', () => {
             ctx.acknowledge(persistedSyncId);
             ctx.advancePersisted(persistedSyncId);
+            observeDrainAcknowledge(persistedSyncId);
             runStage(stagePlugins, 'acknowledge', { syncId: persistedSyncId });
         });
     }

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

@@ -28,6 +28,18 @@ export interface DrainStageTotals {
     /** How many times the stage ran. Per-delta for `parse`, per-batch for the rest. */
     readonly calls: number;
 }
+/**
+ * One flush batch on the wall clock. Wall time (`Date.now`) rather than
+ * `performance.now`, because rows cross the worker boundary and each thread
+ * has its own `performance` origin — the drain-tail stamps learned the same
+ * lesson. Stage entries are the batch's own share of each pipeline stage.
+ */
+export interface DrainBatchRow {
+    readonly startedAtWallMs: number;
+    readonly endedAtWallMs: number;
+    readonly deltas: number;
+    readonly stages: Readonly<Partial<Record<DrainStage, number>>>;
+}
 export interface DrainProfile {
     /** Flush batches drained. The per-batch fixed cost multiplies by this. */
     readonly batches: number;
@@ -38,7 +50,40 @@ export interface DrainProfile {
     /** Wall time from the first observed stage to the last. */
     readonly spanMs: number;
     readonly stages: Readonly<Record<DrainStage, DrainStageTotals>>;
+    /**
+     * The most recent flush batches, oldest first, capped — enough to cover a
+     * drain tail. Optional because derived profiles (window subtraction, fleet
+     * merges) drop it; only a worker's own snapshot carries rows.
+     */
+    readonly recentBatches?: readonly DrainBatchRow[];
 }
+/**
+ * Wall-stamped persisted-cursor advances, oldest first. The benchmark's drain
+ * gate reads THESE rather than observing the cursor from a timer or a
+ * cross-thread poll: any observation that has to be scheduled onto the
+ * worker's event loop queues behind the very drain burst it is measuring and
+ * reports the queue's latency as drain. A stamp taken synchronously inside
+ * the acknowledge stage cannot be deferred by anything.
+ */
+export interface AcknowledgeStamp {
+    readonly syncId: number;
+    readonly atWallMs: number;
+}
+/**
+ * Record a persisted-cursor advance. Called by the pipeline's acknowledge
+ * stage. Unlike every stage timer here, this is NOT gated on the profiler
+ * flag: it is one wall-clock read and one bounded push per flush batch —
+ * nothing against the batch's own work — and the certification benchmark
+ * runs unprofiled (the profiler costs ~15%), so the honest drain stamp must
+ * exist without it.
+ */
+export declare function observeDrainAcknowledge(syncId: number): void;
+/** The recorded persisted-advance stamps, oldest first. */
+export declare function drainAcknowledgeStamps(): readonly AcknowledgeStamp[];
+/** Begin a batch row. Called by the pipeline at flush entry when profiling. */
+export declare function openDrainBatchRow(deltaCount: number): void;
+/** Close the open batch row and commit it to the ring. */
+export declare function closeDrainBatchRow(): void;
 /** Whether drain profiling is on. Callers skip their own bookkeeping when it is not. */
 export declare function drainProfilingEnabled(): boolean;
 /** Attribute already-measured wall time to a stage. */

package/dist/local/sync/drainProfile.js

@@ -40,6 +40,54 @@ let deltas = 0;
 let deduplicated = 0;
 let firstMark;
 let lastMark = 0;
+/** Ring of recent batch rows. ~50 batches/sec at benchmark rates, so this covers seconds of tail. */
+const BATCH_ROW_CAP = 128;
+let batchRows = [];
+/**
+ * The batch currently being flushed. Module-global like the totals above, so
+ * an isolate hosting several stores attributes interleaved awaits to whichever
+ * batch is open — the same per-isolate approximation the totals already make.
+ */
+let currentRow = null;
+const ACK_STAMP_CAP = 512;
+let ackStamps = [];
+/**
+ * Record a persisted-cursor advance. Called by the pipeline's acknowledge
+ * stage. Unlike every stage timer here, this is NOT gated on the profiler
+ * flag: it is one wall-clock read and one bounded push per flush batch —
+ * nothing against the batch's own work — and the certification benchmark
+ * runs unprofiled (the profiler costs ~15%), so the honest drain stamp must
+ * exist without it.
+ */
+export function observeDrainAcknowledge(syncId) {
+    ackStamps.push({ syncId, atWallMs: Date.now() });
+    if (ackStamps.length > ACK_STAMP_CAP)
+        ackStamps.shift();
+}
+/** The recorded persisted-advance stamps, oldest first. */
+export function drainAcknowledgeStamps() {
+    return [...ackStamps];
+}
+/** Begin a batch row. Called by the pipeline at flush entry when profiling. */
+export function openDrainBatchRow(deltaCount) {
+    if (!enabled)
+        return;
+    currentRow = { startedAtWallMs: Date.now(), deltas: deltaCount, stages: {} };
+}
+/** Close the open batch row and commit it to the ring. */
+export function closeDrainBatchRow() {
+    if (!enabled || currentRow === null)
+        return;
+    batchRows.push({
+        startedAtWallMs: currentRow.startedAtWallMs,
+        endedAtWallMs: Date.now(),
+        deltas: currentRow.deltas,
+        stages: currentRow.stages,
+    });
+    if (batchRows.length > BATCH_ROW_CAP)
+        batchRows.shift();
+    currentRow = null;
+}
 /**
  * Read once. A profiler that consults the environment on every delta would
  * itself become a per-delta cost in the path it is measuring.
@@ -64,6 +112,9 @@ export function observeDrainStage(stage, elapsedMs) {
     const entry = totals[stage];
     entry.totalMs += elapsedMs;
     entry.calls += 1;
+    if (currentRow !== null) {
+        currentRow.stages[stage] = (currentRow.stages[stage] ?? 0) + elapsedMs;
+    }
     mark(elapsedMs);
 }
 /** Time a synchronous stage. Returns the callback's value untouched. */
@@ -114,6 +165,7 @@ export function drainProfileSnapshot() {
         deduplicated,
         spanMs: firstMark === undefined ? 0 : lastMark - firstMark,
         stages,
+        recentBatches: [...batchRows],
     };
 }
 /** Clear the totals so a phase measures only its own traffic. */
@@ -124,4 +176,7 @@ export function resetDrainProfile() {
     deduplicated = 0;
     firstMark = undefined;
     lastMark = 0;
+    batchRows = [];
+    currentRow = null;
+    ackStamps = [];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/humans",
-  "version": "0.38.0",
+  "version": "0.39.0",
   "description": "The optional human-facing local-state package for Ablo: presence, live queries, and React bindings.",
   "license": "Apache-2.0",
   "type": "module",
@@ -84,7 +84,7 @@
     "directory": "packages/humans"
   },
   "dependencies": {
-    "@abloatai/transaction": "^0.38.0",
+    "@abloatai/transaction": "^0.39.0",
     "mobx": "^6.13.7",
     "uuid": "^11.1.0",
     "zod": "^4.4.3"

package/src/core.ts

@@ -110,7 +110,10 @@ export {
   drainProfileSnapshot,
   resetDrainProfile,
   drainProfilingEnabled,
+  drainAcknowledgeStamps,
+  type AcknowledgeStamp,
   type DrainProfile,
+  type DrainBatchRow,
   type DrainStage,
   type DrainStageTotals,
 } from './local/sync/drainProfile.js';

package/src/local/BaseSyncedStore.ts

@@ -644,7 +644,13 @@ export class BaseSyncedStore<
     this.smartSyncOptions = {
       maxDeltasBeforeBootstrap: 1000,
       maxBootstrapSize: 10 * 1024 * 1024,
-      batchingDelay: 100,
+      // The inbound-delta flush debounce. Under sustained traffic the
+      // `maxBatchSize` force-flush governs batching, so this timer decides
+      // exactly one thing: how long the FINAL partial batch of a burst sits
+      // before it materializes. At 100 ms it was the largest single term in
+      // the observer's drain tail on the throughput bench; 10 ms coalesces a
+      // trickle just as well and keeps burst tails inside the drain budget.
+      batchingDelay: 10,
       maxBatchSize: 50,
     };