@dsh-electron/dsh-plugin-multi-root-workspace 0.1.6 → 0.1.8

package/lib/types/client/files-tree/directory-node.d.ts

@@ -0,0 +1,62 @@
+/** Watch and read ownership for the Files panel's expanded directory tree. */
+import type { DirLevel } from './store.ts';
+/** One open directory and its active child nodes; cached view preferences live in the store. */
+export declare class DirectoryNode {
+    readonly path: string;
+    private readonly load;
+    private readonly watch;
+    private readonly failed;
+    private restore;
+    /** Open direct-child directories, keyed by absolute path. */
+    readonly children: Map<string, DirectoryNode>;
+    private readonly controller;
+    private readonly signal;
+    private task;
+    private reading;
+    private dirty;
+    private initialized;
+    private automatic;
+    constructor(path: string, load: (path: string, signal: AbortSignal) => Promise<DirLevel | undefined>, watch: (path: string, signal: AbortSignal) => AsyncIterable<'ready' | 'change'>, failed: (path: string, error: unknown) => void, lifetime: AbortSignal, restore?: readonly string[]);
+    /**
+     * Start observation once; readiness triggers the initial listing.
+     * @returns this node.
+     */
+    open(): this;
+    /**
+     * Find an active node in this subtree.
+     * @param path - absolute directory path.
+     * @returns the matching node, or undefined when that directory is closed.
+     */
+    find(path: string): DirectoryNode | undefined;
+    /**
+     * Update the expansion preferences used by pending directory listings.
+     * @param expanded - latest expansion preferences from the store.
+     */
+    setExpanded(expanded: readonly string[]): void;
+    /**
+     * Open a direct child using this node's lifetime and automatic-refresh setting.
+     * @param path - absolute direct-child directory path.
+     * @param restore - descendant expansion preferences to restore after listing.
+     * @returns the active child, or undefined after cancellation.
+     */
+    expand(path: string, restore?: readonly string[]): DirectoryNode | undefined;
+    /**
+     * Remove a child and its pending restoration preferences.
+     * @param path - absolute direct-child directory path.
+     * @returns once the child subtree's reads and watches have ended.
+     */
+    collapse(path: string): Promise<void>;
+    /**
+     * Control subtree rereads without ending subscriptions.
+     * @param enabled - refresh dirty nodes automatically.
+     */
+    setAutomatic(enabled: boolean): void;
+    /** Queue a reread, coalescing with active work. @returns completion of the active read and its coalesced rereads. */
+    refresh(): Promise<void>;
+    /** Refresh this node and its open descendants. @returns once their listings settle. */
+    refreshTree(): Promise<void>;
+    /** Cancel the active subtree. @returns once all owned reads and watches have ended. */
+    close(): Promise<void>;
+    private follow;
+    private read;
+}

package/lib/types/client/files-tree/face.d.ts

@@ -0,0 +1,107 @@
+/**
+ * The tree's asynchronous half: listing directories into the store.
+ *
+ * The component never awaits anything. It calls `start` / `refresh` / `toggle`, and
+ * this face performs the listing and writes the outcome through the store's own
+ * actions — the Slot-standard `inject` shape, so the session id is resolved by
+ * the framework and the write set stays the store's.
+ *
+ * The listing itself is bound here to the Client Remote face: the tree keys
+ * every level by absolute path and hands the endpoint that same absolute path;
+ * the endpoint answers with the directory's workspace-relative path as well,
+ * which the tree has no use for and drops.
+ *
+ * One level has one listing in force: asking for a level again — the reload
+ * gesture, a directory reopened after a reset — retires the listing still in
+ * flight for it, whose settlement then writes nothing. Cleanup rides the owner's
+ * `signal`: a request is not made for a record that already ended, and when the
+ * record goes away the bucket and the tab's listing bookkeeping are forgotten,
+ * so no later settlement writes to it.
+ */
+import type { ClientRemote, RemoteResult } from '@deepseek-ai/dsh-api-remotes/client';
+import type { BoundActions } from '@deepseek-ai/dsh-client-store';
+import type { TabId } from '@deepseek-ai/dsh-client-ui-dockkit';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { DirLevel, createFilesStore } from './store.ts';
+/**
+ * Observe one directory without recursively watching its descendants.
+ * @param sessionId - Session owning the directory tree.
+ * @param path - absolute directory path.
+ * @param signal - node lifetime.
+ * @returns readiness and invalidation notifications.
+ */
+export type WatchWorkspaceDirectory = (sessionId: SessionId, path: string, signal: AbortSignal) => AsyncIterable<'ready' | 'change'>;
+/**
+ * Bind directory observation to the Remote stream supervisor.
+ * @param remote - Client Remote with workspace file streams.
+ * @returns a watcher that awaits stream disposal when its node ends.
+ */
+export declare function createWatch(remote: ClientRemote): WatchWorkspaceDirectory;
+/**
+ * One directory listing, bound to a Remote face.
+ *
+ * The session travels with the call because the endpoint resolves the workspace
+ * root from it: the same path means different directories in different sessions.
+ * A Remote call does not reject — the result carries the failure.
+ */
+export type ListWorkspaceDirectory = (sessionId: SessionId, path: string, signal: AbortSignal) => Promise<RemoteResult<DirLevel>>;
+/**
+ * The slice of the Client Remote face this package calls: the `workspaceFiles`
+ * namespace's `list`, exactly as the Host's generated client declares it.
+ */
+export type WorkspaceFilesListRemote = {
+    readonly workspaceFiles: Pick<ClientRemote['workspaceFiles'], 'list'>;
+};
+/**
+ * Bind the listing to one Remote face, keeping only what the tree stores.
+ * @param remote - the Client Remote face carrying the `workspaceFiles` namespace.
+ * @returns the listing the tree's face performs.
+ */
+export declare function createList(remote: WorkspaceFilesListRemote): ListWorkspaceDirectory;
+/**
+ * The absolute path of one child entry.
+ *
+ * Joined with `/` whatever the parent's separators: the Host resolves mixed
+ * separators, and the tree only needs a stable key.
+ * @param parent - absolute path of the listed directory.
+ * @param name - the entry's basename.
+ * @returns the child's absolute path.
+ */
+export declare function childPath(parent: string, name: string): string;
+/** The tree's injected business face, as the body receives it. */
+export interface FilesInjected {
+    /** Refresh the open directory tree. @param tabId - owning tab. */
+    readonly refresh: (tabId: TabId) => void;
+    /** Control automatic rereads without closing watches. @param tabId - owning tab. @param enabled - automatic-refresh setting. */
+    readonly setAutoRefresh: (tabId: TabId, enabled: boolean) => void;
+    /**
+     * Seed this tab's tree and list its root.
+     * @param tabId - the tab being drawn.
+     * @param root - absolute path of the workspace root.
+     * @param signal - the tab record's lifetime.
+     */
+    readonly start: (tabId: TabId, root: string, signal: AbortSignal) => void;
+    /**
+     * List one directory into the store.
+     * @param tabId - the tab being drawn.
+     * @param path - absolute directory path.
+     * @param signal - the tab record's lifetime.
+     */
+    readonly load: (tabId: TabId, path: string, signal: AbortSignal) => void;
+    /**
+     * Open or collapse one directory, retaining intent during ancestor restoration.
+     * @param tabId - the tab being drawn.
+     * @param parentPath - the listed parent directory's exact tree key.
+     * @param path - absolute directory path.
+     * @param expanded - current expansion preferences, including descendants to restore.
+     * @param signal - the tab record's lifetime.
+     */
+    readonly toggle: (tabId: TabId, parentPath: string, path: string, expanded: readonly string[], signal: AbortSignal) => void;
+}
+/**
+ * Bind the tree's face to one directory listing.
+ * @param list - the bound `workspaceFiles.list` call.
+ * @param watch - target-scoped directory observation.
+ * @returns the Slot `inject` factory: session and bound actions in, face out.
+ */
+export declare function filesFace(list: ListWorkspaceDirectory, watch: WatchWorkspaceDirectory): (sessionId: SessionId, actions: BoundActions<ReturnType<typeof createFilesStore>>) => FilesInjected;

package/lib/types/client/files-tree/locales.d.ts

@@ -0,0 +1,10 @@
+/** Dictionary namespace owned by upstream's plugin (verbatim). */
+export declare const NS = "sidebarFiles";
+/** Key domain of the `sidebarFiles` namespace (verbatim union of upstream's zh keys). */
+export type SidebarFilesKey = 'shortcut.noSession' | 'type.label' | 'guide.title' | 'guide.description' | 'loading' | 'empty' | 'truncated' | 'noWorkspace' | 'reload' | 'autoRefresh' | 'autoRefresh.enable' | 'autoRefresh.disable' | 'entry.other' | 'error.notFound' | 'error.outsideWorkspace' | 'error.notDirectory' | 'error.unavailable';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** File-tree type name, guide entry, row states, and failure lines. */
+        sidebarFiles: SidebarFilesKey;
+    }
+}

package/lib/types/client/files-tree/primitives.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Runtime probes for the `@deepseek-ai/dsh-client-ui-primitives` exports the
+ * verbatim Files-tree files spell.
+ *
+ * The upstream imports name the `*Regular` glyph family (0.1.7+; the pixel
+ * names are kept as fallbacks for the same reason `compat/client-icons`
+ * dual-names them) plus `FileTypeIcon` and `classifyFileType`, which every
+ * supported release carries. A named import cannot spell two release eras at
+ * once, so the resolution goes through `maybeIcon`/`maybeComponent` — the
+ * same probe the open-in-app fork uses.
+ *
+ * The exported bindings are typed definite because the adapter mounts the
+ * tree only after {@link filesTreeSurfaceSupported} passes; reaching for a
+ * binding on a composition that failed the gate is a caller bug, and the
+ * gate — not this module — is what a missing export degrades into.
+ *
+ * @module @dsh-electron/dsh-plugin-multi-root-workspace/client/files-tree/primitives
+ */
+import { type PanelIcon } from '../../compat/client-icons.ts';
+/** The upstream types the probed exports spell, kept honest by the type-only import. */
+type Primitives = typeof import('@deepseek-ai/dsh-client-ui-primitives');
+/**
+ * Whether this composition's primitives carry everything the forked rows
+ * spell. The adapter consults this once: `false` means the additional-root
+ * menu stays menu-only and no fork mount is attempted — the same absence
+ * upstream's own no-such-export state would produce.
+ */
+export declare function filesTreeSurfaceSupported(): boolean;
+export declare const IconFolderCloseRegular: PanelIcon;
+export declare const IconFolderOpenRegular: PanelIcon;
+export declare const FileTypeIcon: Primitives["FileTypeIcon"];
+export declare const classifyFileType: Primitives["classifyFileType"];
+export {};

package/lib/types/client/files-tree/store.d.ts

@@ -0,0 +1,81 @@
+/**
+ * The file tree's view state: which directories are expanded, what each
+ * loaded level contains, and where the body is scrolled to.
+ *
+ * The tree is not one resource. A directory listing per level, expanded lazily,
+ * is state the type owns — so it lives in a Slot-standard exclusive store
+ * (one instance per session), bucketed by tab id because two tabs of this kind
+ * in one session expand independently.
+ *
+ * Writers run between `start` and `forget`: the owner's `signal` is what ends a
+ * bucket's life, and the face stops dispatching once it aborts.
+ */
+import { type EngineStoreHandle } from '@deepseek-ai/dsh-client-store';
+import type { RemoteFailure } from '@deepseek-ai/dsh-api-remotes/client';
+import type { TabId } from '@deepseek-ai/dsh-client-ui-dockkit';
+import type { WorkspaceDirectoryEntry } from '@deepseek-ai/dsh-api-workspace-files/types';
+/**
+ * One directory's contents, as one expanded level of the tree.
+ *
+ * The endpoint's listing also names the directory as a workspace-relative path;
+ * the tree keys every level by absolute path instead, so the adapter drops it.
+ */
+export interface DirLevel {
+    /** The directory's entries, in the endpoint's order. */
+    readonly entries: readonly WorkspaceDirectoryEntry[];
+    /** The listing hit the endpoint's entry cap, so entries are missing. */
+    readonly truncated: boolean;
+}
+/** What one directory level is doing right now. */
+export type LevelState = {
+    readonly kind: 'loading';
+} | {
+    readonly kind: 'ready';
+    readonly level: DirLevel;
+    readonly failure?: RemoteFailure;
+} | {
+    readonly kind: 'failed';
+    readonly failure: RemoteFailure;
+};
+/**
+ * One tab's tree: its root, the levels it has asked for, and what is open.
+ *
+ * Every path here is absolute: the root is the session's working directory as
+ * the Host reports it, and a child is the parent joined with the entry name.
+ */
+export interface FilesTabState {
+    autoRefresh: boolean;
+    /** Absolute path of the workspace root this tree is rooted at. */
+    root: string;
+    /** Level state by absolute directory path; a path absent here was never asked for. */
+    levels: Record<string, LevelState>;
+    /** Expanded absolute directory paths, root included. */
+    expanded: string[];
+    /** The body's scroll offset in px, so a remounted tree comes back where the reader was. */
+    scrollTop: number;
+}
+/** Every tab's tree, keyed by tab id. */
+export interface FilesState {
+    byTab: Record<TabId, FilesTabState>;
+}
+/** The tree store's write set; every action names the tab it writes. */
+type FilesActions = {
+    autoRefresh: (draft: FilesState, tabId: TabId, enabled: boolean) => void;
+    start: (draft: FilesState, tabId: TabId, root: string) => void;
+    loading: (draft: FilesState, tabId: TabId, path: string) => void;
+    loaded: (draft: FilesState, tabId: TabId, path: string, level: DirLevel) => void;
+    failed: (draft: FilesState, tabId: TabId, path: string, failure: RemoteFailure) => void;
+    toggled: (draft: FilesState, tabId: TabId, path: string) => void;
+    scrolled: (draft: FilesState, tabId: TabId, scrollTop: number) => void;
+    reset: (draft: FilesState, tabId: TabId) => void;
+    forget: (draft: FilesState, tabId: TabId) => void;
+};
+/**
+ * Declare the file tree's store.
+ *
+ * A factory rather than a shared handle: the registration declares it as an
+ * exclusive store, so the framework mints one instance per session.
+ * @returns the store handle to declare on the registration.
+ */
+export declare function createFilesStore(): EngineStoreHandle<FilesState, FilesActions>;
+export {};

package/lib/types/client/locales.d.ts

@@ -12,13 +12,20 @@
 export declare const NS = "multiRootWorkspace";
 /** Chinese copy (the canonical shape). */
 export declare const zh: {
-    'files.browse': string;
-    'files.reload': string;
-    'files.empty': string;
-    'files.truncated': string;
-    'files.previewTruncated': string;
+    'panel.mode': string;
+    'panel.effectiveAccess': string;
+    'panel.toolCaps': string;
+    'panel.invalidCap': string;
+    'mode.read-only': string;
+    'mode.workspace-write': string;
+    'mode.danger-full-access': string;
+    'effective.read-only': string;
+    'effective.read-write': string;
+    'effective.full-access': string;
+    'effective.unavailable': string;
     'action.label': string;
     'action.title': string;
+    'switcher.manage': string;
     'panel.title': string;
     'panel.subtitle': string;
     'panel.primary': string;
@@ -26,6 +33,7 @@ export declare const zh: {
     'panel.cwd': string;
     'panel.cwdNote': string;
     'panel.additional': string;
+    'panel.limitReached': string;
     'panel.empty': string;
     'panel.emptyHint': string;
     'panel.noSession': string;
@@ -45,8 +53,19 @@ export declare const zh: {
     'panel.copyPath': string;
     'panel.copied': string;
     'panel.reveal': string;
+    'panel.reRegister': string;
     'panel.moveUp': string;
     'panel.moveDown': string;
+    'access.inherit': string;
+    'access.readWrite': string;
+    'access.readOnly': string;
+    'panel.accessLabel': string;
+    'panel.accessInherit': string;
+    'panel.accessReadOnly': string;
+    'panel.accessReadWrite': string;
+    'panel.accessUpgradeConfirm': string;
+    'panel.accessUpgradeTitle': string;
+    'panel.accessUpgradeDo': string;
     'state.available': string;
     'state.missing': string;
     'state.redirected': string;
@@ -63,23 +82,34 @@ export declare const zh: {
     'error.invalid-ref': string;
     'error.storage-unavailable': string;
     'error.registry-contended': string;
+    'error.root-limit-reached': string;
+    'error.config-invalid': string;
+    'error.root-unavailable': string;
     'error.reveal-unavailable': string;
     'error.unavailable': string;
     'error.copy-failed': string;
     'error.session-not-found': string;
+    'error.unsupported-path': string;
     'error.fallback': string;
 };
 /** The canonical key set. */
 export type Key = keyof typeof zh;
 /** English copy, pinned to the Chinese key set. */
 export declare const en: {
-    'files.browse': string;
-    'files.reload': string;
-    'files.empty': string;
-    'files.truncated': string;
-    'files.previewTruncated': string;
+    'panel.mode': string;
+    'panel.effectiveAccess': string;
+    'panel.toolCaps': string;
+    'panel.invalidCap': string;
+    'mode.read-only': string;
+    'mode.workspace-write': string;
+    'mode.danger-full-access': string;
+    'effective.read-only': string;
+    'effective.read-write': string;
+    'effective.full-access': string;
+    'effective.unavailable': string;
     'action.label': string;
     'action.title': string;
+    'switcher.manage': string;
     'panel.title': string;
     'panel.subtitle': string;
     'panel.primary': string;
@@ -87,6 +117,7 @@ export declare const en: {
     'panel.cwd': string;
     'panel.cwdNote': string;
     'panel.additional': string;
+    'panel.limitReached': string;
     'panel.empty': string;
     'panel.emptyHint': string;
     'panel.noSession': string;
@@ -106,8 +137,19 @@ export declare const en: {
     'panel.copyPath': string;
     'panel.copied': string;
     'panel.reveal': string;
+    'panel.reRegister': string;
     'panel.moveUp': string;
     'panel.moveDown': string;
+    'access.inherit': string;
+    'access.readWrite': string;
+    'access.readOnly': string;
+    'panel.accessLabel': string;
+    'panel.accessInherit': string;
+    'panel.accessReadOnly': string;
+    'panel.accessReadWrite': string;
+    'panel.accessUpgradeConfirm': string;
+    'panel.accessUpgradeTitle': string;
+    'panel.accessUpgradeDo': string;
     'state.available': string;
     'state.missing': string;
     'state.redirected': string;
@@ -124,10 +166,14 @@ export declare const en: {
     'error.invalid-ref': string;
     'error.storage-unavailable': string;
     'error.registry-contended': string;
+    'error.root-limit-reached': string;
+    'error.config-invalid': string;
+    'error.root-unavailable': string;
     'error.reveal-unavailable': string;
     'error.unavailable': string;
     'error.copy-failed': string;
     'error.session-not-found': string;
+    'error.unsupported-path': string;
     'error.fallback': string;
 };
 declare module '@deepseek-ai/dsh-client-ui-slots' {

package/lib/types/client/open-in-app/OpenInAppAction.d.ts

@@ -0,0 +1,27 @@
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+import type { InjectFace, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { OpenInAppLaunchState } from './controller.ts';
+import type { ShortcutCatalogEntry } from '@deepseek-ai/dsh-client-shortcuts/client';
+import { NS } from './locales.ts';
+/** Browser operations and state shared by the Session header and file tree contributions. */
+export interface OpenInAppActionInjected {
+    hooks: {
+        openInAppApps: ObservableSnapshot<readonly string[] | null>;
+        openInAppChoice: ObservableSnapshot<string>;
+        openInAppLaunch: ObservableSnapshot<OpenInAppLaunchState>;
+        shortcuts: ObservableSnapshot<readonly ShortcutCatalogEntry[]>;
+    };
+    launch: (appId: string, path: string) => Promise<void>;
+    choose: (appId: string) => void;
+    iconUrl: (appId: string) => string;
+}
+/** Directory path, installed applications, and launch operations for the split button. */
+export type OpenInAppActionProps = PropsLocale<typeof NS> & InjectFace<OpenInAppActionInjected> & {
+    absolutePath: string;
+};
+/**
+ * Adapt the installed directory catalog to the shared opening control.
+ * @param props - displayed directory, installed catalog, and launch operations.
+ * @returns the shared control, or null without an eligible application.
+ */
+export declare function OpenInAppAction(props: OpenInAppActionProps): React.JSX.Element | null;

package/lib/types/client/open-in-app/OpenTargetButton.d.ts

@@ -0,0 +1,52 @@
+import type { ReactNode } from 'react';
+import type { ShortcutCatalogEntry } from '@deepseek-ai/dsh-client-shortcuts/client';
+import type { TranslateNS } from '@deepseek-ai/dsh-client-ui-slots';
+import type { OpenInAppPathFailure } from './open-path.ts';
+import type { NS } from './locales.ts';
+/** Application metadata supplied by either the directory catalog or a file association query. */
+export interface OpenTargetApplication {
+    readonly id: string;
+    readonly name: string;
+    readonly icon: string | null;
+}
+/** Opening intent; default selection remains owned by the target's adapter. */
+export type OpenTargetOperation = {
+    readonly kind: 'default';
+} | {
+    readonly kind: 'application';
+    readonly id: string;
+} | {
+    readonly kind: 'reveal';
+};
+/** Inputs shared by both target adapters and the file empty-state action. */
+export interface OpenTargetButtonProps {
+    readonly shortcut?: Pick<ShortcutCatalogEntry, 'keys' | 'aria'> | undefined;
+    readonly kind: 'file' | 'directory';
+    readonly applications: readonly OpenTargetApplication[];
+    readonly defaultId: string | undefined;
+    readonly failed: boolean;
+    readonly busy?: boolean;
+    readonly loading?: boolean;
+    readonly prominent?: boolean;
+    readonly t: TranslateNS<typeof NS>;
+    readonly execute: (operation: OpenTargetOperation) => Promise<OpenInAppPathFailure | null>;
+    readonly refresh?: () => void;
+}
+/**
+ * Serialize gestures and announce their failures through the initiating control's toast.
+ * @param execute - target adapter that returns the failure to announce, or null.
+ * @param t - localized control copy.
+ * @returns the pending state, feedback, and guarded action callback.
+ */
+export declare function useOpenTargetGesture(execute: OpenTargetButtonProps['execute'], t: TranslateNS<typeof NS>): {
+    pending: boolean;
+    toast: ReactNode;
+    act: (operation: OpenTargetOperation) => void;
+};
+/**
+ * Render identical split buttons for files and directories. File reveal always
+ * stays last; it is the default only when no application is registered.
+ * @param props - target applications, default selection, and operations.
+ * @returns the control and its transient failure feedback.
+ */
+export declare function OpenTargetButton(props: OpenTargetButtonProps): ReactNode;

package/lib/types/client/open-in-app/OpenTargetButton.module.css.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Fork-facing shim for upstream `OpenTargetButton.module.css`.
+ *
+ * This plugin's bundle has no CSS-module pipeline: the `<style>` element it
+ * installs carries one flat sheet (`src/client/styles.ts`). The upstream
+ * component reads `css.<name>` so the forked file needs one importable
+ * module exporting that same key map — this file, reached through the
+ * verbatim `./OpenTargetButton.module.css.ts` specifier (the one sanctioned
+ * fork edit: the specifier gains the `.ts` this toolchain resolves
+ * everywhere — tsc, tsdown, vitest). The specifier text is spelled without
+ * its `import` clause on purpose: the packed-artifact check scans every
+ * bundle comment too, and quoting the full statement would read as a
+ * relative import the tarball does not carry.
+ *
+ * Each upstream local class maps to an `mrfw-open*` name so the copied
+ * rules cannot collide with host DOM; the rules themselves live in
+ * styles.ts verbatim apart from that rename. `data-open-target` and the
+ * other data attributes are literals in the component and stay byte-exact.
+ * See FORK.md.
+ */
+declare const css: {
+    readonly menuAnchor: "mrfw-openMenuAnchor";
+    readonly split: "mrfw-openSplit";
+    readonly main: "mrfw-openMain";
+    readonly chevron: "mrfw-openChevron";
+    readonly appIcon: "mrfw-openAppIcon";
+    readonly skeleton: "mrfw-openSkeleton";
+};
+export default css;

package/lib/types/client/open-in-app/adapter.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The plugin-owned wiring around the verbatim open-in-app fork.
+ *
+ * Upstream builds the same props in its `apply` (`directoryInjected`): one
+ * controller per page, its SnapshotStores bound by the slot renderer into
+ * `use*` props, and a `t` bound to the `open-in-app` namespace. This module
+ * reproduces exactly that — minus slot machinery the fork never sees —
+ * plus the two degradations only a fork needs:
+ *
+ * - the glyph set the fork spells is the `*Regular` family (0.1.7+); a
+ *   pixel-name runtime (0.1.5/0.1.6) leaves the adapter undefined, so the
+ *   header simply keeps the native button, mirroring upstream's own
+ *   "no apps → no button" absence;
+ * - `ctx.locale.bind('open-in-app')` consumes upstream's registered
+ *   dictionary verbatim — same strings, upstream's updates included;
+ * - the icon route comes through `compat/open-in-app-routes`: the `*_ROUTE`
+ *   spelling is another 0.1.7+ name, so the constant is probed by export
+ *   name rather than imported (a pixel-era manifest lacks it entirely —
+ *   a named import would fail the bundle's own build).
+ *
+ * Everything here is ours; nothing in this file needs upstream sync.
+ *
+ * @module @dsh-electron/dsh-plugin-multi-root-workspace/client/open-in-app/adapter
+ */
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+import type { ShortcutCatalogEntry } from '@deepseek-ai/dsh-client-shortcuts/client';
+import { OpenInAppAction, type OpenInAppActionProps } from './OpenInAppAction.tsx';
+import { NS } from './locales.ts';
+/**
+ * The props `OpenInAppAction` consumes, minus the per-render `absolutePath`
+ * the switcher supplies — the shape upstream's `directoryInjected` returns.
+ */
+export type OpenInAppAdapter = Omit<OpenInAppActionProps, 'absolutePath'>;
+/**
+ * Build the open-in-app props upstream hands its own registration.
+ * @param deps - the namespace-bound translate for `open-in-app`, and the
+ *   composition's shortcuts catalog when it exists.
+ * @returns the adapter, or `undefined` when this runtime cannot render the
+ *   fork (pixel-era icon names — the forked files would crash on missing
+ *   exports, so absence mirrors upstream's own no-button path).
+ */
+export declare function createOpenInAppAdapter(deps: {
+    readonly t: (key: string, params?: Record<string, unknown>) => string;
+    readonly shortcuts?: ObservableSnapshot<readonly ShortcutCatalogEntry[]> | undefined;
+}): OpenInAppAdapter | undefined;
+export { OpenInAppAction, NS as OPEN_IN_APP_NS };

package/lib/types/client/open-in-app/applications.d.ts

@@ -0,0 +1,4 @@
+/** Nameable application ids shared by the button and its keyboard command. */
+import type { OpenInAppKey } from './locales.ts';
+/** Label keys for applications supported by this client. */
+export declare const APP_LABEL_KEY: Record<string, OpenInAppKey | undefined>;

package/lib/types/client/open-in-app/controller.d.ts

@@ -0,0 +1,53 @@
+/** Browser availability/choice state and the launch carrier for the split button. */
+import { type SnapshotStore } from '@deepseek-ai/dsh-client-store';
+/** Shared launch status for controls targeting the captured workspace path. */
+export interface OpenInAppLaunchState {
+    readonly phase: 'idle' | 'busy' | 'error';
+    readonly path: string | null;
+}
+type Fetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+/**
+ * Owns the once-per-page availability read, the persisted last choice, and
+ * the launch POST. Availability and choice publish through uSES-safe sources
+ * so every Session header shares one truth.
+ */
+export declare class OpenInAppController {
+    private readonly fetcher;
+    /** Installed app ids in host menu order; null until the host answered. */
+    readonly apps: SnapshotStore<readonly string[] | null>;
+    /** Last chosen app id, or empty before the first choice, shared across sessions and browser restarts. */
+    readonly choice: SnapshotStore<string>;
+    /** Current launch, shared by pointer and keyboard gestures. */
+    readonly operation: SnapshotStore<OpenInAppLaunchState>;
+    /**
+     * Resolve the remembered nameable installed application, with the button's first-app fallback.
+     * @returns the installed app id, or undefined while unavailable.
+     */
+    currentApp(): string | undefined;
+    private loading;
+    /**
+     * @param fetcher - HTTP carrier for the apps read and the launch POST.
+     */
+    constructor(fetcher?: Fetch);
+    /**
+     * Read availability once per controller life; concurrent calls share the read.
+     * A failed read publishes an empty list, which renders no button at all.
+     * @returns after availability is published.
+     */
+    load(): Promise<void>;
+    /**
+     * Remember one picked app id.
+     * @param appId - catalog id from the availability list.
+     */
+    choose(appId: string): void;
+    /**
+     * Launch one installed app on a workspace directory.
+     * @param appId - catalog id from the availability list.
+     * @param path - the session's absolute workspace directory.
+     * Concurrent gestures are ignored until the current Host request settles.
+     * @returns after the host acknowledged the launch; rejects on any failure.
+     */
+    launch(appId: string, path: string): Promise<void>;
+    private run;
+}
+export {};

package/lib/types/client/open-in-app/locales.d.ts

@@ -0,0 +1,10 @@
+/** Dictionary namespace owned by upstream's plugin (verbatim). */
+export declare const NS = "open-in-app";
+/** Key domain of the `open-in-app` namespace (verbatim union of upstream's zh keys). */
+export type OpenInAppKey = 'open.title' | 'path.appDefault' | 'path.appsError' | 'shortcut.busy' | 'shortcut.unavailable' | 'open.tooltip' | 'path.open' | 'path.more' | 'path.reveal' | 'path.openError' | 'path.revealError' | 'app.cursor' | 'app.vscode' | 'app.vscodeinsiders' | 'app.windsurf' | 'app.zed' | 'app.sublimetext' | 'app.xcode' | 'app.androidstudio' | 'app.intellij' | 'app.pycharm' | 'app.webstorm' | 'app.phpstorm' | 'app.goland' | 'app.rider' | 'app.rustrover' | 'app.fork' | 'app.sourcetree' | 'app.github' | 'app.tower' | 'app.gitkraken' | 'app.smartgit' | 'app.sublimemerge' | 'app.ghostty' | 'app.warp' | 'app.iterm' | 'app.kitty' | 'app.terminal' | 'app.windowsterminal' | 'app.gitbash' | 'app.gnometerminal' | 'app.konsole' | 'app.finder' | 'app.explorer' | 'app.filemanager';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Session-header "open workspace in application" copy (upstream declaration). */
+        'open-in-app': OpenInAppKey;
+    }
+}