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

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

@@ -0,0 +1,148 @@
+/**
+ * The tree's row mutations: creating a file or a directory, renaming one entry,
+ * and deleting one — plus how the tabs already open on a moved or removed path
+ * are reconciled with it.
+ *
+ * The three gestures share one shape: validate the typed name, call one Remote
+ * on the `workspaceFiles` namespace, and on success re-list the directory that
+ * held the entry, so the row is read again rather than guessed at. An entry a
+ * move or a removal touched is also reconciled with the open tabs: a tab whose
+ * address names the old path is retargeted to the new one, and a tab whose path
+ * is gone is closed, because its next read or save would fail against a path
+ * nothing holds.
+ *
+ * Everything here is either a pure path or failure decision — directly testable
+ * on its own — or the thin binding of one Remote to the shape the tree's face
+ * calls.
+ * @module
+ */
+import type { ClientRemote, RemoteFailure, RemoteResult } from '@qilin-agent/api-remotes/client';
+import type { TabId } from '@qilin-agent/client-ui-dockkit';
+import type { TranslateNS } from '@qilin-agent/client-locale/client';
+import type { SessionId } from '@qilin-agent/session/types';
+/** The two entry kinds a create gesture makes. */
+export type EntryKind = 'file' | 'directory';
+/**
+ * The one name a typed text may become, or `undefined` when it may not.
+ *
+ * A name is a single path segment: surrounding spaces are dropped, and a blank
+ * text, a dot segment, or anything carrying a separator is refused. The caller
+ * keeps its box open on `undefined` so nothing is written under a name the
+ * reader did not mean.
+ * @param text - the box's text, exactly as typed.
+ * @returns the trimmed name, or `undefined` when it cannot be one.
+ */
+export declare function normalizedEntryName(text: string): string | undefined;
+/**
+ * The directory holding one path, in that path's own spelling.
+ * @param path - an absolute path.
+ * @returns the parent directory; its root (`/`, `C:\`) when the path is one
+ * level below a root, and the empty string for a path with no separator.
+ */
+export declare function parentDirectoryOf(path: string): string;
+/**
+ * The absolute path of one named entry inside a directory.
+ *
+ * The child joins with `/` whatever the parent's own separators: the Host
+ * resolves mixed separators, and the tree only needs one stable key.
+ * @param directory - absolute path of the directory the entry sits in.
+ * @param name - the entry's basename.
+ * @returns the entry's absolute path.
+ */
+export declare function joinEntryPath(directory: string, name: string): string;
+/**
+ * Whether one path is a target itself or lives under it.
+ *
+ * Both sides are compared with `/` separators and without a trailing separator,
+ * so the same directory spelled with either separator, with or without its
+ * final slash, matches.
+ * @param candidate - the path to classify.
+ * @param target - the entry a move or a removal touched.
+ * @returns whether the candidate is the target or one of its descendants.
+ */
+export declare function pathAtOrUnder(candidate: string, target: string): boolean;
+/**
+ * Say why a row mutation failed, in terms of the entry rather than of the
+ * transport. Codes this tree does not name — the filesystem's own `FS_*`
+ * pass-throughs among them — reach the reader as the carrier's message.
+ * @param t - namespace-bound translate.
+ * @param failure - the settled Remote failure.
+ * @returns the line to show in the tree's mutation strip.
+ */
+export declare function mutationFailureLine(t: TranslateNS<'sidebarFiles'>, failure: RemoteFailure): string;
+/**
+ * The `workspaceFiles` calls one row mutation is made of, as the tree's face
+ * calls them. Each resolves with the endpoint's own result; the caller only
+ * branches on `ok`.
+ */
+export interface WorkspaceFileMutations {
+    /** Write one new, empty file: a `write` with no `baseVersion` is unconditional. */
+    readonly createFile: (sessionId: SessionId, path: string, signal: AbortSignal) => Promise<RemoteResult<unknown>>;
+    /** Create one directory; its parent must already exist. */
+    readonly createDirectory: (sessionId: SessionId, path: string, signal: AbortSignal) => Promise<RemoteResult<unknown>>;
+    /** Move or rename one entry; an existing destination is refused. */
+    readonly move: (sessionId: SessionId, from: string, to: string, signal: AbortSignal) => Promise<RemoteResult<unknown>>;
+    /** Delete one file, or one directory whole with `recursive`. */
+    readonly remove: (sessionId: SessionId, path: string, recursive: boolean, signal: AbortSignal) => Promise<RemoteResult<unknown>>;
+}
+/**
+ * The slice of the Client Remote face this package mutates entries through,
+ * exactly as the Host's generated client declares it.
+ */
+export type WorkspaceFilesMutationRemote = {
+    readonly workspaceFiles: Pick<ClientRemote['workspaceFiles'], 'write' | 'createDirectory' | 'move' | 'delete'>;
+};
+/**
+ * Bind the four row mutations to one Remote face, keeping each call's shape.
+ * @param remote - the Client Remote face carrying the `workspaceFiles` namespace.
+ * @returns the mutations the tree's face performs.
+ */
+export declare function createMutations(remote: WorkspaceFilesMutationRemote): WorkspaceFileMutations;
+/** One open tab, as far as a path mutation cares: the address it was opened at. */
+export interface OpenTabRef {
+    /** The tab's own id, the handle a close or a replacement names. */
+    readonly id: TabId;
+    /** The resource address the tab was opened at. */
+    readonly contentId: string;
+}
+/**
+ * The Sidebar slice open tabs are reconciled through.
+ *
+ * Structural rather than the controller's own type: this package needs three
+ * calls, and the injected service is a superset of them.
+ */
+export interface SidebarTabReconcile {
+    /** The committed tabs of one Session, or an empty list before adoption. */
+    readonly tabsIn: (sessionId: SessionId) => readonly OpenTabRef[];
+    /** Open a resource in one Session, optionally in the replaced tab's own place. */
+    readonly openResourceIn: (sessionId: SessionId, address: string, options: {
+        readonly replaceTab: TabId;
+    }) => void;
+    /** Close one tab of one Session. */
+    readonly closeIn: (sessionId: SessionId, tabId: TabId) => void;
+}
+/** How one touched path is settled against the tabs already open on it. */
+export interface TabReconcile {
+    /**
+     * Retarget every tab open at or under a path that moved.
+     * @param sessionId - the Session whose tabs are read.
+     * @param root - the Session's workspace root, which the addresses are relative to.
+     * @param from - the entry's path before the move.
+     * @param to - the entry's path after it.
+     */
+    readonly moved: (sessionId: SessionId, root: string, from: string, to: string) => void;
+    /**
+     * Close every tab open at or under a path that is gone.
+     * @param sessionId - the Session whose tabs are read.
+     * @param root - the Session's workspace root, which the addresses are relative to.
+     * @param path - the removed entry's path.
+     */
+    readonly removed: (sessionId: SessionId, root: string, path: string) => void;
+}
+/**
+ * Bind the tab reconciliation to one Sidebar controller.
+ * @param sidebar - the right Sidebar's tab paths.
+ * @returns the reconciliation a mutation performs on success.
+ */
+export declare function createTabReconcile(sidebar: SidebarTabReconcile): TabReconcile;
+//# sourceMappingURL=file-mutations.d.ts.map

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

@@ -0,0 +1,41 @@
+/**
+ * Whole-file reading for the editor: one paged walk over `workspaceFiles.read`
+ * assembled into the exact disk text, bounded by the editor's own byte cap.
+ *
+ * A page's lines join by `\n` with no terminator after the last, and a final
+ * `\n` on disk terminates the last line rather than starting an empty one, so
+ * the page stream alone cannot say whether the file ends with a newline. The
+ * complete file's byte size rides every page: an assembled text exactly one
+ * UTF-8 byte short of it had that terminator, and it is restored so a save
+ * round-trips the file byte for byte.
+ * @module
+ */
+import type { RemoteResult } from '@qilin-agent/api-remotes/client';
+import type { SessionId } from '@qilin-agent/session/types';
+import type { WorkspaceFileText } from '@qilin-agent/api-workspace-files/types';
+/** Largest file the editor opens, in bytes; the Host's page cap bounds each read. */
+export declare const MAX_EDIT_BYTES: number;
+/** One page of lines, as the endpoint returns it. */
+export type ReadWorkspaceFilePage = (sessionId: SessionId, path: string, offset: number, signal: AbortSignal) => Promise<RemoteResult<WorkspaceFileText>>;
+/** A whole file, or the failure that stopped the walk. */
+export type WholeFileResult = RemoteResult<{
+    readonly text: string;
+    readonly version: string;
+}>;
+/**
+ * Assemble whole text from a complete page walk.
+ *
+ * Pages join by `\n`; a file whose byte size is exactly one more than the
+ * assembly's UTF-8 length ends with a newline on disk, and it is appended.
+ * A size that matches neither is reported as-is rather than guessed at.
+ * @param pages - the walk's pages, in order.
+ * @returns the file's text as the disk holds it.
+ */
+export declare function reassemblePages(pages: readonly WorkspaceFileText[]): string;
+/**
+ * Bind the whole-file walk to one paged read.
+ * @param readPage - the bound `workspaceFiles.read` call.
+ * @returns the read the editor's face performs.
+ */
+export declare function createReadWhole(readPage: ReadWorkspaceFilePage): (sessionId: SessionId, path: string, signal: AbortSignal) => Promise<WholeFileResult>;
+//# sourceMappingURL=file-pages.d.ts.map

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

@@ -0,0 +1,39 @@
+/**
+ * The routes to the preview viewer: the editor toolbar's targeted open of the
+ * tab's own address, and the open options the workspace trees hand their rows.
+ *
+ * The toolbar cannot use the tab's own `openResource` action for this: that
+ * action opens through the registry's ranking, and this type outranks the
+ * viewer, so the ranking would land back here. Naming the kind is the one way
+ * past it; the Sidebar controller places the open on the session on screen.
+ * @module
+ */
+import type { ISidebarRight, SidebarRightTabActions } from '@qilin-agent/client-ui-sidebar-right/client';
+import type { SessionId } from '@qilin-agent/session/types';
+/** The preview navigation the body receives. */
+export interface FilePreviewInjected {
+    /**
+     * Open this address in the preview viewer.
+     * @param sessionId - the session whose preview toolbar asked; reserved by the
+     *   controller's session-scoped open, which this face does not need.
+     * @param address - the tab's own `qilin-resource://file/` address.
+     */
+    readonly openPreview: (sessionId: SessionId, address: string) => void;
+}
+/**
+ * Bind the preview navigation to the Sidebar controller.
+ * @param sidebarRight - the right-Sidebar navigation controller.
+ * @returns the Slot `inject` factory carrying the callback.
+ */
+export declare function filePreviewFace(sidebarRight: ISidebarRight): () => FilePreviewInjected;
+/**
+ * Open one tree row's file: a renderable document names the `text` viewer so
+ * the first open is the rendered document rather than this package's code
+ * view; the viewer's edit affordance opens the editor in return. Everything
+ * else takes the ranked claim unchanged.
+ * @param actions - the acting tab's action face, carrying `openResource`.
+ * @param address - the row's session file address.
+ * @param path - the row's workspace-relative path, for the renderable check.
+ */
+export declare function openFileRow(actions: Pick<SidebarRightTabActions, 'openResource'>, address: string, path: string): void;
+//# sourceMappingURL=file-preview.d.ts.map

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

@@ -0,0 +1,79 @@
+/**
+ * Browser half: register this package's two right-Sidebar tab types.
+ *
+ * The `files` page — the workspace tree as an empty-state explorer — and the
+ * `file` editor workbench, which claims session file addresses with editable
+ * extensions. Each type goes through the public two-stage path: the type into
+ * `ctx.sidebarRightTabs`, its body into the keyed `sidebar.right.pane.tab`
+ * seat and its chip title into the keyed `sidebar.right.pane.tab.title` seat,
+ * all under the type's own `id`.
+ *
+ * The file split is this package's layering: what each type IS
+ * (`definition.tsx`, `file-definition.ts`), what it keeps (`store.ts`), how it
+ * lists, mutates, and saves (`face.ts`, `file-mutations.ts`, `file-face.ts`,
+ * `file-pages.ts`), how it hands a
+ * file to the preview viewer (`file-preview.ts`), what it draws
+ * (`FilesBody.tsx`, `FilesTitle.tsx`, `FileBody.tsx`, `FileTitle.tsx`,
+ * `FileTree.tsx`), the editor surface behind the adapter (`file-editor.ts`),
+ * what it says (`locales.ts`), and this module, which only wires them
+ * together.
+ */
+import type { Context as ClientContext } from '@qilin-agent/kylin';
+import type { ClientRemote } from '@qilin-agent/api-remotes/client';
+import type { WriteWorkspaceFile } from './file-face.ts';
+import type { ReadWorkspaceFilePage } from './file-pages.ts';
+declare module '@qilin-agent/client-ui-slots' {
+    interface SlotMap {
+        /** Workspace directory actions after the file tree's reload control. */
+        'sidebar.right.tab.files.actions': {
+            kind: 'list';
+            scope: 'session';
+            owner: {
+                /** Absolute directory path displayed by the file tree. */
+                readonly absolutePath: string;
+            };
+        };
+    }
+}
+export type { SidebarFilesKey } from './locales.ts';
+export type { DirLevel, FileEditState, FilesState, FilesTabState, LevelState } from './store.ts';
+export type { FilesInjected, ListWorkspaceDirectory, SearchWorkspaceFileNames, WorkspaceFilesTreeRemote } from './face.ts';
+export type { FilePreviewInjected } from './file-preview.ts';
+export type { FilesBodyProps } from './FilesBody.tsx';
+/**
+ * The slice of the Client Remote face this package calls: the `workspaceFiles`
+ * namespace's `write`, exactly as the Host's generated client declares it.
+ */
+export interface WorkspaceFilesWriteRemote {
+    readonly workspaceFiles: {
+        /** Save one complete UTF-8 text file. */
+        write: WriteWorkspaceFile;
+    };
+}
+/**
+ * Bind the write to one Remote face, keeping the call's shape.
+ * @param remote - the Client Remote face carrying the `workspaceFiles` namespace.
+ * @returns the write the editor's face performs.
+ */
+export declare function createWriteFile(remote: WorkspaceFilesWriteRemote): WriteWorkspaceFile;
+/**
+ * Bind the paged read to one Remote face. The page length is the Host's
+ * configured cap, so no `limit` travels; the walk starts at line 1.
+ * @param remote - the Client Remote face carrying the `workspaceFiles` namespace.
+ * @returns the read the whole-file walk performs.
+ */
+export declare function createReadPage(remote: {
+    readonly workspaceFiles: Pick<ClientRemote['workspaceFiles'], 'read'>;
+}): ReadWorkspaceFilePage;
+/**
+ * Required browser services: the tab registry, the keyed seat, the Sidebar
+ * controller (the preview open), the Remote carrier and its namespace, and copy.
+ */
+export declare const inject: string[];
+/**
+ * Client plugin body: register both types, their dictionaries, and each body
+ * and chip title under its own id.
+ * @param ctx - client root context carrying the registry, the slots, and the Remote face.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,157 @@
+declare module '@qilin-agent/client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** File-tree and file-editor type names, guide entry, row states, and failure lines. */
+        sidebarFiles: SidebarFilesKey;
+    }
+}
+/** Simplified Chinese dictionary and key-set source of truth. */
+export declare const zh: {
+    'type.label': string;
+    'guide.title': string;
+    'guide.description': string;
+    loading: string;
+    empty: string;
+    truncated: string;
+    noWorkspace: string;
+    'upload.dropHint': string;
+    'upload.uploading': string;
+    'upload.done': string;
+    'upload.failed': string;
+    reload: string;
+    'search.label': string;
+    'search.placeholder': string;
+    'search.clear': string;
+    'search.running': string;
+    'search.empty': string;
+    'search.truncated': string;
+    'entry.other': string;
+    'entry.symlink': string;
+    'menu.open': string;
+    'menu.copyRelative': string;
+    'menu.copyAbsolute': string;
+    'menu.newFile': string;
+    'menu.newFolder': string;
+    'menu.rename': string;
+    'menu.delete': string;
+    'create.fileTitle': string;
+    'create.directoryTitle': string;
+    'create.name': string;
+    'create.placeholder': string;
+    'create.inDirectory': string;
+    'create.confirm': string;
+    'delete.title': string;
+    'delete.fileBody': string;
+    'delete.directoryBody': string;
+    'delete.confirm': string;
+    cancel: string;
+    'name.invalid': string;
+    mutating: string;
+    'error.exists': string;
+    'error.gone': string;
+    'error.notEmpty': string;
+    'error.notRegular': string;
+    'error.mutationFailed': string;
+    'error.dismiss': string;
+    'error.notFound': string;
+    'error.outsideWorkspace': string;
+    'error.notDirectory': string;
+    'error.unavailable': string;
+    'file.type.label': string;
+    'file.save': string;
+    'file.saving': string;
+    'file.saved': string;
+    'file.unsaved': string;
+    'file.reload': string;
+    'file.treeToggle': string;
+    'file.wrap': string;
+    'file.preview': string;
+    'file.reloadDirty': string;
+    'file.reloadDirty.confirm': string;
+    'file.reloadDirty.cancel': string;
+    'file.conflict': string;
+    'file.conflict.reload': string;
+    'file.conflict.overwrite': string;
+    'file.error.notFound': string;
+    'file.error.tooLarge': string;
+    'file.error.notText': string;
+    'file.error.notRegularFile': string;
+    'file.error.outsideWorkspace': string;
+    'file.error.unavailable': string;
+};
+/** Files dictionary key union. */
+export type SidebarFilesKey = keyof typeof zh;
+/** English dictionary, checked against the Chinese key set. */
+export declare const en: {
+    'upload.dropHint': string;
+    'upload.uploading': string;
+    'upload.done': string;
+    'upload.failed': string;
+    'type.label': string;
+    'guide.title': string;
+    'guide.description': string;
+    loading: string;
+    empty: string;
+    truncated: string;
+    noWorkspace: string;
+    reload: string;
+    'search.label': string;
+    'search.placeholder': string;
+    'search.clear': string;
+    'search.running': string;
+    'search.empty': string;
+    'search.truncated': string;
+    'entry.other': string;
+    'entry.symlink': string;
+    'menu.open': string;
+    'menu.copyRelative': string;
+    'menu.copyAbsolute': string;
+    'menu.newFile': string;
+    'menu.newFolder': string;
+    'menu.rename': string;
+    'menu.delete': string;
+    'create.fileTitle': string;
+    'create.directoryTitle': string;
+    'create.name': string;
+    'create.placeholder': string;
+    'create.inDirectory': string;
+    'create.confirm': string;
+    'delete.title': string;
+    'delete.fileBody': string;
+    'delete.directoryBody': string;
+    'delete.confirm': string;
+    cancel: string;
+    'name.invalid': string;
+    mutating: string;
+    'error.exists': string;
+    'error.gone': string;
+    'error.notEmpty': string;
+    'error.notRegular': string;
+    'error.mutationFailed': string;
+    'error.dismiss': string;
+    'error.notFound': string;
+    'error.outsideWorkspace': string;
+    'error.notDirectory': string;
+    'error.unavailable': string;
+    'file.type.label': string;
+    'file.save': string;
+    'file.saving': string;
+    'file.saved': string;
+    'file.unsaved': string;
+    'file.reload': string;
+    'file.treeToggle': string;
+    'file.wrap': string;
+    'file.preview': string;
+    'file.reloadDirty': string;
+    'file.reloadDirty.confirm': string;
+    'file.reloadDirty.cancel': string;
+    'file.conflict': string;
+    'file.conflict.reload': string;
+    'file.conflict.overwrite': string;
+    'file.error.notFound': string;
+    'file.error.tooLarge': string;
+    'file.error.notText': string;
+    'file.error.notRegularFile': string;
+    'file.error.outsideWorkspace': string;
+    'file.error.unavailable': string;
+};
+//# sourceMappingURL=locales.d.ts.map

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

@@ -0,0 +1,189 @@
+/**
+ * The two view states this package owns, one store per session, bucketed by
+ * tab id because two tabs in one session are independent:
+ *
+ * - the file tree: which directories are expanded, what each loaded level
+ *   contains, and the filename search beside it. Shared by the `files` page and
+ *   the `file` editor's tree pane.
+ * - the file editor: one open file's load state, draft, and save state.
+ *
+ * Writers run between `start` and `forget` (tree) or the editor face's abort
+ * listener (editor): the owner's `signal` is what ends a bucket's life, and
+ * the faces stop dispatching once it aborts.
+ */
+import { type EngineStoreHandle } from '@qilin-agent/client-store';
+import type { RemoteFailure } from '@qilin-agent/api-remotes/client';
+import type { TabId } from '@qilin-agent/client-ui-dockkit';
+import type { WorkspaceDirectoryEntry, WorkspaceFileNameMatch } from '@qilin-agent/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 kind: 'failed';
+    readonly failure: RemoteFailure;
+};
+/**
+ * What one tab's filename search is showing, carrying the box's own text so the
+ * input is restored with its result after a remount.
+ *
+ * `idle` is the box's content with nothing asked of the Host yet — including the
+ * empty box — and it is also where typing lands: the previous answer describes a
+ * different query, so it is dropped the moment the text changes.
+ */
+export type FileSearchState = {
+    readonly kind: 'idle';
+    readonly query: string;
+} | {
+    readonly kind: 'running';
+    readonly query: string;
+} | {
+    readonly kind: 'ready';
+    readonly query: string;
+    readonly matches: readonly WorkspaceFileNameMatch[];
+    readonly truncated: boolean;
+} | {
+    readonly kind: 'failed';
+    readonly query: string;
+    readonly failure: RemoteFailure;
+};
+/**
+ * What one tab's last row mutation is doing: the create, rename, or delete
+ * gesture the tree asked for and has not heard back about, or the failure it
+ * ended in. One gesture is in force at a time, so a newer one replaces the
+ * record rather than queueing behind it.
+ */
+export type TreeMutationState = {
+    readonly kind: 'idle';
+} | {
+    readonly kind: 'running';
+} | {
+    readonly kind: 'failed';
+    readonly failure: RemoteFailure;
+};
+/**
+ * One tab's tree: its root, the levels it has asked for, what is open, the
+ * filename search beside it, and the last row mutation.
+ *
+ * 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 {
+    /** 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;
+    /** What the search box holds and has last heard back. */
+    search: FileSearchState;
+    /** How the last create, rename, or delete gesture ended, for the tree's strip. */
+    mutation: TreeMutationState;
+}
+/** What one file editor is doing with its file right now. */
+export type FileEditPhase = {
+    readonly kind: 'reading';
+} | {
+    readonly kind: 'ready';
+} | {
+    readonly kind: 'failed';
+    readonly failure: RemoteFailure;
+};
+/** How the last finished save ended, for the toolbar status. */
+export type FileSaveState = 'idle' | 'saved' | 'failed';
+/**
+ * One tab's editor: the file as the disk holds it, the unsaved draft on top
+ * of it, and the save state between them.
+ *
+ * `version` is the opaque equality token every save writes against; `draft`
+ * carries the editor document while it differs from the disk text, so a body
+ * remount restores it. The state survives across a body's unmounts — that is
+ * why it is a declared store and not component state.
+ */
+export interface FileEditState {
+    phase: FileEditPhase;
+    /** The text as last read from or written to the disk. */
+    text: string;
+    /** The freshness token of `text`; every save's `baseVersion`. */
+    version: string;
+    /** Whether the editor holds unsaved changes. */
+    dirty: boolean;
+    /** The editor document while dirty; absent when it matches `text`. */
+    draft: string | undefined;
+    /** Whether a save is in flight. */
+    saving: boolean;
+    /** How the last finished save ended. */
+    saveState: FileSaveState;
+    /** The settled save failure, for its line. */
+    saveFailure: RemoteFailure | undefined;
+    /** A save was refused because the disk moved on; the draft is intact. */
+    conflict: boolean;
+    /** Whether the editor wraps lines. */
+    wrap: boolean;
+    /** Bumped by every load that should remount the editor surface. */
+    loadSeq: number;
+    /** The navigation revision whose line target has been answered. */
+    answered: number;
+}
+/** Every tab's tree, keyed by tab id. */
+export interface FilesState {
+    byTab: Record<TabId, FilesTabState>;
+    /** The `file` editor's buckets; the `files` page never seeds one. */
+    edits: Record<TabId, FileEditState>;
+}
+/** The store's write set; every action names the tab it writes. */
+type FilesActions = {
+    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;
+    searchTyped: (draft: FilesState, tabId: TabId, query: string) => void;
+    searchRunning: (draft: FilesState, tabId: TabId, query: string) => void;
+    searchSettled: (draft: FilesState, tabId: TabId, query: string, matches: readonly WorkspaceFileNameMatch[], truncated: boolean) => void;
+    searchFailed: (draft: FilesState, tabId: TabId, query: string, failure: RemoteFailure) => void;
+    searchCleared: (draft: FilesState, tabId: TabId) => void;
+    mutationStarted: (draft: FilesState, tabId: TabId) => void;
+    mutationFailed: (draft: FilesState, tabId: TabId, failure: RemoteFailure) => void;
+    mutationCleared: (draft: FilesState, tabId: TabId) => void;
+    reset: (draft: FilesState, tabId: TabId) => void;
+    forget: (draft: FilesState, tabId: TabId) => void;
+    editRead: (draft: FilesState, tabId: TabId) => void;
+    editLoaded: (draft: FilesState, tabId: TabId, text: string, version: string) => void;
+    editFailed: (draft: FilesState, tabId: TabId, failure: RemoteFailure) => void;
+    editDraft: (draft: FilesState, tabId: TabId, text: string) => void;
+    editSaving: (draft: FilesState, tabId: TabId) => void;
+    editSaved: (draft: FilesState, tabId: TabId, text: string, version: string) => void;
+    editSaveFailed: (draft: FilesState, tabId: TabId, failure: RemoteFailure) => void;
+    editWrap: (draft: FilesState, tabId: TabId, wrap: boolean) => void;
+    editAnswered: (draft: FilesState, tabId: TabId, revision: number) => void;
+    editForget: (draft: FilesState, tabId: TabId) => void;
+};
+/**
+ * Declare the tree and editor store.
+ *
+ * A factory rather than a shared handle: the registrations declare it as an
+ * exclusive store, so the framework mints one instance per session, shared by
+ * the `files` and `file` seats that receive it.
+ * @returns the store handle to declare on the registrations.
+ */
+export declare function createFilesStore(): EngineStoreHandle<FilesState, FilesActions>;
+export {};
+//# sourceMappingURL=store.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,4 @@
+/** Pure host half; the whole tab type lives in the browser export. */
+/** Host plugin body: the file tree contributes nothing to the host tree. */
+export declare function apply(): void;
+//# sourceMappingURL=index.d.ts.map