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

package/dist/types/hooks/useScopedSessions.d.ts

@@ -0,0 +1,65 @@
+import type { DaemonSessionArchiveState } from '@qwen-code/sdk/daemon';
+import type { SessionCatalogQuery } from '../session-catalog/session-catalog-store';
+interface ScopedSessionsOptions {
+    autoLoad?: boolean;
+    enabled?: boolean;
+    maxAgeMs?: number;
+    pageSize?: number;
+    archiveState?: DaemonSessionArchiveState;
+    view?: 'organized';
+    group?: string;
+    pollIntervalMs?: number;
+}
+export declare function useScopedSessions(workspaceCwd: string | undefined, options?: ScopedSessionsOptions): {
+    data: import("@qwen-code/sdk/daemon").DaemonSessionSummary[] | undefined;
+    sessions: import("@qwen-code/sdk/daemon").DaemonSessionSummary[];
+    loading: boolean;
+    error: Error | undefined;
+    reload: (reloadOptions?: {
+        interactive?: boolean;
+    }) => Promise<import("@qwen-code/sdk/daemon").DaemonSessionSummary[] | undefined>;
+    nextCursor: string | undefined;
+    liveMergeFailed: boolean;
+    truncated: boolean;
+    loadSession: ((sessionId: string, options?: {
+        workspaceCwd?: string;
+        sessionContext?: import("@qwen-code/web-shell/daemon-react-sdk").DaemonProductSessionContext;
+    }) => Promise<void>) | undefined;
+    resumeSession: ((sessionId: string, options?: {
+        workspaceCwd?: string;
+        sessionContext?: import("@qwen-code/web-shell/daemon-react-sdk").DaemonProductSessionContext;
+    }) => Promise<void>) | undefined;
+    newSession: (() => Promise<void>) | undefined;
+    releaseSession: ((sessionId: string) => Promise<void>) | undefined;
+    releaseSessionAction: ((sessionId: string) => Promise<void>) | undefined;
+    deleteSession: (sessionId: string) => Promise<boolean>;
+    deleteSessions: (sessionIds: string[]) => Promise<{
+        removed: string[];
+        notFound: string[];
+        errors: Array<{
+            sessionId: string;
+            error: string;
+        }>;
+    }>;
+    exportSession: (sessionId: string, format?: import("@qwen-code/sdk/daemon").DaemonSessionExportFormat) => Promise<import("@qwen-code/sdk/daemon").DaemonSessionExportResult>;
+    archiveSession: (sessionId: string) => Promise<boolean>;
+    unarchiveSession: (sessionId: string) => Promise<boolean>;
+    catalogQuery: SessionCatalogQuery | undefined;
+} | {
+    data: import("@qwen-code/sdk/daemon").DaemonSessionSummary[] | undefined;
+    sessions: import("@qwen-code/sdk/daemon").DaemonSessionSummary[];
+    loading: boolean;
+    error: Error | undefined;
+    reload: () => Promise<import("@qwen-code/sdk/daemon").DaemonSessionSummary[]>;
+    deleteSession: (sessionId: string) => Promise<boolean>;
+    deleteSessions: (sessionIds: string[]) => Promise<{
+        removed: string[];
+        notFound: string[];
+        errors: Array<{
+            sessionId: string;
+            error: string;
+        }>;
+    }>;
+    releaseSession: ((sessionId: string) => Promise<void | undefined>) | undefined;
+};
+export {};

package/dist/types/hooks/useSessionArtifacts.d.ts

@@ -0,0 +1,10 @@
+import type { DaemonSessionArtifact } from '@qwen-code/sdk/daemon';
+export interface SessionArtifactsState {
+    artifacts: DaemonSessionArtifact[];
+    artifactById: ReadonlyMap<string, DaemonSessionArtifact>;
+    loading: boolean;
+    error: string | null;
+    hydrated: boolean;
+    refresh: () => Promise<void>;
+}
+export declare function useSessionArtifacts(): SessionArtifactsState;

package/dist/types/hooks/useSessionArtifactsChange.d.ts

@@ -0,0 +1,12 @@
+import type { DaemonSessionArtifact } from '@qwen-code/sdk/daemon';
+import type { WebShellSessionArtifactsChange } from '../customization';
+interface SessionArtifactsChangeOptions {
+    sessionId?: string;
+    ready: boolean;
+    hydrated: boolean;
+    artifacts: readonly DaemonSessionArtifact[];
+    artifactsByTurn: ReadonlyMap<string, readonly DaemonSessionArtifact[]>;
+    onChange?: (change: WebShellSessionArtifactsChange) => void;
+}
+export declare function useSessionArtifactsChange({ sessionId, ready, hydrated, artifacts, artifactsByTurn, onChange, }: SessionArtifactsChangeOptions): void;
+export {};

package/dist/types/hooks/useSessionSources.d.ts

@@ -0,0 +1,13 @@
+import type { SessionSourceInput } from '@qwen-code/sdk/daemon';
+export declare function useSessionSources(): {
+    supported: boolean;
+    sources: import("@qwen-code/sdk/daemon").SessionSource[];
+    revision: number;
+    hydrated: boolean;
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+    upsert: (input: SessionSourceInput) => Promise<import("@qwen-code/sdk/daemon").SessionSourceUpsertResult | undefined>;
+    remove: (id: string) => Promise<void>;
+    owner: import("@qwen-code/web-shell/daemon-react-sdk").DaemonSessionOwnerSnapshot;
+};

package/dist/types/hooks/useShallowMemo.d.ts

@@ -0,0 +1,2 @@
+export declare function useShallowMemo<T>(value: T): T;
+export declare function useStableArray<T>(items: T[], keyFn: (item: T) => string): T[];

package/dist/types/hooks/useSharedNow.d.ts

@@ -0,0 +1 @@
+export declare function useSharedNow(enabled: boolean): number;

package/dist/types/hooks/useStreamingLoadingMetrics.d.ts

@@ -0,0 +1,19 @@
+interface LoadingMetrics {
+    estimatedOutputTokens: number;
+    isReceivingContent: boolean;
+}
+/**
+ * CLI-aligned streaming loading metrics derived from transcript blocks.
+ *
+ * CLI source (use-llm-stream.ts + LoadingIndicator.tsx):
+ * - streamingChars: accumulated from text_delta (+text.length) and
+ *   ToolCallRequest (+JSON.stringify(args).length). Reset only on new
+ *   user queries, NOT on tool-result continuations.
+ * - isReceivingContent: false at submitQuery start, true on first
+ *   content event. Never changed elsewhere (tool calls don't flip it).
+ * - outputTokens = agentTokens + round(animatedChars / 4)
+ *   where agentTokens = sum of subagent task_execution.tokenCount
+ * - Animation: 100ms interval, gap<70→+3, 70-200→+20%, >200→+50
+ */
+export declare function useStreamingLoadingMetrics(): LoadingMetrics;
+export {};

package/dist/types/hooks/useTranscriptViewport.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type Translator } from '../adapters/localizedMessages';
+import type { Message } from '../adapters/types';
+export declare function useTranscriptViewport(liveMessages: Message[], t: Translator): {
+    navigation: import("..").DaemonTurnNavigationSnapshot;
+    store: import("../daemon/session/turn-navigation-store").DaemonHistoryNavigationStore;
+    target: {
+        blockId: string;
+        token: number;
+    } | undefined;
+    selectOrdinal: (ordinal: number) => Promise<void>;
+    cancelSelection: () => void;
+    continueLive: (blockId?: string) => void;
+    messages: import("../adapters/messageTypes").DaemonMessage[];
+    toolSources: Map<string, string>;
+    historical: boolean;
+    viewKey: string;
+    range: import("../daemon/session/transcript-page-table").HistoricalViewportRange | undefined;
+    loading: boolean;
+    error: boolean;
+    connected: boolean;
+    canContinueLive: boolean;
+    retry: (beforeAdmit?: () => void) => void;
+    pin: (sourceBlockId?: string) => void;
+    load: (direction: "older" | "newer", beforeAdmit?: () => void) => Promise<void>;
+    returnToLive: () => void;
+};

package/dist/types/i18n.d.ts

@@ -0,0 +1,14 @@
+import { type PropsWithChildren } from 'react';
+export declare const WEB_SHELL_LANGUAGES: readonly ["en", "zh-CN"];
+export type WebShellLanguage = (typeof WEB_SHELL_LANGUAGES)[number];
+export declare function normalizeLanguage(value: string | undefined | null): WebShellLanguage;
+export declare function languageSettingToWebShellLanguage(value: unknown): WebShellLanguage | undefined;
+export declare function languageLabel(language: WebShellLanguage): string;
+export declare function getTranslator(language: WebShellLanguage): (key: string, vars?: Record<string, string | number>) => string;
+export declare function I18nProvider({ language, children, }: PropsWithChildren<{
+    language: WebShellLanguage;
+}>): import("react/jsx-runtime").JSX.Element;
+export declare function useI18n(): {
+    language: WebShellLanguage;
+    t: (key: string, vars?: Record<string, string | number>) => string;
+};

package/dist/types/index.d.ts

@@ -0,0 +1,69 @@
+import { type DaemonProductSessionContext } from '@qwen-code/web-shell/daemon-react-sdk';
+import { type WebShellProps } from './App';
+import { type WebShellBrowserNotificationsOptions } from './browser-turn-notifications';
+export { WebShellTranscript } from './components/WebShellTranscript';
+export type { WebShellTranscriptProps } from './components/WebShellTranscript';
+export * from './daemon-react-sdk';
+export type { WebShellBrowserNotificationsOptions } from './browser-turn-notifications';
+export interface WebShellWithProvidersProps extends WebShellProps {
+    /** Connect browser notifications with optional branding and an initial preference (off by default). */
+    browserNotifications?: WebShellBrowserNotificationsOptions;
+    /** Daemon API base URL. Defaults to the browser origin when omitted. */
+    baseUrl?: string;
+    /** Bearer token passed to daemon requests. */
+    token?: string;
+    /** Session id to load. Undefined starts on an empty page. */
+    sessionId?: string;
+    /** Registered daemon workspace id for the session. Undefined uses primary. */
+    workspaceId?: string;
+    /** Registered daemon workspace path for the session. Takes precedence over workspaceId. */
+    workspaceCwd?: string;
+    /** Explicit product context. Use standalone without workspaceId/workspaceCwd. */
+    sessionContext?: DaemonProductSessionContext;
+    /**
+     * Workspace path to lock this shell to. Missing paths are registered
+     * persistently before rendering. Takes precedence over workspaceCwd and workspaceId.
+     */
+    lockWorkspaceCwd?: string;
+    /** Client identity to reuse when attaching to an externally created session. */
+    clientId?: string;
+    /**
+     * Restart a live SSE event stream after each accepted prompt. Disabled by
+     * default. A stream that is already down is always rebuilt immediately on
+     * prompt admission, regardless of this flag.
+     */
+    restartSseOnPrompt?: boolean;
+    /** Persisted transcript records requested per page. Defaults to 100; valid range is 1–500. */
+    historyPageSize?: number;
+}
+/**
+ * Low-level UI component. Requires ancestor `DaemonWorkspaceProvider` and
+ * `DaemonSessionProvider` from `@qwen-code/web-shell`. The consumer
+ * owns those providers, so this boundary covers only what we render (`App`).
+ */
+export declare function WebShell(props: WebShellProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Batteries-included component for product integrations. It wraps WebShell
+ * with both daemon providers, so MCP/tools/skills/memory/agents/session APIs
+ * are available without extra setup.
+ */
+export declare function WebShellWithProviders(props: WebShellWithProvidersProps): import("react/jsx-runtime").JSX.Element;
+/** Alias for consumers who prefer a standalone naming style. */
+export declare const StandaloneWebShell: typeof WebShellWithProviders;
+export type { WebShellApi, WebShellComposerPlaceholders, WebShellComposerPlaceholderState, WebShellSlashCommand, WebShellSlashCommandHandler, WebShellProps, WebShellSidebarOptions, BugReportInfo, SessionChangeEvent, } from './App';
+export type { WebShellShadowDom, WebShellShadowDomOptions } from './shadowDom';
+export type { ToastTone } from './components/ToastHost';
+export type { WebShellSidebarBranding, WebShellSidebarFooterItem, WebShellSidebarFooterOptions, WebShellSidebarLockedWorkspace, WebShellSidebarPrimaryNavOptions, WebShellSidebarPrimaryNavItem, WebShellSidebarSessionActionsOptions, WebShellSidebarSessionActionItem, WebShellSidebarSessionInlineActionItem, WebShellSidebarWorkspaceOverviewOptions, WorkspaceManagementTarget, WorkspaceOverviewItem, } from './components/sidebar/WebShellSidebar';
+export type { WebShellLanguage } from './i18n';
+export type { WebShellTheme } from './themeContext';
+export type { WebShellBrand, WebShellResolvedBrand } from './brandContext';
+export type { CommandDisplayCategory, CommandDisplayCategoryOrder, } from './utils/commandDisplay';
+export type { ComposerToolbarAction } from './components/ChatEditor';
+export type { CodeBlockRenderer, MarkdownContentSource, MarkdownTableMode, MarkdownRenderContext, ToolHeaderExtraRenderer, ToolHeaderExtraRenderInfo, ToolHeaderKind, ComposerTagClickHandler, ComposerTagRenderer, AssistantTurnFooterRenderer, UserMessageContentRenderer, UserMessageContentRenderInfo, UserMessageContentParser, ComposerHeaderRenderer, ComposerFooterRenderer, ComposerToolbarStartRenderer, ComposerToolbarRightRenderer, WebShellAtItemRenderInfo, WebShellAtItemRenderer, WebShellComposerApi, WebShellBuiltinComposerTagKind, WebShellBuiltinAtProviderId, WebShellBuiltinAtProvidersConfig, WebShellComposerInput, WebShellComposerTag, WebShellComposerTagIconMap, WebShellComposerTagKind, WebShellComposerTagOptions, WebShellComposerTagPlacement, WebShellComposerToolbarRenderInfo, WebShellComposerToolbarStartRenderInfo, WebShellComposerToolbarRightRenderInfo, WebShellComposerTextOptions, WelcomeFooterRenderer, WelcomeHeaderRenderer, ChatHeaderRenderer, ChatHeaderRenderInfo, WebShellChatHeaderItem, WebShellChatHeaderOptions, WebShellRightPanelItem, WebShellRightPanelOptions, WebShellEnvironmentPanelItem, WebShellEnvironmentPanelOptions, WebShellFooterRenderInfo, FooterRenderer, LoadingPhrasesResolver, WebShellAtProviderTab, WebShellAtItem, WebShellAtProvider, WebShellBottomStatusItem, WebShellCodeBlockRenderInfo, WebShellMarkdownChartCustomization, WebShellMarkdownCustomization, WebShellFootnote, WebShellSource, WebShellSourceReference, WebShellSourceIconResolver, WebShellFootnoteIconResolver, WebShellFootnotePreviewInfo, WebShellFootnotePreviewHandle, WebShellFootnotePreviewMount, WebShellAssistantMessageInfo, WebShellAssistantTurnFooterRenderInfo, ArtifactImageRenderer, WebShellArtifactCustomization, WebShellIconSource, WebShellTaskInfo, WebShellUserMessagePart, WebShellAgentTask, WebShellShellTask, WebShellMonitorTask, WebShellWorkflowTask, WebShellPreparedSubmit, WebShellSubmitSnapshot, WebShellSessionArtifactsChange, WebShellSessionArtifactsChangeReason, WebShellModelInfo, WebShellSkillInfo, } from './customization';
+export type { WelcomeHeaderProps } from './components/WelcomeHeader';
+export type { PaneHeaderActionsInfo, PaneHeaderActionsRenderer, } from './components/ChatPane';
+export type { TurnOutputKind, TurnOutputOpenRequest, } from './components/artifacts/TurnOutputs';
+export { ECHARTS_FULLDATA_LANGUAGE, EchartsFullDataBlock, createMarkdownChartRegistry, createEchartsFullDataRenderer, } from './components/messages/MarkdownChartRenderer';
+export type { DatasetCell, EchartsFullDataBlockProps, EchartsFullDataOption, EchartsFullDataRefMeta, EchartsFullDataRefResolver, EchartsFullDataResolvedDataset, EchartsFullDataRendererOptions, EchartsInstance, EchartsRuntime, EchartsRuntimeLoader, } from './components/messages/MarkdownChartRenderer';
+export { WEB_SHELL_SETTING_ITEM_IDS } from './settings';
+export type { WebShellSettingItemId, WebShellSettingsOptions, } from './settings';

package/dist/types/interactionBlockContext.d.ts

@@ -0,0 +1,3 @@
+export type RegisterInteractionBlocker = () => () => void;
+export declare const InteractionBlockContext: import("react").Context<RegisterInteractionBlocker>;
+export declare function useInteractionBlocker(): RegisterInteractionBlocker;

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

@@ -0,0 +1,2 @@
+import { type ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/types/live/HotkeySetter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type KeyboardEvent } from 'react';
+export declare function acceleratorFromKeyboardEvent(event: KeyboardEvent<HTMLInputElement>): string | null;
+export declare function formatAccelerator(accelerator: string): string;
+export declare function HotkeySetter({ accelerator, disabled, captureLabel, clearLabel, offLabel, onChange, }: {
+    accelerator: string;
+    disabled: boolean;
+    captureLabel: string;
+    clearLabel: string;
+    offLabel: string;
+    onChange: (accelerator: string) => Promise<void>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/live/LiveVoiceButton.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type React from 'react';
+export declare function LiveVoiceButton(): React.JSX.Element | null;

package/dist/types/live/LiveVoiceSettingsCard.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type UseLiveVoiceSetupResult } from './useLiveVoiceSetup';
+export declare function LiveVoiceSettingsCard({ setup, }: {
+    setup: UseLiveVoiceSetupResult;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/live/useLiveVoice.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonLiveMuteUpdate, DaemonLiveStatus } from '@qwen-code/sdk';
+export interface UseLiveVoiceResult {
+    supported: boolean;
+    status: DaemonLiveStatus | undefined;
+    loading: boolean;
+    mutating: boolean;
+    refresh: () => Promise<void>;
+    start: (mode?: 'resume' | 'new') => Promise<void>;
+    stop: () => Promise<void>;
+    setMute: (update: DaemonLiveMuteUpdate) => Promise<void>;
+}
+export declare function useLiveVoice(): UseLiveVoiceResult;

package/dist/types/live/useLiveVoiceSetup.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonLiveHostInstallState, DaemonLiveSetupStatus, DaemonLiveSetupUpdate } from '@qwen-code/sdk';
+export declare const INSTALLING_STATES: ReadonlySet<DaemonLiveHostInstallState>;
+export interface UseLiveVoiceSetupResult {
+    supported: boolean;
+    status: DaemonLiveSetupStatus | undefined;
+    loading: boolean;
+    mutating: boolean;
+    error: Error | undefined;
+    refresh: () => Promise<void>;
+    update: (update: DaemonLiveSetupUpdate) => Promise<void>;
+    retryInstall: () => Promise<void>;
+    launchHost: () => Promise<void>;
+}
+export declare function useLiveVoiceSetup(supported: boolean, active?: boolean): UseLiveVoiceSetupResult;

package/dist/types/local-files/bridge-client.d.ts

@@ -0,0 +1,207 @@
+/**
+ * 4c — the reverse-channel client for the local-files bridge.
+ *
+ * Owns one `/acp` WebSocket for the lifetime of a granted directory: ACP
+ * `initialize`, then `mcp_register { server, sessionId }`, then answering the
+ * daemon's `mcp_message` frames from {@link LocalFilesMcpServer}.
+ *
+ * Three behaviours here are not optional, because each was measured rather than
+ * assumed (see `docs/design/2026-09-03-client-filesystem-bridge.md` §3):
+ *
+ *  - Registration needs a LIVE ACP channel. A preheated child can be reaped
+ *    before we ask, and the daemon answers `register_failed`; the daemon's own
+ *    CDP path retries 20x250ms for the same reason, so we re-warm and retry.
+ *  - Closing the socket is the teardown signal: the daemon removes the
+ *    server itself, so a reconnect must register again from scratch.
+ *  - Session scope is what keeps these tools out of sibling sessions, so the
+ *    `sessionId` is part of every register frame.
+ *
+ * Framework-free on purpose (no React, no DOM globals beyond the injected
+ * socket and lock manager) so the whole state machine runs in a node test.
+ */
+import { type JsonRpcRequest, type JsonRpcResponse } from './mcp-server.js';
+/**
+ * The RPC surface the bridge drives. {@link LocalFilesMcpServer} satisfies it;
+ * declared structurally so the state machine is testable without a filesystem.
+ */
+export interface LocalFilesRpcServer {
+    handle(message: JsonRpcRequest): Promise<JsonRpcResponse | undefined>;
+}
+export declare const LOCAL_FILES_CLIENT_NAME = "qwen-web-shell-local-files";
+/** Cross-tab ownership: one bridge per browser profile, not one per tab. */
+export declare const LOCAL_FILES_LOCK_NAME = "qwen-local-files-bridge";
+export type LocalFilesBridgeState = {
+    phase: 'idle';
+} | {
+    phase: 'held-elsewhere';
+} | {
+    phase: 'connecting';
+    attempt: number;
+} | {
+    phase: 'registering';
+    attempt: number;
+} | {
+    phase: 'connected';
+    toolCount: number;
+} | {
+    phase: 'reconnecting';
+    attempt: number;
+    reason: string;
+} | {
+    phase: 'stopped';
+} | {
+    phase: 'failed';
+    code: string;
+    message: string;
+};
+export interface WebSocketHandlers {
+    open(): void;
+    message(data: unknown): void;
+    error(): void;
+    close(code: number, reason: string): void;
+}
+/** The slice of a WebSocket this client drives. */
+export interface WebSocketLike {
+    send(data: string): void;
+    close(): void;
+    setHandlers(handlers: WebSocketHandlers): void;
+}
+export type OpenSocket = (url: string, protocols: string[]) => WebSocketLike;
+/** `navigator.locks`, narrowed to the one call we make. */
+export interface LockManagerLike {
+    request(name: string, options: {
+        ifAvailable: boolean;
+    }, callback: (lock: unknown) => Promise<void>): Promise<unknown>;
+}
+export interface LocalFilesBridgeOptions {
+    baseUrl: string;
+    sessionId: string;
+    server: LocalFilesRpcServer;
+    openSocket: OpenSocket;
+    token?: string;
+    serverName?: string;
+    clientInfo?: {
+        name: string;
+        version: string;
+    };
+    /** Re-warm the ACP child before retrying a failed registration. */
+    rewarm?: () => Promise<void>;
+    locks?: LockManagerLike | null;
+    maxRegisterAttempts?: number;
+    maxReconnectAttempts?: number;
+    reconnectBaseDelayMs?: number;
+    initializeTimeoutMs?: number;
+    registerTimeoutMs?: number;
+    delay?: (ms: number) => Promise<void>;
+    onState?: (state: LocalFilesBridgeState) => void;
+    /**
+     * The session's workspace when it is not the primary one: routes the socket
+     * to the mount that owns the session. Omit for the primary workspace.
+     */
+    workspaceSelector?: AcpWorkspaceSelector;
+}
+/**
+ * Owner-lock acquisition shape, shared with the hook's disconnect
+ * arbitration: one ifAvailable attempt cannot tell a peer's lock from this
+ * context's own release still settling.
+ */
+export declare const DEFAULT_LOCK_ATTEMPTS = 3;
+export declare const DEFAULT_LOCK_RETRY_DELAY_MS = 100;
+/**
+ * Bounded ifAvailable acquisition of the owner lock, shared by the bridge's
+ * start() and the hook's disconnect arbitration so the decline/retry
+ * semantics (a conformant manager declines by invoking the callback with
+ * null, Web Locks 4.1) live in one place. Resolves true when the callback
+ * ran (or the wait was cancelled after a grant), false when every attempt
+ * was declined; a rejecting manager rejects, for the caller to policy.
+ */
+export declare function withOwnerLock(opts: {
+    locks: LockManagerLike;
+    delay: (ms: number) => Promise<void>;
+    cancelled: () => boolean;
+    run: () => Promise<void>;
+}): Promise<boolean>;
+/** Mirrors the bearer-subprotocol scheme the daemon's WS upgrade accepts. */
+export declare function bearerSubprotocols(token: string | undefined): string[];
+/** Identifies the workspace a session belongs to, for the qualified route. */
+export interface AcpWorkspaceSelector {
+    kind: 'id' | 'cwd';
+    value: string;
+}
+/**
+ * Mirrors `TerminalPanel.buildWsUrl`: keep any base path, swap the scheme.
+ *
+ * The bare `/acp` upgrade binds the PRIMARY mount, so a session owned by a
+ * secondary runtime would fail registration there; with a selector the URL
+ * takes the workspace-qualified shape the daemon resolves per runtime (the
+ * same route the voice stream uses).
+ */
+export declare function buildAcpWsUrl(baseUrl: string, selector?: AcpWorkspaceSelector): string;
+/**
+ * Production socket adapter: the only place a real `WebSocket` is touched.
+ *
+ * `setHandlers` MUST be called in the same synchronous block as this factory
+ * (`connect()` does). A real socket starts connecting at construction, and an
+ * `open` delivered before the handlers land would be dropped — leaving the
+ * bridge stuck in `connecting` with no initialize sent and no timeout armed,
+ * because the timeout is armed by `sendInitialize`.
+ */
+export declare function openBrowserSocket(url: string, protocols: string[]): WebSocketLike;
+export declare class LocalFilesBridge {
+    private readonly options;
+    private readonly serverName;
+    private readonly delay;
+    private socket;
+    private state;
+    private stopped;
+    private running;
+    private registerAttempts;
+    private reconnectAttempts;
+    private initializeTimer;
+    private registerTimer;
+    /**
+     * Single-flight for retryRegister: the timeout timer, a late
+     * `register_failed` and a `rate_limited` shed can each spawn a continuation
+     * while one is parked in rewarm; without this guard both send a register
+     * and one logical failure consumes two of the six attempts.
+     */
+    private registerRetryInFlight;
+    /** Resolves the run loop so the cross-tab lock is released. */
+    private releaseRun;
+    constructor(options: LocalFilesBridgeOptions);
+    getState(): LocalFilesBridgeState;
+    /**
+     * Acquire the cross-tab lock and run until stopped. Resolves when the bridge
+     * is done (stopped, failed, or another tab owns it).
+     *
+     * Calling `start()` on a bridge that is already running is a no-op; to
+     * restart (a different session, a re-granted directory) call `stop()` first.
+     */
+    start(): Promise<void>;
+    stop(): void;
+    /**
+     * Release the socket, timers and cross-tab lock WITHOUT touching the state:
+     * a failure path states its reason first and then tears down, and a `stop()`
+     * here would overwrite that reason with `stopped`.
+     */
+    private teardown;
+    private setState;
+    private clearTimers;
+    private run;
+    private connect;
+    private sendInitialize;
+    private sendRegister;
+    private retryRegister;
+    private onMessage;
+    private answerRpc;
+    private onClose;
+    /**
+     * Drop a socket that is still open but useless (an initialize that never
+     * answered) and reconnect. Detaching before `close()` is what keeps the
+     * resulting close event from being handled a second time.
+     */
+    private recycleSocket;
+    private scheduleReconnect;
+    private fail;
+    private send;
+}

package/dist/types/local-files/capabilities.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Runtime probe for the local-files bridge.
+ *
+ * The bridge needs three things the deployment cannot promise: a Chromium
+ * picker, a secure context, and a top-level (or same-origin) document. A remote
+ * daemon reached over plain http fails the second; the Chrome extension's side
+ * panel fails the third, because it frames the Web Shell from a
+ * `chrome-extension://` parent. `localhost` counts as a secure context, so an
+ * SSH tunnel to the daemon host needs no TLS.
+ */
+export type LocalFilesFrame = 'top-level' | 'same-origin-iframe' | 'cross-origin-iframe';
+export type LocalFilesBlocker = 'unsupported-browser' | 'insecure-context' | 'cross-origin-frame'
+/** The session's workspace cannot host a bridge (untrusted or live). */
+ | 'workspace-ineligible'
+/** The workspace snapshot has not landed yet; judgement impossible. */
+ | 'workspace-resolving'
+/** The daemon does not advertise the reverse channel at all. */
+ | 'unsupported-daemon' | null;
+export interface LocalFilesCapability {
+    pickerAvailable: boolean;
+    secureContext: boolean;
+    frame: LocalFilesFrame;
+    /** Why the bridge cannot be offered here, or null when it can. */
+    blocker: LocalFilesBlocker;
+}
+/** The slice of `window` the probe reads; injectable so tests need no DOM. */
+export interface LocalFilesWindowLike {
+    isSecureContext: boolean;
+    showDirectoryPicker?: unknown;
+    self: unknown;
+    top: unknown;
+}
+export declare function detectLocalFilesCapability(win: LocalFilesWindowLike): LocalFilesCapability;

package/dist/types/local-files/directory-handle-store.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Persistence for the granted directory handle.
+ *
+ * A `FileSystemDirectoryHandle` is structured-cloneable, so IndexedDB keeps the
+ * grant across reloads; without it every refresh would force the user back
+ * through the native picker. IndexedDB can itself be unavailable (a blocked or
+ * partitioned storage context), so every method fails soft — the caller treats
+ * a miss as "ask again", never as an error.
+ */
+export interface DirectoryHandleStore {
+    save(handle: FileSystemDirectoryHandle): Promise<boolean>;
+    load(): Promise<FileSystemDirectoryHandle | undefined>;
+    clear(): Promise<boolean>;
+}
+export declare function createDirectoryHandleStore(idb: IDBFactory, baseUrl: string, pageOrigin: string): DirectoryHandleStore;