@astralyn/pi 0.84.11 → 0.84.12

package/dist/core/compaction-controller.d.ts

@@ -1,90 +0,0 @@
-import type { Agent, AgentMessage, PrepareNextTurnContext, ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { AssistantMessage, Model } from "@earendil-works/pi-ai/compat";
-import { type RetryCallbacks } from "@earendil-works/pi-ai/compat";
-import type { AgentSessionEvent } from "./agent-session.ts";
-import type { CompactionTiming, ExtensionRunner, SessionCompactFailedEvent } from "./extensions/index.ts";
-import type { SessionManager } from "./session-manager.ts";
-import type { SettingsManager } from "./settings-manager.ts";
-export declare const CONTEXT_REMAINS_OVER_COMPACTION_THRESHOLD = "Estimated retained context remains above the configured auto-compaction threshold. Reduce compaction.keepRecentTokens, remove large retained content, or switch to a model with a larger context window before continuing.";
-export declare const NOTHING_TO_COMPACT_WITHIN_KEEP_WINDOW = "Nothing to compact while preserving the configured recent context. Reduce compaction.keepRecentTokens, remove large retained content, or switch to a model with a larger context window before continuing.";
-export declare const AUTO_COMPACTION_STOPPED_BEFORE_NEXT_PROVIDER = "Stopped before the next provider request because auto-compaction did not produce a safe context. Review the compaction warning before continuing.";
-export interface MidTurnCompactionOutcome {
-    messages?: AgentMessage[];
-    stopErrorMessage?: string;
-}
-export declare function estimateMessagesTokens(messages: AgentMessage[]): number;
-interface SummarizationRequestAuth {
-    model: Model<any>;
-    apiKey?: string;
-    headers?: Record<string, string>;
-    env?: Record<string, string>;
-}
-/**
- * The slice of AgentSession that auto-compaction needs. Every member forwards
- * to existing session state; the host does not grant new capabilities.
- */
-export interface CompactionHost {
-    readonly agent: Agent;
-    readonly sessionManager: SessionManager;
-    readonly settingsManager: SettingsManager;
-    getModel(): Model<any> | undefined;
-    getThinkingLevel(): ThinkingLevel;
-    getExtensionRunner(): ExtensionRunner;
-    /** Whether a manual /compact run currently owns the compaction lifecycle. */
-    isManualCompactionActive(): boolean;
-    emit(event: AgentSessionEvent): void;
-    emitSessionCompactFailed(event: Omit<SessionCompactFailedEvent, "type">): Promise<void>;
-    getRequiredRequestAuth(model: Model<any>): Promise<SummarizationRequestAuth>;
-    getSummarizationRequestAuth(model: Model<any>, streamFunction: Agent["streamFunction"]): Promise<SummarizationRequestAuth>;
-    summarizationRetryCallbacks(source: {
-        source: "compaction";
-        reason: "manual" | "threshold" | "overflow";
-    }): RetryCallbacks;
-}
-/**
- * Owns automatic compaction: threshold checks after tool batches (mid-turn),
- * after a run, and before a prompt; overflow compact-and-retry recovery; and
- * the fail-closed stop when compaction cannot produce a safe context.
- * Manual /compact stays in AgentSession.
- */
-export declare class CompactionController {
-    private readonly host;
-    private _abortController;
-    private _stopAfterTurnRequested;
-    /** An extension cancelled a mid-turn compaction; skip further mid-turn checks this run. */
-    private _midTurnDeclined;
-    private _overflowRecoveryAttempted;
-    constructor(host: CompactionHost);
-    /** Clear per-run state when a new agent run starts. */
-    noteRunStart(): void;
-    /** Read and clear the pending stop request. */
-    consumeStopAfterTurn(): boolean;
-    /** Stop the run at the next lifecycle boundary instead of sending an unsafe context. */
-    requestStopAfterTurn(): void;
-    /** A user message or a healthy assistant response resets overflow recovery. */
-    resetOverflowRecovery(): void;
-    get isAutoCompacting(): boolean;
-    abort(): void;
-    estimateContextTokens(messages: AgentMessage[]): number;
-    maybeCompactBeforeNextToolTurn(turn: PrepareNextTurnContext, signal?: AbortSignal): Promise<MidTurnCompactionOutcome>;
-    /**
-     * Check if compaction is needed and run it.
-     * Called after agent_end and before prompt submission.
-     *
-     * Two cases:
-     * 1. Recoverable failure: LLM returned context overflow or stopped below its desired output limit;
-     *    remove the assistant message, compact, and auto-retry once
-     * 2. Threshold: Context over threshold, compact, NO auto-retry (user continues manually)
-     *
-     * @param assistantMessage The assistant message to check
-     * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
-     */
-    checkCompaction(assistantMessage: AssistantMessage, skipAbortedCheck?: boolean, timing?: CompactionTiming): Promise<boolean>;
-    /**
-     * Internal: Run auto-compaction with events.
-     */
-    private _runAutoCompaction;
-    private _runAutoCompactionWithOutcome;
-}
-export {};
-//# sourceMappingURL=compaction-controller.d.ts.map

package/dist/core/compaction-controller.d.ts.map

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

package/dist/core/compaction-controller.js

@@ -1,471 +0,0 @@
-import { isContextOverflow, isRecoverableLength, streamSimple, } from "@earendil-works/pi-ai/compat";
-import { calculateContextTokens, compact, estimateContextTokens, estimateTokens, prepareCompaction, shouldCompact, } from "./compaction/index.js";
-import { getLatestCompactionEntry } from "./session-manager.js";
-export const CONTEXT_REMAINS_OVER_COMPACTION_THRESHOLD = "Estimated retained context remains above the configured auto-compaction threshold. Reduce compaction.keepRecentTokens, remove large retained content, or switch to a model with a larger context window before continuing.";
-export const NOTHING_TO_COMPACT_WITHIN_KEEP_WINDOW = "Nothing to compact while preserving the configured recent context. Reduce compaction.keepRecentTokens, remove large retained content, or switch to a model with a larger context window before continuing.";
-export const AUTO_COMPACTION_STOPPED_BEFORE_NEXT_PROVIDER = "Stopped before the next provider request because auto-compaction did not produce a safe context. Review the compaction warning before continuing.";
-export function estimateMessagesTokens(messages) {
-    let tokens = 0;
-    for (const message of messages) {
-        tokens += estimateTokens(message);
-    }
-    return tokens;
-}
-/**
- * Owns automatic compaction: threshold checks after tool batches (mid-turn),
- * after a run, and before a prompt; overflow compact-and-retry recovery; and
- * the fail-closed stop when compaction cannot produce a safe context.
- * Manual /compact stays in AgentSession.
- */
-export class CompactionController {
-    constructor(host) {
-        this._abortController = undefined;
-        this._stopAfterTurnRequested = false;
-        /** An extension cancelled a mid-turn compaction; skip further mid-turn checks this run. */
-        this._midTurnDeclined = false;
-        this._overflowRecoveryAttempted = false;
-        this.host = host;
-    }
-    /** Clear per-run state when a new agent run starts. */
-    noteRunStart() {
-        this._stopAfterTurnRequested = false;
-        this._midTurnDeclined = false;
-    }
-    /** Read and clear the pending stop request. */
-    consumeStopAfterTurn() {
-        const requested = this._stopAfterTurnRequested;
-        this._stopAfterTurnRequested = false;
-        return requested;
-    }
-    /** Stop the run at the next lifecycle boundary instead of sending an unsafe context. */
-    requestStopAfterTurn() {
-        this._stopAfterTurnRequested = true;
-    }
-    /** A user message or a healthy assistant response resets overflow recovery. */
-    resetOverflowRecovery() {
-        this._overflowRecoveryAttempted = false;
-    }
-    get isAutoCompacting() {
-        return this._abortController !== undefined;
-    }
-    abort() {
-        this._abortController?.abort();
-    }
-    estimateContextTokens(messages) {
-        const estimate = estimateContextTokens(messages);
-        const compactionEntry = getLatestCompactionEntry(this.host.sessionManager.getBranch());
-        if (compactionEntry && estimate.lastUsageIndex !== null) {
-            const usageMessage = messages[estimate.lastUsageIndex];
-            if (usageMessage?.role === "assistant" &&
-                usageMessage.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
-                // A retained pre-compaction usage describes the old, larger context. Fall back
-                // to message estimates rather than immediately compacting again from stale data.
-                return estimateMessagesTokens(messages);
-            }
-        }
-        return estimate.tokens;
-    }
-    async maybeCompactBeforeNextToolTurn(turn, signal) {
-        if (signal?.aborted) {
-            return { stopErrorMessage: AUTO_COMPACTION_STOPPED_BEFORE_NEXT_PROVIDER };
-        }
-        // Tool batches always continue the run; a turn without tool results only
-        // continues when steering/follow-up messages are queued, otherwise the
-        // post-run path covers it.
-        if (turn.toolResults.length === 0 && !this.host.agent.hasQueuedMessages()) {
-            return {};
-        }
-        if (this._midTurnDeclined) {
-            return {};
-        }
-        const settings = this.host.settingsManager.getCompactionSettings();
-        if (!settings.enabled) {
-            return {};
-        }
-        const contextTokens = this.estimateContextTokens(turn.context.messages);
-        const contextWindow = this.host.getModel()?.contextWindow ?? 0;
-        if (!shouldCompact(contextTokens, contextWindow, settings)) {
-            return {};
-        }
-        const outcome = await this._runAutoCompactionWithOutcome("threshold", false, "midTurn", signal);
-        if (!outcome.compacted) {
-            if (outcome.cancelled && signal?.aborted !== true) {
-                // The extension took ownership of the risk; don't re-ask on every batch.
-                this._midTurnDeclined = true;
-                return {};
-            }
-            return { stopErrorMessage: AUTO_COMPACTION_STOPPED_BEFORE_NEXT_PROVIDER };
-        }
-        return {
-            messages: this.host.agent.state.messages.slice(),
-            ...(signal?.aborted === true
-                ? { stopErrorMessage: AUTO_COMPACTION_STOPPED_BEFORE_NEXT_PROVIDER }
-                : outcome.mustStop === true
-                    ? { stopErrorMessage: CONTEXT_REMAINS_OVER_COMPACTION_THRESHOLD }
-                    : {}),
-        };
-    }
-    /**
-     * Check if compaction is needed and run it.
-     * Called after agent_end and before prompt submission.
-     *
-     * Two cases:
-     * 1. Recoverable failure: LLM returned context overflow or stopped below its desired output limit;
-     *    remove the assistant message, compact, and auto-retry once
-     * 2. Threshold: Context over threshold, compact, NO auto-retry (user continues manually)
-     *
-     * @param assistantMessage The assistant message to check
-     * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
-     */
-    async checkCompaction(assistantMessage, skipAbortedCheck = true, timing = "postRun") {
-        const settings = this.host.settingsManager.getCompactionSettings();
-        if (!settings.enabled)
-            return false;
-        // Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
-        if (skipAbortedCheck && assistantMessage.stopReason === "aborted")
-            return false;
-        const model = this.host.getModel();
-        const contextWindow = model?.contextWindow ?? 0;
-        // Skip overflow check if the message came from a different model.
-        // This handles the case where user switched from a smaller-context model (e.g. opus)
-        // to a larger-context model (e.g. codex) - the overflow error from the old model
-        // shouldn't trigger compaction for the new model.
-        const sameModel = model && assistantMessage.provider === model.provider && assistantMessage.model === model.id;
-        // Skip compaction checks if this assistant message is older than the latest
-        // compaction boundary. This prevents a stale pre-compaction usage/error
-        // from retriggering compaction on the first prompt after compaction.
-        const compactionEntry = getLatestCompactionEntry(this.host.sessionManager.getBranch());
-        const assistantIsFromBeforeCompaction = compactionEntry !== null && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime();
-        if (assistantIsFromBeforeCompaction) {
-            return false;
-        }
-        // Case 1: Recoverable failure. Explicit/silent context overflow still uses context metadata.
-        // A length stop is recoverable when output ended below the model's original desired limit,
-        // independent of the configured context size or any context-clamped provider request limit.
-        // A successful response over the configured window should compact but must not retry: the
-        // assistant answer already completed and agent.continue() cannot continue from an assistant.
-        const contextOverflow = sameModel && isContextOverflow(assistantMessage, contextWindow);
-        const recoverableLength = sameModel && isRecoverableLength(assistantMessage, model?.maxTokens ?? 0);
-        if (contextOverflow || recoverableLength) {
-            const willRetry = assistantMessage.stopReason !== "stop";
-            if (!willRetry) {
-                return await this._runAutoCompaction("overflow", false, timing);
-            }
-            if (this._overflowRecoveryAttempted) {
-                this._stopAfterTurnRequested = true;
-                const errorMessage = contextOverflow
-                    ? "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model."
-                    : "Truncated response recovery failed after one compact-and-retry attempt.";
-                this.host.emit({
-                    type: "compaction_end",
-                    reason: "overflow",
-                    result: undefined,
-                    aborted: false,
-                    willRetry: false,
-                    errorMessage,
-                });
-                await this.host.emitSessionCompactFailed({
-                    reason: "overflow",
-                    errorMessage,
-                    aborted: false,
-                    willRetry: false,
-                    fromExtension: false,
-                });
-                return false;
-            }
-            this._overflowRecoveryAttempted = true;
-            // Remove the failed or truncated message from agent state. It remains in session history,
-            // but must not be included in the compact-and-retry context.
-            const messages = this.host.agent.state.messages;
-            if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
-                this.host.agent.state.messages = messages.slice(0, -1);
-            }
-            return await this._runAutoCompaction("overflow", willRetry, timing);
-        }
-        // Case 2: Threshold - context is getting large
-        // For error messages or all-zero usage messages, estimate from the last valid response.
-        // This ensures sessions that hit persistent API errors (e.g. 529) or malformed zero-usage
-        // responses can still compact and do not reset context accounting.
-        let contextTokens;
-        const directContextTokens = assistantMessage.usage ? calculateContextTokens(assistantMessage.usage) : 0;
-        if (assistantMessage.stopReason === "error" || directContextTokens === 0) {
-            const messages = this.host.agent.state.messages;
-            const estimate = estimateContextTokens(messages);
-            // Without provider usage, estimate.tokens is the pure message-size estimate.
-            // Only usage-backed estimates need the stale pre-compaction check.
-            if (estimate.lastUsageIndex !== null) {
-                // Verify the usage source is post-compaction. Kept pre-compaction messages
-                // have stale usage reflecting the old (larger) context and would falsely
-                // trigger compaction right after one just finished.
-                const usageMsg = messages[estimate.lastUsageIndex];
-                if (compactionEntry &&
-                    usageMsg.role === "assistant" &&
-                    usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
-                    return false;
-                }
-            }
-            contextTokens = estimate.tokens;
-        }
-        else {
-            contextTokens = directContextTokens;
-        }
-        if (shouldCompact(contextTokens, contextWindow, settings)) {
-            return await this._runAutoCompaction("threshold", false, timing);
-        }
-        return false;
-    }
-    /**
-     * Internal: Run auto-compaction with events.
-     */
-    async _runAutoCompaction(reason, willRetry, timing = "postRun") {
-        const outcome = await this._runAutoCompactionWithOutcome(reason, willRetry, timing);
-        if (!outcome.compacted || outcome.mustStop) {
-            this._stopAfterTurnRequested = true;
-        }
-        return outcome.shouldContinue;
-    }
-    async _runAutoCompactionWithOutcome(reason, willRetry, timing, parentSignal) {
-        const settings = this.host.settingsManager.getCompactionSettings();
-        let started = false;
-        let fromExtension = false;
-        let controller;
-        let removeParentAbortListener;
-        try {
-            const model = this.host.getModel();
-            if (!model || this._abortController || this.host.isManualCompactionActive() || parentSignal?.aborted) {
-                return { compacted: false, shouldContinue: false };
-            }
-            const streamFunction = this.host.agent.streamFunction;
-            const thinkingLevel = this.host.getThinkingLevel();
-            const retrySettings = this.host.settingsManager.getRetrySettings();
-            controller = new AbortController();
-            if (parentSignal) {
-                const abortFromParent = () => controller?.abort();
-                parentSignal.addEventListener("abort", abortFromParent, { once: true });
-                removeParentAbortListener = () => parentSignal.removeEventListener("abort", abortFromParent);
-            }
-            if (controller.signal.aborted) {
-                return { compacted: false, shouldContinue: false };
-            }
-            this._abortController = controller;
-            started = true;
-            this.host.emit({ type: "compaction_start", reason });
-            if (controller.signal.aborted) {
-                this.host.emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: true,
-                    willRetry: false,
-                });
-                await this.host.emitSessionCompactFailed({
-                    reason,
-                    aborted: true,
-                    willRetry: false,
-                    fromExtension: false,
-                });
-                return { compacted: false, shouldContinue: false };
-            }
-            let extensionCompaction;
-            const pathEntries = this.host.sessionManager.getBranch();
-            const preparation = prepareCompaction(pathEntries, settings);
-            if (!preparation) {
-                throw new Error(NOTHING_TO_COMPACT_WITHIN_KEEP_WINDOW);
-            }
-            const extensionRunner = this.host.getExtensionRunner();
-            if (extensionRunner.hasHandlers("session_before_compact")) {
-                const extensionResult = (await extensionRunner.emit({
-                    type: "session_before_compact",
-                    preparation,
-                    branchEntries: pathEntries,
-                    customInstructions: undefined,
-                    reason,
-                    timing,
-                    willRetry,
-                    signal: controller.signal,
-                }));
-                if (extensionResult?.cancel) {
-                    this.host.emit({
-                        type: "compaction_end",
-                        reason,
-                        result: undefined,
-                        aborted: true,
-                        willRetry: false,
-                    });
-                    await this.host.emitSessionCompactFailed({
-                        reason,
-                        aborted: true,
-                        willRetry: false,
-                        fromExtension: false,
-                    });
-                    // A cancel produced by an abort (abortCompaction/parent abort) is not an
-                    // extension decision; only a voluntary cancel hands the risk to the extension.
-                    return { compacted: false, shouldContinue: false, cancelled: !controller.signal.aborted };
-                }
-                if (extensionResult?.compaction) {
-                    extensionCompaction = extensionResult.compaction;
-                    fromExtension = true;
-                }
-            }
-            let summary;
-            let firstKeptEntryId;
-            let tokensBefore;
-            let usage;
-            let details;
-            if (extensionCompaction) {
-                // Extension provided compaction content
-                summary = extensionCompaction.summary;
-                firstKeptEntryId = extensionCompaction.firstKeptEntryId;
-                tokensBefore = extensionCompaction.tokensBefore;
-                usage = extensionCompaction.usage;
-                details = extensionCompaction.details;
-            }
-            else {
-                let requestModel = model;
-                let apiKey;
-                let headers;
-                let env;
-                if (streamFunction === streamSimple) {
-                    ({ model: requestModel, apiKey, headers, env } = await this.host.getRequiredRequestAuth(model));
-                }
-                else {
-                    ({
-                        model: requestModel,
-                        apiKey,
-                        headers,
-                        env,
-                    } = await this.host.getSummarizationRequestAuth(model, streamFunction));
-                }
-                if (controller.signal.aborted) {
-                    this.host.emit({
-                        type: "compaction_end",
-                        reason,
-                        result: undefined,
-                        aborted: true,
-                        willRetry: false,
-                    });
-                    await this.host.emitSessionCompactFailed({
-                        reason,
-                        aborted: true,
-                        willRetry: false,
-                        fromExtension: false,
-                    });
-                    return { compacted: false, shouldContinue: false };
-                }
-                // Generate compaction result
-                const compactResult = await compact(preparation, requestModel, apiKey, headers, undefined, controller.signal, thinkingLevel, streamFunction, env, retrySettings, this.host.summarizationRetryCallbacks({ source: "compaction", reason }));
-                summary = compactResult.summary;
-                firstKeptEntryId = compactResult.firstKeptEntryId;
-                tokensBefore = compactResult.tokensBefore;
-                usage = compactResult.usage;
-                details = compactResult.details;
-            }
-            if (controller.signal.aborted) {
-                this.host.emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: true,
-                    willRetry: false,
-                });
-                await this.host.emitSessionCompactFailed({
-                    reason,
-                    aborted: true,
-                    willRetry: false,
-                    fromExtension,
-                });
-                return { compacted: false, shouldContinue: false };
-            }
-            this.host.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension, usage);
-            const newEntries = this.host.sessionManager.getEntries();
-            const sessionContext = this.host.sessionManager.buildSessionContext();
-            this.host.agent.state.messages = sessionContext.messages;
-            if (willRetry) {
-                const messages = this.host.agent.state.messages;
-                const lastMsg = messages[messages.length - 1];
-                // The overflow response was persisted on message_end before checkCompaction() removed it
-                // from agent state. Rebuilding state from the new compaction can restore that kept entry,
-                // leaving an assistant as the final message. agent.continue() rejects that state, so remove
-                // the retriable error or truncated-length response again before continuing the interrupted turn.
-                if (lastMsg?.role === "assistant" &&
-                    (lastMsg.stopReason === "error" ||
-                        lastMsg.stopReason === "length")) {
-                    this.host.agent.state.messages = messages.slice(0, -1);
-                }
-            }
-            const estimatedTokensAfter = this.estimateContextTokens(this.host.agent.state.messages);
-            const contextStillOverThreshold = shouldCompact(estimatedTokensAfter, model.contextWindow, settings);
-            const effectiveWillRetry = willRetry && !contextStillOverThreshold;
-            // Get the saved compaction entry for the extension event
-            const savedCompactionEntry = newEntries.find((e) => e.type === "compaction" && e.summary === summary);
-            if (savedCompactionEntry) {
-                await extensionRunner.emit({
-                    type: "session_compact",
-                    compactionEntry: savedCompactionEntry,
-                    fromExtension,
-                    reason,
-                    willRetry: effectiveWillRetry,
-                });
-            }
-            const result = {
-                summary,
-                firstKeptEntryId,
-                tokensBefore,
-                estimatedTokensAfter,
-                usage,
-                details,
-            };
-            this.host.emit({
-                type: "compaction_end",
-                reason,
-                result,
-                aborted: false,
-                willRetry: effectiveWillRetry,
-                ...(contextStillOverThreshold ? { errorMessage: CONTEXT_REMAINS_OVER_COMPACTION_THRESHOLD } : {}),
-            });
-            if (contextStillOverThreshold) {
-                return { compacted: true, shouldContinue: false, mustStop: true };
-            }
-            if (effectiveWillRetry) {
-                return { compacted: true, shouldContinue: true };
-            }
-            // Auto-compaction can complete while follow-up/steering/custom messages are waiting.
-            // Continue once so queued messages are delivered.
-            return { compacted: true, shouldContinue: this.host.agent.hasQueuedMessages() };
-        }
-        catch (error) {
-            const aborted = controller?.signal.aborted || (error instanceof Error && error.name === "AbortError");
-            const message = error instanceof Error ? error.message : "compaction failed";
-            if (started) {
-                const errorMessage = aborted
-                    ? undefined
-                    : reason === "overflow"
-                        ? `Context overflow recovery failed: ${message}`
-                        : `Auto-compaction failed: ${message}`;
-                this.host.emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted,
-                    willRetry: false,
-                    ...(errorMessage ? { errorMessage } : {}),
-                });
-                await this.host.emitSessionCompactFailed({
-                    reason,
-                    errorMessage,
-                    aborted,
-                    willRetry: false,
-                    fromExtension,
-                });
-            }
-            return { compacted: false, shouldContinue: false };
-        }
-        finally {
-            removeParentAbortListener?.();
-            if (this._abortController === controller) {
-                this._abortController = undefined;
-            }
-        }
-    }
-}
-//# sourceMappingURL=compaction-controller.js.map