adonisjs-server-stats 1.12.3 → 1.14.0

package/dist/src/engine/request_metrics.js

@@ -28,8 +28,8 @@ export class RequestMetrics {
         }
         else {
             this.records[this.writeIndex] = record;
+            this.writeIndex = (this.writeIndex + 1) % this.maxRecords;
         }
-        this.writeIndex = (this.writeIndex + 1) % this.maxRecords;
     }
     incrementActiveConnections() {
         this.activeConnections++;
@@ -64,15 +64,13 @@ export class RequestMetrics {
         }
     }
     #scanPartialBuffer(cutoff, acc) {
-        let startIdx = 0;
-        for (let i = this.count - 1; i >= 0; i--) {
-            if (this.records[i].timestamp < cutoff) {
-                startIdx = i + 1;
-                break;
-            }
-        }
-        for (let i = startIdx; i < this.count; i++) {
-            accumulateRecord(acc, this.records[i]);
+        // Scan all records unconditionally: during the fill phase the buffer is
+        // small, and completion order is not guaranteed to match timestamp order,
+        // so we must select by timestamp rather than assume an ascending prefix.
+        for (let i = 0; i < this.count; i++) {
+            const r = this.records[i];
+            if (r.timestamp >= cutoff)
+                accumulateRecord(acc, r);
         }
     }
 }

package/dist/src/log_stream/log_stream_service.d.ts

@@ -7,6 +7,7 @@ export declare class LogStreamService {
     private intervalId;
     private logPath;
     private onEntry?;
+    private warnedPollFailure;
     constructor(logPath?: string, onEntry?: (entry: Record<string, unknown>) => void);
     /**
      * Ingest a parsed log entry directly (no file needed).

package/dist/src/log_stream/log_stream_service.js

@@ -1,6 +1,5 @@
 import { open, stat } from 'node:fs/promises';
 import { log } from '../utils/logger.js';
-let warnedPollFailure = false;
 const LEVEL_NAMES = {
     10: 'trace',
     20: 'debug',
@@ -32,6 +31,7 @@ export class LogStreamService {
     intervalId = null;
     logPath;
     onEntry;
+    warnedPollFailure = false;
     constructor(logPath, onEntry) {
         this.logPath = logPath ?? null;
         this.onEntry = onEntry;
@@ -106,7 +106,7 @@ export class LogStreamService {
         if (!this.logPath)
             return;
         try {
-            warnedPollFailure = false;
+            this.warnedPollFailure = false;
             const stats = await stat(this.logPath);
             // File was truncated/rotated — reset
             if (stats.size < this.lastSize) {
@@ -122,14 +122,16 @@ export class LogStreamService {
             for (const line of buffer.toString('utf-8').trim().split('\n')) {
                 const entry = parseAndEnrich(line);
                 if (entry) {
-                    this.recentEntries.push({ time: Date.now(), level: entry.level });
+                    const level = typeof entry.level === 'number' ? entry.level : 30;
+                    const time = typeof entry.time === 'number' ? entry.time : Date.now();
+                    this.recentEntries.push({ time, level });
                     this.onEntry?.(entry);
                 }
             }
         }
         catch (err) {
-            if (!warnedPollFailure) {
-                warnedPollFailure = true;
+            if (!this.warnedPollFailure) {
+                this.warnedPollFailure = true;
                 log.warn('log stream: cannot read log file — ' + err?.message);
             }
         }

package/dist/src/prometheus/prometheus_collector.d.ts

@@ -18,3 +18,12 @@ export declare const ServerStatsCollector: {
         update(stats: Partial<ServerStats>): void;
     } | null;
 };
+/**
+ * Drop the module-level collector singleton on shutdown.
+ *
+ * The `ServerStatsCollector.instance` reference outlives an individual app
+ * lifecycle. Leaving it set means a restart (common in tests / HMR) re-runs
+ * `register()` against a still-populated prom-client registry, which can throw
+ * "Metric already registered". Nulling it lets the next boot register cleanly.
+ */
+export declare function resetServerStatsCollector(): void;

package/dist/src/prometheus/prometheus_collector.js

@@ -213,3 +213,14 @@ export function serverStatsCollector() {
 export const ServerStatsCollector = {
     instance: null,
 };
+/**
+ * Drop the module-level collector singleton on shutdown.
+ *
+ * The `ServerStatsCollector.instance` reference outlives an individual app
+ * lifecycle. Leaving it set means a restart (common in tests / HMR) re-runs
+ * `register()` against a still-populated prom-client registry, which can throw
+ * "Metric already registered". Nulling it lets the next boot register cleanly.
+ */
+export function resetServerStatsCollector() {
+    ServerStatsCollector.instance = null;
+}

package/dist/src/provider/dashboard_init.js

@@ -97,7 +97,22 @@ function pipeDashLogs(pinoHookActive, dashboardStore, makePath) {
     service.start().catch(() => { });
     return service;
 }
+/**
+ * Whether this module has already installed the request-completion handler.
+ * `setOnRequestComplete` is a single-slot setter, so a second `initDashboardStore`
+ * (hot-reload / test restart) would silently clobber the first handler — and its
+ * `lastQueryId`/`dashboardStore` closure — leaving requests attributed to a stale
+ * store. We install once and warn on any later attempt. There is only ever one
+ * dashboard request pipe, so accumulating handlers would just double-persist.
+ */
+let dashRequestPipeInstalled = false;
 function pipeDashRequests(debugStore, dashboardStore) {
+    if (dashRequestPipeInstalled) {
+        log.warn('dashboard: request pipe already installed — ignoring duplicate registration ' +
+            '(likely a hot-reload/re-init). Restart the process for a clean state.');
+        return;
+    }
+    dashRequestPipeInstalled = true;
     let lastQueryId = 0;
     setOnRequestComplete(({ method, url, statusCode, duration, trace, httpRequestId }) => {
         if (!dashboardStore.isReady())

package/dist/src/provider/dashboard_setup.js

@@ -27,10 +27,17 @@ export function classifyDashboardError(err) {
  * Race a promise against a timeout.
  */
 export function createStartTimeout(promise, timeoutMs) {
+    let timer;
     const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => reject(new Error(`Dashboard SQLite initialization timed out after ${timeoutMs / 1000}s`)), timeoutMs);
+        timer = setTimeout(() => reject(new Error(`Dashboard SQLite initialization timed out after ${timeoutMs / 1000}s`)), timeoutMs);
+    });
+    // Clear the timer once the race settles so a winning primary promise doesn't
+    // leave a dangling 15s timer that keeps the event loop alive (blocks clean
+    // test exit).
+    return Promise.race([promise, timeoutPromise]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
     });
-    return Promise.race([promise, timeoutPromise]);
 }
 /**
  * Build the list of URL prefixes to exclude from tracing.

package/dist/src/provider/email_bridge.d.ts

@@ -13,14 +13,25 @@ interface RedisPublisher {
 interface RedisSubscriber extends RedisPublisher {
     subscribe(channel: string, handler: (message: string) => void): unknown;
 }
+/** Sink that persists an ingested email (the SQLite dashboard store). */
+interface DashboardEmailSink {
+    recordEmail(record: Record<string, unknown>): void;
+}
 /** Targets for ingesting remote emails. */
 export interface EmailBridgeTargets {
     debugEmails: {
         ingest(record: Record<string, unknown>): void;
     } | null;
-    dashboardStore: {
-        recordEmail(record: Record<string, unknown>): void;
-    } | null;
+    /**
+     * The persistent dashboard store, or a (possibly async) getter for it.
+     *
+     * A getter is used because the bridge subscribes during early boot —
+     * before the SQLite dashboard store exists — yet remote emails arrive
+     * later, by which time the store is available. Resolving lazily lets
+     * cross-process (queue-worker) emails land in SQLite, where the
+     * dashboard/debug APIs read from when persistence is enabled.
+     */
+    dashboardStore: DashboardEmailSink | (() => DashboardEmailSink | null | Promise<DashboardEmailSink | null>) | null;
 }
 /**
  * Ingest a remote email message from Redis pub/sub.

package/dist/src/provider/email_bridge.js

@@ -1,8 +1,23 @@
 /**
  * Email bridge helpers for cross-process email capture via Redis pub/sub.
  */
+import { randomUUID } from 'node:crypto';
 import { log } from '../utils/logger.js';
 import { buildEmailPayload, MAIL_STATUS_MAP } from './email_helpers.js';
+/** Resolve the dashboard sink whether it's a direct object, a getter, or null. */
+async function resolveDashboardSink(store) {
+    if (!store)
+        return null;
+    if (typeof store === 'function') {
+        try {
+            return (await store()) ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return store;
+}
 /**
  * Ingest a remote email message from Redis pub/sub.
  * Skips messages from the same process.
@@ -19,7 +34,11 @@ export function ingestRemoteEmail(message, processTag, targets) {
             text: fields.text || null,
         };
         targets.debugEmails?.ingest(record);
-        targets.dashboardStore?.recordEmail({ id: 0, ...record });
+        // Persist to SQLite too (where the APIs read from). The store may be
+        // resolved lazily, so fire-and-forget without blocking ingestion.
+        void resolveDashboardSink(targets.dashboardStore).then((sink) => {
+            sink?.recordEmail({ id: 0, ...record });
+        });
     }
     catch {
         // Ignore malformed messages
@@ -61,7 +80,10 @@ async function subscribeToEmailBridge(opts) {
  * Returns the Redis instance (for cleanup) or null.
  */
 export async function setupFullEmailBridge(emitter, redis, channel, targets) {
-    const processTag = `${process.pid}-${Date.now()}`;
+    // Append a random UUID: in PID-recycling environments (e.g. every container is
+    // pid 1) `pid-timestamp` can collide across processes, causing a peer's emails
+    // to be filtered out as self-sent. The UUID makes the tag unique per instance.
+    const processTag = `${process.pid}-${Date.now()}-${randomUUID()}`;
     registerMailEventPublisher(emitter, redis, processTag, channel);
     return subscribeToEmailBridge({
         redis,
@@ -74,7 +96,7 @@ export async function setupFullEmailBridge(emitter, redis, channel, targets) {
  * Lightweight publisher-only email bridge (for non-web environments).
  */
 export function setupPublisherOnlyBridge(emitter, redis, channel) {
-    const tag = `${process.pid}-${Date.now()}`;
+    const tag = `${process.pid}-${Date.now()}-${randomUUID()}`;
     registerMailEventPublisher(emitter, redis, tag, channel);
     log.info('email bridge publisher active (queue worker → Redis)');
 }

package/dist/src/provider/email_helpers.d.ts

@@ -1,5 +1,13 @@
 /**
- * Cap an HTML/text body to a maximum size.
+ * Redact token-bearing links from an email body before persistence.
+ *
+ * Conservative by design: strips values of known sensitive query params,
+ * neutralizes reset/verify/magic-link URLs, and redacts long opaque tokens
+ * that appear in URL path segments. Ordinary content is left untouched.
+ */
+export declare function redactTokenLinks(body: string): string;
+/**
+ * Cap an HTML/text body to a maximum size, stripping token-bearing links first.
  * Returns `null` for falsy or non-string inputs.
  */
 export declare function capHtmlSize(v: unknown, maxSize?: number): string | null;

package/dist/src/provider/email_helpers.js

@@ -1,15 +1,43 @@
 import { extractAddresses } from '../utils/mail_helpers.js';
 const MAX_HTML = 50_000;
 /**
- * Cap an HTML/text body to a maximum size.
+ * Sensitive query-parameter names whose values are stripped from captured
+ * URLs. These carry one-time login/reset/verify credentials.
+ */
+const SENSITIVE_QUERY_PARAMS = /\b(token|code|access_token|refresh_token|api_key|apikey|key|secret|signature|sig|password|pwd|auth|otp|nonce|state)=[^\s&"'<>]*/gi;
+/**
+ * URL path segments that indicate a credential-bearing link even when the
+ * secret is in the path rather than the query string (reset/verify/magic).
+ */
+const SENSITIVE_URL_PATHS = /(https?:\/\/[^\s"'<>]*?\/(?:reset|verify|verification|confirm|magic|magic-link|activate|invite|unsubscribe)[^\s"'<>]*)/gi;
+/**
+ * Redact token-bearing links from an email body before persistence.
+ *
+ * Conservative by design: strips values of known sensitive query params,
+ * neutralizes reset/verify/magic-link URLs, and redacts long opaque tokens
+ * that appear in URL path segments. Ordinary content is left untouched.
+ */
+export function redactTokenLinks(body) {
+    return (body
+        // ?token=… / &code=… → keep the key, drop the value
+        .replace(SENSITIVE_QUERY_PARAMS, (m) => m.slice(0, m.indexOf('=') + 1) + '[redacted]')
+        // reset/verify/magic URLs → redact everything after the sensitive segment
+        .replace(SENSITIVE_URL_PATHS, (_m, url) => {
+        const marker = url.search(/\/(reset|verify|verification|confirm|magic|magic-link|activate|invite|unsubscribe)/i);
+        return marker === -1 ? url : url.slice(0, marker) + '/[redacted]';
+    }));
+}
+/**
+ * Cap an HTML/text body to a maximum size, stripping token-bearing links first.
  * Returns `null` for falsy or non-string inputs.
  */
 export function capHtmlSize(v, maxSize = MAX_HTML) {
     if (!v || typeof v !== 'string')
         return null;
-    if (v.length <= maxSize)
-        return v;
-    return v.slice(0, maxSize) + '\n<!-- truncated -->';
+    const cleaned = redactTokenLinks(v);
+    if (cleaned.length <= maxSize)
+        return cleaned;
+    return cleaned.slice(0, maxSize) + '\n<!-- truncated -->';
 }
 /**
  * Mapping of AdonisJS mail events to their corresponding status strings.

package/dist/src/provider/pino_hook.d.ts

@@ -6,10 +6,18 @@
  * Pino uses a local Symbol('pino.stream'), not a global registry symbol.
  */
 export declare function findPinoStreamSymbol(obj: object): symbol | undefined;
+/** Undo a previously-applied {@link wrapWriteMethod} on the same stream. */
+export declare function unwrapWriteMethod(stream: {
+    write: Function;
+    [key: string]: unknown;
+}): void;
 /**
  * Wrap a stream's `write` method to intercept JSON log entries.
  * Calls `ingest` for each valid JSON entry that has a numeric `level`.
  * The original write is always called to preserve normal logging.
+ *
+ * Idempotent: if the stream's `write` is already wrapped by us, this is a
+ * no-op so a hot-reload can't double-ingest. Restore via {@link unwrapWriteMethod}.
  */
 export declare function wrapWriteMethod(stream: {
     write: Function;

package/dist/src/provider/pino_hook.js

@@ -8,14 +8,29 @@
 export function findPinoStreamSymbol(obj) {
     return Object.getOwnPropertySymbols(obj).find((s) => s.description === 'pino.stream');
 }
+/** Marks a wrapped write fn so we never double-wrap and can restore the original. */
+const WRAPPED_WRITE = Symbol('server-stats.wrappedWrite');
+/** Undo a previously-applied {@link wrapWriteMethod} on the same stream. */
+export function unwrapWriteMethod(stream) {
+    const current = stream.write;
+    const original = current?.[WRAPPED_WRITE];
+    if (original)
+        stream.write = original;
+}
 /**
  * Wrap a stream's `write` method to intercept JSON log entries.
  * Calls `ingest` for each valid JSON entry that has a numeric `level`.
  * The original write is always called to preserve normal logging.
+ *
+ * Idempotent: if the stream's `write` is already wrapped by us, this is a
+ * no-op so a hot-reload can't double-ingest. Restore via {@link unwrapWriteMethod}.
  */
 export function wrapWriteMethod(stream, ingest) {
+    // Guard against re-wrapping an already-wrapped stream (hot-reload / restart).
+    if (stream.write?.[WRAPPED_WRITE])
+        return;
     const originalWrite = stream.write.bind(stream);
-    stream.write = function wrappedWrite(chunk, ...args) {
+    const wrappedWrite = function wrappedWrite(chunk, ...args) {
         try {
             const str = typeof chunk === 'string'
                 ? chunk
@@ -32,4 +47,7 @@ export function wrapWriteMethod(stream, ingest) {
         }
         return originalWrite(chunk, ...args);
     };
+    // Store the pre-wrap write so cleanup can restore it exactly.
+    wrappedWrite[WRAPPED_WRITE] = stream.write;
+    stream.write = wrappedWrite;
 }

package/dist/src/provider/provider_helpers_extra.d.ts

@@ -25,6 +25,8 @@ export declare function setupDevToolbarCore(args: SetupDevToolbarArgs): Promise<
 export declare function applyToolbarResult(result: ToolbarCoreResult, tc: DevToolbarConfig, provider: ProviderFields): void;
 /** Hook the AdonisJS Pino logger into the log collector. Returns true if hooked. */
 export declare function hookPinoToLogStream(logger: unknown): boolean;
+/** Restore the original pino `write`, undoing {@link hookPinoToLogStream}. */
+export declare function unhookPinoFromLogStream(): void;
 /** Set up log stream broadcasting via Transmit. Returns LogStreamService if file-based fallback. */
 export declare function setupLogStreamBroadcast(transmit: {
     broadcast(ch: string, d: unknown): void;

package/dist/src/provider/provider_helpers_extra.js

@@ -9,7 +9,7 @@ import { getLogStreamService } from '../collectors/log_collector.js';
 import { LogStreamService } from '../log_stream/log_stream_service.js';
 import { log, dim, bold } from '../utils/logger.js';
 import { setupPublisherOnlyBridge } from './email_bridge.js';
-import { findPinoStreamSymbol, wrapWriteMethod } from './pino_hook.js';
+import { findPinoStreamSymbol, wrapWriteMethod, unwrapWriteMethod } from './pino_hook.js';
 // Re-export toolbar/dashboard functions with provider-compatible signatures
 import { setupDevToolbarCore as coreSetup, applyToolbarResult as coreApply, } from './toolbar_setup.js';
 export { initDashboardStore } from './dashboard_init.js';
@@ -22,6 +22,12 @@ export function applyToolbarResult(result, tc, provider) {
     coreApply(result, tc, provider);
 }
 // ── hookPinoToLogStream ─────────────────────────────────────────
+/**
+ * The pino stream whose `write` we last wrapped, kept so shutdown can restore
+ * it. Without this, a hot-reload would leave a stale wrapper in place and the
+ * next hook would stack on top — double-ingesting every log line.
+ */
+let hookedPinoStream = null;
 /** Hook the AdonisJS Pino logger into the log collector. Returns true if hooked. */
 export function hookPinoToLogStream(logger) {
     const logStream = getLogStreamService();
@@ -38,10 +44,19 @@ export function hookPinoToLogStream(logger) {
         return false;
     if (typeof rawStream.write !== 'function')
         return false;
-    wrapWriteMethod(rawStream, (entry) => logStream.ingest(entry));
+    const stream = rawStream;
+    wrapWriteMethod(stream, (entry) => logStream.ingest(entry));
+    hookedPinoStream = stream;
     log.info('log collector hooked into AdonisJS logger (zero-config)');
     return true;
 }
+/** Restore the original pino `write`, undoing {@link hookPinoToLogStream}. */
+export function unhookPinoFromLogStream() {
+    if (!hookedPinoStream)
+        return;
+    unwrapWriteMethod(hookedPinoStream);
+    hookedPinoStream = null;
+}
 // ── setupLogStreamBroadcast ─────────────────────────────────────
 /** Set up log stream broadcasting via Transmit. Returns LogStreamService if file-based fallback. */
 export function setupLogStreamBroadcast(transmit, channelName, pinoHookActive, makePath) {

package/dist/src/provider/server_stats_provider.js

@@ -94,6 +94,7 @@ export default class ServerStatsProvider {
             debugEndpoint,
             dashboardPath,
             shouldShow: config.shouldShow,
+            unsafeAllowNoAuth: config.unsafeAllowNoAuth,
             whenReady: () => this.whenReady(),
         });
         const paths = collectRegisteredPaths(statsEndpoint, debugEndpoint, dashboardPath);
@@ -194,7 +195,17 @@ export default class ServerStatsProvider {
             return await this.app.container.make(binding);
         }
         catch (err) {
-            log.info(`resolve('${binding}') failed: ${err?.message ?? err}`);
+            const message = err?.message ?? String(err);
+            // An unregistered optional binding (transmit, redis, etc.) is expected and
+            // stays quiet. Anything else is likely a real programming error surfacing
+            // during construction — surface it at warn level instead of hiding it.
+            const isMissingBinding = /cannot resolve|is not (bound|registered)|resolve .* binding/i.test(message);
+            if (isMissingBinding) {
+                log.info(`resolve('${binding}') failed: ${message}`);
+            }
+            else {
+                log.warn(`resolve('${binding}') failed unexpectedly: ${message}`);
+            }
             return null;
         }
     }
@@ -271,5 +282,12 @@ export default class ServerStatsProvider {
             debugStore: this.debugStore,
             engine: this.engine,
         });
+        if (this.prometheusActive) {
+            // Drop the module-level prometheus collector singleton so a restart can
+            // re-register metrics without hitting "Metric already registered".
+            const { resetServerStatsCollector } = await import('../prometheus/prometheus_collector.js');
+            resetServerStatsCollector();
+            this.prometheusActive = false;
+        }
     }
 }

package/dist/src/provider/shutdown_helpers.js

@@ -2,6 +2,7 @@
  * Shutdown helper functions extracted from ServerStatsProvider.
  */
 import { setOnRequestComplete, setDashboardPath, setExcludedPrefixes, } from '../middleware/request_tracking_middleware.js';
+import { unhookPinoFromLogStream } from './provider_helpers_extra.js';
 import { log } from '../utils/logger.js';
 /**
  * Clear all active timers and null out the references.
@@ -61,6 +62,7 @@ export function unsubscribeEmailBridge(redis, channel) {
 export async function cleanupResources(deps) {
     deps.logStreamService?.stop();
     deps.dashboardLogStream?.stop();
+    unhookPinoFromLogStream();
     setOnRequestComplete(null);
     setDashboardPath(null);
     setExcludedPrefixes([]);

package/dist/src/provider/toolbar_setup.js

@@ -18,7 +18,7 @@ export async function setupDevToolbarCore(opts) {
     if (!em)
         log.warn('emitter not available — query/event collection disabled');
     await debugStore.start(em, await resolve('router'));
-    const emailBridgeRedis = await setupBridgeInternal(em, debugStore);
+    const emailBridgeRedis = await setupBridgeInternal(em, debugStore, app);
     const debugController = await createDebugController(debugStore, config, getDiagnostics, app);
     if (debugStore.traces)
         setTraceCollector(debugStore.traces);
@@ -66,14 +66,26 @@ function createFlushTimer(debugStore, persistPath) {
         catch { }
     }, 30_000);
 }
-async function setupBridgeInternal(emitter, debugStore) {
+async function setupBridgeInternal(emitter, debugStore, app) {
     if (!emitter)
         return null;
     try {
         const { appImport } = await import('../utils/app_import.js');
         const mod = await appImport('@adonisjs/redis/services/main');
         const redis = mod.default;
-        return await setupFullEmailBridge(emitter, redis, 'adonisjs-server-stats:emails', { debugEmails: debugStore.emails ?? null, dashboardStore: null });
+        // Lazily resolve the SQLite dashboard store: it's registered as a
+        // container singleton later in boot, but remote emails only arrive
+        // post-boot, so cross-process (queue-worker) emails get persisted
+        // where the dashboard/debug APIs read from.
+        const getDashboardStore = async () => {
+            try {
+                return (await app.container.make('dashboard.store'));
+            }
+            catch {
+                return null;
+            }
+        };
+        return await setupFullEmailBridge(emitter, redis, 'adonisjs-server-stats:emails', { debugEmails: debugStore.emails ?? null, dashboardStore: getDashboardStore });
     }
     catch {
         return null;
@@ -85,23 +97,26 @@ async function setupDebugBroadcastInternal(debugStore, resolve) {
         return { timer: null, transmitAvailable: false, channels: [] };
     const ch = 'server-stats/debug';
     const pending = new Set();
-    let timer = null;
+    // A persistent (unref'd) interval flushes pending item types every 200ms.
+    // Returning this live handle lets shutdown clear it — the previous per-item
+    // `setTimeout` was never returned (returned `null`), so shutdown could not
+    // clear it and it could fire after stop() on a destroyed transmit instance.
+    const timer = setInterval(() => {
+        if (pending.size === 0)
+            return;
+        const ts = [...pending];
+        pending.clear();
+        try {
+            ;
+            t.broadcast(ch, { types: ts });
+        }
+        catch { }
+    }, 200);
+    timer.unref?.();
     debugStore.onNewItem((type) => {
         pending.add(type);
-        if (timer)
-            return;
-        timer = setTimeout(() => {
-            timer = null;
-            const ts = [...pending];
-            pending.clear();
-            try {
-                ;
-                t.broadcast(ch, { types: ts });
-            }
-            catch { }
-        }, 200);
     });
-    return { timer: null, transmitAvailable: true, channels: [ch] };
+    return { timer, transmitAvailable: true, channels: [ch] };
 }
 /** Apply the toolbar core result back onto the provider instance. */
 export function applyToolbarResult(result, tc, provider) {