@abloatai/humans 0.37.1 → 0.39.0

package/dist/local/sync/SyncWebSocket.js

@@ -11,6 +11,7 @@
  */
 import { getContext } from '../context.js';
 import { clientSyncDeltaSchema } from '@abloatai/transaction/wire/delta';
+import { drainProfilingEnabled, observeDrainStage } from './drainProfile.js';
 import { WsTransport, } from '@abloatai/transaction/transport/wsTransport';
 import { isRecord } from './wsFrameHandlers.js';
 // Sync-position state (lastSyncId watermark, version vector, server cursor).
@@ -123,7 +124,24 @@ export class SyncWebSocket extends WsTransport {
      * and an observability breadcrumb; it is never applied. There is one parse per
      * delta — callers must not re-parse.
      */
+    /**
+     * Wire validation runs once per delta, so at drain scale it is a per-delta
+     * fixed cost rather than a payload-proportional one. The guard keeps the
+     * normal path free: when profiling is off this is a boolean test and a
+     * direct call, with no closure allocated per delta.
+     */
     normalizeWireDelta(raw) {
+        if (!drainProfilingEnabled())
+            return this.parseWireDelta(raw);
+        const startedAt = performance.now();
+        try {
+            return this.parseWireDelta(raw);
+        }
+        finally {
+            observeDrainStage('parse', performance.now() - startedAt);
+        }
+    }
+    parseWireDelta(raw) {
         let candidate = raw;
         if (isRecord(raw)) {
             const normalized = { ...raw };
@@ -160,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,6 +14,7 @@ import { runInAction } from 'mobx';
 import { globalRuntime } from '../context.js';
 import { ModelScope } from '../InstanceCache.js';
 import { runStage, pluginsForStage, } from '../../plugin.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
@@ -294,8 +295,18 @@ 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 = ctx.deduplicateDeltas(queuedDeltas);
+    const deduplicatedDeltas = timeDrainStage('dedupe', () => ctx.deduplicateDeltas(queuedDeltas));
+    observeDrainBatch(queuedDeltas.length, deduplicatedDeltas.length);
     runStage(stagePlugins, 'dedupe', { deltas: deduplicatedDeltas });
     // Custom entities → apply straight to the pool, skipping the local store.
     const customDeltas = deduplicatedDeltas.filter((d) => ctx.isCustomEntity(d.modelName));
@@ -332,7 +343,7 @@ async function flushDeltaBatch(ctx, queuedDeltas) {
     // handleGroupRemoved) and never reach here, though the persistence
     // signature accepts them defensively.
     const regularDeltas = deduplicatedDeltas.filter((d) => !ctx.isCustomEntity(d.modelName));
-    const batch = await ctx.processDeltaBatch(regularDeltas.map((d) => ({
+    const batch = await timeDrainStageAsync('persist', () => ctx.processDeltaBatch(regularDeltas.map((d) => ({
         syncId: d.id,
         actionType: d.actionType,
         modelName: d.modelName,
@@ -341,7 +352,7 @@ async function flushDeltaBatch(ctx, queuedDeltas) {
         // Thread `transactionId` through so the receive layer can recognize
         // echoes of locally-applied transactions and skip the pool mutation.
         transactionId: d.transactionId,
-    })));
+    }))));
     const dbResults = batch.results;
     runStage(stagePlugins, 'persist', { deltas: regularDeltas });
     // Apply the batch results to the in-memory graph. When a plugin has
@@ -349,12 +360,14 @@ async function flushDeltaBatch(ctx, queuedDeltas) {
     // materialiser attached where it said it would. The direct call is the
     // bridge for stores constructed without plugins (subclasses, tests),
     // whose own apply is the whole pipeline.
-    if (pluginsForStage(stagePlugins, 'apply').length > 0) {
-        runStage(stagePlugins, 'apply', { changes: dbResults });
-    }
-    else {
-        ctx.applyDeltaBatchToPool(dbResults);
-    }
+    timeDrainStage('apply', () => {
+        if (pluginsForStage(stagePlugins, 'apply').length > 0) {
+            runStage(stagePlugins, 'apply', { changes: dbResults });
+        }
+        else {
+            ctx.applyDeltaBatchToPool(dbResults);
+        }
+    });
     // Acknowledge and advance the sync cursor, gated on persistence.
     //
     // We must acknowledge `persistedSyncId` — the high-water mark of deltas whose
@@ -365,10 +378,15 @@ async function flushDeltaBatch(ctx, queuedDeltas) {
     // be lost. The cursor and the persisted state must move together.
     const persistedSyncId = batch.persistedSyncId;
     if (persistedSyncId > ctx.lastAckedId) {
-        ctx.acknowledge(persistedSyncId);
-        ctx.advancePersisted(persistedSyncId);
-        runStage(stagePlugins, 'acknowledge', { syncId: persistedSyncId });
+        timeDrainStage('acknowledge', () => {
+            ctx.acknowledge(persistedSyncId);
+            ctx.advancePersisted(persistedSyncId);
+            observeDrainAcknowledge(persistedSyncId);
+            runStage(stagePlugins, 'acknowledge', { syncId: persistedSyncId });
+        });
     }
     // Cache invalidation happens automatically via the 'models:changed' event.
-    runStage(stagePlugins, 'notify', { changes: dbResults });
+    timeDrainStage('notify', () => {
+        runStage(stagePlugins, 'notify', { changes: dbResults });
+    });
 }

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

@@ -0,0 +1,104 @@
+/**
+ * Where the drain's seconds go.
+ *
+ * A commit's receipt is confirmed the moment its PostgreSQL transaction
+ * commits, but an observer is not caught up until it has applied the last
+ * delta. Server publication p95 is single-digit milliseconds while the final
+ * observer takes seconds, so the gap is client-side and has never been
+ * attributed to a stage. Two fixes aimed at wire bytes (project filtering,
+ * patch-only UPDATE delivery) each returned well under a third, which is
+ * evidence the dominant term is a per-delta or per-batch fixed cost rather
+ * than payload size.
+ *
+ * This times the stages a delta actually passes through so a benchmark run can
+ * state the attribution instead of inferring it. It is off unless
+ * `ABLO_PROFILE_DRAIN=true`, and every entry point returns before doing work
+ * when off, mirroring the server's commit profiler.
+ *
+ * The stage vocabulary derives from {@link PipelineStage}; `parse` is the one
+ * addition, because wire validation happens in the transport before a delta
+ * reaches the pipeline at all.
+ */
+import type { PipelineStage } from '../../plugin.js';
+/** The pipeline's own stages plus the transport-level wire validation ahead of them. */
+export type DrainStage = 'parse' | PipelineStage;
+export interface DrainStageTotals {
+    /** Accumulated wall time attributed to this stage. */
+    readonly totalMs: number;
+    /** 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;
+    /** Deltas that reached the pipeline. The per-delta fixed cost multiplies by this. */
+    readonly deltas: number;
+    /** Deltas dropped by the dedupe stage before persistence. */
+    readonly deduplicated: number;
+    /** 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. */
+export declare function observeDrainStage(stage: DrainStage, elapsedMs: number): void;
+/** Time a synchronous stage. Returns the callback's value untouched. */
+export declare function timeDrainStage<T>(stage: DrainStage, run: () => T): T;
+/** Time an asynchronous stage. Returns the callback's value untouched. */
+export declare function timeDrainStageAsync<T>(stage: DrainStage, run: () => Promise<T>): Promise<T>;
+/**
+ * Record one drained batch: how many deltas entered it and how many survived
+ * deduplication. Batch count is the multiplier on every per-batch cost, so it
+ * is reported alongside the timings rather than derived from them.
+ */
+export declare function observeDrainBatch(received: number, survived: number): void;
+/** The totals accumulated since the last reset. */
+export declare function drainProfileSnapshot(): DrainProfile;
+/** Clear the totals so a phase measures only its own traffic. */
+export declare function resetDrainProfile(): void;

package/dist/local/sync/drainProfile.js

@@ -0,0 +1,182 @@
+/**
+ * Where the drain's seconds go.
+ *
+ * A commit's receipt is confirmed the moment its PostgreSQL transaction
+ * commits, but an observer is not caught up until it has applied the last
+ * delta. Server publication p95 is single-digit milliseconds while the final
+ * observer takes seconds, so the gap is client-side and has never been
+ * attributed to a stage. Two fixes aimed at wire bytes (project filtering,
+ * patch-only UPDATE delivery) each returned well under a third, which is
+ * evidence the dominant term is a per-delta or per-batch fixed cost rather
+ * than payload size.
+ *
+ * This times the stages a delta actually passes through so a benchmark run can
+ * state the attribution instead of inferring it. It is off unless
+ * `ABLO_PROFILE_DRAIN=true`, and every entry point returns before doing work
+ * when off, mirroring the server's commit profiler.
+ *
+ * The stage vocabulary derives from {@link PipelineStage}; `parse` is the one
+ * addition, because wire validation happens in the transport before a delta
+ * reaches the pipeline at all.
+ */
+const DRAIN_STAGES = [
+    'parse',
+    'receive',
+    'dedupe',
+    'persist',
+    'apply',
+    'acknowledge',
+    'notify',
+];
+function emptyTotals() {
+    const totals = {};
+    for (const stage of DRAIN_STAGES)
+        totals[stage] = { totalMs: 0, calls: 0 };
+    return totals;
+}
+let totals = emptyTotals();
+let batches = 0;
+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.
+ */
+const enabled = (() => {
+    const host = globalThis;
+    return host.process?.env?.ABLO_PROFILE_DRAIN === 'true';
+})();
+/** Whether drain profiling is on. Callers skip their own bookkeeping when it is not. */
+export function drainProfilingEnabled() {
+    return enabled;
+}
+function mark(elapsedMs) {
+    const now = performance.now();
+    firstMark ??= now - elapsedMs;
+    lastMark = now;
+}
+/** Attribute already-measured wall time to a stage. */
+export function observeDrainStage(stage, elapsedMs) {
+    if (!enabled)
+        return;
+    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. */
+export function timeDrainStage(stage, run) {
+    if (!enabled)
+        return run();
+    const startedAt = performance.now();
+    try {
+        return run();
+    }
+    finally {
+        observeDrainStage(stage, performance.now() - startedAt);
+    }
+}
+/** Time an asynchronous stage. Returns the callback's value untouched. */
+export async function timeDrainStageAsync(stage, run) {
+    if (!enabled)
+        return run();
+    const startedAt = performance.now();
+    try {
+        return await run();
+    }
+    finally {
+        observeDrainStage(stage, performance.now() - startedAt);
+    }
+}
+/**
+ * Record one drained batch: how many deltas entered it and how many survived
+ * deduplication. Batch count is the multiplier on every per-batch cost, so it
+ * is reported alongside the timings rather than derived from them.
+ */
+export function observeDrainBatch(received, survived) {
+    if (!enabled)
+        return;
+    batches += 1;
+    deltas += received;
+    deduplicated += Math.max(0, received - survived);
+}
+/** The totals accumulated since the last reset. */
+export function drainProfileSnapshot() {
+    const stages = {};
+    for (const stage of DRAIN_STAGES) {
+        stages[stage] = { totalMs: totals[stage].totalMs, calls: totals[stage].calls };
+    }
+    return {
+        batches,
+        deltas,
+        deduplicated,
+        spanMs: firstMark === undefined ? 0 : lastMark - firstMark,
+        stages,
+        recentBatches: [...batchRows],
+    };
+}
+/** Clear the totals so a phase measures only its own traffic. */
+export function resetDrainProfile() {
+    totals = emptyTotals();
+    batches = 0;
+    deltas = 0;
+    deduplicated = 0;
+    firstMark = undefined;
+    lastMark = 0;
+    batchRows = [];
+    currentRow = null;
+    ackStamps = [];
+}

package/dist/local/sync/initialize.js

@@ -13,8 +13,8 @@ export function* initialize(host, context, signal) {
             organizationId: context.organizationId,
             participantKind: context.kind ?? 'user',
             projectId: context.projectId ?? context.organizationId,
-            environment: context.environment ?? null,
-            sandboxId: context.sandboxId ?? null,
+            branchId: context.branchId,
+            branchRoot: context.branchRoot ?? false,
         });
         // Propagate identity only after storage is ready, then restore sealed
         // requests before accepting fresh mutations.

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

@@ -861,17 +861,18 @@ export class MutationQueue extends EventEmitter {
      * transaction.
      */
     confirmationFor(modelName, modelId) {
-        const candidates = [
-            ...this.store.getByStatus('pending'),
-            ...this.store.getByStatus('executing'),
-            ...this.store.getByStatus('awaiting_delta'),
-        ].filter((tx) => tx.modelName === modelName && tx.modelId === modelId);
-        if (candidates.length === 0)
-            return Promise.resolve();
-        const latest = candidates.sort((a, b) => b.createdAt - a.createdAt)[0];
-        if (!latest)
-            return Promise.resolve();
-        return latest.confirmation ?? Promise.resolve();
+        const transactions = this.store.getAll();
+        for (let index = transactions.length - 1; index >= 0; index--) {
+            const transaction = transactions[index];
+            if (transaction?.modelName === modelName &&
+                transaction.modelId === modelId &&
+                (transaction.status === 'pending' ||
+                    transaction.status === 'executing' ||
+                    transaction.status === 'awaiting_delta')) {
+                return transaction.confirmation ?? Promise.resolve();
+            }
+        }
+        return Promise.resolve();
     }
     /**
      * Attaches a `confirmation` promise to a newly created transaction. Call this
@@ -1046,7 +1047,26 @@ export class MutationQueue extends EventEmitter {
         return this.pendingDrainPromise;
     }
     async drainPendingInternal() {
-        await drainPendingSettlements(this.pendingDrainContext);
+        // 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 drainPendingSettlements(this.pendingDrainContext);
+        }
+        finally {
+            this.isProcessing = false;
+            if (this.executionQueue.length > 0)
+                this.scheduleProcessing(true);
+        }
     }
     async create(model, context, writeOptions, sourceMutationId) {
         return createModel(this.modelMutationContext, model, context, writeOptions, sourceMutationId);

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

@@ -10,7 +10,7 @@ export interface PendingDrainContext {
         deltaConfirmationTimeout: number;
     };
     readonly store: MutationStore;
-    executionQueue: QueuedMutation[];
+    readonly executionQueue: QueuedMutation[];
     readonly optimisticUpdates: Map<string, OptimisticUpdateEntry>;
     readonly assertDurableReplayOpen: () => void;
     readonly processCommitLane: () => Promise<void>;

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

@@ -13,7 +13,8 @@ export async function drainPendingSettlements(ctx) {
     // These rows may already be waiting behind the normal batch timer. The
     // reconnect fast path takes ownership of them for this attempt so the same
     // transaction cannot dispatch concurrently through both paths.
-    ctx.executionQueue = ctx.executionQueue.filter((tx) => !pendingIds.has(tx.id));
+    const retainedQueue = ctx.executionQueue.filter((tx) => !pendingIds.has(tx.id));
+    ctx.executionQueue.splice(0, ctx.executionQueue.length, ...retainedQueue);
     const remaining = [...pending];
     while (remaining.length > 0) {
         const batch = ctx.takePendingDrainBatch(remaining);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/humans",
-  "version": "0.37.1",
+  "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.37.1",
+    "@abloatai/transaction": "^0.39.0",
     "mobx": "^6.13.7",
     "uuid": "^11.1.0",
     "zod": "^4.4.3"

package/src/core.ts

@@ -102,3 +102,18 @@ export { LoadStrategy } from '@abloatai/transaction/types';
 // client around an existing store/provider. Kept on the explicit extension
 // surface so those packages do not need the private alias package.
 export type { InternalAbloOptions } from './local/client/options.js';
+
+// Stage timings for the delta drain, so a benchmark harness can report where
+// an observer's catch-up time went instead of inferring it. Inert unless
+// `ABLO_PROFILE_DRAIN=true`, and read-only: the pipeline does the recording.
+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

@@ -146,8 +146,10 @@ export interface UserContext {
   organizationId: string;
   /** Authenticated data-plane coordinates used to isolate local persistence. */
   projectId?: string | null;
-  environment?: 'sandbox' | 'production' | null;
-  sandboxId?: string | null;
+  /** Immutable branch target. Authoritative whenever present. */
+  branchId: string;
+  /** True only when branchId is the project's production root. */
+  branchRoot?: boolean;
   role?: string;
   teamIds?: string[];
   /** Participant kind on the wire. Default 'user' for browser
@@ -642,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,
     };