@qwen-code/web-shell 0.24.1-preview.0

package/dist/types/session-catalog/workspace-session-live-state.d.ts

@@ -0,0 +1,20 @@
+import type { DaemonClient, DaemonSessionGroupCatalog } from '@qwen-code/sdk/daemon';
+export { SESSION_LIVE_STATE_POLL_MS } from './session-live-state-poll-interval';
+export declare const SESSION_LIVE_STATE_ERROR_RETRY_MS = 30000;
+/**
+ * Consecutive live-state request failures before the retained snapshot is
+ * dropped as no longer current. Failures are spaced by
+ * `SESSION_LIVE_STATE_ERROR_RETRY_MS`, so this is a ~minute of a channel that
+ * cannot answer — long enough to ride out a daemon restart, short enough that
+ * a pane held loading by this authority is released while the turn is still
+ * interesting (#9487).
+ */
+export declare const SESSION_LIVE_STATE_STALE_AFTER_FAILURES = 3;
+export declare const SESSION_LIVE_STATE_RECONCILE_COOLDOWN_MS = 10000;
+interface WorkspaceSessionLiveStateOptions {
+    enabled: boolean;
+    pollIntervalMs?: number;
+    workspaceCwds: readonly string[];
+    groupWorkspaceCwds: readonly string[];
+}
+export declare function useWorkspaceSessionLiveState(client: DaemonClient, { enabled, pollIntervalMs: configuredPollIntervalMs, workspaceCwds, groupWorkspaceCwds, }: WorkspaceSessionLiveStateOptions): ReadonlyMap<string, DaemonSessionGroupCatalog>;

package/dist/types/settings.d.ts

@@ -0,0 +1,70 @@
+/** Stable presentation aliases; schema paths are private implementation details. */
+declare const SETTING_KEYS: {
+    readonly 'setting:auto-update': "general.enableAutoUpdate";
+    readonly 'setting:session-recap': "general.showSessionRecap";
+    readonly 'setting:session-recap-away-threshold': "general.sessionRecapAwayThresholdMinutes";
+    readonly 'setting:cleanup-period': "general.cleanupPeriodDays";
+    readonly 'setting:git-commit-co-author': "general.gitCoAuthor.commit";
+    readonly 'setting:git-pr-co-author': "general.gitCoAuthor.pr";
+    readonly 'setting:language': "general.language";
+    readonly 'setting:prevent-system-sleep': "general.preventSystemSleep";
+    readonly 'setting:review-attribution': "review.attribution";
+    readonly 'setting:review-sandbox': "review.sandbox";
+    readonly 'setting:review-effort': "review.effort";
+    readonly 'setting:review-comment': "review.comment";
+    readonly 'setting:review-severity-floor': "review.severityFloor";
+    readonly 'setting:review-reverse-audit-rounds': "review.reverseAuditRounds";
+    readonly 'setting:review-approach-rounds': "review.approachRounds";
+    readonly 'setting:timestamps': "output.showTimestamps";
+    readonly 'setting:theme': "ui.theme";
+    readonly 'setting:workflow-keyword-trigger': "ui.disableWorkflowKeywordTrigger";
+    readonly 'setting:status-in-title': "ui.showStatusInTitle";
+    readonly 'setting:response-speed': "ui.showResponseTokensPerSecond";
+    readonly 'setting:followup-suggestions': "ui.enableFollowupSuggestions";
+    readonly 'setting:tool-call-details': "ui.showToolCallDetails";
+    readonly 'setting:shell-output-limit': "ui.shellOutputMaxLines";
+    readonly 'setting:usage-statistics': "privacy.usageStatisticsEnabled";
+    readonly 'setting:fast-model': "fastModel";
+    readonly 'setting:advisor-model': "advisorModel";
+    readonly 'setting:vision-model': "visionModel";
+    readonly 'setting:model-fallbacks': "modelFallbacks";
+    readonly 'setting:respect-git-ignore': "context.fileFiltering.respectGitIgnore";
+    readonly 'setting:respect-qwen-ignore': "context.fileFiltering.respectQwenIgnore";
+    readonly 'setting:fuzzy-file-search': "context.fileFiltering.enableFuzzySearch";
+    readonly 'setting:code-mode-only': "tools.codeModeOnly";
+    readonly 'setting:web-search': "tools.webSearch.enabled";
+    readonly 'setting:web-search-model': "tools.webSearch.model";
+    readonly 'setting:web-extractor': "tools.webSearch.webExtractor";
+    readonly 'setting:web-search-timeout': "tools.webSearch.timeoutMs";
+    readonly 'setting:web-search-limit': "tools.webSearch.maxPerSession";
+    readonly 'setting:tool-search': "tools.toolSearch.enabled";
+    readonly 'setting:tool-search-threshold': "tools.toolSearch.threshold";
+    readonly 'setting:list-directory': "tools.listDirectory.enabled";
+    readonly 'setting:todo-write': "tools.todoWrite.enabled";
+    readonly 'setting:interactive-shell': "tools.shell.enableInteractiveShell";
+    readonly 'setting:workflows': "tools.workflowsEnabled";
+    readonly 'setting:workflow-size': "tools.workflowSizeGuideline";
+    readonly 'setting:workflow-name-only': "tools.workflowNameOnly";
+    readonly 'setting:permission-strategy': "policy.permissionStrategy";
+    readonly 'setting:model-proposed-goals': "goals.modelProposed";
+    readonly 'setting:arena-artifacts': "agents.arena.preserveArtifacts";
+    readonly 'setting:session-workflow': "experimental.sessionWorkflow";
+    readonly 'setting:scheduled-tasks': "experimental.cron";
+    readonly 'setting:session-writer-lease': "experimental.sessionWriterLease";
+    readonly 'setting:agent-team': "experimental.agentTeam";
+    readonly 'setting:omni-media-delivery': "omni.enabled";
+    readonly 'setting:artifacts': "experimental.artifact";
+    readonly 'setting:tool-use-summaries': "experimental.emitToolUseSummaries";
+    readonly 'setting:voice-model': "voiceModel";
+    readonly 'setting:image-model': "imageModel";
+};
+declare const BUILTIN_IDS: readonly ["builtin:chat-width", "builtin:browser-notifications", "builtin:live-setup", "builtin:local-control", "builtin:model-management"];
+export type WebShellSettingItemId = keyof typeof SETTING_KEYS | (typeof BUILTIN_IDS)[number];
+export declare const WEB_SHELL_SETTING_ITEM_IDS: readonly WebShellSettingItemId[];
+export interface WebShellSettingsOptions {
+    /** Hide native settings items. Presentation only; other commands/APIs remain available. */
+    excludeItems?: readonly WebShellSettingItemId[];
+}
+export declare function isItemExcluded(id: WebShellSettingItemId, options?: WebShellSettingsOptions): boolean;
+export declare function isSettingExcluded(key: string, options?: WebShellSettingsOptions): boolean;
+export {};

package/dist/types/shadowDom.d.ts

@@ -0,0 +1,17 @@
+export interface WebShellShadowDomOptions {
+    /** Isolate the plugin manager page body from host-page CSS. */
+    plugins?: boolean;
+    /** Isolate every Web Shell portal surface from host-page CSS. */
+    portals?: boolean;
+    /** Additional CSS applied inside every enabled Web Shell ShadowRoot. */
+    styles?: string;
+}
+export type WebShellShadowDom = boolean | WebShellShadowDomOptions;
+export interface ResolvedWebShellShadowDomOptions {
+    plugins: boolean;
+    portals: boolean;
+    styles?: string;
+}
+export declare function isPluginShadowPanel(panel: string | null): boolean;
+export declare function resolveWebShellShadowDom(value: WebShellShadowDom | undefined): ResolvedWebShellShadowDomOptions;
+export declare function installWebShellShadowStyles(shadowRoot: ShadowRoot, additionalStyles?: string): () => void;

package/dist/types/subagentDetailsContext.d.ts

@@ -0,0 +1,15 @@
+import type { DaemonBackgroundTurn } from '@qwen-code/sdk/daemon';
+import { type ReactNode } from 'react';
+import type { ACPToolCall } from './adapters/types';
+export type OpenSubagentDetails = (tool: ACPToolCall) => void;
+interface SubagentDetailsContextValue {
+    onOpen: OpenSubagentDetails;
+    onOpenBackground?: (turn: DaemonBackgroundTurn) => void;
+}
+export declare function SubagentDetailsProvider({ onOpen, onOpenBackground, children, }: {
+    onOpen: OpenSubagentDetails;
+    onOpenBackground?: (turn: DaemonBackgroundTurn) => void;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useSubagentDetails(): SubagentDetailsContextValue | undefined;
+export {};

package/dist/types/themeContext.d.ts

@@ -0,0 +1,12 @@
+export declare const WebShellThemeId: {
+    readonly Dark: "dark";
+    readonly Light: "light";
+};
+export type WebShellTheme = (typeof WebShellThemeId)[keyof typeof WebShellThemeId];
+export declare const WEB_SHELL_THEMES: readonly WebShellTheme[];
+export declare const ThemeProvider: import("react").Provider<WebShellTheme>;
+export declare function useTheme(): WebShellTheme;
+export declare const THEME_SETTING_KEY = "ui.theme";
+export declare const LANGUAGE_SETTING_KEY = "general.language";
+export declare function themeSettingToWebShellTheme(value: unknown, fallback?: WebShellTheme): WebShellTheme | undefined;
+export declare function webShellThemeToSettingValue(theme: WebShellTheme): string;

package/dist/types/transcript.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Transcript-only entrypoint for `@qwen-code/web-shell`.
+ *
+ * Exposes the read-only transcript renderer without the interactive shell:
+ * no `App`, no composer, no editor/terminal chrome. Bundlers that only render
+ * transcripts (for example the `/export html` document renderer in
+ * `@qwen-code/web-templates`) must import this subpath instead of the package
+ * root, so the interactive runtime is not pulled into their output.
+ *
+ * Known residual: this is not free of the daemon React runtime. `MessageList`
+ * renders `McpStatusMessage`, `TasksStatusMessage` and the artifact turn
+ * outputs, and those call the strict `useDaemonActions` / `useDaemonWorkspace`
+ * hooks, so their provider guards are in `dist/transcript.js`. Decoupling them
+ * is #11100. `client/build-artifact.test.ts` therefore bounds this entry's size
+ * rather than asserting a symbol is absent.
+ *
+ * Do not rely on importing the package root or incidental tree shaking to
+ * keep this payload small; see
+ * `docs/design/2026-07-14-chat-record-daemon-transcript-block-projection.md`.
+ *
+ * @example
+ * ```tsx
+ * import { WebShellTranscript } from '@qwen-code/web-shell/transcript';
+ * ```
+ */
+export { WebShellTranscript } from './components/WebShellTranscript';
+export type { WebShellTranscriptProps } from './components/WebShellTranscript';
+export type { WebShellFootnote, WebShellSource, WebShellSourceReference, WebShellSourceIconResolver, WebShellFootnoteIconResolver, WebShellFootnotePreviewInfo, WebShellFootnotePreviewHandle, WebShellFootnotePreviewMount, WebShellIconSource, WebShellMarkdownCustomization, } from './customization';

package/dist/types/transcriptRenderMode.d.ts

@@ -0,0 +1,5 @@
+export type TranscriptRenderMode = 'interactive' | 'readonly' | 'document';
+export declare const TranscriptRenderModeProvider: import("react").Provider<TranscriptRenderMode>;
+export declare const TranscriptDocumentExpandedProvider: import("react").Provider<boolean>;
+export declare function useTranscriptRenderMode(): TranscriptRenderMode;
+export declare function useTranscriptDocumentExpanded(): boolean;

package/dist/types/utils/ansi.d.ts

@@ -0,0 +1,9 @@
+interface Segment {
+    text: string;
+    color?: string;
+    bold?: boolean;
+    dim?: boolean;
+}
+export declare function parseAnsi(input: string): Segment[];
+export declare function hasAnsi(input: string): boolean;
+export {};

package/dist/types/utils/askUserPermission.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { PermissionRequest } from '../adapters/types';
+/**
+ * True when a pending permission is an AskUserQuestion prompt (it carries a
+ * `questions` array, and either no tool name or the AskUserQuestion tool name)
+ * rather than a normal tool-call approval. Shared by the single-session App and
+ * the split-view ChatPane so the two never drift.
+ */
+export declare function isAskUserPermission(request: PermissionRequest | null): boolean;

package/dist/types/utils/base64.d.ts

@@ -0,0 +1 @@
+export declare function base64ToBlob(data: string, mimeType: string): Blob;

package/dist/types/utils/bounded-map.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Sets `key` to `value`, marks it most-recently-used, and evicts
+ * least-recently-used entries while the map exceeds `cap`. Callers own the
+ * cap because legitimate budgets differ per cache.
+ */
+export declare function setBoundedMapEntry<V>(map: Map<string, V>, key: string, value: V, cap: number): void;

package/dist/types/utils/clipboard.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Clipboard write helper with a fallback for non-secure contexts.
+ *
+ * The async Clipboard API (`navigator.clipboard`) is only exposed in secure
+ * contexts (HTTPS or loopback). The daemon serves the Web Shell over plain
+ * HTTP, so opening it through a non-loopback address (e.g.
+ * `http://10.x.x.x:4170`) leaves `navigator.clipboard` undefined and every
+ * copy entry point used to fail. Fall back to the legacy
+ * `document.execCommand('copy')` path so copying keeps working there.
+ * See https://github.com/QwenLM/qwen-code/issues/9485.
+ *
+ * Known edge: in a secure context where clipboard-write permission has never
+ * been decided, `writeText` only settles when the user answers the permission
+ * prompt. If they block it after several seconds, the transient user
+ * activation that `execCommand('copy')` needs may already have expired, so
+ * the fallback can still fail. The common repeat-visit case (permission
+ * already `denied`) is covered because `writeText` rejects promptly and the
+ * fallback runs while the gesture is still active.
+ *
+ * `writeText` is invoked synchronously in the caller's tick (no permission
+ * pre-query) so gesture-bound tests and click handlers observe the call
+ * immediately; the rejection is the fallback trigger.
+ */
+export declare function writeClipboardText(text: string): Promise<void>;
+/**
+ * Single reporter for clipboard write failures. Call sites that only want to
+ * log a failed copy (no user-visible error surface) attach
+ * `.catch(warnClipboardWriteFailure)` so the prefix/format lives in one place;
+ * callers that surface the failure in the UI keep their own handling.
+ */
+export declare function warnClipboardWriteFailure(error: unknown): void;

package/dist/types/utils/commandDisplay.d.ts

@@ -0,0 +1,7 @@
+import type { CommandInfo } from '../adapters/types';
+export type CommandDisplayCategory = 'custom' | 'skill' | 'system';
+export type CommandDisplayCategoryOrder = readonly CommandDisplayCategory[];
+export declare const DEFAULT_COMMAND_CATEGORY_ORDER: CommandDisplayCategoryOrder;
+export declare function getCommandDisplayCategory(command: CommandInfo): CommandDisplayCategory;
+export declare function compareCommandsByCategory(a: CommandInfo, b: CommandInfo, order?: CommandDisplayCategoryOrder): number;
+export declare function getCategoryRank(category: CommandDisplayCategory, order?: CommandDisplayCategoryOrder): number;

package/dist/types/utils/composerInputState.d.ts

@@ -0,0 +1,19 @@
+type ComposerConnectionStatus = 'idle' | 'connecting' | 'connected' | 'disconnected' | 'error';
+export type ComposerPlaceholderState = 'idle' | 'processing';
+export declare function shouldDisableComposerInput({ pendingApproval, isPreparingPrompt, }: {
+    pendingApproval: boolean;
+    isPreparingPrompt: boolean;
+}): boolean;
+export declare function getComposerPlaceholderState({ isPreparingPrompt, isStreaming, }: {
+    isPreparingPrompt: boolean;
+    isStreaming: boolean;
+}): ComposerPlaceholderState;
+export declare function getComposerPlaceholderKey(input: {
+    isPreparingPrompt: boolean;
+    isStreaming: boolean;
+}): 'editor.processing' | 'editor.placeholder';
+export declare function shouldBlockComposerSubmit({ connectionStatus, hasSession, }: {
+    connectionStatus: ComposerConnectionStatus;
+    hasSession: boolean;
+}): boolean;
+export {};

package/dist/types/utils/composerModels.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Model IDs hidden from the composer's model picker — internal / duplicate
+ * entries that must not be user-selectable. Shared by the main chat composer
+ * (App) and the split-view pane composers (ChatPane) so both hide the same set.
+ */
+export declare const HIDDEN_COMPOSER_MODEL_IDS: Set<string>;
+/** Whether a model may appear in the composer's model picker. */
+export declare function isVisibleComposerModel(model: {
+    id: string;
+}): boolean;
+/**
+ * Whether the model picker is unavailable for a fresh standalone draft: no
+ * session attached yet and the hydrated catalog has no user-selectable
+ * models. Shared by every picker entry point (composer toolbar, StatusBar
+ * button, /model command) so the gates never drift apart.
+ */
+export declare function isStandaloneModelPickerUnavailable(input: {
+    sessionId: string | null | undefined;
+    sessionContextKind: string | undefined;
+    models: readonly {
+        id: string;
+    }[] | undefined;
+}): boolean;

package/dist/types/utils/composerTag.d.ts

@@ -0,0 +1,42 @@
+import type { DaemonInputAnnotation } from '@qwen-code/sdk/daemon';
+import type { UserMessageContentParser, WebShellComposerTag, WebShellComposerTagIconMap, WebShellComposerTagKind, WebShellUserMessagePart } from '../customization';
+export interface ComposerTagViewModel {
+    tagLabel: string;
+    tagValue: string;
+    fallback: string;
+    iconUrl?: string;
+}
+export type ComposerTagContentSegment = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'reference';
+    tag: WebShellComposerTag;
+};
+/**
+ * Composer-tag display getters.
+ *
+ * These live here rather than in `hooks/useComposerCore.ts` on purpose: that
+ * module imports the whole CodeMirror editor at top level, and read-only
+ * consumers (`UserMessage`, and through it the `@qwen-code/web-shell/transcript`
+ * entry that `/export html` bundles) need nothing but these three string
+ * getters. Importing them from `useComposerCore` dragged ~1 MB of CodeMirror
+ * into every exported HTML file (#11031).
+ */
+export declare function getComposerTagLabel(tag: WebShellComposerTag): string;
+export declare function getComposerTagValue(tag: WebShellComposerTag): string;
+export declare function getComposerTagDisplay(tag: WebShellComposerTag): string;
+export declare function isPreviewableFileComposerTag(tag: WebShellComposerTag): tag is WebShellComposerTag & {
+    kind: 'file';
+    value: string;
+};
+export interface ParseUserMessageContentOptions {
+    requireSourcePreservation?: boolean;
+}
+export declare function parseUserMessageContentSafely(content: string, parser: UserMessageContentParser | undefined, warning: string, options?: ParseUserMessageContentOptions): readonly WebShellUserMessagePart[] | null;
+export declare function getComposerTagSerialized(tag: WebShellComposerTag): string;
+export declare function getComposerTagIconUrl(kind: WebShellComposerTagKind | undefined, customIconUrls?: WebShellComposerTagIconMap): string | undefined;
+export declare function isBuiltinComposerTagIconUrl(iconUrl: string | undefined): boolean;
+export declare function createInputAnnotationsFromComposerTags(content: string, tags: readonly WebShellComposerTag[]): DaemonInputAnnotation[];
+export declare function splitComposerTagContentByAnnotations(content: string, inputAnnotations?: readonly DaemonInputAnnotation[]): ComposerTagContentSegment[];
+export declare function getComposerTagViewModel(tag: WebShellComposerTag, composerTagIcons?: WebShellComposerTagIconMap): ComposerTagViewModel;

package/dist/types/utils/composerTasks.d.ts

@@ -0,0 +1,16 @@
+import type { DaemonSessionTaskWithWorkflowStatus } from '@qwen-code/sdk/daemon';
+/**
+ * Tasks that belong to THIS session's live background state — what the
+ * status-bar pill counts and the environment panel lists.
+ *
+ * Agent tasks have their own surfaces, and retained workflow runs are
+ * history: `getWorkflowTasks()` merges the project's saved snapshots into
+ * the same list, so without the `isHistorical` exclusion a project with
+ * saved runs shows "30 tasks done" in the pill the first time polling runs,
+ * for the rest of the session, with no way to clear it. Consumers that
+ * genuinely want the history (the workflow details provider, the tasks
+ * dialog) read the unfiltered list instead.
+ */
+export declare function isComposerTask(task: DaemonSessionTaskWithWorkflowStatus): task is Exclude<DaemonSessionTaskWithWorkflowStatus, {
+    kind: 'agent';
+}>;

package/dist/types/utils/contextUsage.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared severity thresholds for context-window occupancy, used by the
+ * composer ring and the /context panel so the two surfaces never disagree
+ * about when usage turns warning or error.
+ */
+export declare const CONTEXT_USAGE_WARNING_PCT = 60;
+export declare const CONTEXT_USAGE_ERROR_PCT = 80;
+export type ContextUsageLevel = 'normal' | 'warning' | 'error';
+export declare function getContextUsageLevel(pct: number): ContextUsageLevel;

package/dist/types/utils/copyCommand.d.ts

@@ -0,0 +1,18 @@
+import type { Message } from '../adapters/types';
+export interface CopyCommandResult {
+    status: 'info' | 'error';
+    message: string;
+}
+export declare const COPY_MESSAGES: {
+    readonly NO_OUTPUT: "No output in history";
+    readonly NO_TEXT: "Last AI output contains no text to copy.";
+    readonly CODE_MISSING: "No matching code block found in the last AI output.";
+    readonly LATEX_MISSING: "No matching LaTeX block found in the last AI output.";
+    readonly INLINE_LATEX_MISSING: "No matching inline LaTeX expression found in the last AI output.";
+    readonly OUTPUT_COPIED: "Last output copied to the clipboard";
+    readonly CLIPBOARD_PREFIX: "Failed to copy to the clipboard. ";
+    readonly COPIED_SUFFIX: " copied to the clipboard";
+};
+type ClipboardWriter = (text: string) => Promise<void>;
+export declare function copyFromLastAssistantMessage(messages: readonly Message[], args: string, writeText?: ClipboardWriter): Promise<CopyCommandResult>;
+export {};

package/dist/types/utils/cssUrlVar.d.ts

@@ -0,0 +1,3 @@
+import type { CSSProperties } from 'react';
+export declare function cssUrlValue(url: string): string;
+export declare function cssUrlVar(name: string, url: string): CSSProperties;

package/dist/types/utils/dialogLabels.d.ts

@@ -0,0 +1 @@
+export declare function trimDialogLabel(label: string): string;

package/dist/types/utils/dom.d.ts

@@ -0,0 +1,2 @@
+export declare function isEditableTarget(target: EventTarget | null): boolean;
+export declare function getShadowAwareActiveElement(element: Element | null | undefined): Element | null;

package/dist/types/utils/errorDetail.d.ts

@@ -0,0 +1 @@
+export declare function extractErrorDetail(error: unknown): string;

package/dist/types/utils/escapeIntent.d.ts

@@ -0,0 +1,29 @@
+export type EscArmedAction = 'cancel' | 'clear';
+export interface EscapeContext {
+    /** A pending approval or blocking dialog swallows Escape entirely. */
+    blocked: boolean;
+    /** A turn is in flight (streaming, or the daemon reports an active prompt). */
+    streaming: boolean;
+    /** The composer currently has text that could be cleared. */
+    hasInput: boolean;
+    /** Which action the previous Escape armed, or null when idle. */
+    armed: EscArmedAction | null;
+}
+export type EscapeIntent = {
+    kind: 'cancel';
+} | {
+    kind: 'clear';
+} | {
+    kind: 'arm';
+    action: EscArmedAction;
+} | {
+    kind: 'ignore';
+};
+/**
+ * Decide what an Escape press means. Streaming takes priority over clearing
+ * text (stopping a live turn is what the user most wants), and each action is a
+ * two-press confirm: the first press arms, a matching second press confirms. A
+ * press armed for the wrong action (e.g. clear-armed while now streaming)
+ * re-arms the action that currently applies rather than confirming.
+ */
+export declare function decideEscapeIntent(ctx: EscapeContext): EscapeIntent;

package/dist/types/utils/externalOpen.d.ts

@@ -0,0 +1,15 @@
+/**
+ * External-URL opening helper shared by markdown links and `external_url`
+ * link artifacts.
+ *
+ * Inside the packaged desktop shell, external clicks use Tauri's opener
+ * plugin. Plain browsers keep native anchor behavior at the call sites.
+ */
+/** True when the Web Shell runs inside the packaged Tauri desktop window. */
+export declare function isDesktopShell(): boolean;
+export declare function isExternalOpenUrl(url: string | undefined): boolean;
+/**
+ * Opens `url` in the OS default browser. Rejects when the open fails so
+ * callers can surface a visible error instead of swallowing the click.
+ */
+export declare function openExternalUrl(url: string): Promise<void>;

package/dist/types/utils/formatDateTime.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Precise timestamp for hover details: a session from the current calendar
+ * day shows the local wall-clock time `HH:mm:ss`; anything older shows the
+ * calendar date `yyyy-MM-dd`. Calendar days — not elapsed milliseconds — so
+ * yesterday 08:01 can never masquerade as today 08:01 across midnight.
+ */
+export declare function formatDateTime(iso: string, now?: number): string;

package/dist/types/utils/formatRelativeTime.d.ts

@@ -0,0 +1,4 @@
+import type { useI18n } from '../i18n';
+type Translate = ReturnType<typeof useI18n>['t'];
+export declare function formatRelativeTime(iso: string, t: Translate): string;
+export {};

package/dist/types/utils/formatRuntime.d.ts

@@ -0,0 +1 @@
+export declare function formatRuntime(ms: number): string;

package/dist/types/utils/formatTokenCount.d.ts

@@ -0,0 +1,13 @@
+export declare function formatTokenCount(count: number): string;
+/**
+ * Context-usage token count — k/M with one decimal (e.g. `53.6k`, `1.0M`),
+ * used by context cards and usage summaries. The composer tooltip shows
+ * exact locale-grouped counts instead.
+ */
+export declare function formatContextTokens(count: number): string;
+/**
+ * Token count in megatokens — always `M` with one decimal (e.g. `810.7M`,
+ * `9382.8M`), the usage dashboard's convention where even billions read as M.
+ * Sub-1M values render raw with locale grouping (e.g. `80`, `12,345`).
+ */
+export declare function formatMegaTokens(count: number): string;

package/dist/types/utils/gitModeIntent.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonWorkspaceGitStatus } from '@qwen-code/sdk/daemon';
+/**
+ * Whether an armed git-mode intent (new branch / worktree) for the next
+ * session can no longer apply and must fall back to the current branch.
+ *
+ * Only definitive states reset it: a session already exists, the workspace
+ * is not trusted, or git status answered and reported no branch. A status
+ * that is merely absent — not fetched yet, or a poll round that failed — is
+ * transient and leaves the intent alone; otherwise one rejected refetch
+ * while a draft sits would silently turn a requested worktree task into a
+ * plain session in the main checkout.
+ */
+export declare function gitModeIntentMustReset({ sessionId, workspaceTrusted, gitStatus, }: {
+    sessionId: string | null | undefined;
+    workspaceTrusted: boolean | undefined;
+    gitStatus: Pick<DaemonWorkspaceGitStatus, 'branch'> | undefined;
+}): boolean;

package/dist/types/utils/goalCondition.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Words the daemon reads as "drop the goal" rather than as a condition.
+ *
+ * Mirrors CLEAR_KEYWORDS in packages/cli/src/ui/commands/goalCommand.ts, which
+ * is the authority. The test beside this file reads that source and fails on
+ * drift — this client bundles for the browser and cannot import from core.
+ */
+export declare const GOAL_CLEAR_KEYWORDS: ReadonlySet<string>;
+export type ParsedWebShellGoalCommand = {
+    kind: 'status';
+} | {
+    kind: 'set' | 'edit';
+    objective: string;
+} | {
+    kind: 'pause' | 'resume' | 'clear';
+} | {
+    kind: 'error';
+    keyword: 'set' | 'edit';
+};
+/** The argument of a `/goal …` command; `''` for a bare `/goal`. */
+export declare function goalArgOf(text: string): string;
+/** Browser-side mirror of the CLI's Goal v3 command grammar. */
+export declare function parseWebShellGoalCommand(text: string): ParsedWebShellGoalCommand;
+/**
+ * True when `text` is a `/goal <clear-keyword>` invocation.
+ *
+ * The prefix is checked here rather than assumed. `goalArgOf` strips `/goal`
+ * only when it is present and otherwise returns the text unchanged, so without
+ * this guard a bare `"clear"` — a perfectly ordinary thing to type into a chat
+ * box — would answer true to "is this a goal-clear command?".
+ */
+export declare function isGoalClearCommand(text: string): boolean;
+/**
+ * True when a would-be goal condition is really a clear keyword. `/goal clear`
+ * clears rather than sets, so a form that accepts "clear" as a condition would
+ * silently start a session that immediately drops the goal.
+ */
+export declare function isGoalClearKeyword(condition: string): boolean;

package/dist/types/utils/goalControlRequest.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type GoalControlRequest, type GoalRecord } from '@qwen-code/sdk/daemon';
+export type GoalControlAction = 'create' | 'replace' | 'edit' | 'pause' | 'resume' | 'clear';
+/**
+ * Build the versioned control request for `action` against the goal the daemon
+ * just reported.
+ *
+ * Shared by the main composer and the split-view pane: both read a fresh
+ * snapshot, then stamp `expectedGoalId`/`expectedRevision` from it. Keeping the
+ * construction in one place is what stops the two surfaces from drifting apart
+ * on the optimistic-concurrency contract.
+ */
+export declare function buildGoalControlRequest(action: GoalControlAction, goal: GoalRecord | null | undefined, objective: string | undefined, errors: {
+    emptyObjective: string;
+    goalUnavailable: string;
+}): GoalControlRequest;

package/dist/types/utils/goalGate.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { GoalSnapshotV2, GoalStatus } from '@qwen-code/sdk/daemon';
+/** The slice of the daemon connection the Goal gate reads. */
+export interface GoalGateConnection {
+    sessionId?: string | undefined;
+    goalState?: GoalSnapshotV2 | undefined;
+}
+/**
+ * Whether a local action must be held back because a Goal owns the session.
+ *
+ * Fails CLOSED while `goalState` is still hydrating: the session load clears
+ * `loadingTranscript` (making the composer writable) before its `goal()` fetch
+ * resolves, so an unknown Goal state on a real session has to read as "a Goal
+ * may be active". Commands and automatic runs must not start against that
+ * unknown ownership state.
+ *
+ * Command and automatic/manual run guards go through here. Ordinary chat
+ * submissions are routed only by the session's streaming state.
+ */
+export declare function isGoalGateBlocked(connection: GoalGateConnection): boolean;
+/** The slice of a Goal record the resume gate reads. */
+export interface GoalResumeGateRecord {
+    status: GoalStatus;
+}
+/**
+ * Whether `resume` is a transition the reducer will accept for this Goal.
+ *
+ * Stated as the reducer states it (`reduceGoalControl`), not as an
+ * approximation of it: every Goal resume affordance in the client goes through
+ * here, so an offered Resume button cannot dead-end in an invalid-transition
+ * 409 that the UI itself promised would not happen. The reducer accepts resume
+ * for every stopped status -- an evidence-limited Goal resumes by restarting
+ * its evidence window -- so status is the whole contract.
+ */
+export declare function canResumeGoal(goal: GoalResumeGateRecord): boolean;