comisai 1.0.4

package/node_modules/@comis/channels/dist/shared/retry-engine.js

@@ -0,0 +1,258 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Retry Engine: Configurable message delivery retry with exponential backoff.
+ *
+ * Wraps `adapter.sendMessage()` calls with:
+ * - Error classification (retry / markdown-fallback / abort)
+ * - Exponential backoff with full jitter (prevents thundering herd)
+ * - Platform retry_after header respect
+ * - Markdown/HTML parse error fallback to plain text
+ * - EventBus integration for observability
+ *
+ * Designed to sit ABOVE platform SDK retry (Grammy auto-retry, discord.js
+ * rate limiter, etc.) and handle general delivery failures the SDKs miss:
+ * network errors, transient server errors, and markdown parse errors.
+ *
+ * @module
+ */
+import { err } from "@comis/shared";
+// ---------------------------------------------------------------------------
+// Error classification
+// ---------------------------------------------------------------------------
+/**
+ * Classify a sendMessage error to determine retry strategy.
+ *
+ * - `"markdown-fallback"`: Parse errors (Telegram HTML, general parse failures)
+ *   -> strip HTML tags and retry without parse_mode
+ * - `"retry"`: Transient errors (rate limits, server errors, network errors)
+ *   -> exponential backoff retry
+ * - `"abort"`: Non-retriable errors (400, 404, auth errors)
+ *   -> return error immediately
+ */
+export function classifySendError(error) {
+    const msg = error.message.toLowerCase();
+    // Telegram HTML parse error patterns
+    if (msg.includes("can't parse entities") || msg.includes("bad request: can't parse")) {
+        return "markdown-fallback";
+    }
+    // General parse errors (any platform)
+    if (msg.includes("parse") && msg.includes("error")) {
+        return "markdown-fallback";
+    }
+    // Rate limit (may still escape SDK retry if SDK exhausts its own attempts)
+    if (msg.includes("429") || msg.includes("too many requests") || msg.includes("rate limit")) {
+        return "retry";
+    }
+    // Server errors
+    if (msg.includes("500") || msg.includes("502") || msg.includes("503") || msg.includes("504")) {
+        return "retry";
+    }
+    // Network errors
+    if (msg.includes("econnrefused") || msg.includes("econnreset") || msg.includes("etimedout")) {
+        return "retry";
+    }
+    // Everything else: abort (400, 404, auth errors should NOT be retried)
+    return "abort";
+}
+// ---------------------------------------------------------------------------
+// HTML tag stripping
+// ---------------------------------------------------------------------------
+/**
+ * Strip HTML tags from text, preserving text content.
+ * Used for markdown fallback when parse_mode causes errors.
+ */
+export function stripHtmlTags(text) {
+    return text.replace(/<[^>]+>/g, "");
+}
+// ---------------------------------------------------------------------------
+// Retry-After extraction
+// ---------------------------------------------------------------------------
+/**
+ * Extract retry_after delay from an error message.
+ *
+ * Looks for patterns like:
+ * - "retry_after: 5" / "retry_after:5"
+ * - "Retry-After: 3"
+ * - "retry after 10 seconds"
+ *
+ * @returns delay in milliseconds, or undefined if not found
+ */
+export function extractRetryAfter(error) {
+    const msg = error.message;
+    // Pattern: retry_after: <number> or Retry-After: <number>
+    const match = msg.match(/retry[_-]after\s*:\s*(\d+)/i);
+    if (match) {
+        const seconds = parseInt(match[1], 10);
+        if (!isNaN(seconds) && seconds > 0) {
+            return seconds * 1000; // Convert to ms
+        }
+    }
+    // Pattern: "retry after <number> seconds"
+    const altMatch = msg.match(/retry\s+after\s+(\d+)\s*(?:second|sec|s\b)/i);
+    if (altMatch) {
+        const seconds = parseInt(altMatch[1], 10);
+        if (!isNaN(seconds) && seconds > 0) {
+            return seconds * 1000;
+        }
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Delay computation
+// ---------------------------------------------------------------------------
+/**
+ * Compute exponential backoff delay with optional full jitter.
+ *
+ * Formula: min(minDelayMs * 2^(attempt-1), maxDelayMs)
+ * With jitter: random value in [0, exponential)
+ */
+function computeDelay(attempt, config) {
+    const exponential = Math.min(config.minDelayMs * Math.pow(2, attempt - 1), config.maxDelayMs);
+    return config.jitter
+        ? Math.floor(Math.random() * exponential)
+        : exponential;
+}
+// ---------------------------------------------------------------------------
+// Sleep utility (abort-aware)
+// ---------------------------------------------------------------------------
+/**
+ * Abort-aware sleep: resolves after `ms` or immediately when signal fires.
+ */
+function abortAwareSleep(ms, signal) {
+    if (!signal)
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        function onAbort() {
+            clearTimeout(timer);
+            resolve();
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+/**
+ * Create a retry engine with configurable backoff and error classification.
+ *
+ * @param config - Retry configuration (maxAttempts, delays, jitter, etc.)
+ * @param eventBus - Event bus for retry observability events
+ * @param logger - Logger for retry warnings
+ */
+export function createRetryEngine(config, eventBus, _logger, abortSignal) {
+    return {
+        async sendWithRetry(adapter, channelId, text, options) {
+            let lastError;
+            let currentText = text;
+            let currentOptions = options;
+            for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
+                // Abort check at top of each retry attempt
+                if (abortSignal?.aborted) {
+                    return err(new Error("Aborted"));
+                }
+                const result = await adapter.sendMessage(channelId, currentText, currentOptions);
+                if (result.ok)
+                    return result;
+                lastError = result.error;
+                const classification = classifySendError(result.error);
+                // --- Markdown fallback path ---
+                if (classification === "markdown-fallback" && config.markdownFallback) {
+                    const originalParseMode = currentOptions?.parseMode ?? currentOptions?.extra?.parse_mode ?? "unknown";
+                    // Strip HTML tags from text
+                    currentText = stripHtmlTags(text);
+                    // Remove parseMode and parse_mode from options
+                    const { parseMode: _pm, ...restOptions } = currentOptions ?? {};
+                    const { parse_mode: _pm2, ...restExtra } = (restOptions.extra ?? {});
+                    currentOptions = { ...restOptions, parseMode: undefined, extra: restExtra };
+                    eventBus.emit("retry:markdown_fallback", {
+                        channelId: adapter.channelId,
+                        chatId: channelId,
+                        originalParseMode: String(originalParseMode),
+                        timestamp: Date.now(),
+                    });
+                    // Try sending plain text (counts as one attempt)
+                    const fallbackResult = await adapter.sendMessage(channelId, currentText, currentOptions);
+                    if (fallbackResult.ok)
+                        return fallbackResult;
+                    lastError = fallbackResult.error;
+                    // Continue retry loop with remaining attempts
+                    if (attempt < config.maxAttempts) {
+                        const delayMs = computeDelay(attempt, config);
+                        eventBus.emit("retry:attempted", {
+                            channelId: adapter.channelId,
+                            chatId: channelId,
+                            attempt,
+                            maxAttempts: config.maxAttempts,
+                            delayMs,
+                            error: lastError.message,
+                            timestamp: Date.now(),
+                        });
+                        await abortAwareSleep(delayMs, abortSignal);
+                    }
+                    continue;
+                }
+                // --- Abort path ---
+                if (classification === "abort") {
+                    return err(result.error);
+                }
+                // --- Retry path ---
+                if (attempt < config.maxAttempts) {
+                    // Determine delay
+                    let delayMs;
+                    const retryAfterMs = config.respectRetryAfter ? extractRetryAfter(result.error) : undefined;
+                    if (retryAfterMs !== undefined) {
+                        delayMs = retryAfterMs;
+                    }
+                    else {
+                        delayMs = computeDelay(attempt, config);
+                    }
+                    eventBus.emit("retry:attempted", {
+                        channelId: adapter.channelId,
+                        chatId: channelId,
+                        attempt,
+                        maxAttempts: config.maxAttempts,
+                        delayMs,
+                        error: result.error.message,
+                        timestamp: Date.now(),
+                    });
+                    await abortAwareSleep(delayMs, abortSignal);
+                }
+            }
+            // All attempts exhausted
+            const finalError = lastError ?? new Error("Retry exhausted");
+            eventBus.emit("retry:exhausted", {
+                channelId: adapter.channelId,
+                chatId: channelId,
+                totalAttempts: config.maxAttempts,
+                finalError: finalError.message,
+                timestamp: Date.now(),
+            });
+            return err(finalError);
+        },
+    };
+}
+/**
+ * Create a guard that tracks consecutive block delivery failures.
+ *
+ * If 2+ consecutive blocks fail, the guard signals to abort remaining
+ * blocks rather than creating a retry storm.
+ *
+ * @param threshold - Number of consecutive failures before abort (default: 2)
+ */
+export function createBlockRetryGuard(threshold = 2) {
+    let consecutiveFailures = 0;
+    return {
+        recordFailure() {
+            consecutiveFailures++;
+        },
+        recordSuccess() {
+            consecutiveFailures = 0;
+        },
+        get shouldAbort() {
+            return consecutiveFailures >= threshold;
+        },
+    };
+}

package/node_modules/@comis/channels/dist/shared/sanitize-for-plain-text.d.ts

@@ -0,0 +1,32 @@
+/**
+ * HTML sanitizer for plain-text channel surfaces.
+ *
+ * Strips HTML tags from LLM output and converts them to lightweight markup
+ * for plain-text channel surfaces (WhatsApp, Signal, IRC, iMessage, LINE).
+ *
+ * Only needed after IR render because the IR pipeline handles markdown
+ * conversion but not raw HTML that LLMs sometimes produce directly.
+ *
+ * @module
+ */
+/**
+ * Channel surfaces that receive plain text (no native HTML/rich formatting).
+ */
+export declare const PLAIN_TEXT_SURFACES: Set<string>;
+/**
+ * Check whether the given channel type is a plain-text surface.
+ */
+export declare function isPlainTextSurface(channelType: string): boolean;
+/**
+ * Sanitize HTML tags from text intended for plain-text channel surfaces.
+ *
+ * Converts common HTML formatting tags to lightweight markup equivalents
+ * and decodes HTML entities. Processing order matters: tags are stripped
+ * before entities are decoded, so encoded angle brackets (`&lt;`, `&gt;`)
+ * in the original text are preserved as literal characters, not
+ * re-interpreted as HTML.
+ *
+ * @param text - Text potentially containing HTML tags
+ * @returns Clean text with HTML converted to lightweight markup
+ */
+export declare function sanitizeForPlainText(text: string): string;

package/node_modules/@comis/channels/dist/shared/sanitize-for-plain-text.js

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * HTML sanitizer for plain-text channel surfaces.
+ *
+ * Strips HTML tags from LLM output and converts them to lightweight markup
+ * for plain-text channel surfaces (WhatsApp, Signal, IRC, iMessage, LINE).
+ *
+ * Only needed after IR render because the IR pipeline handles markdown
+ * conversion but not raw HTML that LLMs sometimes produce directly.
+ *
+ * @module
+ */
+/**
+ * Channel surfaces that receive plain text (no native HTML/rich formatting).
+ */
+export const PLAIN_TEXT_SURFACES = new Set([
+    "whatsapp",
+    "signal",
+    "irc",
+    "imessage",
+    "line",
+]);
+/**
+ * Check whether the given channel type is a plain-text surface.
+ */
+export function isPlainTextSurface(channelType) {
+    return PLAIN_TEXT_SURFACES.has(channelType);
+}
+/**
+ * Sanitize HTML tags from text intended for plain-text channel surfaces.
+ *
+ * Converts common HTML formatting tags to lightweight markup equivalents
+ * and decodes HTML entities. Processing order matters: tags are stripped
+ * before entities are decoded, so encoded angle brackets (`<`, `>`)
+ * in the original text are preserved as literal characters, not
+ * re-interpreted as HTML.
+ *
+ * @param text - Text potentially containing HTML tags
+ * @returns Clean text with HTML converted to lightweight markup
+ */
+export function sanitizeForPlainText(text) {
+    let result = text;
+    // a. Preserve autolinks: <https://...> or <mailto:...>
+    result = result.replace(/<((?:https?:\/\/|mailto:)[^<>\s]+)>/gi, "$1");
+    // b. Extract URLs from <a> tags — if label differs from URL, show both
+    result = result.replace(/<a\s+[^>]*href=["']([^"']+)["'][^>]*>(.*?)<\/a>/gi, (_match, url, label) => {
+        if (label === url)
+            return url;
+        return `${label} (${url})`;
+    });
+    // c. Line breaks
+    result = result.replace(/<br\s*\/?>/gi, "\n");
+    // d. Block elements — add newlines
+    result = result.replace(/<\/?(p|div)>/gi, "\n");
+    // e. Bold
+    result = result.replace(/<(b|strong)>(.*?)<\/\1>/gi, "*$2*");
+    // f. Italic
+    result = result.replace(/<(i|em)>(.*?)<\/\1>/gi, "_$2_");
+    // g. Strikethrough
+    result = result.replace(/<(s|strike|del)>(.*?)<\/\1>/gi, "~$2~");
+    // h. Inline code
+    result = result.replace(/<code>(.*?)<\/code>/gi, "`$1`");
+    // i. Headings
+    result = result.replace(/<h[1-6][^>]*>(.*?)<\/h[1-6]>/gi, "\n*$1*\n");
+    // j. List items
+    result = result.replace(/<li[^>]*>(.*?)<\/li>/gi, "- $1\n");
+    // k. Strip remaining HTML tags
+    result = result.replace(/<\/?[a-z][a-z0-9]*\b[^>]*>/gi, "");
+    // l. Decode HTML entities (AFTER tag stripping)
+    result = result.replace(/&amp;/g, "&");
+    result = result.replace(/&lt;/g, "<");
+    result = result.replace(/&gt;/g, ">");
+    result = result.replace(/&nbsp;/g, " ");
+    result = result.replace(/&#39;/g, "'");
+    result = result.replace(/&quot;/g, '"');
+    // m. Collapse excessive newlines
+    result = result.replace(/\n{3,}/g, "\n\n");
+    // n. Trim
+    return result.trim();
+}

package/node_modules/@comis/channels/dist/shared/send-policy.d.ts

@@ -0,0 +1,53 @@
+import type { SendPolicyConfig, SendPolicyRule } from "@comis/core";
+/**
+ * Context for evaluating a send policy decision.
+ */
+export interface SendPolicyContext {
+    readonly channelId: string;
+    readonly channelType: string;
+    readonly chatType?: string;
+}
+/**
+ * Result of evaluating a send policy.
+ */
+export interface SendPolicyDecision {
+    readonly allowed: boolean;
+    readonly rule?: SendPolicyRule;
+    readonly reason: string;
+}
+/**
+ * Per-session send override: "on" allows all, "off" blocks all, "inherit" uses policy.
+ */
+export type SendOverride = "on" | "off" | "inherit";
+/**
+ * Ephemeral in-memory store for per-session send overrides.
+ */
+export interface SendOverrideStore {
+    get(sessionKey: string): SendOverride;
+    set(sessionKey: string, override: SendOverride): void;
+    delete(sessionKey: string): void;
+}
+/**
+ * Evaluate whether an outbound send is allowed by the policy.
+ *
+ * Rules are evaluated in order with first-match-wins semantics.
+ * If the policy is disabled, all sends are allowed.
+ * If no rule matches, the defaultAction determines the outcome.
+ */
+export declare function evaluateSendPolicy(ctx: SendPolicyContext, config: SendPolicyConfig): SendPolicyDecision;
+/**
+ * Apply a per-session send override to a policy decision.
+ *
+ * Priority: session override > send policy rules > default action.
+ * - "on": overrides to allowed
+ * - "off": overrides to denied
+ * - "inherit": returns policy decision unchanged
+ */
+export declare function applySessionOverride(policyDecision: SendPolicyDecision, override: SendOverride): SendPolicyDecision;
+/**
+ * Create an ephemeral in-memory store for per-session send overrides.
+ *
+ * Overrides are intentionally not persisted to disk. They clear on daemon
+ * restart, which is the expected behavior per design.
+ */
+export declare function createSendOverrideStore(): SendOverrideStore;

package/node_modules/@comis/channels/dist/shared/send-policy.js

@@ -0,0 +1,88 @@
+/**
+ * Check whether a single rule matches the given context.
+ *
+ * A rule matches if every defined field equals the corresponding context field.
+ * Omitted fields are treated as wildcards (match anything).
+ */
+function ruleMatches(rule, ctx) {
+    if (rule.channelId !== undefined && rule.channelId !== ctx.channelId) {
+        return false;
+    }
+    if (rule.chatType !== undefined && rule.chatType !== ctx.chatType) {
+        return false;
+    }
+    if (rule.channelType !== undefined && rule.channelType !== ctx.channelType) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Evaluate whether an outbound send is allowed by the policy.
+ *
+ * Rules are evaluated in order with first-match-wins semantics.
+ * If the policy is disabled, all sends are allowed.
+ * If no rule matches, the defaultAction determines the outcome.
+ */
+export function evaluateSendPolicy(ctx, config) {
+    if (!config.enabled) {
+        return { allowed: true, reason: "policy-disabled" };
+    }
+    for (const rule of config.rules) {
+        if (ruleMatches(rule, ctx)) {
+            return {
+                allowed: rule.action === "allow",
+                rule,
+                reason: rule.description ?? `rule-${rule.action}`,
+            };
+        }
+    }
+    return {
+        allowed: config.defaultAction === "allow",
+        reason: `default-${config.defaultAction}`,
+    };
+}
+/**
+ * Apply a per-session send override to a policy decision.
+ *
+ * Priority: session override > send policy rules > default action.
+ * - "on": overrides to allowed
+ * - "off": overrides to denied
+ * - "inherit": returns policy decision unchanged
+ */
+export function applySessionOverride(policyDecision, override) {
+    if (override === "on") {
+        return { allowed: true, reason: "session-override-on" };
+    }
+    if (override === "off") {
+        return { allowed: false, reason: "session-override-off" };
+    }
+    // "inherit" — use policy decision as-is
+    return policyDecision;
+}
+/**
+ * Create an ephemeral in-memory store for per-session send overrides.
+ *
+ * Overrides are intentionally not persisted to disk. They clear on daemon
+ * restart, which is the expected behavior per design.
+ */
+export function createSendOverrideStore() {
+    const map = new Map();
+    return {
+        get(sessionKey) {
+            return map.get(sessionKey) ?? "inherit";
+        },
+        set(sessionKey, override) {
+            // Setting "inherit" is equivalent to removing the override —
+            // prevents stale entries from accumulating in memory.
+            if (override === "inherit") {
+                map.delete(sessionKey);
+            }
+            else {
+                map.set(sessionKey, override);
+            }
+        },
+        delete(sessionKey) {
+            map.delete(sessionKey);
+        },
+    };
+}

package/node_modules/@comis/channels/dist/shared/slack-emoji-map.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Unicode-to-Slack shortname mapping for lifecycle reaction emoji.
+ *
+ * Slack's reactions.add/remove APIs require shortnames (e.g., "thinking_face"),
+ * not Unicode characters. This map covers all lifecycle reaction emoji from
+ * both the unicode and platform emoji tiers.
+ */
+/**
+ * Maps Unicode emoji characters to their Slack reaction shortnames.
+ *
+ * Covers all emoji used in EMOJI_SETS (both unicode and platform tiers).
+ * Slack shortnames do not include colons -- they are bare names
+ * (e.g., "thinking_face" not ":thinking_face:").
+ */
+export declare const UNICODE_TO_SLACK: Map<string, string>;
+/**
+ * Converts a Unicode emoji to its Slack reaction shortname.
+ *
+ * If the emoji is not in the mapping, returns the input unchanged.
+ * This allows non-lifecycle emoji to pass through unmodified.
+ */
+export declare function toSlackShortname(unicode: string): string;

package/node_modules/@comis/channels/dist/shared/slack-emoji-map.js

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Unicode-to-Slack shortname mapping for lifecycle reaction emoji.
+ *
+ * Slack's reactions.add/remove APIs require shortnames (e.g., "thinking_face"),
+ * not Unicode characters. This map covers all lifecycle reaction emoji from
+ * both the unicode and platform emoji tiers.
+ */
+/**
+ * Maps Unicode emoji characters to their Slack reaction shortnames.
+ *
+ * Covers all emoji used in EMOJI_SETS (both unicode and platform tiers).
+ * Slack shortnames do not include colons -- they are bare names
+ * (e.g., "thinking_face" not ":thinking_face:").
+ */
+export const UNICODE_TO_SLACK = new Map([
+    ["\u{1F440}", "eyes"],
+    ["\u{1F914}", "thinking_face"],
+    ["\u{1F50D}", "mag"],
+    ["\u{1F50E}", "mag_right"],
+    ["\u{1F527}", "wrench"],
+    ["\u{1F4BB}", "computer"],
+    ["\u{1F310}", "globe_with_meridians"],
+    ["\u{1F3A8}", "art"],
+    ["\u{2705}", "white_check_mark"],
+    ["\u{274C}", "x"],
+    ["\u{23F3}", "hourglass_flowing_sand"],
+    ["\u{26A0}\u{FE0F}", "warning"],
+    ["\u{1F9E0}", "brain"],
+    ["\u{2699}\u{FE0F}", "gear"],
+    ["\u{1F4DD}", "memo"],
+    ["\u{1F578}\u{FE0F}", "spider_web"],
+    ["\u{1F5BC}\u{FE0F}", "frame_with_picture"],
+    ["\u{1F6A8}", "rotating_light"],
+]);
+/**
+ * Converts a Unicode emoji to its Slack reaction shortname.
+ *
+ * If the emoji is not in the mapping, returns the input unchanged.
+ * This allows non-lifecycle emoji to pass through unmodified.
+ */
+export function toSlackShortname(unicode) {
+    return UNICODE_TO_SLACK.get(unicode) ?? unicode;
+}

package/node_modules/@comis/channels/dist/shared/stall-detector.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Stall detection with per-phase multipliers for lifecycle reactions.
+ *
+ * Computes per-phase stall thresholds by applying multipliers to the
+ * configurable base thresholds (stallSoftMs, stallHardMs). Phases with
+ * longer expected durations (coding, web, media) get higher multipliers
+ * to avoid false stall warnings.
+ */
+import type { LifecycleReactionsTimingConfig } from "@comis/core";
+import type { LifecyclePhase } from "./lifecycle-state-machine.js";
+/**
+ * Stall time multipliers per lifecycle phase.
+ *
+ * Higher multipliers for phases that are expected to take longer:
+ * - coding (2.0x): Long-running bash/code operations
+ * - web (1.5x): Network-bound operations
+ * - media (3.0x): Image/video/audio processing
+ * - thinking/memory/tool (1.0x): Standard processing time
+ *
+ * Phases not listed (idle, queued, done, error, stall_soft, stall_hard)
+ * default to 1.0x via getPhaseMultiplier().
+ */
+export declare const PHASE_MULTIPLIERS: Record<string, number>;
+/** Computed stall thresholds for a specific phase. */
+export interface StallThresholds {
+    /** Soft stall warning threshold in milliseconds. */
+    softMs: number;
+    /** Hard stall warning threshold in milliseconds. */
+    hardMs: number;
+}
+/**
+ * Returns the stall time multiplier for a given lifecycle phase.
+ *
+ * Defaults to 1.0 for phases not explicitly listed in PHASE_MULTIPLIERS
+ * (idle, queued, done, error, stall_soft, stall_hard).
+ */
+export declare function getPhaseMultiplier(phase: LifecyclePhase): number;
+/**
+ * Computes stall detection thresholds for a specific phase.
+ *
+ * Multiplies the base timing thresholds (stallSoftMs, stallHardMs) by
+ * the phase-specific multiplier.
+ *
+ * @example
+ * ```ts
+ * // Default timing: stallSoftMs=15000, stallHardMs=30000
+ * computeStallThresholds("coding", timing)
+ * // => { softMs: 30000, hardMs: 60000 } (2.0x multiplier)
+ *
+ * computeStallThresholds("media", timing)
+ * // => { softMs: 45000, hardMs: 90000 } (3.0x multiplier)
+ * ```
+ */
+export declare function computeStallThresholds(phase: LifecyclePhase, timing: Pick<LifecycleReactionsTimingConfig, "stallSoftMs" | "stallHardMs">): StallThresholds;