dsh-coding-sidebar 1.0.0

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

@@ -0,0 +1,12 @@
+import type { MermaidMarkdownProps } from './mermaid-blocks.ts';
+/**
+ * The chunk-resident markdown preview renderer: ONE MarkdownText pass over
+ * the full source (cross-fence reference/footnote/list semantics intact),
+ * then every rendered `language-mermaid` code block is swapped for a
+ * `MermaidDiagram`. The `.md-code-block` host stays in the React tree —
+ * only its children are replaced — so reconciliation never loses the host;
+ * a block that stops being a mermaid fence gets its original children back.
+ * Only mounted when the source contains at least one mermaid fence (see
+ * TextEditor.tsx).
+ */
+export declare function MermaidMarkdown({ text, codeLabels }: MermaidMarkdownProps): React.ReactNode;

package/lib/types/client/open-when-sized.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Deferred one-shot open for hosts that may not have a real size yet.
+ *
+ * xterm's `Terminal.open()` must not run in a zero-size container: the
+ * renderer creation fails there (the DomRenderer is built from the host's
+ * dimensions), leaving the render service's renderer `undefined`, and the
+ * next Viewport refresh crashes reading `.dimensions` off it. WebKit-based
+ * hosts (WKWebView) reliably report zero while the bottom panel's expand
+ * slide is in flight; any `display:none`-hidden ancestor does the same.
+ *
+ * The caller's `open` callback (open + fit + resize) is invoked exactly
+ * once, on the first frame where the host reports a real size. While the
+ * host stays zero-sized the polling continues every frame; it stops when
+ * the host leaves the document (`isConnected`), so a pending open never
+ * fires after unmount. The returned cancel function drops a pending frame
+ * immediately (idempotent).
+ *
+ * `raf`/`caf` are injectable so tests can drive the polling deterministically.
+ */
+export declare function openWhenSized(host: HTMLElement, open: () => void, raf?: (cb: FrameRequestCallback) => number, caf?: (id: number) => void): () => void;

package/lib/types/client/open-with-settings.d.ts

@@ -0,0 +1,4 @@
+export declare function OpenWithSettings(props: {
+    pluginSettings: Record<string, unknown>;
+    updatePluginSetting: (key: string, value: unknown) => void;
+}): import("react").JSX.Element;

package/lib/types/client/open-with.d.ts

@@ -0,0 +1,87 @@
+/**
+ * The file tree's "open with" vocabulary: which external editors / file
+ * managers the context menu can hand a row's path to, how the per-user
+ * configuration (custom editors, SSH host, pinned ids) is parsed out of the
+ * persisted blob, and how the external URL is built (local `file` URLs and
+ * VSCode-family SSH-remote URLs).
+ *
+ * Pure by design (no React / no `api`), so the whole surface is unit-testable
+ * without a DOM or a host route. The menu and the settings panel only consume
+ * the exported types and functions.
+ */
+import type { CopyKey } from './locales.ts';
+/** One user-configured editor (persisted in `pluginSettings['editor'].openWith`). */
+export interface CustomEditor {
+    id: string;
+    /** Human label shown in the menu (e.g. "Windsurf"). */
+    name: string;
+    /** URL template with a `{path}` placeholder (e.g. `cursor://file/{path}`). */
+    urlTemplate: string;
+    /** Whether the editor speaks the VSCode URL dialect — the only editors
+     *  with an SSH-remote form (`<scheme>://vscode-remote/ssh-remote+<host>/…`). */
+    isVscodeFamily: boolean;
+}
+/** The per-user "open with" configuration (one key of the editor blob). */
+export interface OpenWithConfig {
+    /** SSH host (user@host or an ~/.ssh/config alias); '' = local workspace. */
+    sshHost: string;
+    /** User-defined editors, appended after the built-ins. */
+    customEditors: CustomEditor[];
+    /** Ids of open-with targets pinned to the menu's top level
+     *  ('explorer' | 'vscode' | 'cursor' | 'zed' | 'custom:<id>'). */
+    pinned: string[];
+}
+/** One menu-visible open target (built-in or custom, SSH-filtered). */
+export interface OpenWithTarget {
+    /** Stable id (`explorer` / `vscode` / `cursor` / `zed` / `custom:<id>`). */
+    id: string;
+    /** Locale key of a built-in label (custom editors carry `name` instead). */
+    nameKey?: CopyKey;
+    /** User-defined label (custom editors only; '' for built-ins). */
+    name: string;
+    /** 'reveal' = show in the OS file manager; 'url' = open a URL. */
+    kind: 'reveal' | 'url';
+    /** URL template with `{path}`; undefined for reveal targets. */
+    urlTemplate?: string;
+    /** Whether the editor talks the VSCode URL dialect. */
+    isVscodeFamily: boolean;
+    /** Hidden in SSH mode (a host-local opener cannot reach a remote path). */
+    localOnly: boolean;
+}
+/** The default open-with configuration (fresh documents). */
+export declare const OPEN_WITH_DEFAULTS: OpenWithConfig;
+/** The built-in open targets, in menu order. */
+export declare const OPEN_WITH_BUILTINS: readonly OpenWithTarget[];
+/**
+ * Parse the persisted `openWith` blob (tolerant): malformed fields fall back
+ * to the defaults, malformed custom-editor rows are dropped, and pinned ids
+ * are kept verbatim (unknown ids are pruned when the targets are resolved —
+ * the menu is the only consumer of the resolved list).
+ */
+export declare function parseOpenWithConfig(raw: unknown): OpenWithConfig;
+/**
+ * The menu-visible open targets, in order (built-ins then custom editors).
+ * In SSH mode the local-only targets (the OS file manager, Zed, custom
+ * editors without the VSCode dialect) are dropped — they cannot reach a
+ * remote path. Unknown pinned ids are pruned here too.
+ */
+export declare function resolveOpenWithTargets(config: OpenWithConfig): OpenWithTarget[];
+/** The SSH hint appended to a target's label in remote mode. */
+export declare function openWithSshActive(config: OpenWithConfig): boolean;
+/**
+ * The URL to open for one resolved target, or undefined when the target has
+ * no URL form (reveal) or the template is malformed. The path is inserted
+ * RAW into the template (browsers percent-encode as needed; VSCode-family
+ * URL parsers consume the absolute path with its leading slash, e.g.
+ * `vscode://file//home/u/f.ts` or `vscode://file/C:/Users/u/f.ts`).
+ */
+export declare function openWithUrl(target: OpenWithTarget, path: string, config: OpenWithConfig): string | undefined;
+/** Normalize a filesystem path for embedding in a URL (backslashes → '/'). */
+export declare function normalizeUrlPath(path: string): string;
+/** A fresh custom-editor id (uuid when available, time-based fallback). */
+export declare function newCustomEditorId(): string;
+/** Validate one custom-editor row before the settings panel accepts it. */
+export declare function isValidCustomEditor(row: {
+    name: string;
+    urlTemplate: string;
+}): boolean;

package/lib/types/client/openpath-intercept.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Interception of the chat's file-open funnel. Two doors have carried every
+ * chat-side file open (tool-row path links, the produced-files row, and prose
+ * file mentions alike):
+ *
+ * - `ctx.workspaces.openPath` — the pre-0.1.2 funnel; ui-chat's apply.ts was
+ *   its only production caller. Wrapped by {@link wrapOpenPath}.
+ * - `ctx.remote.session.openWorkspacePath` — the 0.1.2-alpha.1 funnel (the
+ *   unary Remote-namespace migration rewired apply.ts to call the RPC
+ *   directly and stopped calling `workspaces.openPath` altogether, leaving
+ *   that door dead). Wrapped by {@link wrapRemoteOpenPath}.
+ *
+ * Both wrappers reroute opens into the sidebar editor instead of the Host
+ * OS — no DSH modification needed. They are installed together: each door is
+ * wrapped only when it exists on the runtime, so one build covers baselines
+ * on either side of the migration (and a baseline that still routes through
+ * the old door stays intercepted).
+ *
+ * The wrappers are dependency-free by design (no React / ui-primitives), so
+ * the takeover logic is unit-testable and the file stays importable from the
+ * test runtime.
+ */
+/** The one service method the wrapper replaces (mirror of the runtime IWorkspaces). */
+export interface OpenPathService {
+    openPath(path: string): Promise<void>;
+}
+/** Per-call decisions the wrapper needs (wired to the store + ctx in the client half). */
+export interface OpenPathInterceptDeps {
+    /**
+     * Whether to take over this call: the `interceptOpenPath` pref AND the
+     * editor tab's own enable switch must both be on (an editor that cannot
+     * open must not swallow opens — they fall through to the Host).
+     */
+    takeoverEnabled(): boolean;
+    /** The session whose scope the sidebar editor loads the file in (current session). */
+    currentSessionId(): string | undefined;
+    /** Route the open into the sidebar editor (the established openSidebarFile). */
+    openInSidebar(path: string, sessionId: string): void;
+    /** Route a folder-reveal gesture ("Show in folder" passes '.') into the sidebar explorer. */
+    revealInExplorer(path: string, sessionId: string): void;
+}
+/** The Remote session namespace face the new funnel is wrapped through. */
+export interface RemoteSessionStub {
+    openWorkspacePath(request: {
+        path: string;
+    }): Promise<unknown>;
+}
+/**
+ * Whether a path is the "Show in folder" folder-reveal gesture. The stock
+ * ui-deliverables row passes `'.'` (the session workspace root, resolved by
+ * the chat view to `"<cwd>/."`); any path whose final segment is `.` is the
+ * same gesture. A directory has no editor content, so these opens must reach
+ * the explorer instead of an editor tab.
+ */
+export declare function isFolderRevealPath(path: string): boolean;
+/**
+ * Wrap `workspaces.openPath`: intercepted calls open the file in the sidebar
+ * editor instead of the Host OS and resolve as success (the original's
+ * callers ignore the result); anything that declines falls through to the
+ * original method untouched. The one exception is the folder-reveal gesture,
+ * which is routed to {@link OpenPathInterceptDeps.revealInExplorer} instead.
+ * @param workspaces - the client workspaces service to wrap.
+ * @param deps - per-call takeover decisions.
+ * @returns the disposer restoring the original method (HMR-safe).
+ */
+export declare function wrapOpenPath(workspaces: OpenPathService, deps: OpenPathInterceptDeps): () => void;
+/**
+ * Wrap `session.openWorkspacePath` — the post-migration funnel — to the same
+ * takeover semantics as {@link wrapOpenPath}: intercepted opens land in the
+ * sidebar editor (folder reveals in the explorer) and resolve with the RPC
+ * success envelope, declined opens reach the untouched original.
+ *
+ * The namespace service installs each method as a configurable getter (the
+ * upstream gateway re-reads its method table on every access), so the raw
+ * property descriptor is captured and re-defined rather than assigned: the
+ * wrapped getter re-reads the ORIGINAL descriptor each call, meaning a
+ * remount that swaps the underlying method is picked up transparently, and
+ * the disposer restores the exact original descriptor (a chain of wrappers
+ * from other plugins keeps working across disposals in any order).
+ * @param session - the Remote session namespace to wrap.
+ * @param deps - per-call takeover decisions (same face as the old door).
+ * @returns the disposer restoring the original descriptor (HMR-safe); a
+ *   no-op when the method is absent (pre-carrier baseline).
+ */
+export declare function wrapRemoteOpenPath(session: RemoteSessionStub, deps: OpenPathInterceptDeps): () => void;

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

@@ -0,0 +1,43 @@
+/**
+ * Path projection helpers shared by the explorer rows: a path relative to
+ * the session cwd (for the @-reference button and "copy relative path").
+ * The fs-tree joins with '/' even on Windows, so both separators normalize
+ * to '/' before comparison.
+ *
+ * This module is dependency-free (no node:path in the client bundle): the
+ * host is the authority for path semantics, so this mirror deliberately
+ * accepts a SUPERSET of absolute forms — anything a Windows host would emit
+ * (drive letters, UNC) plus POSIX roots. A form the host would reject
+ * (e.g. a backslash UNC path on a POSIX host) passes through here and then
+ * fails loudly in the host's requireAbsolute instead of being silently
+ * joined onto the cwd.
+ */
+/**
+ * Mirror of the host's absolute-path notion (see fs-tree.requireAbsolute):
+ * POSIX roots, Windows drive letters, and Windows UNC network shares in
+ * both backslash (`\\server\share\...`) and forward-slash
+ * (`//server/share/...`) form. Deliberately a superset — see the module
+ * comment — so a produced UNC path is never joined onto the cwd.
+ */
+export declare function isAbsolutePath(path: string): boolean;
+/**
+ * The path relative to the session's working directory.
+ * @param cwd - the explorer root (absolute).
+ * @param path - an absolute entry path from the fs-tree.
+ * @returns the relative path with '/' separators ('.' for the cwd itself),
+ * or `path` unchanged when it lies outside the cwd.
+ *
+ * The prefix test is case-insensitive: Windows paths (and macOS's
+ * case-insensitive volumes) may arrive with different casing than the cwd
+ * row, and the containment decision must not depend on it. The returned
+ * relative text keeps the caller's own casing.
+ */
+export declare function relativeTo(cwd: string, path: string): string;
+/**
+ * Whether `target` lies under `base` (or equals it), tolerant of separator
+ * style and — on Windows-style drive paths — of letter case. A client-side
+ * mirror of the host's `isWithin` (fs-tree.ts) used to decide whether a
+ * git-derived path can be opened in the editor (a linked worktree outside
+ * the session workspace cannot: the host's workspace fence would reject it).
+ */
+export declare function isWithinWorkspace(base: string, target: string): boolean;

package/lib/types/client/pdf-types.d.ts

@@ -0,0 +1,2 @@
+/** Pure PDF extension dispatch, separate from React for unit testing. */
+export declare function isPdfExt(ext: string): boolean;

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

@@ -0,0 +1,86 @@
+/**
+ * Cross-session pinned-terminal resolution (v0.17.0+).
+ *
+ * A pinned terminal tab lives in its HOME session's state (the only
+ * authoritative copy) — switching sessions never copies or projects it.
+ * The viewer session's TabBar renders the tabs OTHER sessions have pinned
+ * as VIRTUAL tabs appended to the first leaf's tab list, so the user sees
+ * them inline with their own tabs. Clicking a virtual tab activates it
+ * in-place: TerminalView connects to the home session's PTY via WebSocket
+ * (sessionId + tab query params resolve to the home PTY on the host side),
+ * so the terminal renders in the current workbench without jumping sessions.
+ *
+ * Visibility rule:
+ *
+ * | pin.scope | visible when |
+ * |-----------|--------------|
+ * | `global`  | any session (cwd-independent) |
+ * | `workspace` | `viewer.cwd === tab.pin.homeCwd` (both undefined match; viewer.cwd unknown → conservative visible) |
+ *
+ * The "viewer.cwd unknown → visible" branch is intentional: during
+ * hydration the session summary may carry no cwd yet, and hiding pinned
+ * workspace tabs on first paint would flash them away. Once the cwd
+ * resolves, the next store notify re-runs the resolver with the real cwd.
+ *
+ * The viewer's OWN session is excluded: its pinned tabs are already on its
+ * own tab strip, so rendering them again as virtual tabs would double-show.
+ * Tabs whose `pin` field is missing or whose `type` is not `'terminal'` are
+ * ignored — only terminal tabs can be pinned.
+ */
+import type { SidebarState, SidebarTab, SplitNode } from './state.ts';
+/** A pinned terminal surfaced to the viewer, paired with its home session. */
+export interface PinnedTabEntry {
+    tab: SidebarTab;
+    homeSessionId: string;
+}
+/** A viewer's session identity for visibility resolution. */
+export interface PinnedViewer {
+    sessionId: string;
+    cwd: string | undefined;
+}
+/** The home-session scope stored on a pinned virtual tab's meta, so
+ *  TerminalView connects to the home session's PTY (not the viewer's). */
+export interface PinnedHomeScope {
+    sessionId: string;
+    cwd: string | undefined;
+    /** The original tab id in the home session (TerminalView's `tab` param). */
+    tabId: string;
+}
+/** Whether a tab id is a pinned virtual id (prefixed). */
+export declare function isPinnedVirtualId(tabId: string): boolean;
+/** Parse a pinned virtual id into its home session id and original tab id.
+ *  Format: `pinned:<homeSessionId>:<originalTabId>` — session ids are UUIDs
+ *  (no colons), so the first colon after the prefix delimits the session. */
+export declare function parsePinnedVirtualId(tabId: string): {
+    homeSessionId: string;
+    tabId: string;
+};
+/** Extract the home scope from a pinned virtual tab's meta (undefined for
+ *  regular tabs). */
+export declare function getPinnedHomeScope(tab: SidebarTab): PinnedHomeScope | undefined;
+/** Whether a tab is a pinned virtual tab (injected from another session). */
+export declare function isPinnedVirtualTab(tab: SidebarTab): boolean;
+/** Create a virtual SidebarTab for a pinned entry. The virtual id is unique
+ *  (prefixed with home session) to avoid collision with the viewer's own
+ *  tab ids; the original id is stored in meta for TerminalView. */
+export declare function createPinnedVirtualTab(entry: PinnedTabEntry): SidebarTab;
+/** Inject pinned virtual tabs into the first leaf of a split tree, and
+ *  override that leaf's `active` when a pinned tab is activated. Returns
+ *  the original tree when there are no pinned tabs and no active override. */
+export declare function injectPinnedIntoTree(tree: SplitNode, pinned: readonly SidebarTab[], activePinnedId: string | null): SplitNode;
+/**
+ * Whether a pinned tab is visible to the viewer session. Conservative on
+ * unknown cwd: a `workspace` pin with no `homeCwd` is visible everywhere
+ * (the pin was set before the home session's cwd resolved), and a viewer
+ * whose cwd is unknown sees every workspace pin (avoids hydration flash).
+ */
+export declare function pinnedVisibleTo(tab: SidebarTab, viewer: PinnedViewer): boolean;
+/**
+ * Collect every pinned terminal visible to the viewer across ALL cached
+ * session states. Excludes the viewer's own session (those tabs are on its
+ * own strip). Order is stable: sessions in the cache's insertion order,
+ * tabs in tree order (splits → floats) within each session
+ * — the order tabs were opened/pinned, so the rail never reorders between
+ * renders.
+ */
+export declare function collectPinnedTabs(bySession: ReadonlyMap<string, SidebarState>, viewer: PinnedViewer): PinnedTabEntry[];

package/lib/types/client/plugin-settings.d.ts

@@ -0,0 +1,8 @@
+import type { SidebarStore } from './state.ts';
+/**
+ * Merge one plugin-owned settings blob of one descriptor and persist it.
+ * @param store - the sidebar store (its prefs are replaced by the write result).
+ * @param descriptorId - the descriptor whose blob is patched ('editor' here).
+ * @param updater - pure patch function; receives a shallow copy of the blob.
+ */
+export declare function updatePluginSettings(store: SidebarStore, descriptorId: string, updater: (blob: Record<string, unknown>) => Record<string, unknown>): void;

package/lib/types/client/plugins-shared.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared vocabulary of the recommended plugin catalogs: the entry shape and
+ * the GitHub topic URL. The two catalogs live in sibling modules —
+ * `plugins-tabs.ts` (tab registrations) and `plugins-viewers.ts` (file
+ * previewer registrations) — and are shown in the two "add plugin" modals
+ * (Side card settings → the dashed cards at the end of the 侧边栏内容 /
+ * 文件预览 grids).
+ */
+/** The GitHub topic page listing every repo tagged `dsh-coding-sidebar`. */
+export declare const PLUGIN_TOPIC_URL = "https://github.com/topics/dsh-coding-sidebar";
+/** One curated plugin entry (name / url / description / install script). */
+export interface PluginEntry {
+    /** Unique id (the npm package name). */
+    id: string;
+    /** Short display name. */
+    name: string;
+    /** GitHub repository URL. */
+    url: string;
+    /** One-line description (i18n friendly: string or () => string). */
+    description: string | (() => string);
+    /** Optional catalog group heading (i18n friendly); entries without one
+     *  render under the plain list (a flat catalog stays flat). */
+    category?: string | (() => string);
+    /** The full shell command pre-filled into the install terminal (not
+     *  executed until the user presses Enter). */
+    install: string;
+}

package/lib/types/client/plugins-tabs.d.ts

@@ -0,0 +1,3 @@
+import type { PluginEntry } from './plugins-shared.ts';
+/** Tab-registration plugins (alphabetical order). */
+export declare const builtinTabPlugins: readonly PluginEntry[];

package/lib/types/client/plugins-viewers.d.ts

@@ -0,0 +1,3 @@
+import type { PluginEntry } from './plugins-shared.ts';
+/** File-previewer plugins (alphabetical order). */
+export declare const builtinViewerPlugins: readonly PluginEntry[];

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

@@ -0,0 +1,41 @@
+/**
+ * Client-side read of the user-facing "Side card" preferences. The host owns
+ * the namespace through the settings seam (in-process); the DSH settings RPC
+ * domain only serves allowlisted namespaces to configuration clients, so the
+ * client reads and writes THIS namespace through the plugin's own fenced
+ * /sidebar routes instead (api.settingsGet/settingsUpdate). Any failure
+ * (route rejected, namespace absent, a field of the wrong type, a value out
+ * of the contract range) falls back to the schema defaults — the side card
+ * must keep working exactly as composed when the settings surface is missing.
+ */
+import type { api } from './api.ts';
+import { clampTerminalFontSize, clampTitleBarStrip, clampWidthPercent, SIDEBAR_PREFS_DEFAULTS, TITLE_BAR_SCHEMES, TITLE_BAR_STRIP_DEFAULT, type SidebarPrefs, type TitleBarScheme } from '../prefs-shared.ts';
+export { SIDEBAR_PREFS_DEFAULTS, TITLE_BAR_SCHEMES, TITLE_BAR_STRIP_DEFAULT, clampTerminalFontSize, clampTitleBarStrip, clampWidthPercent, };
+export type { SidebarPrefs, TitleBarScheme };
+/** The settings wire face the preferences need (a subset of the plugin api). */
+export type SidebarSettingsClient = Pick<typeof api, 'settingsGet' | 'settingsUpdate'>;
+/** Validate one raw resolved value into {@link SidebarPrefs}. Used for the
+ * settings.get payload AND the settings.update response (both carry the
+ * layered resolved value); any malformed field falls back to its default.
+ * @param value - the raw resolved section from the settings wire.
+ * @returns validated prefs (always well-formed).
+ */
+export declare function parsePrefs(value: unknown): SidebarPrefs;
+/**
+ * Read the resolved side card preferences through the plugin's settings route.
+ * @param settings - the settings wire face (the plugin api by default).
+ * @returns validated prefs, or the schema defaults when the route rejects,
+ * the namespace is absent, or a stored value violates the contract.
+ */
+export declare function loadPrefs(settings: SidebarSettingsClient): Promise<SidebarPrefs>;
+/**
+ * Read the external-disable flag from the same settings route: the
+ * dsh-web-ui family's aionui-panel provider choice. True only when the host
+ * resolved `aionui-panel.rightPanel` to 'aionui-panel' — while true the
+ * sidebar must not mount (the two right panels are mutually exclusive). Any
+ * failure (route rejected, aionui absent, malformed response) reads false,
+ * so a missing family never hides the sidebar.
+ * @param settings - the settings wire face (the plugin api by default).
+ * @returns the external-disable flag (false on any failure).
+ */
+export declare function loadExternalDisable(settings: SidebarSettingsClient): Promise<boolean>;

package/lib/types/client/produced-files.d.ts

@@ -0,0 +1,29 @@
+/** Paths a tool-result view reports as produced, by render intent. */
+export declare function producedPaths(view: unknown): readonly string[];
+/**
+ * Files produced by the turn the assistant at `seq` closes. Accumulation
+ * resets on turn boundaries (a user message, or a node reporting a different
+ * turn number); paths keep first-seen order and appear once.
+ * @param nodes - snapshot nodes in surface order (structural, unknown-safe).
+ * @param seq - the closing assistant's seq (the render site's anchor).
+ * @returns produced paths; empty when the turn wrote nothing.
+ */
+export declare function producedForClosing(nodes: readonly unknown[], seq: number): readonly string[];
+/**
+ * Claim the turn-tail chain only when the closing turn produced files.
+ *
+ * The authoritative source is the engine Turn data — the same value
+ * ui-deliverables reads (`owner.turn.data.get('deliverables')`): a
+ * `{ produced: [{ seq, path }, ...] }` record accumulated per Turn. The
+ * node-based replica below stays as a fallback for compositions that do not
+ * publish it.
+ * @param owner - the turn-tail owner currency ({turn, seq, openFile}).
+ * @returns produced paths as the matched value, or null to decline.
+ */
+export declare function selectProducedFiles(owner: unknown): readonly string[] | null;
+/**
+ * Resolve a (possibly relative) path against the session cwd for the sidebar.
+ * Absolute detection mirrors the host (see client/paths.isAbsolutePath):
+ * POSIX roots, drive letters and UNC shares must not be joined onto the cwd.
+ */
+export declare function resolveSidebarPath(cwd: string | undefined, path: string): string;

package/lib/types/client/selection-payload.d.ts

@@ -0,0 +1,27 @@
+/** Max inserted selection length (UTF-16 code units, i.e. JS `.length`). */
+export declare const SELECTION_LIMIT = 500;
+/** The source line span a selection maps to (1-based, inclusive). */
+export interface SelectionLines {
+    start: number;
+    end: number;
+}
+/**
+ * The fence info line: `rel[:start[-end]]` — lines are omitted entirely
+ * when unknown (the preview reverse-search missed).
+ */
+export declare function headerOf(path: string, cwd: string | undefined, lines?: SelectionLines): string;
+/**
+ * The full text appended to the composer draft for one selection.
+ * Over the limit the content is dropped: the plain path line is the whole
+ * payload (an empty fenced block would just occupy the draft).
+ */
+export declare function buildSelectionInsert(path: string, cwd: string | undefined, lines: SelectionLines | undefined, selected: string): string;
+/**
+ * Reverse-map a rendered-DOM selection back to source line numbers. The
+ * preview selection is plain text (block boundaries come out as `\n`), so
+ * this is a best-effort substring search: a single trailing newline is
+ * stripped first (DOM block selections tend to carry one), and only an
+ * EXACTLY-ONE occurrence yields lines — an ambiguous or missing match
+ * returns null (the header then carries the path without line numbers).
+ */
+export declare function linesOfSelection(source: string, selected: string): SelectionLines | null;