@vellumai/assistant 0.11.2-dev.202608050507.7e832db → 0.11.2-dev.202608050900.b357993

package/openapi.yaml

@@ -21920,8 +21920,6 @@ paths:
                   type: string
                 throwOnError:
                   type: boolean
-                originatingConversationId:
-                  type: string
               required:
                 - sourceEventName
                 - sourceChannel

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.2-dev.202608050507.7e832db",
+  "version": "0.11.2-dev.202608050900.b357993",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/cli/commands/notifications.ts

@@ -258,9 +258,9 @@ export function registerNotificationsCommand(program: Command): void {
               return;
             }
 
-            // Picks up __CONVERSATION_ID / __SKILL_CONTEXT_JSON env vars
-            // so deferred-emit can buffer notifications when called from a
-            // background job that hasn't confirmed success yet.
+            // Picks up __CONVERSATION_ID / __SKILL_CONTEXT_JSON env vars so
+            // a send invoked from inside an agent turn resolves the
+            // conversation it originated from.
             const originatingConversationId = tryResolveConversationId();
 
             // The signal's `sourceContextId` doubles as the home-feed's
@@ -306,9 +306,6 @@ export function registerNotificationsCommand(program: Command): void {
                 ...(conversationId
                   ? { conversationAffinityHint: { vellum: conversationId } }
                   : {}),
-                ...(originatingConversationId
-                  ? { originatingConversationId }
-                  : {}),
                 throwOnError: true,
               },
             });

package/src/heartbeat/heartbeat-service.ts

@@ -848,7 +848,6 @@ export class HeartbeatService {
       callSite: "heartbeatAgent",
       timeoutMs: getConfig().timeouts.backgroundTurnTimeoutSec * 1000,
       origin: "heartbeat",
-      deferNotifications: true,
       onConversationCreated: (newConversationId) => {
         conversationId = newConversationId;
         broadcastMessage({

package/src/notifications/emit-signal.ts

@@ -21,6 +21,7 @@ import type { ConversationCreateType } from "../persistence/conversation-types.j
 import { isPlatformClientConfigured } from "../platform/client.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getLogger } from "../util/logger.js";
+import { withSqliteRetry } from "../util/sqlite-retry.js";
 import { VellumAdapter } from "./adapters/macos.js";
 import { PlatformPushAdapter } from "./adapters/platform.js";
 import { SlackAdapter } from "./adapters/slack.js";
@@ -263,16 +264,27 @@ export async function emitNotificationSignal<TEventName extends string>(
   };
 
   try {
-    // Step 1: Persist the event
-    const eventRow = createEvent({
-      id: signalId,
-      sourceEventName: params.sourceEventName,
-      sourceChannel: params.sourceChannel,
-      sourceContextId: params.sourceContextId,
-      attentionHints: params.attentionHints,
-      payload: (params.contextPayload ?? {}) as Record<string, unknown>,
-      dedupeKey: params.dedupeKey,
-    });
+    // Step 1: Persist the event. The insert contends with other writers on
+    // the shared database (notably the memory worker's bulk writes), and a
+    // lost signal is unrecoverable (the producer has already returned by
+    // the time contention surfaces), so transient `SQLITE_BUSY`/`SQLITE_IOERR`
+    // rides the shared retry helper instead of failing the pipeline.
+    const eventRow = await withSqliteRetry(
+      () =>
+        createEvent({
+          id: signalId,
+          sourceEventName: params.sourceEventName,
+          sourceChannel: params.sourceChannel,
+          sourceContextId: params.sourceContextId,
+          attentionHints: params.attentionHints,
+          payload: (params.contextPayload ?? {}) as Record<string, unknown>,
+          dedupeKey: params.dedupeKey,
+        }),
+      {
+        op: "notification-create-event",
+        context: { signalId, sourceEventName: params.sourceEventName },
+      },
+    );
 
     if (!eventRow) {
       log.info(

package/src/plugins/defaults/memory/substrate/consolidation-lock.ts

@@ -31,11 +31,16 @@ const log = getLogger("memory-v2-consolidate");
 
 /**
  * Hard timeout for the consolidation run. Consolidation reads the buffer,
- * rewrites several files, and re-encodes essentials/threads: generous
- * upper bound so a slow run isn't killed mid-edit, but bounded so a stuck
- * provider can't pin the worker indefinitely.
+ * rewrites several files, and re-encodes essentials/threads: on a mature
+ * corpus a full pass legitimately runs ~20 minutes under cross-process write
+ * contention, so the bound leaves headroom above that while still keeping a
+ * stuck run from pinning the worker indefinitely. Matches the default
+ * `timeouts.backgroundTurnTimeoutSec` budget for heartbeat/background turns.
+ * Overrunning it marks the run failed and skips its follow-up jobs (reembeds,
+ * v3 maintenance) even though the agent's file edits land, so the bound must
+ * comfortably exceed a healthy run's duration.
  */
-export const CONSOLIDATION_TIMEOUT_MS = 15 * 60 * 1000;
+export const CONSOLIDATION_TIMEOUT_MS = 30 * 60 * 1000;
 
 /**
  * Age past which a lock held by an apparently-live PID is taken over anyway.

package/src/runtime/__tests__/background-job-runner.test.ts

@@ -96,8 +96,6 @@ mock.module("../pre-first-message-gate.js", () => ({
 
 // Import after mocks are in place.
 const { runBackgroundJob } = await import("../background-job-runner.js");
-const { bufferIfDeferred, resetDeferredForTest } =
-  await import("../../notifications/deferred-emit.js");
 
 // ── Shared fixtures ──────────────────────────────────────────────────
 
@@ -125,7 +123,6 @@ beforeEach(() => {
   processMessageCalls.length = 0;
   emitCalls.length = 0;
   addMessageCalls.length = 0;
-  resetDeferredForTest();
   preFirstMessageGateOpen = true;
   processMessageImpl = async () => ({ messageId: "msg-1" });
   emitImpl = async () => ({
@@ -290,22 +287,6 @@ describe("runBackgroundJob", () => {
     ).toBe("model_provider");
   });
 
-  test("non-throwing turn failure with deferNotifications drops buffered notifications", async () => {
-    processMessageImpl = async () => ({
-      messageId: "msg-failed-turn",
-      turnFailure: { failureCode: "provider_error" },
-    });
-
-    const result = await runBackgroundJob(
-      baseOpts({ deferNotifications: true }),
-    );
-
-    expect(result.ok).toBe(false);
-    // Only the runner's failure signal emits — no committed "success" signal.
-    expect(emitCalls).toHaveLength(1);
-    expect(emitCalls[0].sourceEventName).toBe("activity.failed");
-  });
-
   test("timeout: returns ok=false with errorKind=timeout and emits activity.failed", async () => {
     // Never resolve — force timeout to win the race.
     processMessageImpl = () => new Promise(() => {});
@@ -464,129 +445,4 @@ describe("runBackgroundJob", () => {
       expect(processMessageCalls).toHaveLength(1);
     });
   });
-
-  describe("deferNotifications", () => {
-    function buildSkillNotificationParams(message: string) {
-      return {
-        sourceEventName: "assistant.share",
-        sourceChannel: "assistant_tool" as const,
-        sourceContextId: "skill-ctx",
-        contextPayload: { requestedMessage: message },
-        attentionHints: {
-          requiresAction: false,
-          urgency: "low" as const,
-          isAsyncBackground: false,
-          visibleInSourceNow: false,
-        },
-      };
-    }
-
-    test("success path commits buffered in-band notifications", async () => {
-      processMessageImpl = async () => {
-        // Stand in for the IPC route's bufferIfDeferred call when the model
-        // invokes `notifications send` mid-turn.
-        const buffered = bufferIfDeferred(
-          STUB_CONVERSATION_ID,
-          buildSkillNotificationParams("all green"),
-        );
-        expect(buffered).not.toBeNull();
-        expect(buffered!.dispatched).toBe(false);
-        return { messageId: "msg-success" };
-      };
-
-      const result = await runBackgroundJob(
-        baseOpts({ deferNotifications: true }),
-      );
-
-      expect(result.ok).toBe(true);
-      // Commit flushed the buffered notification through emitNotificationSignal.
-      const successEmits = emitCalls.filter(
-        (e) => e.sourceEventName !== "activity.failed",
-      );
-      expect(successEmits).toHaveLength(1);
-      expect(successEmits[0].sourceEventName).toBe("assistant.share");
-    });
-
-    // Regression for the PR #31216 Codex P1 finding: a heartbeat that calls
-    // the notifications skill and then times out must not leave a "success"
-    // notification standing alongside the runner's `activity.failed` emit.
-    test("timeout drops buffered in-band notifications; only activity.failed emits", async () => {
-      processMessageImpl = () => {
-        bufferIfDeferred(
-          STUB_CONVERSATION_ID,
-          buildSkillNotificationParams("premature success"),
-        );
-        return new Promise(() => {});
-      };
-
-      const result = await runBackgroundJob(
-        baseOpts({ deferNotifications: true, timeoutMs: 30 }),
-      );
-
-      expect(result.ok).toBe(false);
-      expect(result.errorKind).toBe("timeout");
-      // Only the runner's failure signal makes it out — the buffered
-      // "success" notification is discarded.
-      expect(emitCalls).toHaveLength(1);
-      expect(emitCalls[0].sourceEventName).toBe("activity.failed");
-    });
-
-    test("thrown exception also drops buffered notifications", async () => {
-      processMessageImpl = async () => {
-        bufferIfDeferred(
-          STUB_CONVERSATION_ID,
-          buildSkillNotificationParams("doomed"),
-        );
-        throw new Error("kaboom");
-      };
-
-      const result = await runBackgroundJob(
-        baseOpts({ deferNotifications: true }),
-      );
-
-      expect(result.ok).toBe(false);
-      expect(emitCalls).toHaveLength(1);
-      expect(emitCalls[0].sourceEventName).toBe("activity.failed");
-    });
-
-    // Regression: after timeout, `processMessage` keeps running and may
-    // emit a late skill call. The tombstone must swallow it instead of
-    // letting it bypass the buffer and reach the dispatch pipeline.
-    test("late skill call after timeout is swallowed by the tombstone", async () => {
-      processMessageImpl = () => new Promise(() => {});
-
-      const result = await runBackgroundJob(
-        baseOpts({ deferNotifications: true, timeoutMs: 20 }),
-      );
-      expect(result.ok).toBe(false);
-
-      const late = bufferIfDeferred(
-        STUB_CONVERSATION_ID,
-        buildSkillNotificationParams("post-timeout"),
-      );
-      expect(late).not.toBeNull();
-      expect(late!.dispatched).toBe(false);
-      expect(late!.reason).toMatch(/did not complete/);
-
-      // Only the runner's failure signal made it out.
-      expect(emitCalls).toHaveLength(1);
-      expect(emitCalls[0].sourceEventName).toBe("activity.failed");
-    });
-
-    test("without deferNotifications, bufferIfDeferred is a no-op", async () => {
-      processMessageImpl = async () => {
-        const buffered = bufferIfDeferred(
-          STUB_CONVERSATION_ID,
-          buildSkillNotificationParams("immediate"),
-        );
-        // Buffer was never armed, so the call returns null and the IPC
-        // handler would emit directly.
-        expect(buffered).toBeNull();
-        return { messageId: "msg-success" };
-      };
-
-      const result = await runBackgroundJob(baseOpts());
-      expect(result.ok).toBe(true);
-    });
-  });
 });

package/src/runtime/background-job-runner.ts

@@ -22,11 +22,6 @@ import type { LLMCallSite } from "../config/schemas/llm.js";
 import { processMessage } from "../daemon/process-message.js";
 import type { SubagentToolGateMode } from "../daemon/tool-setup-types.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
-import {
-  commitDeferredConversation,
-  discardDeferredConversation,
-  registerDeferredConversation,
-} from "../notifications/deferred-emit.js";
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
 import type { AttentionHints } from "../notifications/signal.js";
 import { bootstrapConversation } from "../persistence/conversation-bootstrap.js";
@@ -188,11 +183,6 @@ export interface RunBackgroundJobOptions {
    * the `assistant` role and cannot override the action prompt.
    */
   assistantSandwich?: { preamble: string; content: string; postamble: string };
-  /**
-   * Buffer in-band `notifications send` calls and only flush them after the
-   * run completes successfully. See `notifications/deferred-emit.ts`.
-   */
-  deferNotifications?: boolean;
   /**
    * Persist the kickoff `prompt` without indexing it — no memory segments,
    * no embeddings, no lexical-index entry. Opt-in for jobs whose prompt is a
@@ -304,10 +294,6 @@ export async function runBackgroundJob(
       ...(opts.scheduleJobId ? { scheduleJobId: opts.scheduleJobId } : {}),
     });
 
-    if (opts.deferNotifications) {
-      registerDeferredConversation(conversation.id);
-    }
-
     // Fire the sidebar-creation callback synchronously after bootstrap so
     // connected clients (macOS sidebar, etc.) see the conversation appear
     // immediately rather than after `processMessage` returns. Wrapped so a
@@ -382,23 +368,19 @@ export async function runBackgroundJob(
 
     const runResult = await Promise.race([work, timeout]);
     // Symmetric with the `work.catch` above: once `work` has won the race,
-    // the orphan timeout promise can still reject during the await below
-    // (commitDeferredConversation). Swallow so it doesn't surface as an
-    // unhandled rejection that Bun can use to terminate the process.
+    // the orphan timeout promise can still reject if the timer fires before
+    // the `finally` clears it. Swallow so it doesn't surface as an unhandled
+    // rejection that Bun can use to terminate the process.
     timeout.catch(() => {});
     // The turn completed but its LLM call failed (e.g. an invalid provider):
     // `processMessage` reports this via `turnFailure` instead of throwing.
-    // Rethrow so it flows through the shared failure path below (which
-    // discards any deferred notifications) rather than committing them and
-    // returning `ok: true`.
+    // Rethrow so it flows through the shared failure path below (logging +
+    // `activity.failed` emission) rather than returning `ok: true`.
     if (runResult.turnFailure) {
       throw new BackgroundJobTurnFailureError(
         runResult.turnFailure.failureCode,
       );
     }
-    if (opts.deferNotifications) {
-      await commitDeferredConversation(conversation.id);
-    }
     return { conversationId: conversation.id, ok: true };
   } catch (err) {
     const errorKind = classifyError(err);
@@ -411,10 +393,6 @@ export async function runBackgroundJob(
     // so the structured failure result still flows to the caller.
     const conversationId = conversation?.id ?? "";
 
-    if (opts.deferNotifications && conversationId) {
-      discardDeferredConversation(conversationId);
-    }
-
     log.error(
       {
         err: error.message,

package/src/runtime/routes/notification-routes.ts

@@ -6,7 +6,6 @@ import { eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { FeedItemSchema } from "../../api/responses/home.js";
-import { bufferIfDeferred } from "../../notifications/deferred-emit.js";
 import { editNotification } from "../../notifications/edit-notification.js";
 import { emitNotificationSignal } from "../../notifications/emit-signal.js";
 import { listEvents } from "../../notifications/events-store.js";
@@ -72,7 +71,6 @@ const EmitSignalParams = z.object({
   conversationAffinityHint: z.record(z.string(), z.string()).optional(),
   dedupeKey: z.string().optional(),
   throwOnError: z.boolean().optional(),
-  originatingConversationId: z.string().optional(),
 });
 
 const EmitSignalResponse = z.object({
@@ -90,18 +88,6 @@ async function handleEmitSignal({ body = {} }: RouteHandlerArgs) {
     );
   }
   const validated = parsed.data;
-  const buffered = bufferIfDeferred(
-    validated.originatingConversationId,
-    validated,
-  );
-  if (buffered) {
-    return {
-      signalId: buffered.signalId,
-      dispatched: buffered.dispatched,
-      deduplicated: buffered.deduplicated,
-      reason: buffered.reason,
-    };
-  }
   const result = await emitNotificationSignal(validated);
   return {
     signalId: result.signalId,

package/src/util/__tests__/sqlite-retry.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Tests for `withSqliteRetry()`, the shared retry wrapper for transient
+ * SQLite write contention (`SQLITE_BUSY*` / `SQLITE_IOERR*`).
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { isRetryableSqliteError, withSqliteRetry } from "../sqlite-retry.js";
+
+function sqliteError(code: string): Error {
+  const err = new Error(code);
+  (err as Error & { code: string }).code = code;
+  return err;
+}
+
+describe("isRetryableSqliteError", () => {
+  test("matches the SQLITE_BUSY and SQLITE_IOERR families", () => {
+    expect(isRetryableSqliteError(sqliteError("SQLITE_BUSY"))).toBe(true);
+    expect(isRetryableSqliteError(sqliteError("SQLITE_BUSY_SNAPSHOT"))).toBe(
+      true,
+    );
+    expect(isRetryableSqliteError(sqliteError("SQLITE_IOERR"))).toBe(true);
+    expect(isRetryableSqliteError(sqliteError("SQLITE_IOERR_SHORT_READ"))).toBe(
+      true,
+    );
+  });
+
+  test("rejects non-transient errors", () => {
+    expect(isRetryableSqliteError(sqliteError("SQLITE_CONSTRAINT"))).toBe(
+      false,
+    );
+    expect(isRetryableSqliteError(new Error("database is locked"))).toBe(false);
+    expect(isRetryableSqliteError(null)).toBe(false);
+    expect(isRetryableSqliteError(undefined)).toBe(false);
+  });
+});
+
+describe("withSqliteRetry", () => {
+  test("returns the wrapped value on first success", async () => {
+    let calls = 0;
+    const result = await withSqliteRetry(
+      () => {
+        calls += 1;
+        return "ok";
+      },
+      { op: "test-op" },
+    );
+    expect(result).toBe("ok");
+    expect(calls).toBe(1);
+  });
+
+  test("retries transient contention and returns the eventual success", async () => {
+    let calls = 0;
+    const result = await withSqliteRetry(
+      () => {
+        calls += 1;
+        if (calls <= 2) {
+          throw sqliteError("SQLITE_BUSY");
+        }
+        return "recovered";
+      },
+      { op: "test-op", baseDelayMs: 1 },
+    );
+    expect(result).toBe("recovered");
+    expect(calls).toBe(3);
+  });
+
+  test("awaits an async wrapped function", async () => {
+    let calls = 0;
+    const result = await withSqliteRetry(
+      async () => {
+        calls += 1;
+        if (calls === 1) {
+          throw sqliteError("SQLITE_IOERR");
+        }
+        return 42;
+      },
+      { op: "test-op", baseDelayMs: 1 },
+    );
+    expect(result).toBe(42);
+    expect(calls).toBe(2);
+  });
+
+  test("throws immediately on a non-retryable error", async () => {
+    let calls = 0;
+    await expect(
+      withSqliteRetry(
+        () => {
+          calls += 1;
+          throw sqliteError("SQLITE_CONSTRAINT_PRIMARYKEY");
+        },
+        { op: "test-op", baseDelayMs: 1 },
+      ),
+    ).rejects.toThrow("SQLITE_CONSTRAINT_PRIMARYKEY");
+    expect(calls).toBe(1);
+  });
+
+  test("rethrows after exhausting maxRetries", async () => {
+    let calls = 0;
+    await expect(
+      withSqliteRetry(
+        () => {
+          calls += 1;
+          throw sqliteError("SQLITE_BUSY");
+        },
+        { op: "test-op", maxRetries: 2, baseDelayMs: 1 },
+      ),
+    ).rejects.toThrow("SQLITE_BUSY");
+    // Initial attempt + 2 retries.
+    expect(calls).toBe(3);
+  });
+});

package/src/notifications/deferred-emit.ts

@@ -1,147 +0,0 @@
-/**
- * Per-conversation notification buffer used to keep a background job's
- * "success" notification from racing the runner's `activity.failed` when
- * the job times out after the model already invoked `notifications send`.
- *
- * `registerDeferredConversation` arms the buffer before the LLM turn.
- * `bufferIfDeferred` is called from the IPC route handler — it buffers when
- * armed, swallows when tombstoned (post-discard grace window), and returns
- * null otherwise so the route emits normally.
- * `commitDeferredConversation` flushes on success; `discardDeferredConversation`
- * drops on failure and tombstones briefly to catch late tool calls that
- * arrive after `processMessage` keeps running past the runner's timeout.
- */
-
-import { v4 as uuid } from "uuid";
-
-import { getLogger } from "../util/logger.js";
-import {
-  emitNotificationSignal,
-  type EmitSignalParams,
-  type EmitSignalResult,
-} from "./emit-signal.js";
-
-const log = getLogger("notifications-deferred-emit");
-
-// How long after the last observed late notification we keep the tombstone
-// alive. `work` in `runBackgroundJob` is not cancelled on timeout — it can
-// continue running and emit skill calls indefinitely. We refresh the timer
-// on every late arrival, so the tombstone persists as long as the turn is
-// still draining and only expires once the conversation has been quiet for
-// this long.
-const TOMBSTONE_TTL_MS = 5 * 60 * 1000;
-
-type BufferEntry =
-  | { state: "buffered"; items: EmitSignalParams<string>[] }
-  | { state: "tombstoned"; timer: ReturnType<typeof setTimeout> };
-
-const buffers = new Map<string, BufferEntry>();
-
-function scheduleTombstoneEviction(
-  conversationId: string,
-): ReturnType<typeof setTimeout> {
-  const timer = setTimeout(() => {
-    const cur = buffers.get(conversationId);
-    if (cur?.state === "tombstoned") {
-      buffers.delete(conversationId);
-    }
-  }, TOMBSTONE_TTL_MS);
-  timer.unref?.();
-  return timer;
-}
-
-export function registerDeferredConversation(conversationId: string): void {
-  buffers.set(conversationId, { state: "buffered", items: [] });
-}
-
-/**
- * Buffer the signal when the originating conversation is armed, swallow it
- * when tombstoned, otherwise return null so the caller emits normally.
- */
-export function bufferIfDeferred(
-  originatingConversationId: string | undefined,
-  params: EmitSignalParams<string>,
-): EmitSignalResult | null {
-  if (!originatingConversationId) {
-    return null;
-  }
-  const entry = buffers.get(originatingConversationId);
-  if (!entry) {
-    return null;
-  }
-  if (entry.state === "tombstoned") {
-    // Refresh the eviction timer so the tombstone outlives any continuing
-    // turn activity. Otherwise a long-running orphan `processMessage` could
-    // emit a `notifications send` after the fixed TTL elapsed and bypass
-    // buffering, recreating the "success + activity.failed" contradiction.
-    clearTimeout(entry.timer);
-    entry.timer = scheduleTombstoneEviction(originatingConversationId);
-    return {
-      signalId: uuid(),
-      deduplicated: false,
-      dispatched: false,
-      reason: "Notification dropped: background job did not complete",
-      deliveryResults: [],
-    };
-  }
-  entry.items.push(params);
-  return {
-    signalId: uuid(),
-    deduplicated: false,
-    dispatched: false,
-    reason: "Notification deferred until background job completes",
-    deliveryResults: [],
-  };
-}
-
-export async function commitDeferredConversation(
-  conversationId: string,
-): Promise<void> {
-  const entry = buffers.get(conversationId);
-  if (!entry || entry.state !== "buffered") {
-    return;
-  }
-  buffers.delete(conversationId);
-  for (const params of entry.items) {
-    try {
-      await emitNotificationSignal(params);
-    } catch (err) {
-      log.warn(
-        { err, conversationId },
-        "Buffered notification failed to emit on commit",
-      );
-    }
-  }
-}
-
-/**
- * Drop any buffered signals and tombstone the conversation. The tombstone
- * persists until the turn has been quiet for `TOMBSTONE_TTL_MS`; each late
- * notification observed via `bufferIfDeferred` refreshes the timer.
- */
-export function discardDeferredConversation(conversationId: string): number {
-  const entry = buffers.get(conversationId);
-  if (!entry) {
-    return 0;
-  }
-  const droppedCount = entry.state === "buffered" ? entry.items.length : 0;
-  if (entry.state === "tombstoned") {
-    clearTimeout(entry.timer);
-  }
-  buffers.set(conversationId, {
-    state: "tombstoned",
-    timer: scheduleTombstoneEviction(conversationId),
-  });
-  if (droppedCount > 0) {
-    log.info(
-      { conversationId, droppedCount },
-      "Discarded buffered notifications for failed background job",
-    );
-  }
-  return droppedCount;
-}
-
-/** @internal Test-only reset hook. */
-export function resetDeferredForTest(): void {
-  buffers.clear();
-}