@parall/claude-agent 1.58.2 → 1.60.0

package/dist/busy-state.d.ts

@@ -0,0 +1,56 @@
+import type { RuntimeBusyState } from '@parall/agent-core';
+import type { ClaudeRuntimeTaskEvent } from './output-parser.js';
+export type ClaudeBackgroundTask = {
+    taskId: string;
+    description?: string;
+    /** Ambient tasks (e.g. Monitor) never finish on their own. */
+    ambient: boolean;
+};
+export type ClaudeTaskNotification = {
+    taskId?: string;
+    status?: string;
+    summary?: string;
+    description?: string;
+    at: number;
+};
+/** Default follow-up hold after a background task finishes (ms). */
+export declare const DEFAULT_FOLLOW_UP_HOLD_MS = 30000;
+/**
+ * Per-process background-work ledger fed by the CLI's task frames
+ * (`system/background_tasks_changed`, `task_started`, `task_notification`).
+ *
+ * `busy` is: a turn is running, OR a background task finished within the
+ * follow-up hold and the CLI has not yet started (or folded) the follow-up
+ * turn it usually runs on that notification. Outstanding background tasks by
+ * themselves are NOT busy — a `make dev` may run forever and must never
+ * block a restart or a shutdown drain.
+ */
+export declare class ClaudeBusyTracker {
+    private readonly holdMs;
+    readonly backgroundTasks: Map<string, ClaudeBackgroundTask>;
+    followUpHoldUntil: number | null;
+    lastNotification: ClaudeTaskNotification | undefined;
+    /**
+     * Descriptions of tasks that already left the live set: the REPLACE frame
+     * arrives BEFORE the task_notification for the task it removed, and the
+     * notification itself carries only a summary.
+     */
+    private readonly finishedDescriptions;
+    constructor(holdMs?: number);
+    onTaskFrame(frame: ClaudeRuntimeTaskEvent, now?: number): void;
+    /** A turn started (dispatch or runtime-initiated): the hold did its job. */
+    clearHold(): void;
+    holdActive(now?: number): boolean;
+    /** The hold's expiry while it is still pending, else undefined. */
+    activeHoldUntil(now?: number): number | undefined;
+    /** The notification a runtime-initiated turn most plausibly follows. */
+    takeRecentNotification(now?: number): ClaudeTaskNotification | undefined;
+    outstanding(): {
+        total: number;
+        ambient: number;
+    };
+    /** Background shells die with the process. */
+    reset(): void;
+}
+export declare function aggregateBusyState(states: RuntimeBusyState[]): RuntimeBusyState;
+//# sourceMappingURL=busy-state.d.ts.map

package/dist/busy-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"busy-state.d.ts","sourceRoot":"","sources":["../src/busy-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAEjE,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8DAA8D;IAC9D,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,oEAAoE;AACpE,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;;;;;GASG;AACH,qBAAa,iBAAiB;IAWhB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAVnC,QAAQ,CAAC,eAAe,oCAA2C;IACnE,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAQ;IACxC,gBAAgB,EAAE,sBAAsB,GAAG,SAAS,CAAC;IACrD;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA0D;gBAElE,MAAM,GAAE,MAAkC;IAEvE,WAAW,CAAC,KAAK,EAAE,sBAAsB,EAAE,GAAG,SAAa,GAAG,IAAI;IA6DlE,4EAA4E;IAC5E,SAAS,IAAI,IAAI;IAIjB,UAAU,CAAC,GAAG,SAAa,GAAG,OAAO;IAIrC,mEAAmE;IACnE,eAAe,CAAC,GAAG,SAAa,GAAG,MAAM,GAAG,SAAS;IAMrD,wEAAwE;IACxE,sBAAsB,CAAC,GAAG,SAAa,GAAG,sBAAsB,GAAG,SAAS;IAS5E,WAAW,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IAMjD,8CAA8C;IAC9C,KAAK,IAAI,IAAI;CAMd;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,EAAE,GAAG,gBAAgB,CAY/E"}

package/dist/busy-state.js

@@ -0,0 +1,140 @@
+/** Default follow-up hold after a background task finishes (ms). */
+export const DEFAULT_FOLLOW_UP_HOLD_MS = 30_000;
+/**
+ * Per-process background-work ledger fed by the CLI's task frames
+ * (`system/background_tasks_changed`, `task_started`, `task_notification`).
+ *
+ * `busy` is: a turn is running, OR a background task finished within the
+ * follow-up hold and the CLI has not yet started (or folded) the follow-up
+ * turn it usually runs on that notification. Outstanding background tasks by
+ * themselves are NOT busy — a `make dev` may run forever and must never
+ * block a restart or a shutdown drain.
+ */
+export class ClaudeBusyTracker {
+    holdMs;
+    backgroundTasks = new Map();
+    followUpHoldUntil = null;
+    lastNotification;
+    /**
+     * Descriptions of tasks that already left the live set: the REPLACE frame
+     * arrives BEFORE the task_notification for the task it removed, and the
+     * notification itself carries only a summary.
+     */
+    finishedDescriptions = new Map();
+    constructor(holdMs = DEFAULT_FOLLOW_UP_HOLD_MS) {
+        this.holdMs = holdMs;
+    }
+    onTaskFrame(frame, now = Date.now()) {
+        switch (frame.subtype) {
+            case 'background_tasks_changed': {
+                // REPLACE semantics: the frame lists every live task after the change.
+                const next = new Map();
+                for (const task of frame.tasks ?? []) {
+                    const prior = this.backgroundTasks.get(task.taskId);
+                    next.set(task.taskId, {
+                        taskId: task.taskId,
+                        description: task.description ?? prior?.description,
+                        ambient: task.ambient ?? prior?.ambient ?? false,
+                    });
+                }
+                for (const [id, task] of this.backgroundTasks) {
+                    if (!next.has(id) && task.description) {
+                        this.finishedDescriptions.set(id, { description: task.description, at: now });
+                    }
+                }
+                // Nothing older than takeRecentNotification's horizon is ever read
+                // again: tasks that ended without a notification must not accumulate.
+                for (const [id, entry] of this.finishedDescriptions) {
+                    if (now - entry.at > this.holdMs * 2)
+                        this.finishedDescriptions.delete(id);
+                }
+                this.backgroundTasks.clear();
+                for (const [id, task] of next)
+                    this.backgroundTasks.set(id, task);
+                return;
+            }
+            case 'task_started': {
+                if (!frame.taskId || frame.isBackgrounded === false)
+                    return;
+                const prior = this.backgroundTasks.get(frame.taskId);
+                this.backgroundTasks.set(frame.taskId, {
+                    taskId: frame.taskId,
+                    description: frame.description ?? prior?.description,
+                    ambient: prior?.ambient ?? false,
+                });
+                return;
+            }
+            case 'task_notification': {
+                const prior = frame.taskId ? this.backgroundTasks.get(frame.taskId) : undefined;
+                const finished = frame.taskId ? this.finishedDescriptions.get(frame.taskId) : undefined;
+                if (frame.taskId) {
+                    this.backgroundTasks.delete(frame.taskId);
+                    this.finishedDescriptions.delete(frame.taskId);
+                }
+                this.lastNotification = {
+                    taskId: frame.taskId,
+                    status: frame.status,
+                    summary: frame.summary,
+                    description: prior?.description ?? finished?.description ?? frame.description,
+                    at: now,
+                };
+                // Unconditional: if the notification folds into a running turn the
+                // hold expires harmlessly (bounded by holdMs).
+                this.followUpHoldUntil = now + this.holdMs;
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    /** A turn started (dispatch or runtime-initiated): the hold did its job. */
+    clearHold() {
+        this.followUpHoldUntil = null;
+    }
+    holdActive(now = Date.now()) {
+        return this.activeHoldUntil(now) !== undefined;
+    }
+    /** The hold's expiry while it is still pending, else undefined. */
+    activeHoldUntil(now = Date.now()) {
+        return this.followUpHoldUntil !== null && this.followUpHoldUntil > now
+            ? this.followUpHoldUntil
+            : undefined;
+    }
+    /** The notification a runtime-initiated turn most plausibly follows. */
+    takeRecentNotification(now = Date.now()) {
+        const notification = this.lastNotification;
+        this.lastNotification = undefined;
+        if (!notification)
+            return undefined;
+        // A notification older than two hold windows is not "recent" — the
+        // turn opening now is more likely unrelated; report it as such.
+        return now - notification.at <= this.holdMs * 2 ? notification : undefined;
+    }
+    outstanding() {
+        let ambient = 0;
+        for (const task of this.backgroundTasks.values())
+            if (task.ambient)
+                ambient += 1;
+        return { total: this.backgroundTasks.size, ambient };
+    }
+    /** Background shells die with the process. */
+    reset() {
+        this.backgroundTasks.clear();
+        this.finishedDescriptions.clear();
+        this.followUpHoldUntil = null;
+        this.lastNotification = undefined;
+    }
+}
+export function aggregateBusyState(states) {
+    let activeTurns = 0;
+    let backgroundWork = 0;
+    let holdUntil;
+    for (const state of states) {
+        activeTurns += state.activeTurns;
+        backgroundWork += state.backgroundWork;
+        if (state.holdUntil !== undefined && (holdUntil === undefined || state.holdUntil > holdUntil)) {
+            holdUntil = state.holdUntil;
+        }
+    }
+    return { activeTurns, backgroundWork, ...(holdUntil !== undefined ? { holdUntil } : {}) };
+}

package/dist/compact.d.ts

@@ -0,0 +1,29 @@
+import type { CompactOpts, CompactResult, GatewayLogger } from '@parall/agent-core';
+import type { ProcessState } from './dispatch.js';
+import type { ClaudeProcessHandle } from './session-manager.js';
+/**
+ * Idle auto-compact on the Claude bridge (idle-auto-compact-design.md §3.4):
+ * write a `/compact` user frame into the long-lived process — the Agent
+ * SDK's documented way to run the built-in — and wait for that command's
+ * lifecycle to settle. The process pump (process-pump.ts) is the only
+ * stdout reader: the command is registered like a dispatch delivery, the
+ * pump routes its frames into the delivery's sink and records the evidence
+ * on it — a `system/compact_boundary` means the CLI folded history (`done`);
+ * a result without one is the CLI declining ("Not enough messages to
+ * compact." — `noop`). The gateway holds the lane, so no dispatch shares the
+ * process while this runs. Nothing here persists steps, sends messages or
+ * touches session status.
+ *
+ * The host is the narrow slice of ClaudeCodeAdapter's process bookkeeping
+ * this needs; the adapter's `compact()` is a thin delegate.
+ */
+export interface ClaudeCompactHost {
+    ensureRuntimeCapability(log: GatewayLogger | undefined): Promise<void>;
+    ensureProcess(sessionKey: string, log: GatewayLogger | undefined): ProcessState;
+    killProcess(sessionKey: string, state: ProcessState): void;
+    writeUserMessage(handle: ClaudeProcessHandle, text: string, commandUuid: string): void;
+    /** Lazy restart re-check once the command settled (the adapter's own gate). */
+    applyPendingRestart(sessionKey: string, state: ProcessState): void;
+}
+export declare function runClaudeCompact(host: ClaudeCompactHost, { sessionKey, signal, log }: CompactOpts): Promise<CompactResult>;
+//# sourceMappingURL=compact.d.ts.map

package/dist/compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../src/compact.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACpF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEhE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,iBAAiB;IAChC,uBAAuB,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvE,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,GAAG,SAAS,GAAG,YAAY,CAAC;IAChF,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;IAC3D,gBAAgB,CAAC,MAAM,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACvF,+EAA+E;IAC/E,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;CACpE;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,iBAAiB,EACvB,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,WAAW,GACvC,OAAO,CAAC,aAAa,CAAC,CA4BxB"}

package/dist/compact.js

@@ -0,0 +1,98 @@
+import { randomUUID } from 'node:crypto';
+export async function runClaudeCompact(host, { sessionKey, signal, log }) {
+    if (signal.aborted)
+        return { status: 'timeout' };
+    let state;
+    try {
+        await host.ensureRuntimeCapability(log);
+        state = host.ensureProcess(sessionKey, log);
+    }
+    catch (err) {
+        return { status: 'failed', detail: `Claude spawn failed: ${String(err)}` };
+    }
+    // Defensive: an injection still owing bookkeeping means a dispatch is
+    // not actually settled on this session — the gateway never gets here in
+    // that state, but a compaction must not steal its frames.
+    if (state.inputs.hasPendingInjections() || state.inputs.hasUnsettledInjections()) {
+        return { status: 'failed', detail: 'injections still pending on the session' };
+    }
+    const delivery = state.inputs.register(`compact:${randomUUID()}`, undefined, false);
+    try {
+        host.writeUserMessage(state.handle, '/compact', delivery.commandUuid);
+    }
+    catch (err) {
+        state.inputs.remove(delivery);
+        host.killProcess(sessionKey, state);
+        return { status: 'failed', detail: `Claude stdin write failed: ${String(err)}` };
+    }
+    try {
+        return await consumeCompact(host, sessionKey, state, delivery, signal, log);
+    }
+    finally {
+        state.inputs.remove(delivery);
+    }
+}
+/**
+ * Drain the command's sink until its lifecycle settles. The pump already
+ * did the process bookkeeping (init, lifecycle, EOF); this only reads the
+ * evidence it left on the delivery. On abort the process is SIGTERMed — the
+ * session survives via --resume on the next spawn — and the pump's `killed`
+ * envelope reports `timeout`.
+ */
+async function consumeCompact(host, sessionKey, state, target, signal, log) {
+    const onAbort = () => host.killProcess(sessionKey, state);
+    signal.addEventListener('abort', onAbort, { once: true });
+    // The budget may have expired while the process was being spawned or the
+    // frame written; an abort that already fired never reaches the listener,
+    // and without the kill the sink drain below would never settle — and the
+    // gateway's main-lane hold would leak with it.
+    if (signal.aborted)
+        onAbort();
+    try {
+        while (true) {
+            const next = await target.sink.next();
+            if (next.done)
+                break;
+            const envelope = next.value;
+            if (envelope.kind === 'runtime')
+                continue; // the summary's own frames: progress only
+            if (envelope.kind === 'terminal')
+                break;
+            // The process is gone (eof / killed) or the pump ended this window.
+            const detail = state.handle.stderrChunks.join('').trim();
+            if (detail)
+                log?.warn?.(`subprocess stderr: ${detail}`);
+            if (signal.aborted)
+                return { status: 'timeout', detail: detail || undefined };
+            const exit = await state.handle.exitPromise.catch(() => ({ code: null, signal: null }));
+            return {
+                status: 'failed',
+                detail: detail ||
+                    envelope.message ||
+                    `Claude exited with code ${exit.code ?? 'unknown'}${exit.signal ? ` (${exit.signal})` : ''}`,
+            };
+        }
+    }
+    finally {
+        signal.removeEventListener('abort', onAbort);
+    }
+    host.applyPendingRestart(sessionKey, state);
+    const { compactBoundary, zeroTurnResultMeta, lastResultMeta } = target.evidence;
+    // The /compact result frame reports num_turns 0 (no model turn ran on the
+    // user's behalf): it is this command's boundary, not the resume poison
+    // frame, so it is read from the zero-turn slot first.
+    const result = zeroTurnResultMeta ?? lastResultMeta;
+    if (compactBoundary) {
+        return {
+            status: 'done',
+            ...(compactBoundary.preTokens !== undefined ? { preTokens: compactBoundary.preTokens } : {}),
+        };
+    }
+    if (result?.isError) {
+        return { status: 'failed', detail: result.resultText || 'compact result reported an error' };
+    }
+    if (target.terminal !== 'completed') {
+        return { status: 'failed', detail: `compact command ${target.terminal}` };
+    }
+    return { status: 'noop', detail: result?.resultText || 'no compact boundary emitted' };
+}

package/dist/dispatch.d.ts

@@ -1,6 +1,8 @@
-import type { CleanupForkOpts, DispatchAdapter, DispatchInputLifecycle, DispatchOpts, ForkOpts, RuntimeEvent } from '@parall/agent-core';
+import type { CleanupForkOpts, CompactOpts, CompactResult, DispatchAdapter, DispatchInputLifecycle, DispatchOpts, ForkOpts, GatewayLogger, RuntimeActivityEvent, RuntimeBusyState, RuntimeEvent } from '@parall/agent-core';
 import type { ClaudeAgentConfig } from './config.js';
-import type { ClaudeSessionManager } from './session-manager.js';
+import { ClaudeInputRegistry } from './input-lifecycle.js';
+import { ClaudeProcessPump } from './process-pump.js';
+import type { ClaudeProcessHandle, ClaudeSessionManager } from './session-manager.js';
 import { buildSpawnEnv } from './spawn-env.js';
 export { buildSpawnEnv };
 type ClaudeCodeAdapterOptions = Pick<ClaudeAgentConfig, 'additionalDirs' | 'allowApiKey' | 'allowedTools' | 'appendSystemPrompt' | 'claudeBin' | 'claudeHome' | 'disallowedTools' | 'model' | 'permissionMode' | 'workspaceDir'> & {
@@ -32,14 +34,43 @@ type ClaudeCodeAdapterOptions = Pick<ClaudeAgentConfig, 'additionalDirs' | 'allo
      * subprocess on its next shell command — no respawn needed.
      */
     capabilityBinDir?: string;
+    /**
+     * How long the bridge stays busy after a background task finishes,
+     * waiting for the follow-up turn the CLI usually runs on that
+     * notification (busy-state.ts). Default 30 s.
+     */
+    followUpHoldMs?: number;
+    /** Test port. */
+    now?: () => number;
+};
+/**
+ * Per-sessionKey long-lived process state. The process stays alive across
+ * dispatches; each dispatch writes one NDJSON user message to stdin and
+ * drains the envelopes the stdout pump routes to that delivery until its
+ * lifecycle terminal. The pump (process-pump.ts) is the ONLY stdout reader:
+ * between dispatches it keeps reading, so turns the CLI starts on its own
+ * (background-task follow-ups) are observed instead of piling up in the
+ * pipe. Gateway's `drainMainBuffer` serializes dispatch calls per
+ * sessionKey, so no two drains compete for the same delivery.
+ */
+export type ProcessState = {
+    handle: ClaudeProcessHandle;
+    pump: ClaudeProcessPump;
+    done: boolean;
+    needsRestart: boolean;
+    inputs: ClaudeInputRegistry;
+    log?: GatewayLogger;
 };
 export declare class ClaudeCodeAdapter implements DispatchAdapter {
     private readonly opts;
     readonly inputLifecycleMode: "explicit";
     private readonly processes;
+    /** Retired by abortDispatch while the CLI still had its own work: busy until idle, then terminated. */
+    private readonly retiring;
     private capabilityProbe?;
     private capabilityProbeHandle?;
     private shuttingDown;
+    private readonly activity;
     private _model;
     private _effortLevel;
     private _contextWindow;
@@ -54,9 +85,14 @@ export declare class ClaudeCodeAdapter implements DispatchAdapter {
         maxTokens?: number | null;
     }): void;
     requestProcessRestart(): void;
+    subscribeRuntimeActivity(handler: (event: RuntimeActivityEvent) => void): () => void;
+    busyState(now?: number): RuntimeBusyState;
+    isBusy(now?: number): boolean;
     enqueueDuringDispatch(sessionKey: string, body: string, inputLifecycle?: DispatchInputLifecycle): boolean;
     abortDispatch(sessionKey: string): void;
     hasPendingInjections(sessionKey: string): boolean;
+    hasUnsettledInjections(sessionKey: string): boolean;
+    acknowledgeDiscardedInjection(sessionKey: string, deliveryKey: string): void;
     dispatch({ event, bodyForAgent, sessionKey, context, inputLifecycle, noteActivity, }: DispatchOpts): AsyncIterable<RuntimeEvent>;
     getBranchPoint(_sessionKey: string): string | undefined;
     getSessionHistoryPath(sessionKey: string): string | undefined;
@@ -64,7 +100,10 @@ export declare class ClaudeCodeAdapter implements DispatchAdapter {
     cleanupFork({ fork }: CleanupForkOpts): void;
     resetProcesses(): void;
     shutdown(): Promise<void>;
+    private now;
     private runTurn;
+    /** Idle auto-compact (compact.ts): a `/compact` frame into the long-lived process. */
+    compact(opts: CompactOpts): Promise<CompactResult>;
     private ensureRuntimeCapability;
     /**
      * Claude does not emit system.init until it receives its first stdin
@@ -74,15 +113,24 @@ export declare class ClaudeCodeAdapter implements DispatchAdapter {
      */
     private probeRuntimeCapability;
     /**
-     * Drain the shared stdout stream until the exact UUID written for target
-     * reaches a terminal lifecycle state. Other injected inputs may start and
-     * finish while this drain is active; their callbacks advance independently
-     * and their later bookkeeping dispatch becomes a no-op.
+     * Drain the envelopes the pump routed to `target` until its exact stdin
+     * UUID reaches a terminal lifecycle state. Other injected inputs may start
+     * and finish while this drain is active; their callbacks advance in the
+     * pump independently and their later bookkeeping dispatch becomes a no-op.
      */
     private consumeDelivery;
+    /**
+     * Lazy restart: kill the process so the next dispatch respawns it (the
+     * session survives via --resume). Waits for every injection to settle, for
+     * an open runtime-initiated turn and for a follow-up hold — but NOT for
+     * outstanding background tasks (a `make dev` would defer a config change
+     * forever); those die with the process, logged.
+     */
+    private maybeApplyRestart;
     private ensureProcess;
     private spawnProcess;
     private killProcess;
+    private endStdin;
     private terminateHandle;
     private writeCapabilityProbe;
     private writeUserMessage;

package/dist/dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../src/dispatch.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../src/dispatch.ts"],"names":[],"mappings":"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"}