@dotdirfm/ui 0.1.1

package/dist/lib/features/extensions/extensionHost.worker.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Extension Host Worker
+ *
+ * Runs in a Web Worker to isolate extension loading from the main thread.
+ * Can be safely terminated and restarted to pick up extension changes.
+ *
+ * Communication protocol with main thread:
+ *   Main → Worker:
+ *     { type: 'start', homePath: string }           — begin loading extensions
+ *     { type: 'readFileResult', id, data, error? }   — response to a file read request
+ *   Worker → Main:
+ *     { type: 'readFile', id, path }                 — request file contents
+ *     { type: 'loaded', extensions }                 — all extensions loaded
+ *     { type: 'error', message }                     — fatal loading error
+ */
+interface ExtensionIconTheme {
+    id: string;
+    label: string;
+    path: string;
+}
+interface ExtensionLanguage {
+    id: string;
+    aliases?: string[];
+    extensions?: string[];
+    filenames?: string[];
+    configuration?: string;
+}
+interface ExtensionGrammar {
+    language: string;
+    scopeName: string;
+    path: string;
+    embeddedLanguages?: Record<string, string>;
+}
+interface LoadedGrammar {
+    contribution: ExtensionGrammar;
+    content: object;
+}
+interface LoadedGrammarRef {
+    contribution: ExtensionGrammar;
+    /** Absolute path to the grammar JSON file on disk. */
+    path: string;
+}
+interface ExtensionViewerContribution {
+    id: string;
+    label: string;
+    patterns: string[];
+    mimeTypes?: string[];
+    entry: string;
+    priority?: number;
+}
+interface ExtensionEditorContribution {
+    id: string;
+    label: string;
+    patterns: string[];
+    mimeTypes?: string[];
+    langId?: string;
+    entry: string;
+    priority?: number;
+}
+interface ExtensionColorTheme {
+    id?: string;
+    label: string;
+    uiTheme: string;
+    path: string;
+}
+interface ExtensionCommand {
+    command: string;
+    title: string;
+    category?: string;
+    icon?: string;
+}
+interface ExtensionKeybinding {
+    command: string;
+    key: string;
+    mac?: string;
+    when?: string;
+}
+interface ExtensionFsProviderContribution {
+    id: string;
+    label: string;
+    patterns: string[];
+    entry: string;
+    priority?: number;
+    runtime?: "frontend" | "backend";
+}
+interface ExtensionShellIntegration {
+    shell: string;
+    label: string;
+    scriptPath: string;
+    executableCandidates: string[];
+    platforms?: ("darwin" | "linux" | "unix" | "windows")[];
+    hiddenCdTemplate?: string;
+    cwdEscape?: "posix" | "powershell" | "cmd";
+    lineEnding?: "\n" | "\r\n";
+    spawnArgs?: string[];
+    scriptArg?: boolean;
+}
+interface ExtensionContributions {
+    iconTheme?: ExtensionIconTheme;
+    themes?: ExtensionColorTheme[];
+    languages?: ExtensionLanguage[];
+    grammars?: ExtensionGrammar[];
+    viewers?: ExtensionViewerContribution[];
+    editors?: ExtensionEditorContribution[];
+    commands?: ExtensionCommand[];
+    keybindings?: ExtensionKeybinding[];
+    fsProviders?: ExtensionFsProviderContribution[];
+    shellIntegrations?: ExtensionShellIntegration[];
+}
+interface ExtensionManifest {
+    name: string;
+    version: string;
+    publisher: string;
+    displayName?: string;
+    description?: string;
+    activationEvents?: string[];
+    /**
+     * Optional browser activation script entry.
+     * If present, the host will load it and call exported `activate()` / `deactivate()`.
+     */
+    browser?: string;
+    contributes?: ExtensionContributions;
+}
+interface ExtensionRef {
+    publisher: string;
+    name: string;
+    version: string;
+    /** Optional absolute path for development; when set, load from this dir instead of extensionsDir. */
+    path?: string;
+}
+interface WorkerLoadedColorTheme {
+    id: string;
+    label: string;
+    uiTheme: string;
+    jsonPath: string;
+}
+export interface WorkerLoadedExtension {
+    ref: ExtensionRef;
+    manifest: ExtensionManifest;
+    dirPath: string;
+    iconThemeFss?: string;
+    iconThemeFssPath?: string;
+    iconThemeBasePath?: string;
+    vscodeIconThemePath?: string;
+    vscodeIconThemeId?: string;
+    colorThemes?: WorkerLoadedColorTheme[];
+    languages?: ExtensionLanguage[];
+    /** Grammar contributions (lazy JSON loading for editor). */
+    grammarRefs?: LoadedGrammarRef[];
+    /** Previously loaded grammars (kept for compatibility). */
+    grammars?: LoadedGrammar[];
+    viewers?: ExtensionViewerContribution[];
+    editors?: ExtensionEditorContribution[];
+    /** Command contributions from this extension */
+    commands?: ExtensionCommand[];
+    /** Keybinding contributions from this extension */
+    keybindings?: ExtensionKeybinding[];
+    /** FsProvider contributions from this extension */
+    fsProviders?: ExtensionFsProviderContribution[];
+    /** Shell integration contributions (scripts fully loaded). */
+    shellIntegrations?: Array<{
+        shell: string;
+        label: string;
+        script: string;
+        executableCandidates: string[];
+        platforms?: ("darwin" | "linux" | "unix" | "windows")[];
+        hiddenCdTemplate?: string;
+        cwdEscape?: "posix" | "powershell" | "cmd";
+        lineEnding?: "\n" | "\r\n";
+        spawnArgs?: string[];
+        scriptArg?: boolean;
+    }>;
+}
+export {};

package/dist/lib/features/extensions/extensionHostClient.d.ts

@@ -0,0 +1,29 @@
+import { Bridge } from '../../../features/bridge';
+import { LoadedExtension } from './extensions';
+type ExtensionsLoadedCallback = (extensions: LoadedExtension[]) => void;
+export declare class ExtensionHostClient {
+    private bridge;
+    private worker;
+    private homePath;
+    private listeners;
+    private starting;
+    private nextRequestId;
+    private pendingRequests;
+    constructor(bridge: Bridge);
+    /** Subscribe to extension load events. Returns an unsubscribe function. */
+    onLoaded(cb: ExtensionsLoadedCallback): () => void;
+    /** Start the extension host worker. Non-blocking — extensions load in background. */
+    start(): Promise<void>;
+    /** Terminate the current worker and start a fresh one. */
+    restart(): Promise<void>;
+    /** Terminate the worker and clean up. */
+    dispose(): void;
+    activateByEvent(event: string): Promise<void>;
+    executeCommand(command: string, args?: unknown[]): Promise<void>;
+    private spawnWorker;
+    private request;
+    private handleFileRead;
+}
+export declare const extensionHostClientAtom: import('jotai').Atom<ExtensionHostClient>;
+export declare function useExtensionHostClient(): ExtensionHostClient;
+export {};

package/dist/lib/features/extensions/extensionLoader.d.ts

@@ -0,0 +1,8 @@
+import { Bridge } from '../../../features/bridge';
+/**
+ * Read the extension entry file and return a blob URL for the script.
+ * Caller must revoke the URL when done (e.g. when extension is disposed or cache cleared).
+ */
+export declare function getExtensionScriptUrl(bridge: Bridge, extensionDirPath: string, entry: string): Promise<{
+    scriptUrl: string;
+}>;

package/dist/lib/features/extensions/extensions.d.ts

@@ -0,0 +1,251 @@
+import { Bridge, CwdEscapeMode } from '../../../features/bridge';
+export declare const MARKETPLACE_URL = "https://dotdir.dev";
+export interface ExtensionIconThemeFss {
+    id: string;
+    label: string;
+    path: string;
+}
+export interface ExtensionIconThemeVSCode {
+    id: string;
+    label: string;
+    path: string;
+}
+export type ExtensionIconTheme = ExtensionIconThemeFss | ExtensionIconThemeVSCode;
+export interface ExtensionLanguage {
+    id: string;
+    aliases?: string[];
+    extensions?: string[];
+    filenames?: string[];
+    configuration?: string;
+}
+export interface ExtensionGrammar {
+    language: string;
+    scopeName: string;
+    path: string;
+    embeddedLanguages?: Record<string, string>;
+}
+export interface ExtensionCommand {
+    command: string;
+    title: string;
+    category?: string;
+    icon?: string;
+}
+export interface ExtensionKeybinding {
+    command: string;
+    key: string;
+    mac?: string;
+    when?: string;
+}
+export interface ExtensionMenu {
+    command: string;
+    group?: string;
+    when?: string;
+}
+export interface ExtensionViewerContribution {
+    id: string;
+    label: string;
+    patterns: string[];
+    mimeTypes?: string[];
+    entry: string;
+    priority?: number;
+}
+export interface ExtensionEditorContribution {
+    id: string;
+    label: string;
+    patterns: string[];
+    mimeTypes?: string[];
+    langId?: string;
+    entry: string;
+    priority?: number;
+}
+/**
+ * An fsProvider contribution allows an extension to expose the contents of a
+ * file (e.g. a ZIP archive) as a browsable directory tree.
+ * Patterns match the container file name (same glob syntax as viewers/editors).
+ */
+export interface ExtensionFsProviderContribution {
+    id: string;
+    label: string;
+    patterns: string[];
+    entry: string;
+    priority?: number;
+    /**
+     * Where the provider runs.
+     * - 'frontend' (default): a JS/CJS bundle loaded in the browser context.
+     * - 'backend': a WASM module executed by the Rust host via wasmtime.
+     */
+    runtime?: "frontend" | "backend";
+}
+export interface ExtensionColorTheme {
+    id?: string;
+    label: string;
+    uiTheme: string;
+    path: string;
+}
+/**
+ * A shellIntegration contribution declares a shell that .dir can spawn:
+ * how to find its executable and what init script to inject.
+ *
+ * The `shell` value matches the executable basename (without .exe on Windows),
+ * e.g. "bash", "zsh", "fish", "pwsh", "cmd".
+ */
+export interface ExtensionShellIntegration {
+    shell: string;
+    /** Display label shown in the shell picker dropdown. */
+    label: string;
+    /** Relative path to the init script file within the extension directory. */
+    scriptPath: string;
+    /**
+     * Ordered list of filesystem paths to check for the shell executable.
+     * Supports $VAR substitution from environment variables.
+     * The first existing path wins for each platform.
+     */
+    executableCandidates: string[];
+    /** Optional platform filter. If omitted, applies to all platforms. */
+    platforms?: ("darwin" | "linux" | "unix" | "windows")[];
+    /** Hidden `cd` line before running a command from the UI; must contain `{{cwd}}`. */
+    hiddenCdTemplate?: string;
+    cwdEscape?: CwdEscapeMode;
+    lineEnding?: "\n" | "\r\n";
+    /** Extra argv after the shell executable (e.g. `--noprofile` for bash). */
+    spawnArgs?: string[];
+    /**
+     * When true, the init script is passed as the last CLI argument (after spawnArgs)
+     * rather than written to PTY stdin. Use for shells like pwsh that accept `-Command <script>`.
+     */
+    scriptArg?: boolean;
+}
+export interface ExtensionContributions {
+    iconTheme?: ExtensionIconTheme;
+    iconThemes?: ExtensionIconThemeVSCode[];
+    themes?: ExtensionColorTheme[];
+    languages?: ExtensionLanguage[];
+    grammars?: ExtensionGrammar[];
+    commands?: ExtensionCommand[];
+    keybindings?: ExtensionKeybinding[];
+    menus?: {
+        commandPalette?: ExtensionMenu[];
+        "explorer/context"?: ExtensionMenu[];
+    };
+    viewers?: ExtensionViewerContribution[];
+    editors?: ExtensionEditorContribution[];
+    fsProviders?: ExtensionFsProviderContribution[];
+    shellIntegrations?: ExtensionShellIntegration[];
+}
+export interface ExtensionManifest {
+    name: string;
+    version: string;
+    publisher: string;
+    displayName?: string;
+    description?: string;
+    icon?: string;
+    /**
+     * Optional browser activation script entry.
+     * If present, the host will load it and call its exported `activate()` / `deactivate()`.
+     */
+    browser?: string;
+    contributes?: ExtensionContributions;
+}
+export interface ExtensionRef {
+    publisher: string;
+    name: string;
+    version: string;
+    /** Optional absolute path for development; when set, load extension from this dir instead of ~/.dotdir/extensions/<publisher>-<name>-<version>. */
+    path?: string;
+}
+export interface LoadedGrammar {
+    contribution: ExtensionGrammar;
+    content: object;
+}
+export interface LoadedGrammarRef {
+    contribution: ExtensionGrammar;
+    /** Absolute path to the grammar JSON file on disk. */
+    path: string;
+}
+export interface LoadedColorTheme {
+    id: string;
+    label: string;
+    uiTheme: string;
+    jsonPath: string;
+}
+export interface LoadedExtension {
+    ref: ExtensionRef;
+    manifest: ExtensionManifest;
+    dirPath: string;
+    iconUrl?: string;
+    /** FSS-based icon theme content (lazy-loaded when active). */
+    iconThemeFss?: string;
+    /** Absolute path to the FSS icon theme file on disk (lazy-loaded). */
+    iconThemeFssPath?: string;
+    /** Directory containing the icon theme FSS file, for resolving relative url() paths */
+    iconThemeBasePath?: string;
+    /** VS Code icon theme JSON path (absolute) */
+    vscodeIconThemePath?: string;
+    /** VS Code icon theme ID */
+    vscodeIconThemeId?: string;
+    /** Color theme contributions from this extension */
+    colorThemes?: LoadedColorTheme[];
+    /** Language contributions from this extension */
+    languages?: ExtensionLanguage[];
+    /** Grammar contributions (lazy JSON loading for editor). */
+    grammarRefs?: LoadedGrammarRef[];
+    /** Previously loaded grammars (kept for compatibility). */
+    grammars?: LoadedGrammar[];
+    /** Command contributions from this extension */
+    commands?: ExtensionCommand[];
+    /** Keybinding contributions from this extension */
+    keybindings?: ExtensionKeybinding[];
+    /** Viewer contributions from this extension */
+    viewers?: ExtensionViewerContribution[];
+    /** Editor contributions from this extension */
+    editors?: ExtensionEditorContribution[];
+    /** FsProvider contributions from this extension */
+    fsProviders?: ExtensionFsProviderContribution[];
+    /** Shell integration contributions from this extension (fully resolved). */
+    shellIntegrations?: Array<{
+        shell: string;
+        label: string;
+        script: string;
+        executableCandidates: string[];
+        platforms?: ("darwin" | "linux" | "unix" | "windows")[];
+        hiddenCdTemplate?: string;
+        cwdEscape?: CwdEscapeMode;
+        lineEnding?: "\n" | "\r\n";
+        spawnArgs?: string[];
+        scriptArg?: boolean;
+    }>;
+}
+export interface MarketplaceExtension {
+    id: string;
+    name: string;
+    display_name: string;
+    description: string;
+    icon_url: string | null;
+    categories: string[];
+    tags: string[];
+    total_downloads: number;
+    publisher: {
+        username: string;
+        display_name: string | null;
+    };
+    latest_version: {
+        version: string;
+        archive_size: number;
+        created_at: string;
+    } | null;
+}
+export declare function loadExtensions(bridge: Bridge): Promise<LoadedExtension[]>;
+export declare function searchMarketplace(query?: string, page?: number): Promise<{
+    extensions: MarketplaceExtension[];
+    total: number;
+}>;
+export declare function installExtension(bridge: Bridge, publisherUsername: string, extName: string, version: string): Promise<void>;
+export declare function installVSCodeExtension(bridge: Bridge, publisherName: string, extName: string, downloadUrl: string): Promise<void>;
+export declare function uninstallExtension(bridge: Bridge, publisherUsername: string, extName: string): Promise<void>;
+export declare function extensionIconThemeId(ext: LoadedExtension): string | null;
+export declare function isVSCodeIconTheme(ext: LoadedExtension): boolean;
+export declare function colorThemeKey(ext: LoadedExtension, themeId: string): string;
+export declare function findColorTheme(exts: LoadedExtension[], key: string): {
+    ext: LoadedExtension;
+    theme: LoadedColorTheme;
+} | null;

package/dist/lib/features/extensions/useExtensionHost.d.ts

@@ -0,0 +1,6 @@
+interface UseExtensionHostOptions {
+    settingsLoaded: boolean;
+    onRefreshPanels: () => void;
+}
+export declare function useExtensionHost({ settingsLoaded, onRefreshPanels, }: UseExtensionHostOptions): void;
+export {};

package/dist/lib/features/file-icons/iconCache.d.ts

@@ -0,0 +1,3 @@
+import { Bridge } from '../../../features/bridge';
+export declare function loadIcons(bridge: Bridge, names: string[]): Promise<void>;
+export declare function getCachedIconUrl(name: string): string | undefined;

package/dist/lib/features/file-icons/iconResolver.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Unified Icon Resolver
+ *
+ * Provides a single interface for resolving file/folder icons,
+ * supporting both FSS-based and VS Code icon themes.
+ */
+export type IconThemeType = "fss" | "vscode" | "none";
+export declare function useSetIconTheme(): {
+    setIconTheme: (type: IconThemeType, path?: string) => Promise<void>;
+};
+export declare function useSetIconThemeKind(): {
+    setIconThemeKind: (kind: "dark" | "light") => void;
+};
+export declare function getIconThemeType(): IconThemeType;
+export declare function onIconThemeChange(listener: () => void): () => void;
+export interface ResolvedIcon {
+    path: string;
+    url: string | null;
+    fallbackUrl: string;
+}
+/**
+ * Resolve icon for a file or folder.
+ * Returns the icon path (for loading), cached URL if available, and a fallback URL.
+ */
+export declare function useResolveIcon(): (name: string, isDirectory: boolean, isExpanded: boolean, isRoot: boolean, langId?: string, fssIconPath?: string | null) => ResolvedIcon;
+/**
+ * Load icons by path.
+ * Handles both FSS (via iconCache) and VS Code (via vscodeIconTheme).
+ */
+export declare function useLoadIconsForPaths(): (paths: string[]) => Promise<void>;
+/**
+ * Get cached icon URL by path.
+ */
+export declare function useGetCachedIcon(): (path: string) => string | null;

package/dist/lib/features/file-icons/vscodeIconTheme.d.ts

@@ -0,0 +1,62 @@
+import { Bridge } from '../../../features/bridge';
+export interface VSCodeIconDefinition {
+    iconPath: string;
+}
+export interface VSCodeIconThemeJson {
+    iconDefinitions: Record<string, VSCodeIconDefinition>;
+    file?: string;
+    folder?: string;
+    folderExpanded?: string;
+    rootFolder?: string;
+    rootFolderExpanded?: string;
+    fileExtensions?: Record<string, string>;
+    fileNames?: Record<string, string>;
+    folderNames?: Record<string, string>;
+    folderNamesExpanded?: Record<string, string>;
+    languageIds?: Record<string, string>;
+    light?: {
+        file?: string;
+        folder?: string;
+        folderExpanded?: string;
+        fileExtensions?: Record<string, string>;
+        fileNames?: Record<string, string>;
+        folderNames?: Record<string, string>;
+        folderNamesExpanded?: Record<string, string>;
+    };
+    highContrast?: {
+        file?: string;
+        folder?: string;
+        folderExpanded?: string;
+        fileExtensions?: Record<string, string>;
+        fileNames?: Record<string, string>;
+        folderNames?: Record<string, string>;
+        folderNamesExpanded?: Record<string, string>;
+    };
+}
+export interface LoadedVSCodeIconTheme {
+    json: VSCodeIconThemeJson;
+    basePath: string;
+    iconCache: Map<string, string>;
+}
+export interface IconMatch {
+    iconPath: string | null;
+    iconUrl: string | null;
+}
+export declare class VSCodeIconThemeResolver {
+    private bridge;
+    private theme;
+    private loadingIcons;
+    private themeKind;
+    constructor(bridge: Bridge);
+    load(jsonPath: string): Promise<void>;
+    setTheme(kind: "dark" | "light"): void;
+    clear(): void;
+    isLoaded(): boolean;
+    private getEffectiveMap;
+    resolveIcon(name: string, isDirectory: boolean, isExpanded: boolean, isRoot: boolean, langId?: string): string | null;
+    loadIcon(iconPath: string): Promise<string | null>;
+    preloadIcons(paths: string[]): Promise<void>;
+    getCachedIcon(iconPath: string): string | null;
+}
+export declare const vscodeIconThemeAtom: import('jotai').Atom<VSCodeIconThemeResolver>;
+export declare function useVscodeIconTheme(): VSCodeIconThemeResolver;

package/dist/lib/features/file-ops/model/fileOperationHandlers.d.ts

@@ -0,0 +1,10 @@
+export interface FileOperationHandlers {
+    moveToTrash(sourcePaths: string[], refresh: () => void): void;
+    permanentDelete(sourcePaths: string[], refresh: () => void): void;
+    copy(sourcePaths: string[], refresh: () => void): void;
+    move(sourcePaths: string[], refresh: () => void): void;
+    rename(sourcePath: string, currentName: string, refresh: () => void): void;
+    pasteToCommandLine(text: string): void;
+}
+export declare function setFileOperationHandlers(handlers: FileOperationHandlers): void;
+export declare function getFileOperationHandlers(): FileOperationHandlers | null;

package/dist/lib/features/file-ops/model/useFileOperations.d.ts

@@ -0,0 +1,15 @@
+import { PanelSide } from '../../../../entities/panel/model/types';
+import { Dispatch, RefObject, SetStateAction } from 'react';
+export type { PanelSide };
+/** Minimal interface the hook needs from each panel. */
+export interface PanelHandle {
+    currentPath: string;
+    navigateTo(path: string, force?: boolean): void;
+}
+export declare function useFileOperations(activePanelRef: RefObject<PanelSide>, leftRef: RefObject<PanelHandle>, rightRef: RefObject<PanelHandle>, setSelectionKey: Dispatch<SetStateAction<number>>): {
+    handleCopy: (sourcePaths: string[], refresh: () => void) => void;
+    handleMove: (sourcePaths: string[], refresh: () => void) => void;
+    handleMoveToTrash: (sourcePaths: string[], refresh: () => void) => void;
+    handlePermanentDelete: (sourcePaths: string[], _refresh: () => void) => void;
+    handleRename: (sourcePath: string, currentName: string, refresh: () => void) => void;
+};

package/dist/lib/features/marketplace/vscodeMarketplace.d.ts

@@ -0,0 +1,33 @@
+/**
+ * VS Code Marketplace API and VSIX support
+ */
+export interface VSCodeExtension {
+    publisher: {
+        publisherName: string;
+        displayName: string;
+    };
+    extensionName: string;
+    displayName: string;
+    shortDescription: string;
+    versions: {
+        version: string;
+        assetUri: string;
+    }[];
+    statistics: {
+        statisticName: string;
+        value: number;
+    }[];
+}
+export interface VSCodeSearchResult {
+    results: {
+        extensions: VSCodeExtension[];
+    }[];
+}
+export declare function searchVSCodeMarketplace(query: string, page?: number): Promise<{
+    extensions: VSCodeExtension[];
+    total: number;
+}>;
+export declare function getVSCodeInstallCount(ext: VSCodeExtension): number;
+export declare function getVSCodeLatestVersion(ext: VSCodeExtension): string | null;
+export declare function getVSCodeDownloadUrl(ext: VSCodeExtension): string | null;
+export declare function getVSCodeIconUrl(ext: VSCodeExtension): string | null;

package/dist/lib/features/navigation/lib/commandLineCd.d.ts

@@ -0,0 +1,20 @@
+import { Bridge } from '../../../../features/bridge';
+export type ParsedCdCommand = {
+    kind: "setAlias";
+    alias: string;
+} | {
+    kind: "goAlias";
+    alias: string;
+} | {
+    kind: "chdir";
+    pathArg: string;
+} | {
+    kind: "error";
+    message: string;
+};
+/** Returns null if this is not a `cd` command (should run in terminal). */
+export declare function parseCdCommand(cmd: string): ParsedCdCommand | null;
+/** Resolve `cd` path argument relative to cwd (empty → home). */
+export declare function resolveCdPath(bridge: Bridge, pathArg: string, cwd: string): Promise<string>;
+/** True if path exists and can be listed as a directory. */
+export declare function isExistingDirectory(bridge: Bridge, path: string): Promise<boolean>;

package/dist/lib/features/settings/types.d.ts

@@ -0,0 +1,12 @@
+export interface DotDirSettings {
+    iconTheme?: string;
+    colorTheme?: string;
+    /**
+     * Max file size in bytes to open for editing.
+     * Use 0 (or any negative value) to disable the limit.
+     */
+    editorFileSizeLimit?: number;
+    showHidden?: boolean;
+    /** Command-line folder aliases: `cd:name` navigates to the absolute path. Set with `cd::name`. */
+    pathAliases?: Record<string, string>;
+}

package/dist/lib/features/settings/useUserSettings.d.ts

@@ -0,0 +1,6 @@
+import { DotDirSettings } from '../../../features/settings/types';
+export declare function useUserSettings(): {
+    settings: DotDirSettings;
+    ready: boolean;
+    updateSettings: (partial: Partial<DotDirSettings>) => void;
+};

package/dist/lib/features/settings/userSettings.d.ts

@@ -0,0 +1,8 @@
+import { Bridge } from '../../../features/bridge';
+import { DotDirSettings } from './types';
+export declare const DEFAULT_EDITOR_FILE_SIZE_LIMIT = 0;
+export declare function getSettings(): DotDirSettings;
+export declare function updateSettings(bridge: Bridge, partial: Partial<DotDirSettings>): void;
+export declare function onSettingsChange(callback: (settings: DotDirSettings) => void): () => void;
+export declare function initUserSettings(bridge: Bridge): Promise<DotDirSettings>;
+export declare function disposeUserSettings(): Promise<void>;