@qilin-agent/client-ui-sidebar-files 0.0.0-stage → 3.1.4

package/lib/index.js

@@ -0,0 +1,6 @@
+//#region lib/types/index.js
+/** Pure host half; the whole tab type lives in the browser export. */
+/** Host plugin body: the file tree contributes nothing to the host tree. */
+function apply() {}
+//#endregion
+export { apply };

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

@@ -0,0 +1,11 @@
+import type { ReactNode } from 'react';
+import type { PropsLocale, PropsRuntime, PropsStore } from '@qilin-agent/client-ui-slots';
+import type { FilesInjected } from './face.ts';
+import type { FileEditorInjected } from './file-face.ts';
+import type { FilePreviewInjected } from './file-preview.ts';
+import type { createFilesStore } from './store.ts';
+/** The body's composed props: the tab it draws, its store, its faces, and its copy. */
+export type FileBodyProps = PropsRuntime<'sidebar.right.pane.tab'> & PropsStore<ReturnType<typeof createFilesStore>> & FilesInjected & FileEditorInjected & FilePreviewInjected & PropsLocale<'sidebarFiles'>;
+/** The file editor's body: the tree pane and the open file's editor pane. */
+export declare function FileBody({ useTabInfo, sessionId, useSessions, useStore, actions, start, toggle, createEntry, renameEntry, removeEntry, readFile, saveFile, openPreview, t, }: FileBodyProps): ReactNode;
+//# sourceMappingURL=FileBody.d.ts.map

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

@@ -0,0 +1,33 @@
+/**
+ * The filename search beside the tree: the box in the pane's header strip and
+ * the matches it returns, drawn in the tree's place while a query stands.
+ *
+ * Both halves are pure props: the box reports keystrokes and the results report
+ * a click, and the body owns what either means. Paths here are the Host's
+ * workspace-relative matches, split for display only.
+ */
+import type { ReactNode } from 'react';
+import type { TranslateNS } from '@qilin-agent/client-locale/client';
+import type { FileSearchState } from './store.ts';
+/**
+ * The search box.
+ * @param props - the box's text, the two gestures, and its copy.
+ * @returns the input row.
+ */
+export declare function FileSearchBox(props: {
+    readonly query: string;
+    readonly onQuery: (query: string) => void;
+    readonly onClear: () => void;
+    readonly t: TranslateNS<'sidebarFiles'>;
+}): ReactNode;
+/**
+ * The matches, or one line naming why there are none.
+ * @param props - the search's state, the open gesture, and its copy.
+ * @returns the rows of the results list.
+ */
+export declare function FileSearchResults(props: {
+    readonly state: FileSearchState;
+    readonly onOpen: (path: string) => void;
+    readonly t: TranslateNS<'sidebarFiles'>;
+}): ReactNode;
+//# sourceMappingURL=FileSearch.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * The `file` type's chip title: the open file's type sheet before its basename.
+ * Registered under `sidebar.right.pane.tab.title`. The glyph classifies the
+ * captured title — the address's decoded basename — so each file carries its
+ * own sheet, which is why the type declares no static `icon`.
+ */
+import type { ReactNode } from 'react';
+import type { PropsRuntime } from '@qilin-agent/client-ui-slots';
+/**
+ * The title as the chip and a floating panel's header show it.
+ * @param props - the tab information hook.
+ * @returns the file's type sheet followed by its basename.
+ */
+export declare function FileTitle({ useTabInfo }: PropsRuntime<'sidebar.right.pane.tab.title'>): ReactNode;
+//# sourceMappingURL=FileTitle.d.ts.map

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

@@ -0,0 +1,48 @@
+import type { ReactNode } from 'react';
+import type { RemoteFailure } from '@qilin-agent/api-remotes/client';
+import type { TranslateNS } from '@qilin-agent/client-locale/client';
+import type { WorkspaceDirectoryEntry } from '@qilin-agent/api-workspace-files/types';
+import type { EntryKind } from './file-mutations.ts';
+import type { FilesTabState } from './store.ts';
+/**
+ * Order one level's entries for display: directories first, then everything
+ * else, each group by name. The endpoint's order is a listing fact; this is the
+ * reader's.
+ * @param entries - the listing as the endpoint returned it.
+ * @returns a new array, directories first, then by name within each group.
+ */
+export declare function orderEntries(entries: readonly WorkspaceDirectoryEntry[]): WorkspaceDirectoryEntry[];
+/**
+ * Say why a directory could not be listed, in terms of the directory.
+ * @param t - namespace-bound translate.
+ * @param failure - the settled Remote failure.
+ * @returns the line to show under the directory.
+ */
+export declare function failureLine(t: TranslateNS<'sidebarFiles'>, failure: RemoteFailure): string;
+/**
+ * The text one row's menu copies.
+ * @param root - the workspace root, the prefix relative paths drop.
+ * @param path - the row's absolute path.
+ * @param form - whether the copy keeps or drops the root prefix.
+ * @returns `.` for the root itself, the suffix after the root's `/` when under
+ * it, and the absolute path for a tree rooted somewhere neither covers.
+ */
+export declare function copyTextOf(root: string, path: string, form: 'relative' | 'absolute'): string;
+/**
+ * The tree itself: the root level, whatever the reader has opened under it, and
+ * the one context menu its rows and its background share.
+ * @param props - the tab's tree state, its gestures, its copy, and the row
+ * mutations it dispatches.
+ * @returns the root level's rows, with the menu and both dialogs in portals.
+ */
+export declare function FileTree(props: {
+    readonly state: FilesTabState;
+    readonly onToggle: (path: string) => void;
+    readonly onOpen: (path: string) => void;
+    readonly onCreate: (directory: string, name: string, kind: EntryKind) => void;
+    readonly onRename: (path: string, name: string) => void;
+    readonly onDelete: (path: string, kind: EntryKind) => void;
+    readonly onDismissMutation: () => void;
+    readonly t: TranslateNS<'sidebarFiles'>;
+}): ReactNode;
+//# sourceMappingURL=FileTree.d.ts.map

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

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+import type { FilesInjected } from './face.ts';
+import type { PropsLocale, PropsRenderSlots, PropsRuntime, PropsStore } from '@qilin-agent/client-ui-slots';
+import type { createFilesStore } from './store.ts';
+/** The body's composed props: the tab it draws, its store, its face, and its copy. */
+export type FilesBodyProps = PropsRuntime<'sidebar.right.pane.tab'> & PropsStore<ReturnType<typeof createFilesStore>> & FilesInjected & PropsLocale<'sidebarFiles'> & PropsRenderSlots<'sidebar.right.tab.files.actions'>;
+/** The file tree's body: the workspace root and whatever the reader has opened under it. */
+export declare function FilesBody({ useTabInfo, sessionId, useSessions, useStore, actions, start, load, toggle, search, createEntry, renameEntry, removeEntry, t, renderSlot, }: FilesBodyProps): ReactNode;
+//# sourceMappingURL=FilesBody.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * The files type's chip title: the folder sheet before the type's label.
+ * Registered under `sidebar.right.pane.tab.title`; without it the chip would
+ * show the bare label. The tree in the body draws its own row glyphs and never
+ * this one.
+ */
+import type { ReactNode } from 'react';
+import type { PropsRuntime } from '@qilin-agent/client-ui-slots';
+/**
+ * The title as the chip and a floating panel's header show it.
+ * @param props - the tab information hook.
+ * @returns the folder sheet followed by the tab's title text.
+ */
+export declare function FilesTitle({ useTabInfo }: PropsRuntime<'sidebar.right.pane.tab.title'>): ReactNode;
+//# sourceMappingURL=FilesTitle.d.ts.map

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

@@ -0,0 +1,25 @@
+/**
+ * Upload overlay for the files page: a drag-and-drop target over the file
+ * tree that PUTs each dropped file to the preview-media upload route,
+ * relative to the tree's displayed root. The tree reloads on success.
+ */
+import { type ReactNode } from 'react';
+/** Props: the session and root the upload resolves against, plus reload. */
+export interface UploadOverlayProps {
+    readonly sessionId: string;
+    /** The tree's displayed workspace root; dropped relative paths resolve under it. */
+    readonly root: string;
+    /** Ask the owner to refresh the tree after uploads land. */
+    readonly onUploaded: () => void;
+    /** Localized copy for the overlay and its report. */
+    readonly t: import('@qilin-agent/client-ui-slots').TranslateNS<'sidebarFiles'>;
+    /** The wrapped tree. */
+    readonly children: ReactNode;
+}
+/**
+ * Wrap one file tree with a drag-and-drop upload overlay.
+ * @param props - session identity, displayed root, reload callback, copy.
+ * @returns the overlay that mounts over the tree while a drag is active.
+ */
+export declare function UploadOverlay({ sessionId, root, onUploaded, t, children }: UploadOverlayProps): ReactNode;
+//# sourceMappingURL=UploadOverlay.d.ts.map

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

@@ -0,0 +1,20 @@
+/**
+ * Stage one of this package's registration: what the `files` tab type IS.
+ *
+ * The type is a page, not a viewer: it claims no address. The guide page offers
+ * it as an entry box, and the tree opens files through `tabActions.openResource`
+ * for the `qilin-resource://file` viewers to claim.
+ */
+import type { SidebarRightTabDefinition } from '@qilin-agent/client-ui-sidebar-right/client';
+import type { TranslateNS } from '@qilin-agent/client-locale/client';
+/** The tab kind this package owns. */
+export declare const FILES_KIND = "files";
+/** This implementation's identity in the tab system, and the key its body registers under. */
+export declare const FILES_ID = "@qilin-agent/client-ui-sidebar-files";
+/**
+ * The files type's registry definition.
+ * @param t - namespace-bound translate, read fresh on every label call.
+ * @returns the definition to register.
+ */
+export declare function filesDefinition(t: TranslateNS<'sidebarFiles'>): SidebarRightTabDefinition;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1,150 @@
+/**
+ * The tree's asynchronous half: listing directories into the store, and the
+ * row mutations that change what a directory holds.
+ *
+ * The component never awaits anything. It calls `start` / `load` / `toggle` /
+ * `search` / `createEntry` / `renameEntry` / `removeEntry`, and this face
+ * performs the work 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. The mutations are bound the same
+ * way, and their successful settlement re-lists the directory that held the
+ * entry and reconciles the tabs open on the touched path.
+ *
+ * One level has one listing in force, and one tab has one mutation in force:
+ * asking for a level again — the reload gesture, a directory reopened after a
+ * reset — retires the listing still in flight for it, and a newer gesture
+ * retires the mutation still out, 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 '@qilin-agent/api-remotes/client';
+import type { BoundActions } from '@qilin-agent/client-store';
+import type { TabId } from '@qilin-agent/client-ui-dockkit';
+import type { WorkspaceFileNameSearch } from '@qilin-agent/api-workspace-files/types';
+import type { SessionId } from '@qilin-agent/session/types';
+import type { EntryKind, TabReconcile, WorkspaceFileMutations } from './file-mutations.ts';
+import type { DirLevel, createFilesStore } from './store.ts';
+/**
+ * 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>>;
+/**
+ * One filename search, bound to a Remote face.
+ *
+ * The query is matched against basenames below the same workspace root the
+ * listing is rooted at, and the answer is workspace-relative paths.
+ */
+export type SearchWorkspaceFileNames = (sessionId: SessionId, query: string, signal: AbortSignal) => Promise<RemoteResult<WorkspaceFileNameSearch>>;
+/**
+ * The slice of the Client Remote face this package calls: the `workspaceFiles`
+ * namespace's `list` and `searchNames`, exactly as the Host's generated client
+ * declares them.
+ */
+export type WorkspaceFilesTreeRemote = {
+    readonly workspaceFiles: Pick<ClientRemote['workspaceFiles'], 'list' | 'searchNames'>;
+};
+/**
+ * Bind the listing to one Remote face, keeping only what the tree stores.
+ * @param remote - the Client Remote face carrying the `workspaceFiles` namespace's `list`.
+ * @returns the listing the tree's face performs.
+ */
+export declare function createList(remote: {
+    readonly workspaceFiles: Pick<ClientRemote['workspaceFiles'], 'list'>;
+}): ListWorkspaceDirectory;
+/**
+ * How long the box settles before a query reaches the Host. Keystrokes that
+ * arrive inside the window replace the pending query instead of asking the
+ * Host for a prefix nobody wants finished.
+ */
+export declare const SEARCH_SETTLE_MS = 200;
+/**
+ * Bind the filename search to one Remote face, dropping the entries this
+ * package does not draw.
+ * @param remote - the Client Remote face carrying the `workspaceFiles` namespace's `searchNames`.
+ * @returns the search the tree's face performs.
+ */
+export declare function createSearch(remote: {
+    readonly workspaceFiles: Pick<ClientRemote['workspaceFiles'], 'searchNames'>;
+}): SearchWorkspaceFileNames;
+/**
+ * The tree's injected business face, as the body receives it.
+ */
+export interface FilesInjected {
+    /**
+     * 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, listing it the first time it opens.
+     * @param tabId - the tab being drawn.
+     * @param path - absolute directory path.
+     * @param loaded - whether this level already has state.
+     * @param signal - the tab record's lifetime.
+     */
+    readonly toggle: (tabId: TabId, path: string, loaded: boolean, signal: AbortSignal) => void;
+    /**
+     * Ask for the files whose names contain one query, after the box settles.
+     * @param tabId - the tab being drawn.
+     * @param query - the box's text, exactly as typed; blank asks nothing.
+     * @param signal - the tab record's lifetime.
+     */
+    readonly search: (tabId: TabId, query: string, signal: AbortSignal) => void;
+    /**
+     * Create one empty file or one directory inside a listed directory.
+     * @param tabId - the tab being drawn.
+     * @param directory - absolute path of the directory to create the entry in.
+     * @param name - the entry name, already normalized by the caller.
+     * @param kind - whether to write an empty file or make a directory.
+     * @param signal - the tab record's lifetime.
+     */
+    readonly createEntry: (tabId: TabId, directory: string, name: string, kind: EntryKind, signal: AbortSignal) => void;
+    /**
+     * Rename one entry in place, keeping it in its own directory.
+     * @param tabId - the tab being drawn.
+     * @param path - absolute path of the entry to rename.
+     * @param name - the entry name, already normalized by the caller.
+     * @param root - absolute workspace root, which the tabs' addresses are relative to.
+     * @param signal - the tab record's lifetime.
+     */
+    readonly renameEntry: (tabId: TabId, path: string, name: string, root: string, signal: AbortSignal) => void;
+    /**
+     * Delete one entry; a directory goes with everything inside it.
+     * @param tabId - the tab being drawn.
+     * @param path - absolute path of the entry to delete.
+     * @param kind - whether the entry is a directory, which decides `recursive`.
+     * @param root - absolute workspace root, which the tabs' addresses are relative to.
+     * @param signal - the tab record's lifetime.
+     */
+    readonly removeEntry: (tabId: TabId, path: string, kind: EntryKind, root: string, signal: AbortSignal) => void;
+}
+/**
+ * Bind the tree's face to one directory listing, one filename search, and the
+ * row mutations.
+ * @param list - the bound `workspaceFiles.list` call.
+ * @param searchNames - the bound `workspaceFiles.searchNames` call.
+ * @param mutations - the bound create, move, and remove calls.
+ * @param reconcile - how a touched path is settled against the open tabs.
+ * @returns the Slot `inject` factory: session and bound actions in, face out.
+ */
+export declare function filesFace(list: ListWorkspaceDirectory, searchNames: SearchWorkspaceFileNames, mutations: WorkspaceFileMutations, reconcile: TabReconcile): (sessionId: SessionId, actions: BoundActions<ReturnType<typeof createFilesStore>>) => FilesInjected;
+//# sourceMappingURL=face.d.ts.map

package/lib/types/client/file-definition.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Stage one of the `file` tab type's registration: the workspace file editor.
+ *
+ * A resource type in the `builtin` band claiming every session-scoped file
+ * address `file-guard` accepts — text and code extensions only, so images,
+ * PDFs, and unknown extensions fall through to the `text` fallback viewer.
+ * Markdown is a text extension, so this editor claims it and the preview
+ * control opens the rendered document. One tab opens per address: the registry's default, and the reason
+ * the type declares no `single` and no guide entry.
+ */
+import type { SidebarRightTabDefinition } from '@qilin-agent/client-ui-sidebar-right/client';
+import type { TranslateNS } from '@qilin-agent/client-locale/client';
+/** The editor tab kind this package owns beside the `files` page. */
+export declare const FILE_KIND = "file";
+/** This implementation's identity, and the key its body and title register under. */
+export declare const FILE_ID = "@qilin-agent/client-ui-sidebar-files/file";
+/**
+ * The editor type's registry definition.
+ *
+ * No static `icon`: the chip's glyph comes from the title slot, which draws
+ * the file-type sheet for the open file's own name — a static type glyph here
+ * could not classify by path and would double the chip's sheet.
+ * @param t - namespace-bound translate, read fresh on every label call.
+ * @returns the definition to register.
+ */
+export declare function fileDefinition(t: TranslateNS<'sidebarFiles'>): SidebarRightTabDefinition;
+//# sourceMappingURL=file-definition.d.ts.map

package/lib/types/client/file-editor.d.ts

@@ -0,0 +1,40 @@
+import { EditorView } from '@codemirror/view';
+/** What the body holds after mounting, and what it can change in place. */
+export interface FileEditorHandle {
+    /** The live view: the body needs nothing from it; specs and callers do. */
+    readonly view: EditorView;
+    /** Destroy the view and detach its DOM. */
+    destroy(): void;
+    /** @returns the editor's current document. */
+    getDocument(): string;
+    /**
+     * Turn line wrapping on or off without disturbing the document, history,
+     * or scroll position.
+     * @param wrap - whether lines wrap.
+     */
+    setWrap(wrap: boolean): void;
+}
+/** What one mount needs: the document, its grammar, and the two gestures. */
+export interface FileEditorOptions {
+    /** The initial document: the loaded text, or the unsaved draft. */
+    readonly text: string;
+    /** The file's path, for the grammar. */
+    readonly path: string;
+    /** Whether lines wrap initially. */
+    readonly wrap: boolean;
+    /**
+     * Called after every document change with the whole document.
+     * @param text - the editor document.
+     */
+    readonly onDocumentChange: (text: string) => void;
+    /** Called for the platform save gesture (`Mod-s`). */
+    readonly onSave: () => void;
+}
+/**
+ * Mount one editor view into `host`.
+ * @param host - the element the view attaches to; its size is the editor's.
+ * @param options - the document, its grammar, and the two gestures.
+ * @returns the handle the body keeps until unmount.
+ */
+export declare function mountFileEditor(host: HTMLElement, options: FileEditorOptions): FileEditorHandle;
+//# sourceMappingURL=file-editor.d.ts.map

package/lib/types/client/file-face.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The editor's asynchronous half: reading the whole file, saving it back.
+ *
+ * The component never awaits anything. It calls `readFile` / `saveFile`, and
+ * this face performs the calls and writes the outcome through the store's own
+ * actions — the Slot-standard `inject` shape, so the write set stays the
+ * store's. The session travels inside `file`: it comes from the tab's
+ * address, whose session authorizes the read and the write, not from the
+ * slot's.
+ *
+ * One tab has one call in force: a reload while a read is still out, or a
+ * save overtaken by another, retires the older call, whose settlement then
+ * writes nothing. Cleanup rides the owner's `signal`, armed by the tab's
+ * first call: the abort forgets the bucket and this bookkeeping, a request is
+ * not made for a record that already ended, and a settlement arriving after
+ * the record is gone has nothing left to write to.
+ * @module
+ */
+import type { BoundActions } from '@qilin-agent/client-store';
+import type { RemoteResult } from '@qilin-agent/api-remotes/client';
+import type { WorkspaceFileStat } from '@qilin-agent/api-workspace-files/types';
+import type { TabId } from '@qilin-agent/client-ui-dockkit';
+import type { SessionId } from '@qilin-agent/session/types';
+import type { WholeFileResult } from './file-pages.ts';
+import type { SessionFile } from './file-guard.ts';
+import type { createFilesStore } from './store.ts';
+/** The bound `workspaceFiles.write` call, as the generated client declares it. */
+export type WriteWorkspaceFile = (sessionId: SessionId, path: string, text: string, request: {
+    readonly baseVersion?: string;
+}, signal: AbortSignal) => Promise<RemoteResult<WorkspaceFileStat>>;
+/** What one save writes against. */
+export interface SaveOptions {
+    /** The version the text was read at; refused with `workspace-file/stale` when the disk moved on. */
+    readonly baseVersion: string;
+    /** `true` omits `baseVersion`: the conflict's overwrite. */
+    readonly force: boolean;
+}
+/** The editor's injected face, as the body receives it. */
+export interface FileEditorInjected {
+    /**
+     * Read the whole file into the store, resetting the editor's bucket.
+     * @param tabId - the tab being drawn.
+     * @param file - the session and path the tab's address names.
+     * @param signal - the tab record's lifetime.
+     */
+    readonly readFile: (tabId: TabId, file: SessionFile, signal: AbortSignal) => void;
+    /**
+     * Save one text as the file's content.
+     * @param tabId - the tab being drawn.
+     * @param file - the session and path the tab's address names.
+     * @param text - the complete text to write.
+     * @param options - the version written against, or a forced overwrite.
+     * @param signal - the tab record's lifetime.
+     */
+    readonly saveFile: (tabId: TabId, file: SessionFile, text: string, options: SaveOptions, signal: AbortSignal) => void;
+}
+/**
+ * Bind the editor's face to one whole-file read and one write.
+ * @param readWhole - the paged whole-file read.
+ * @param write - the bound `workspaceFiles.write` call.
+ * @returns the Slot `inject` factory: session and bound actions in, face out.
+ */
+export declare function fileEditFace(readWhole: (sessionId: SessionId, path: string, signal: AbortSignal) => Promise<WholeFileResult>, write: WriteWorkspaceFile): (sessionId: SessionId, actions: BoundActions<ReturnType<typeof createFilesStore>>) => FileEditorInjected;
+//# sourceMappingURL=file-face.d.ts.map

package/lib/types/client/file-failure.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The failure line one Remote code deserves, in terms of the file the editor
+ * could not read or save. Kept apart from the component so the mapping is
+ * testable on its own; codes this editor does not name fall to the generic
+ * line carrying the carrier's message.
+ * @module
+ */
+import type { RemoteFailure } from '@qilin-agent/api-remotes/client';
+import type { TranslateNS } from '@qilin-agent/client-locale/client';
+/**
+ * Say what went wrong, in terms of the file rather than of the transport.
+ * @param t - namespace-bound translate.
+ * @param failure - the settled Remote failure.
+ * @returns the line to show in the editor pane.
+ */
+export declare function fileFailureLine(t: TranslateNS<'sidebarFiles'>, failure: RemoteFailure): string;
+//# sourceMappingURL=file-failure.d.ts.map

package/lib/types/client/file-guard.d.ts

@@ -0,0 +1,34 @@
+import type { SessionId } from '@qilin-agent/session/types';
+/** The session and path one claimed address names, as the endpoints receive them. */
+export interface SessionFile {
+    /** The Session whose workspace resolves relative paths and authorizes writes. */
+    readonly sessionId: SessionId;
+    /** The path handed to the Host, absolute or workspace-relative. */
+    readonly path: string;
+}
+/**
+ * The type's `canOpen`: take only session-scoped addresses whose path is
+ * editable. An absolute address is refused because saving it has no
+ * authorizing Session, so the read-only `text` viewer keeps it.
+ * @param address - a candidate resource address.
+ * @returns whether the type opens the address.
+ */
+export declare function canOpenFileAddress(address: string): boolean;
+/**
+ * The tab title for one file address: the decoded basename, as the chip names
+ * the open file. A malformed percent sequence shows raw rather than refusing
+ * the address.
+ * @param address - a file-shaped resource address.
+ * @returns the decoded last path segment.
+ */
+export declare function fileTabTitle(address: string): string;
+/**
+ * The session and path one claimed address names.
+ *
+ * The registry routes only addresses `canOpenFileAddress` accepted, so a
+ * non-session address here is a programming error and throws.
+ * @param address - a tab's qilin-resource://file/ address.
+ * @returns the session and the path to hand the endpoints.
+ */
+export declare function sessionFileOf(address: string): SessionFile;
+//# sourceMappingURL=file-guard.d.ts.map

package/lib/types/client/file-lang.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Language grammar for one file path, as the editor mounts it.
+ *
+ * The map covers the installed `@codemirror/lang-*` packages plus the legacy
+ * modes worth carrying for shell-family and config files; an unmapped path
+ * edits as plain text.
+ * @module
+ */
+import type { Extension } from '@codemirror/state';
+/**
+ * The grammar for one file path, from its extension.
+ * @param path - the path the Host receives.
+ * @returns the language extension, or `undefined` for a path edited as plain text.
+ */
+export declare function langForPath(path: string): Extension | undefined;
+//# sourceMappingURL=file-lang.d.ts.map