@dotdirfm/ui 0.1.1

package/dist/lib/features/ui-state/types.d.ts

@@ -0,0 +1,22 @@
+export type PersistedTab = {
+    type: "filelist";
+    path: string;
+    selectedName?: string;
+    topmostName?: string;
+} | {
+    type: "preview";
+    path: string;
+    name: string;
+    size: number;
+};
+export interface PanelPersistedState {
+    currentPath: string;
+    tabs?: PersistedTab[];
+    activeTabIndex?: number;
+}
+/** UI state persisted across launches (tabs, active panel). Not watched — read once on startup. */
+export interface DotDirUiState {
+    leftPanel?: PanelPersistedState;
+    rightPanel?: PanelPersistedState;
+    activePanel?: "left" | "right";
+}

package/dist/lib/features/ui-state/uiState.d.ts

@@ -0,0 +1,5 @@
+import { Bridge } from '../../../features/bridge';
+import { DotDirUiState } from './types';
+export declare function initUiState(bridge: Bridge): Promise<DotDirUiState>;
+export declare function updateUiState(bridge: Bridge, partial: Partial<DotDirUiState>): void;
+export declare function flushUiState(bridge: Bridge): void;

package/dist/lib/fileListHandlers.d.ts

@@ -0,0 +1,31 @@
+export interface ActiveFileListHandlers {
+    cursorUp(): void;
+    cursorDown(): void;
+    cursorLeft(): void;
+    cursorRight(): void;
+    cursorHome(): void;
+    cursorEnd(): void;
+    cursorPageUp(): void;
+    cursorPageDown(): void;
+    selectUp(): void;
+    selectDown(): void;
+    selectLeft(): void;
+    selectRight(): void;
+    selectHome(): void;
+    selectEnd(): void;
+    selectPageUp(): void;
+    selectPageDown(): void;
+    execute(): void;
+    open(): void;
+    viewFile(): void;
+    editFile(): void;
+    moveToTrash(): void;
+    permanentDelete(): void;
+    copy(): void;
+    move(): void;
+    rename(): void;
+    pasteFilename(): void;
+    pastePath(): void;
+}
+export declare function setActiveFileListHandlers(handlers: ActiveFileListHandlers | null): void;
+export declare function getActiveFileListHandlers(): ActiveFileListHandlers | null;

package/dist/lib/focusContext.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Focus Context System
+ *
+ * Tracks which component currently has focus for keyboard handling.
+ * Components push/pop themselves onto the focus stack.
+ */
+export type FocusLayer = "panel" | "commandPalette" | "modal" | "terminal" | "editor" | "viewer";
+type FocusChangeCallback = (layer: FocusLayer) => void;
+declare class FocusContextManager {
+    private stack;
+    private listeners;
+    get current(): FocusLayer;
+    push(layer: FocusLayer): void;
+    pop(layer: FocusLayer): void;
+    set(layer: FocusLayer): void;
+    is(layer: FocusLayer): boolean;
+    onChange(callback: FocusChangeCallback): () => void;
+    private notify;
+}
+export declare const focusContext: FocusContextManager;
+export {};

package/dist/lib/fs.d.ts

@@ -0,0 +1,36 @@
+import { Bridge, EntryKind, FsChangeType } from '../features/bridge';
+export interface HandleMeta {
+    size: number;
+    mtimeMs: number;
+    mode: number;
+    nlink: number;
+    kind: EntryKind;
+    hidden: boolean;
+    linkTarget?: string;
+}
+export declare function readFile(bridge: Bridge, path: string): Promise<ArrayBuffer>;
+export declare function readFileBuffer(bridge: Bridge, path: string): Promise<ArrayBuffer>;
+export declare function readFileText(bridge: Bridge, path: string): Promise<string>;
+export interface FileSystemChangeRecord {
+    root: {
+        path: string;
+    };
+    changedHandle: {
+        path: string;
+        name: string;
+    } | null;
+    relativePathComponents: string[];
+    type: FsChangeType;
+}
+type ObserverCallback = (records: FileSystemChangeRecord[], observer: FileSystemObserver) => void;
+export declare class FileSystemObserver {
+    #private;
+    private bridge;
+    constructor(bridge: Bridge, callback: ObserverCallback);
+    observe(path: string): Promise<void>;
+    unobserve(path: string): void;
+    /** Update the set of watched paths, adding/removing only what changed. */
+    sync(paths: string[]): void;
+    disconnect(): void;
+}
+export {};

package/dist/lib/fss.d.ts

@@ -0,0 +1,9 @@
+import { Bridge } from '../features/bridge';
+import { LoadedExtension } from '../features/extensions/extensions';
+import { ResolvedEntryStyle } from '../types';
+import { FsNode, LayeredResolver, ThemeKind } from 'fss-lang';
+export declare function setExtensionLayers(extensions: LoadedExtension[], activeIconTheme?: string): void;
+export declare function invalidateFssCache(dirPath: string): void;
+export declare function createPanelResolver(theme?: ThemeKind): LayeredResolver;
+export declare function syncLayers(bridge: Bridge, resolver: LayeredResolver, dirPath: string): Promise<void>;
+export declare function resolveEntryStyle(resolver: LayeredResolver, node: FsNode): ResolvedEntryStyle;

package/dist/lib/hooks/useBuiltInCommands.d.ts

@@ -0,0 +1,24 @@
+import { DialogSpec } from '../../dialogs/dialogContext';
+import { RefObject } from 'react';
+interface PanelHandle {
+    currentPath: string;
+    navigateTo: (path: string, force?: boolean, cursorName?: string) => Promise<void>;
+    cancelNavigation: () => void;
+}
+export interface BuiltInCommandDeps {
+    leftRef: RefObject<PanelHandle>;
+    rightRef: RefObject<PanelHandle>;
+    onPreviewInOppositePanel: () => void;
+    onOpenCurrentFolderInOppositeCurrentTab: () => void;
+    onOpenCurrentFolderInOppositeNewTab: () => void;
+    onOpenSelectedFolderInOppositeCurrentTab: () => void;
+    onOpenSelectedFolderInOppositeNewTab: () => void;
+    onOpenCreateFileConfirm: (path: string, name: string, langId: string) => Promise<void>;
+    showDialog: (spec: DialogSpec) => void;
+    onViewFile: (filePath: string, fileName: string, fileSize: number) => void;
+    onEditFile: (filePath: string, fileName: string, fileSize: number, langId: string) => void;
+    onExecuteInTerminal: (cmd: string) => Promise<void>;
+    editorFileSizeLimit: number;
+}
+export declare function useBuiltInCommands(deps: BuiltInCommandDeps): void;
+export {};

package/dist/lib/hooks/useDialogButtonNav.d.ts

@@ -0,0 +1,10 @@
+import { RefObject } from 'react';
+/**
+ * Arrow-key navigation between buttons inside a dialog.
+ * Left/Right arrows cycle focus; the default button is focused on mount.
+ */
+export declare function useDialogButtonNav(containerRef: RefObject<HTMLElement | null>, opts?: {
+    defaultIndex?: number;
+}): {
+    onKeyDown: (e: React.KeyboardEvent) => void;
+};

package/dist/lib/hooks/useMediaQuery.d.ts

@@ -0,0 +1 @@
+export declare function useMediaQuery(query: string): boolean;

package/dist/lib/hooks/usePanel.d.ts

@@ -0,0 +1,23 @@
+import { Bridge } from '../../features/bridge';
+import { LayeredResolver, FsNode } from 'fss-lang';
+export declare function findExistingParent(bridge: Bridge, startPath: string): Promise<string>;
+export interface PanelState {
+    currentPath: string;
+    parentNode?: FsNode;
+    entries: FsNode[];
+    /** Name of the entry to focus when navigating to a directory (e.g. the archive file when leaving a ZIP). */
+    requestedCursor?: string;
+}
+export declare const emptyPanel: PanelState;
+export declare function usePanel(showError: (message: string) => void): {
+    navigateTo: (path: string, force?: boolean, cursorName?: string) => Promise<void>;
+    navigating: boolean;
+    cancelNavigation: () => void;
+    refresh: () => void;
+    resolver: LayeredResolver;
+    currentPath: string;
+    parentNode?: FsNode;
+    entries: FsNode[];
+    /** Name of the entry to focus when navigating to a directory (e.g. the archive file when leaving a ZIP). */
+    requestedCursor?: string;
+};

package/dist/lib/hooks/useTerminal.d.ts

@@ -0,0 +1,12 @@
+interface UseTerminalOptions {
+    activePanelCwd: string;
+    onNavigatePanel: (path: string) => void;
+}
+export interface UseTerminalResult {
+    activeCwd: string;
+    writeToTerminal: (data: string) => Promise<void>;
+    runCommand: (cmd: string, cwd: string) => Promise<void>;
+    rememberExpectedTerminalCwd: (path: string) => void;
+}
+export declare function useTerminal({ activePanelCwd, onNavigatePanel }: UseTerminalOptions): UseTerminalResult;
+export {};

package/dist/lib/jsoncFileWatcher.d.ts

@@ -0,0 +1,15 @@
+import { Bridge } from '../features/bridge';
+export interface JsoncFileWatcher<T> {
+    getValue(): T;
+    setValue(value: T): void;
+    onChange(callback: (value: T) => void): () => void;
+    dispose(): Promise<void>;
+}
+export interface JsoncFileWatcherOptions<T> {
+    name: string;
+    getPath: () => Promise<string>;
+    validate: (parsed: unknown) => T | null;
+    defaultValue: T;
+    onLoad?: (value: T) => void;
+}
+export declare function createJsoncFileWatcher<T>(bridge: Bridge, options: JsoncFileWatcherOptions<T>): Promise<JsoncFileWatcher<T>>;

package/dist/lib/languageRegistry.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Language Registry (host-only)
+ *
+ * Manages language and grammar metadata from extension contributions.
+ * Used for language detection (filename → langId) when opening files.
+ * Syntax highlighting and tokenization are handled inside editor extensions (e.g. Monaco).
+ */
+export interface LanguageContribution {
+    id: string;
+    aliases?: string[];
+    extensions?: string[];
+    filenames?: string[];
+}
+export interface GrammarContribution {
+    language: string;
+    scopeName: string;
+    path: string;
+    embeddedLanguages?: Record<string, string>;
+}
+export interface GrammarData {
+    contribution: GrammarContribution;
+    content: object;
+}
+declare class LanguageRegistry {
+    private grammarContents;
+    private languageToScope;
+    private extToLang;
+    private filenameToLang;
+    /** No-op for compatibility; host does not run Monaco. */
+    initialize(): Promise<void>;
+    /** Register a language contributed by an extension. */
+    registerLanguage(lang: LanguageContribution): void;
+    /** Store grammar metadata (for hasGrammar); tokenization is done in editor extensions. */
+    registerGrammar(data: GrammarData): void;
+    /** No-op; tokenization is handled inside editor extensions. */
+    activateGrammars(): Promise<void>;
+    clear(): void;
+    hasGrammar(langId: string): boolean;
+    detectLanguage(filename: string): string;
+    getLanguageForFilename(filename: string): string;
+}
+export declare const languageRegistry: LanguageRegistry;
+export {};

package/dist/lib/panelGroupHandlers.d.ts

@@ -0,0 +1,6 @@
+export interface ActivePanelGroupHandlers {
+    newTab(): void;
+    closeActiveTab(): Promise<void>;
+}
+export declare function setActivePanelGroupHandlers(handlers: ActivePanelGroupHandlers | null): void;
+export declare function getActivePanelGroupHandlers(): ActivePanelGroupHandlers | null;

package/dist/lib/processes/workspace-session/model/useWorkspaceSessionProcess.d.ts

@@ -0,0 +1,59 @@
+import { PanelTab } from '../../../../components/FileList/PanelTabs';
+import { PanelSide } from '../../../../entities/panel/model/types';
+import { PanelPersistedState } from '../../../../features/ui-state/types';
+import { FsNode } from 'fss-lang';
+import { Dispatch, RefObject, SetStateAction } from 'react';
+type TabSelectionRef = RefObject<Record<string, {
+    selectedName?: string;
+    topmostName?: string;
+}>>;
+type NameRef = RefObject<string | undefined>;
+type IdRef = RefObject<string>;
+type TabsRef = RefObject<PanelTab[]>;
+interface PanelModel {
+    currentPath: string;
+    entries: FsNode[];
+}
+interface RestoreParams {
+    ready: boolean;
+    setLeftTabs: Dispatch<SetStateAction<PanelTab[]>>;
+    setRightTabs: Dispatch<SetStateAction<PanelTab[]>>;
+    setLeftActiveTabId: Dispatch<SetStateAction<string>>;
+    setRightActiveTabId: Dispatch<SetStateAction<string>>;
+    leftTabSelectionRef: TabSelectionRef;
+    rightTabSelectionRef: TabSelectionRef;
+    prevLeftActiveTabIdRef: RefObject<string>;
+    prevRightActiveTabIdRef: RefObject<string>;
+    onAfterRestore: () => void;
+}
+export declare function useWorkspaceRestoreProcess({ ready, setLeftTabs, setRightTabs, setLeftActiveTabId, setRightActiveTabId, leftTabSelectionRef, rightTabSelectionRef, prevLeftActiveTabIdRef, prevRightActiveTabIdRef, onAfterRestore, }: RestoreParams): {
+    settingsLoaded: boolean;
+    initialLeftPanel: PanelPersistedState | undefined;
+    initialRightPanel: PanelPersistedState | undefined;
+    initialActivePanel: PanelSide | undefined;
+    setInitialLeftPanel: Dispatch<SetStateAction<PanelPersistedState | undefined>>;
+    setInitialRightPanel: Dispatch<SetStateAction<PanelPersistedState | undefined>>;
+    setInitialActivePanel: Dispatch<SetStateAction<PanelSide | undefined>>;
+};
+interface PersistParams {
+    activePanel: PanelSide;
+    settingsLoaded: boolean;
+    left: PanelModel;
+    right: PanelModel;
+    leftTabsRef: TabsRef;
+    rightTabsRef: TabsRef;
+    leftActiveTabIdRef: IdRef;
+    rightActiveTabIdRef: IdRef;
+    leftTabSelectionRef: TabSelectionRef;
+    rightTabSelectionRef: TabSelectionRef;
+    leftSelectedNameRef: NameRef;
+    rightSelectedNameRef: NameRef;
+    setLeftTabs: Dispatch<SetStateAction<PanelTab[]>>;
+    setRightTabs: Dispatch<SetStateAction<PanelTab[]>>;
+    setLeftActiveTabId: Dispatch<SetStateAction<string>>;
+    setRightActiveTabId: Dispatch<SetStateAction<string>>;
+}
+export declare function useWorkspacePersistenceProcess({ activePanel, settingsLoaded, left, right, leftTabsRef, rightTabsRef, leftActiveTabIdRef, rightActiveTabIdRef, leftTabSelectionRef, rightTabSelectionRef, leftSelectedNameRef, rightSelectedNameRef, setLeftTabs, setRightTabs, setLeftActiveTabId, setRightActiveTabId, }: PersistParams): {
+    handlePanelStateChange: (side: PanelSide, selectedName: string | undefined, topmostName: string | undefined) => void;
+};
+export {};

package/dist/lib/registerKeybindings.d.ts

@@ -0,0 +1,11 @@
+import { Keybinding, KeybindingLayer } from '../features/commands/commands';
+export type Disposable = () => void;
+type CommandRegistryLike = {
+    registerKeybinding: (binding: Keybinding, layer?: KeybindingLayer) => Disposable;
+};
+export declare function registerAppBuiltInKeybindings(registry: CommandRegistryLike): Disposable[];
+export declare function registerCommandLineKeybindings(registry: CommandRegistryLike): Disposable[];
+export declare function registerFileListKeybindings(registry: CommandRegistryLike): Disposable[];
+export declare function registerExtensionKeybinding(registry: CommandRegistryLike, binding: Keybinding): Disposable;
+export declare function registerExtensionKeybindings(registry: CommandRegistryLike, bindings: Keybinding[]): Disposable[];
+export {};

package/dist/lib/styleHost.d.ts

@@ -0,0 +1,2 @@
+export declare function setStyleHostElement(element: HTMLElement | null): void;
+export declare function getStyleHostElement(): HTMLElement;

package/dist/lib/terminal/TerminalSession.d.ts

@@ -0,0 +1,59 @@
+import { Bridge, TerminalProfile } from '../../features/bridge';
+import { TerminalCapabilities, TerminalSessionEvent } from './types';
+type SessionListener = (event: TerminalSessionEvent) => void;
+export declare class TerminalSession {
+    private bridge;
+    private static readonly replayLimit;
+    private readonly listeners;
+    private readonly decoder;
+    private readonly initialCwd;
+    private ptyId;
+    private currentCwd;
+    private status;
+    private capabilities;
+    private launchInfo;
+    private replayData;
+    private inputBuffer;
+    private activeCommand;
+    private suppressNextCommandFinish;
+    private cleanupData;
+    private cleanupExit;
+    private pendingCwdSync;
+    private readonly profile;
+    /** While true, xterm OSC hooks must not mutate session state (replay buffer re-written to the terminal). */
+    private oscHooksSuppressed;
+    constructor(bridge: Bridge, initialCwd: string, profile: TerminalProfile);
+    subscribe(listener: SessionListener): () => void;
+    getCapabilities(): TerminalCapabilities;
+    getReplayData(): string;
+    setOscHooksSuppressed(suppressed: boolean): void;
+    /** xterm OSC 7 — cwd from shell integration. */
+    notifyOsc7FromXterm(cwd: string): void;
+    /**
+     * .dir OSC 779 — shell integration emits this on preexec (S) and command finish (F).
+     * Payload `S` = command starting (preexec); `F` = command finished (postexec / precmd).
+     */
+    notifyDotDirPromptOsc(payload: string): void;
+    start(): Promise<void>;
+    write(data: string): Promise<void>;
+    /**
+     * Write to the PTY without tracking as user input (used for hidden `cd`).
+     * The next OSC 779 (prompt after this line) is ignored for command-finish.
+     */
+    writeHidden(data: string): Promise<void>;
+    resize(cols: number, rows: number): Promise<void>;
+    syncToCwd(nextCwd: string): Promise<void>;
+    refreshPrompt(): Promise<void>;
+    dispose(): Promise<void>;
+    private acceptLaunch;
+    private handleData;
+    private appendVisibleData;
+    private finishCommand;
+    private applyCwdUpdate;
+    private consumeUserInput;
+    private emit;
+    private emitCapabilities;
+    private setStatus;
+    private flushPendingCwdSync;
+}
+export {};

package/dist/lib/terminal/TerminalView.d.ts

@@ -0,0 +1,8 @@
+import { TerminalSession } from './TerminalSession';
+interface TerminalViewProps {
+    session: TerminalSession;
+    expanded?: boolean;
+    focusRequestKey?: number;
+}
+export declare function TerminalView({ session, expanded, focusRequestKey }: TerminalViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/terminal/path.d.ts

@@ -0,0 +1,7 @@
+import { TerminalProfile } from '../../features/bridge';
+export declare function normalizeTerminalPath(raw: string): string;
+/**
+ * Hidden `cd` sent before running a command from the command line or panel sync.
+ * Template comes from shell-integration contributions (`{{cwd}}` = escaped path).
+ */
+export declare function formatHiddenCd(absoluteCwd: string, profile: TerminalProfile): string;

package/dist/lib/terminal/shellProfiles.d.ts

@@ -0,0 +1,15 @@
+import { Bridge, TerminalProfile } from '../../features/bridge';
+import { LoadedExtension } from '../../features/extensions/extensions';
+export interface ShellProfilesResult {
+    profiles: TerminalProfile[];
+    shellScripts: Record<string, {
+        script: string;
+        scriptArg: boolean;
+    }>;
+}
+/**
+ * Resolve available shell profiles from extension contributions.
+ *
+ * Each unique shell path becomes a profile (id = shell path).
+ */
+export declare function resolveShellProfiles(bridge: Bridge, extensions: LoadedExtension[], env: Record<string, string>): Promise<ShellProfilesResult>;

package/dist/lib/terminal/terminalAtoms.d.ts

@@ -0,0 +1,7 @@
+import { ManagedTerminalSession } from './types';
+export declare const terminalSessionsAtom: import('jotai').PrimitiveAtom<ManagedTerminalSession[]> & {
+    init: ManagedTerminalSession[];
+};
+export declare const terminalActiveSessionIdAtom: import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+};

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

@@ -0,0 +1,53 @@
+import { TerminalProfile } from '../../features/bridge';
+import { TerminalSession } from './TerminalSession';
+export type TerminalSessionStatus = "idle" | "starting" | "running" | "exited" | "error";
+export interface ManagedTerminalSession {
+    id: string;
+    session: TerminalSession;
+    profile: TerminalProfile;
+    profileId: string;
+    profileLabel: string;
+    cwd: string;
+    cwdUserInitiated: boolean;
+    status: TerminalSessionStatus;
+    error?: string;
+}
+export interface PtyLaunchInfo {
+    ptyId: number;
+    cwd: string;
+    shell: string;
+}
+export interface TerminalCapabilities {
+    cwd: string;
+    profileId: string | null;
+    hasOsc7Cwd: boolean;
+    /** .dir OSC 779 (prompt / command finished) seen at least once. */
+    hasDotDirOsc: boolean;
+    promptReady: boolean;
+    commandRunning: boolean;
+    lastCommand: string | null;
+}
+export type TerminalSessionEvent = {
+    type: "data";
+    data: string;
+} | {
+    type: "launch";
+    launch: PtyLaunchInfo;
+} | {
+    type: "cwd";
+    cwd: string;
+    userInitiated: boolean;
+} | {
+    type: "status";
+    status: TerminalSessionStatus;
+    error?: string;
+} | {
+    type: "capabilities";
+    capabilities: TerminalCapabilities;
+} | {
+    type: "command-start";
+    command: string;
+} | {
+    type: "command-finish";
+    command: string | null;
+};

package/dist/lib/terminal/useTerminalState.d.ts

@@ -0,0 +1,20 @@
+import { TerminalProfile } from '../../features/bridge';
+import { ManagedTerminalSession } from './types';
+export type { ManagedTerminalSession };
+export interface TerminalState {
+    sessions: ManagedTerminalSession[];
+    activeSessionId: string | null;
+    activeSession: ManagedTerminalSession | null;
+    setProfiles: (profiles: TerminalProfile[], cwd: string) => void;
+    setCurrentCwd: (cwd: string) => void;
+    createSession: (profileId?: string) => void;
+    activate: (sessionId: string) => void;
+    closeSession: (sessionId: string) => void;
+    switchActiveProfile: (profileId: string) => void;
+    restartAll: () => void;
+    refreshActivePrompt: () => void;
+    writeToActiveSession: (data: string) => Promise<void>;
+    executeCommandInCwd: (command: string, cwd: string) => Promise<void>;
+    dispose: () => void;
+}
+export declare function useTerminalState(): TerminalState;

package/dist/lib/types.d.ts

@@ -0,0 +1,12 @@
+export interface ResolvedEntryStyle {
+    color?: string;
+    opacity?: number;
+    fontWeight?: string | number;
+    fontStyle?: string;
+    fontStretch?: string;
+    fontVariant?: string;
+    textDecoration?: string;
+    icon: string | null;
+    sortPriority: number;
+    groupFirst: boolean;
+}

package/dist/lib/userKeybindings.d.ts

@@ -0,0 +1,3 @@
+import { Bridge } from '../features/bridge';
+export declare function initUserKeybindings(bridge: Bridge): Promise<void>;
+export declare function disposeUserKeybindings(): Promise<void>;

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

@@ -0,0 +1,45 @@
+/**
+ * Container path utilities.
+ *
+ * A "container path" represents a location inside a file that can be browsed
+ * like a directory (e.g. a ZIP archive). The null byte '\0' is used as the
+ * separator between the real filesystem path and the inner path, because '\0'
+ * cannot appear in real file names on any supported platform.
+ *
+ * Examples:
+ *   /home/user/archive.zip\0           → root of archive.zip
+ *   /home/user/archive.zip\0/sub/dir   → /sub/dir inside archive.zip
+ *   C:/Users/user/arch.zip\0/inner     → /inner inside arch.zip (Windows)
+ *
+ * The existing dirname/join/basename functions in path.ts work correctly with
+ * container paths because they only manipulate '/' separators — the '\0' passes
+ * through untouched.  The only addition required is getBreadcrumbSegments, which
+ * splits on '\0' to produce the mixed real-path + inner-path breadcrumb.
+ */
+export declare const CONTAINER_SEP = "\0";
+/** Returns true if the path refers to a location inside a container file. */
+export declare function isContainerPath(path: string): boolean;
+/**
+ * Parse a container path into the real container-file path and the inner path.
+ * @returns containerFile — real FS path; innerPath — always starts with '/'.
+ */
+export declare function parseContainerPath(path: string): {
+    containerFile: string;
+    innerPath: string;
+};
+/**
+ * Build a container path.
+ * @param containerFile — real FS path of the container file.
+ * @param innerPath — path within the container; '/' means the root.
+ */
+export declare function buildContainerPath(containerFile: string, innerPath: string): string;
+/**
+ * Return the real filesystem path of the outermost container file.
+ * For a plain path, returns the path unchanged.
+ */
+export declare function containerFile(path: string): string;
+/**
+ * Return the inner path from a container path.
+ * Returns '/' when at the container root, or the path unchanged for plain paths.
+ */
+export declare function containerInner(path: string): string;

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

@@ -0,0 +1 @@
+export declare function cx(styles: Record<string, string>, ...classNames: Array<string | false | null | undefined>): string;

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

@@ -0,0 +1,9 @@
+/**
+ * Spread onto text/search `<input>`s to disable browser autocompletion, spellcheck,
+ * and mobile autocorrect/capitalization for path-like fields.
+ */
+export declare const INPUT_NO_ASSIST: {
+    readonly autoComplete: "off";
+    readonly spellCheck: false;
+    readonly autoCapitalize: "none";
+};

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

@@ -0,0 +1 @@
+export declare function detectLang(name: string): string;

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

@@ -0,0 +1,7 @@
+/**
+ * Helpers for detecting image/video files (used for viewer gallery and focus).
+ * Viewer implementations live in extensions (e.g. dotdir-image-viewer).
+ */
+export declare function isImageFile(name: string): boolean;
+export declare function isVideoFile(name: string): boolean;
+export declare function isMediaFile(name: string): boolean;

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

@@ -0,0 +1,26 @@
+export declare function normalizePath(path: string): string;
+export declare function isUncRoot(path: string): boolean;
+export declare function isRootPath(path: string): boolean;
+export declare function dirname(path: string): string;
+export declare function join(...parts: string[]): string;
+/**
+ * Resolves `.` and `..` segments (POSIX-style). Does not touch symlinks.
+ * Handles Unix absolute paths, Windows `C:/...`, and relative paths.
+ */
+export declare function resolveDotSegments(path: string): string;
+export declare function basename(path: string): string;
+/**
+ * Returns whether a file should be treated as executable.
+ * Uses mode bits (Unix) and/or executable extension (Windows and fallback).
+ */
+export declare function isFileExecutable(mode: number, fileName: string): boolean;
+/**
+ * Returns breadcrumb segments for a path. On Windows, first segment is the drive (e.g. "C:").
+ * Each segment has a display label and the full path up to that segment (for navigation).
+ * Container paths (real-file\0inner-path) produce a mixed breadcrumb: the real ancestors
+ * first, then the container-root segment, then the inner-path segments.
+ */
+export declare function getBreadcrumbSegments(path: string): {
+    label: string;
+    path: string;
+}[];

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

@@ -0,0 +1,2 @@
+/** Build a URL that serves an absolute VFS path. */
+export declare function vfsUrl(absPath: string): string;