@fde-desktop/fde-core 0.3.8 → 0.4.2

package/dist/index.d.cts

@@ -1,68 +1,116 @@
-import * as zustand_middleware from 'zustand/middleware';
-import * as zustand from 'zustand';
-import * as framer_motion from 'framer-motion';
-import { Transition, TargetAndTransition, Variants } from 'framer-motion';
 import * as react from 'react';
-import { MouseEvent, RefObject, ReactNode, FC } from 'react';
-import { IconType } from 'react-icons';
-import * as _tanstack_react_query from '@tanstack/react-query';
+import react__default, { ReactNode, FC, MouseEvent, ReactElement } from 'react';
 import { MantineThemeOverride } from '@mantine/core';
+import i18n from 'i18next';
 export { default as i18n } from 'i18next';
+import * as framer_motion from 'framer-motion';
+import { Transition, TargetAndTransition, Variants } from 'framer-motion';
+import { IconType, IconBaseProps } from 'react-icons';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import * as zustand_middleware from 'zustand/middleware';
+import * as zustand from 'zustand';
 export { v4 as uuidv4 } from 'uuid';
 
-interface AppEntry {
-    id: string;
-    name: string;
-    icon: string;
-    fcIcon?: string;
-    iconUrl?: string;
-    iconColor?: string;
-    defaultWidth?: number;
-    defaultHeight?: number;
-    minWidth?: number | false;
-    minHeight?: number | false;
-    canMaximize?: boolean;
-    alwaysOnTop?: boolean;
-    autoLoad?: {
-        url: string;
-        name?: string;
-    };
-    hasContextMenu?: boolean;
-    multipleWindow?: boolean;
+type SupportedLanguage$2 = 'en' | 'es';
+interface CustomThemeColors {
+    taskbar: string;
+    window: string;
+    accent: string;
+}
+interface ISettingsState {
+    wallpaper: string | null;
+    wallpaperModule: string;
+    launcherIcon: string;
+    font: string;
+    downloadedFonts: string[];
+    fontSize: number;
+    animationDuration: number;
+    theme: FdeTheme;
+    themeSetManually: boolean;
+    customThemeColors: CustomThemeColors | null;
+    language: SupportedLanguage$2;
+    setWallpaper: (url: string | null) => void;
+    setWallpaperModule: (module: string) => void;
+    setLauncherIcon: (icon: string) => void;
+    setFont: (font: string) => void;
+    markFontDownloaded: (fontName: string) => void;
+    setFontSize: (size: number) => void;
+    setAnimationDuration: (duration: number) => void;
+    setThemeMode: (mode: ThemeMode) => void;
+    toggleTheme: () => void;
+    setThemeAutomatic: () => void;
+    applySystemTheme: (mode: ThemeMode) => void;
+    setCustomThemeColors: (colors: CustomThemeColors | null) => void;
+    setLanguage: (lang: SupportedLanguage$2) => void;
 }
 
-declare const DEFAULT_WINDOW_DIMENSIONS: {
-    readonly defaultWidth: 800;
-    readonly defaultHeight: 600;
-    readonly minWidth: 640;
-    readonly minHeight: 480;
-};
-declare const FilesApp: AppEntry;
-declare const SettingsApp: AppEntry;
-declare const NotepadApp: AppEntry;
-declare const ImageViewerApp: AppEntry;
-declare const PdfApp: AppEntry;
-declare const UploaderApp: AppEntry;
-declare const MenuEditApp: AppEntry;
-declare const DeviceInfoApp: AppEntry;
-declare const CalendarApp: AppEntry;
-declare const CORE_APPS: AppEntry[];
-declare const CORE_APP_IDS: string[];
-
-interface CreateFolderOptions {
-    iconName?: string;
-    iconColor?: string;
+type ThemeMode = 'light' | 'dark';
+interface Theme {
+    mode: ThemeMode;
+    desktop: string;
+    taskbar: string;
+    window: string;
+    accent: string;
+}
+interface WindowTheme {
+    borderRadius: string;
+    headerHeight: number;
+    minWidth: number;
+    minHeight: number;
+    defaultWidth: number;
+    defaultHeight: number;
+    shadow: string;
+}
+interface TaskbarTheme {
+    height: number;
+    position: 'bottom' | 'top';
+    background: string;
+    blur: boolean;
+}
+interface DesktopTheme {
+    background: string;
+    iconSize: number;
+    iconSpacing: number;
+}
+interface FdeTheme {
+    mode: ThemeMode;
+    colors: {
+        desktop: string;
+        taskbar: string;
+        window: string;
+        accent: string;
+    };
+    window: WindowTheme;
+    taskbar: TaskbarTheme;
+    desktop: DesktopTheme;
+}
+interface PartialFdeTheme {
+    mode?: ThemeMode;
+    colors?: Partial<FdeTheme['colors']>;
+    window?: Partial<WindowTheme>;
+    taskbar?: Partial<TaskbarTheme>;
+    desktop?: Partial<DesktopTheme>;
+}
+interface IThemeProvider {
+    getTheme(): FdeTheme;
+    setMode(mode: ThemeMode): void;
+    toggle(): void;
+    setCustomColors(colors: CustomThemeColors | null): void;
 }
 
-interface FolderNode extends FileSystemNode {
-    type: 'folder';
-    children: string[];
-    iconName?: string;
-    iconColor?: string;
+interface ThemeProviderProps {
+    children: react__default.ReactNode;
+    initialMode?: ThemeMode;
+    /** External mode override - when provided, syncs internal state with this value */
+    mode?: ThemeMode;
+    theme?: PartialFdeTheme;
 }
+declare function ThemeProvider({ children, initialMode, mode: externalMode, theme, }: ThemeProviderProps): react__default.ReactElement;
 
-type FileSystemNodeType = 'file' | 'folder';
-type FSNode = FileNode | FolderNode;
+declare function useTheme(): FdeTheme;
+declare function useThemeContext(): IThemeProvider;
+
+declare const DEFAULT_FDE_THEME: Record<ThemeMode, FdeTheme>;
 
 interface FileSystemNode {
     id: string;
@@ -82,6 +130,16 @@ interface FileNode extends FileSystemNode {
     iconColor?: string;
 }
 
+interface FolderNode extends FileSystemNode {
+    type: 'folder';
+    children: string[];
+    iconName?: string;
+    iconColor?: string;
+}
+
+type FileSystemNodeType = 'file' | 'folder';
+type FSNode = FileNode | FolderNode;
+
 interface FsManifestFile {
     name: string;
     folder: string;
@@ -119,99 +177,68 @@ interface IFileSystem {
     clearAll(): Promise<void>;
 }
 
-declare class IndexedDBFileSystem implements IFileSystem {
-    private db;
-    private nodes;
-    private ready;
-    private initPromise;
-    private persistQueue;
-    private persistScheduled;
-    initialize(): Promise<void>;
-    private doInitialize;
-    private openDatabase;
-    private loadNodes;
-    private migrateFromLocalStorage;
-    isReady(): boolean;
-    reinitialize(): Promise<void>;
-    private persistAllNodes;
-    private schedulePersist;
-    private flushPersistQueue;
-    private persistNode;
-    private deleteNodeFromPersist;
-    saveBlob(blob: Blob): Promise<string>;
-    /** Accepts the full URL returned by saveBlob (e.g. `idb://{hash}`) */
-    getBlob(url: string): Promise<Blob | null>;
-    toBlobUrl(url: string): Promise<string | null>;
-    clearBlobs(): Promise<void>;
-    readFile(_path: string): Promise<string>;
-    writeFile(_path: string, _content: string): Promise<void>;
-    getNode(id: string): FSNode | undefined;
-    getChildren(folderId: string): FSNode[];
-    getRootNodes(): FSNode[];
-    getAllNodes(): FSNode[];
-    isEmpty(): boolean;
-    createFile(name: string, content: string, parentId: string | null, url?: string): Promise<FileNode>;
-    createFolder(name: string, parentId: string | null, iconName?: string, iconColor?: string): Promise<FolderNode>;
-    updateFile(id: string, content: string): Promise<FileNode>;
-    move(id: string, newParentId: string | null): Promise<FSNode>;
-    delete(id: string): Promise<void>;
-    getManifestSha(): Promise<string | null>;
-    saveManifestSha(sha: string): Promise<void>;
-    clearAll(): Promise<void>;
-    seed(manifest: FsManifest): Promise<void>;
-    mergeSeed(manifest: FsManifest): Promise<void>;
-    /**
-     * Builds a folderPath → FolderNode map from a manifest, creating all intermediate
-     * subfolders (e.g. "Documents/docker") as children of their parent folders.
-     * @param mergeMode - when true, reuse existing nodes from this.nodes instead of creating new ones
-     */
-    private buildFolderMapFromManifest;
-    private addChildToFolder;
-    private removeChildFromParent;
-    private deleteRecursive;
+interface FdeProviderProps {
+    children: react__default.ReactNode;
+    fileSystem: IFileSystem;
+    initialMode?: ThemeMode;
+    theme?: PartialFdeTheme;
+    mantineTheme?: MantineThemeOverride;
+    fallback?: react__default.ReactNode;
+    onError?: (error: Error) => void;
 }
+declare function FdeProvider({ children, fileSystem, initialMode, theme, mantineTheme, fallback, onError, }: FdeProviderProps): react__default.ReactElement;
 
-declare class DockerFileSystemAdapter implements IFileSystem {
-    private nodes;
-    private pathToId;
-    private ready;
-    private rootFolderId;
-    private initPromise;
-    constructor();
-    initialize(): Promise<void>;
-    private doInitialize;
-    reinitialize(): Promise<void>;
-    isReady(): boolean;
-    isEmpty(): boolean;
-    getNode(id: string): FSNode | undefined;
-    getChildren(folderId: string): FSNode[];
-    getRootNodes(): FSNode[];
-    getAllNodes(): FSNode[];
-    createFile(name: string, content: string, parentId: string | null, url?: string): Promise<FileNode>;
-    createFolder(name: string, parentId: string | null, iconName?: string, iconColor?: string): Promise<FolderNode>;
-    updateFile(id: string, content: string): Promise<FileNode>;
-    move(id: string, newParentId: string | null): Promise<FSNode>;
-    delete(id: string): Promise<void>;
-    readFile(path: string): Promise<string>;
-    writeFile(path: string, content: string): Promise<void>;
-    saveBlob(blob: Blob): Promise<string>;
-    getBlob(url: string): Promise<Blob | null>;
-    toBlobUrl(url: string): Promise<string | null>;
-    getManifestSha(): Promise<string | null>;
-    saveManifestSha(_sha: string): Promise<void>;
-    seed(_manifest: FsManifest): Promise<void>;
-    mergeSeed(_manifest: FsManifest): Promise<void>;
-    clearAll(): Promise<void>;
-    private getMimeType;
-    private getPathFromId;
-    private deleteRecursive;
-    private syncFromEntries;
-    private fetchReaddir;
-    private writeFileToServer;
-    private createDirOnServer;
-    private deleteFromServer;
+interface FdeContextValue {
+    fs: IFileSystem | null;
+    isReady: boolean;
+    error: Error | null;
+    theme: FdeTheme;
+    setThemeMode: (mode: ThemeMode) => void;
+    toggleTheme: () => void;
+}
+
+declare function useFdeContext(): FdeContextValue;
+
+interface AppEntry {
+    id: string;
+    name: string;
+    icon: string;
+    fcIcon?: string;
+    iconUrl?: string;
+    iconColor?: string;
+    defaultWidth?: number;
+    defaultHeight?: number;
+    minWidth?: number | false;
+    minHeight?: number | false;
+    canMaximize?: boolean;
+    alwaysOnTop?: boolean;
+    autoLoad?: {
+        url: string;
+        name?: string;
+    };
+    hasContextMenu?: boolean;
+    singleWindow?: boolean;
 }
 
+type WindowState = 'normal' | 'minimized' | 'maximized';
+type WindowInput<T = Record<string, unknown>> = {
+    title: string;
+    content: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    minWidth?: number;
+    minHeight?: number;
+    icon?: string;
+    fcIcon?: string;
+    iconUrl?: string;
+    iconColor?: string;
+    canMaximize?: boolean;
+    alwaysOnTop?: boolean;
+    contentData?: T;
+};
+
 interface WindowEntity {
     id: string;
     title: string;
@@ -235,37 +262,239 @@ interface WindowEntity {
     closeInterceptor?: () => boolean;
 }
 
-type WindowState = 'normal' | 'minimized' | 'maximized';
-type WindowInput = Omit<WindowEntity, 'id' | 'isOpen' | 'state' | 'zIndex'>;
-
-interface DesktopIconEntity {
-    id: string;
-    name: string;
-    icon: string;
-    iconName?: string;
-    iconColor?: string;
-    x: number;
-    y: number;
-    appId: string;
-    nodeId?: string;
+interface MenuItemAction {
+    type: 'item';
+    label: string;
+    icon?: string;
+    onClick: () => void;
+    disabled?: boolean;
 }
-
-type DesktopIconInput = Omit<DesktopIconEntity, 'id'>;
-
-/**
- * Sorts an array of filesystem nodes: folders first, then files, each group
- * sorted alphabetically by name (locale-aware, case-insensitive).
- */
-declare const sortNodes: (nodes: FSNode[]) => FSNode[];
-type DesktopSortMode = 'default' | 'name-asc' | 'name-desc' | 'type';
-/**
- * Sorts desktop icons by DESKTOP_APPS_ORDER (apps first, then folders, then files).
- */
-declare const sortDesktopIcons: (icons: DesktopIconEntity[]) => DesktopIconEntity[];
-/**
- * Sorts desktop icons by the specified mode.
- */
-declare const sortDesktopIconsByMode: (icons: DesktopIconEntity[], mode: DesktopSortMode) => DesktopIconEntity[];
+interface MenuItemDivider {
+    type: 'divider';
+}
+interface MenuItemSlider {
+    type: 'slider';
+    label?: string;
+    min: number;
+    max: number;
+    value: number;
+    onChange: (value: number) => void;
+    labelFormat?: (value: number) => string;
+}
+type MenuItem = MenuItemAction | MenuItemDivider | MenuItemSlider;
+interface AppMenuDropdown {
+    type: 'menu';
+    label: string;
+    icon?: string;
+    items: MenuItem[];
+    rightSection?: ReactNode;
+}
+interface AppMenuCombobox {
+    type: 'combobox';
+    label?: string;
+    options: string[];
+    value: string;
+    onChange: (value: string) => void;
+}
+interface AppMenuSwitch {
+    type: 'switch';
+    label: string;
+    checked: boolean;
+    onChange: (value: boolean) => void;
+}
+interface AppMenuSlider {
+    type: 'slider';
+    label?: string;
+    min: number;
+    max: number;
+    value: number;
+    onChange: (value: number) => void;
+    marks?: {
+        value: number;
+        label?: string;
+    }[];
+    labelFormat?: (value: number) => string;
+}
+interface AppMenuTextInput {
+    type: 'text-input';
+    placeholder?: string;
+    value: string;
+    onChange: (value: string) => void;
+}
+interface AppMenuNumberInput {
+    type: 'number-input';
+    label?: string;
+    value: number;
+    onChange: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    placeholder?: string;
+}
+interface AppMenuSelect {
+    type: 'select';
+    label?: string;
+    options: {
+        value: string;
+        label: string;
+    }[];
+    value: string;
+    onChange: (value: string) => void;
+}
+interface AppMenuDirtyIndicator {
+    type: 'dirty-indicator';
+}
+type AppMenuElement = AppMenuDropdown | AppMenuCombobox | AppMenuSwitch | AppMenuSlider | AppMenuTextInput | AppMenuNumberInput | AppMenuSelect | AppMenuDirtyIndicator;
+
+interface WindowContentProps {
+    window?: WindowEntity;
+    notifyReady?: (contentData?: Record<string, unknown>) => void;
+}
+type AppComponent$1 = FC<WindowContentProps>;
+type MenuBarBuilder = (window: WindowEntity) => AppMenuElement[] | undefined;
+interface MenuBarComponentProps {
+    windowId: string;
+    onExit: () => void;
+    contentData?: Record<string, unknown>;
+}
+type MenuBarComponent = FC<MenuBarComponentProps>;
+interface AppRegistration {
+    component: AppComponent$1;
+    buildMenuBar?: MenuBarBuilder;
+    MenuBarComponent?: MenuBarComponent;
+}
+
+interface DesktopIconEntity {
+    id: string;
+    name: string;
+    icon: string;
+    iconName?: string;
+    iconColor?: string;
+    x: number;
+    y: number;
+    appId: string;
+    nodeId?: string;
+}
+
+interface MenuPosition {
+    x: number;
+    y: number;
+}
+
+interface CreateFolderOptions {
+    iconName?: string;
+    iconColor?: string;
+}
+
+type LoadingState = 'idle' | 'fetching' | 'compiling' | 'loading' | 'ready' | 'error';
+interface LoadingProgress {
+    state: LoadingState;
+    progress: number;
+    message?: string;
+    appName?: string;
+    error?: string;
+}
+interface WindowLoading extends LoadingProgress {
+    windowId: string;
+}
+
+type DesktopIconInput = Omit<DesktopIconEntity, 'id'>;
+
+interface OpenAppOptions {
+    title?: string;
+    icon?: string;
+    contentData?: Record<string, unknown>;
+    position?: {
+        x?: number;
+        y?: number;
+    };
+    size?: {
+        width?: number;
+        height?: number;
+    };
+}
+interface FileDialogOptions {
+    acceptedMimeTypes?: string[];
+    multiple?: boolean;
+    defaultPath?: string;
+}
+interface SaveDialogOptions {
+    defaultName?: string;
+    defaultPath?: string;
+    acceptedMimeTypes?: string[];
+}
+interface NotificationOptions {
+    title: string;
+    message: string;
+    type?: 'info' | 'success' | 'warning' | 'error';
+    duration?: number;
+}
+type FdeEventType = 'window-opened' | 'window-closed' | 'window-focused' | 'window-minimized' | 'window-maximized' | 'file-opened' | 'file-saved' | 'theme-changed' | 'notification-shown';
+interface FdeEventPayloads {
+    'window-opened': {
+        windowId: string;
+        content: string;
+    };
+    'window-closed': {
+        windowId: string;
+    };
+    'window-focused': {
+        windowId: string;
+    };
+    'window-minimized': {
+        windowId: string;
+    };
+    'window-maximized': {
+        windowId: string;
+    };
+    'file-opened': {
+        path: string;
+        appId?: string;
+    };
+    'file-saved': {
+        path: string;
+        success: boolean;
+    };
+    'theme-changed': {
+        theme: string;
+    };
+    'notification-shown': {
+        notificationId: string;
+    };
+}
+interface FdeDesktopAPI {
+    openApp: (appId: string, options?: OpenAppOptions) => void;
+    closeWindow: (windowId?: string) => void;
+    minimizeWindow: (windowId?: string) => void;
+    maximizeWindow: (windowId?: string) => void;
+    restoreWindow: (windowId?: string) => void;
+    focusWindow: (windowId?: string) => void;
+    openFile: (path: string, appId?: string) => void;
+    openFileDialog: (options?: FileDialogOptions) => Promise<string | null>;
+    saveFile: (content: string, options?: SaveDialogOptions) => Promise<boolean>;
+    saveFileDialog: (options?: SaveDialogOptions) => Promise<string | null>;
+    getTheme: () => Record<string, unknown>;
+    setTheme: (theme: Record<string, unknown>) => void;
+    showNotification: (options: NotificationOptions) => string;
+    hideNotification: (notificationId: string) => void;
+    getWindows: () => WindowEntity[];
+    getActiveWindow: () => WindowEntity | null;
+    getWindowById: (windowId: string) => WindowEntity | null;
+    fs: IFileSystem;
+    on: <T extends FdeEventType>(event: T, callback: (data: FdeEventPayloads[T]) => void) => () => void;
+    off: <T extends FdeEventType>(event: T, callback: (data: FdeEventPayloads[T]) => void) => void;
+    appReady: (appId: string) => void;
+    registerAppInstance: (appId: string, instance: unknown) => void;
+}
+declare global {
+    interface Window {
+        __FDE_API__?: FdeDesktopAPI;
+    }
+}
+
+declare const createWindow: (input: WindowInput) => WindowEntity;
+
+declare const createDesktopIcon: (input: DesktopIconInput) => DesktopIconEntity;
 
 interface LauncherFolder {
     id: string;
@@ -285,8 +514,12 @@ interface LauncherFolderInput {
     order?: number;
 }
 declare const createLauncherFolder: (input: LauncherFolderInput) => LauncherFolder;
+declare const createPredefinedLauncherFolder: (input: Omit<LauncherFolderInput, "isPredefined">) => LauncherFolder;
 declare const updateLauncherFolder: (folder: LauncherFolder, updates: Partial<Omit<LauncherFolder, "id" | "isPredefined">>) => LauncherFolder;
 
+declare const createFolder: (name: string, parentId?: string | null, options?: CreateFolderOptions) => FolderNode;
+declare const createFile: (name: string, content: string, parentId?: string | null, mimeType?: string, url?: string) => FileNode;
+
 interface CustomAppManifest {
     id: string;
     name: string;
@@ -301,14 +534,43 @@ interface CustomAppManifest {
         minHeight?: number | false;
         canMaximize?: boolean;
         alwaysOnTop?: boolean;
+        singleWindow?: boolean;
     };
 }
+interface AppsManifest {
+    version: string;
+    generated: string;
+    apps: CustomAppManifest[];
+}
+declare function fetchAppManifest(forceRefresh?: boolean): Promise<AppsManifest | null>;
+declare function getCachedManifest(): AppsManifest | null;
+declare function clearManifestCache(): void;
+declare function updateManifestCache(manifest: CustomAppManifest): void;
+declare function removeFromManifestCache(appId: string): void;
+declare function getCustomApps(): Promise<CustomAppManifest[]>;
+declare function getCustomAppById(appId: string): Promise<CustomAppManifest | undefined>;
+declare function isCustomApp(appId: string): boolean;
+declare function convertToAppEntry(manifest: CustomAppManifest): Partial<AppEntry>;
+declare function mergeAppsWithCustomApps(staticApps: AppEntry[], customApps: CustomAppManifest[]): AppEntry[];
+declare function syncWithServer(currentRegisteredApps: Record<string, CustomAppManifest>): Promise<{
+    added: CustomAppManifest[];
+    removed: string[];
+    manifest: AppsManifest | null;
+}>;
 
 type ClipboardAction = 'copy' | 'cut' | null;
 interface ClipboardState {
     content: FSNode[];
     action: ClipboardAction;
 }
+type DesktopSortMode$1 = 'default' | 'name-asc' | 'name-desc' | 'type';
+interface NotificationItem {
+    id: string;
+    title: string;
+    message: string;
+    onClose?: () => void;
+    fcIcon?: string;
+}
 interface DesktopState {
     windows: WindowEntity[];
     openWindow: (input: WindowInput) => void;
@@ -357,10 +619,10 @@ interface DesktopState {
     viewportHeight: number;
     isViewportInitialized: boolean;
     setViewportSize: (width: number, height: number) => void;
-    desktopSortMode: DesktopSortMode;
-    filesSortMode: DesktopSortMode;
-    setDesktopSortMode: (mode: DesktopSortMode) => void;
-    setFilesSortMode: (mode: DesktopSortMode) => void;
+    desktopSortMode: DesktopSortMode$1;
+    filesSortMode: DesktopSortMode$1;
+    setDesktopSortMode: (mode: DesktopSortMode$1) => void;
+    setFilesSortMode: (mode: DesktopSortMode$1) => void;
     launcherFolders: LauncherFolder[];
     setLauncherFolders: (folders: LauncherFolder[]) => void;
     createLauncherFolder: (input: LauncherFolderInput) => LauncherFolder;
@@ -374,89 +636,6 @@ interface DesktopState {
     handleCustomAppRegistered: (manifest: CustomAppManifest) => void;
     handleCustomAppUnregistered: (appId: string) => void;
 }
-interface NotificationItem {
-    id: string;
-    title: string;
-    message: string;
-    onClose?: () => void;
-    fcIcon?: string;
-}
-
-declare const fileSystem: IndexedDBFileSystem | DockerFileSystemAdapter;
-/** Sync reset for tests — clears in-memory state immediately, async DB flush follows. */
-declare const resetFileSystem: () => void;
-declare const resetWindowManager: () => void;
-declare const useDesktopStore: zustand.UseBoundStore<Omit<zustand.StoreApi<DesktopState>, "setState" | "persist"> & {
-    setState(partial: DesktopState | Partial<DesktopState> | ((state: DesktopState) => DesktopState | Partial<DesktopState>), replace?: false | undefined): unknown;
-    setState(state: DesktopState | ((state: DesktopState) => DesktopState), replace: true): unknown;
-    persist: {
-        setOptions: (options: Partial<zustand_middleware.PersistOptions<DesktopState, unknown, unknown>>) => void;
-        clearStorage: () => void;
-        rehydrate: () => Promise<void> | void;
-        hasHydrated: () => boolean;
-        onHydrate: (fn: (state: DesktopState) => void) => () => void;
-        onFinishHydration: (fn: (state: DesktopState) => void) => () => void;
-        getOptions: () => Partial<zustand_middleware.PersistOptions<DesktopState, unknown, unknown>>;
-    };
-}>;
-
-type ThemeMode = 'light' | 'dark';
-interface Theme {
-    mode: ThemeMode;
-    desktop: string;
-    taskbar: string;
-    window: string;
-    accent: string;
-}
-
-declare const SUPPORTED_LANGUAGES: readonly ["en", "es"];
-type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];
-
-interface CustomThemeColors {
-    taskbar: string;
-    window: string;
-    accent: string;
-}
-interface ISettingsState {
-    wallpaper: string | null;
-    wallpaperModule: string;
-    launcherIcon: string;
-    font: string;
-    downloadedFonts: string[];
-    fontSize: number;
-    animationDuration: number;
-    theme: Theme;
-    themeSetManually: boolean;
-    customThemeColors: CustomThemeColors | null;
-    language: SupportedLanguage;
-    setWallpaper: (url: string | null) => void;
-    setWallpaperModule: (module: string) => void;
-    setLauncherIcon: (icon: string) => void;
-    setFont: (font: string) => void;
-    markFontDownloaded: (fontName: string) => void;
-    setFontSize: (size: number) => void;
-    setAnimationDuration: (duration: number) => void;
-    setThemeMode: (mode: ThemeMode) => void;
-    toggleTheme: () => void;
-    setThemeAutomatic: () => void;
-    applySystemTheme: (mode: ThemeMode) => void;
-    setCustomThemeColors: (colors: CustomThemeColors | null) => void;
-    setLanguage: (lang: SupportedLanguage) => void;
-}
-
-declare const useSettingsStore: zustand.UseBoundStore<Omit<zustand.StoreApi<ISettingsState>, "setState" | "persist"> & {
-    setState(partial: ISettingsState | Partial<ISettingsState> | ((state: ISettingsState) => ISettingsState | Partial<ISettingsState>), replace?: false | undefined): unknown;
-    setState(state: ISettingsState | ((state: ISettingsState) => ISettingsState), replace: true): unknown;
-    persist: {
-        setOptions: (options: Partial<zustand_middleware.PersistOptions<ISettingsState, unknown, unknown>>) => void;
-        clearStorage: () => void;
-        rehydrate: () => Promise<void> | void;
-        hasHydrated: () => boolean;
-        onHydrate: (fn: (state: ISettingsState) => void) => () => void;
-        onFinishHydration: (fn: (state: ISettingsState) => void) => () => void;
-        getOptions: () => Partial<zustand_middleware.PersistOptions<ISettingsState, unknown, unknown>>;
-    };
-}>;
 
 interface MountedAppState {
     isLoaded: boolean;
@@ -488,162 +667,408 @@ interface CustomAppState {
     resetHmrRetry: () => void;
 }
 
-declare const useCustomAppStore: zustand.UseBoundStore<zustand.StoreApi<CustomAppState>>;
+interface IWindowManager {
+    getAll(): WindowEntity[];
+    getById(id: string): WindowEntity | undefined;
+    open(input: WindowInput): WindowEntity;
+    close(id: string): void;
+    minimize(id: string): void;
+    maximize(id: string): void;
+    restore(id: string): void;
+    focus(id: string): void;
+    move(id: string, x: number, y: number): void;
+    resize(id: string, width: number, height: number): void;
+    loadWindows(windows: WindowEntity[]): void;
+}
 
-/**
- * Store for temporary snapshots used by the `useIsDirty` hook.
- * Each app (identified by a unique string id) can store its own snapshot.
- * Snapshots are persisted to `localStorage` so they survive page reloads.
- */
-interface AppTempMemoryState {
-    /** Mapping of appId → snapshot (any serializable value) */
-    snapshots: Record<string, unknown>;
-    /** Set a snapshot for a given appId */
-    setSnapshot: (appId: string, snapshot: unknown) => void;
-    /** Retrieve a snapshot for a given appId */
-    getSnapshot: (appId: string) => unknown | null;
-    /** Clear the snapshot for a given appId */
-    clearSnapshot: (appId: string) => void;
+interface WindowProps {
+    window: WindowEntity;
+    menuBar?: AppMenuElement[];
+    children?: ReactNode;
+    closeInterceptor?: () => boolean;
+}
+interface DesktopIconProps {
+    icon: DesktopIconEntity;
+    onDoubleClick: (appId: string, nodeId?: string) => void;
+    onContextMenu: (e: React.MouseEvent, nodeId: string) => void;
+}
+interface DesktopContextMenuProps {
+    opened: boolean;
+    position: MenuPosition;
+    onClose: () => void;
+    onOpenApp: (appId: string) => void;
+    onToggleTheme: () => void;
+}
+interface LauncherProps {
+    fcIcon?: string;
+    onContextMenu?: (e: React.MouseEvent) => void;
+}
+interface DesktopAreaProps {
+    children?: ReactNode;
+    onContextMenu?: (e: MouseEvent<HTMLDivElement>) => void;
+}
+interface TaskbarContextMenuProps {
+    windowMenuOpened: boolean;
+    panelMenuOpened: boolean;
+    launcherMenuOpened: boolean;
+    menuPosition: MenuPosition;
+    targetWindowId: string | null;
+    targetWindowState: string | null;
+    onCloseWindow: (id: string) => void;
+    onMinimizeWindow: (id: string) => void;
+    onMaximizeWindow: (id: string) => void;
+    onRestoreWindow: (id: string) => void;
+    onClose: () => void;
 }
-declare const useAppTempMemoryStore: zustand.UseBoundStore<Omit<zustand.StoreApi<AppTempMemoryState>, "setState" | "persist"> & {
-    setState(partial: AppTempMemoryState | Partial<AppTempMemoryState> | ((state: AppTempMemoryState) => AppTempMemoryState | Partial<AppTempMemoryState>), replace?: false | undefined): unknown;
-    setState(state: AppTempMemoryState | ((state: AppTempMemoryState) => AppTempMemoryState), replace: true): unknown;
-    persist: {
-        setOptions: (options: Partial<zustand_middleware.PersistOptions<AppTempMemoryState, unknown, unknown>>) => void;
-        clearStorage: () => void;
-        rehydrate: () => Promise<void> | void;
-        hasHydrated: () => boolean;
-        onHydrate: (fn: (state: AppTempMemoryState) => void) => () => void;
-        onFinishHydration: (fn: (state: AppTempMemoryState) => void) => () => void;
-        getOptions: () => Partial<zustand_middleware.PersistOptions<AppTempMemoryState, unknown, unknown>>;
-    };
-}>;
 
-type OpenAppOptions$1 = {
-    /** Extra data passed to the window's content component. */
-    contentData?: Record<string, unknown>;
-    /** Override position (e.g. for the initial seed window). */
-    position?: {
-        x: number;
-        y: number;
-    };
-};
-/**
- * Returns a stable `openApp(appId, options?)` callback that looks up app
- * metadata from static or custom apps, picks a random desktop position
- * (unless overridden) and calls `openWindow` on the desktop store.
- *
- * If `multipleWindow: true` on the app, always opens a new window.
- * Otherwise, focuses existing window if one is already open.
- */
-declare const useOpenApp: () => (appId: string, { contentData, position }?: OpenAppOptions$1) => void;
+interface FileIconProps {
+    type: 'file' | 'folder';
+    name?: string;
+    folderNode?: FolderNode;
+    fileNode?: FileNode;
+    size?: number;
+    iconName?: string;
+}
 
-interface OpenAppOptions {
-    title?: string;
+type AppComponent = FC<WindowContentProps>;
+interface AppRegistryEntry {
+    component?: AppComponent;
+    loader?: () => Promise<{
+        default: AppComponent;
+    }>;
+    menuBarLoader?: () => Promise<{
+        default: MenuBarComponent;
+    }>;
+    buildMenuBar?: MenuBarBuilder;
+    MenuBarComponent?: MenuBarComponent;
+    isLazy?: boolean;
+    appName?: string;
+    singleWindow?: boolean;
+    defaultWidth?: number;
+    defaultHeight?: number;
+    minWidth?: number | false;
+    minHeight?: number | false;
+    canMaximize?: boolean;
+    alwaysOnTop?: boolean;
     icon?: string;
-    contentData?: Record<string, unknown>;
-    position?: {
-        x?: number;
-        y?: number;
-    };
-    size?: {
-        width?: number;
-        height?: number;
-    };
+    fcIcon?: string;
+    iconUrl?: string;
+    iconColor?: string;
 }
-interface FileDialogOptions {
-    acceptedMimeTypes?: string[];
-    multiple?: boolean;
-    defaultPath?: string;
+declare function initRegistry(registry: Record<string, AppRegistryEntry>): void;
+declare function getAppComponent(content: string): AppComponent;
+declare function getMenuBarBuilder(content: string): MenuBarBuilder | undefined;
+declare function getMenuBarComponent(content: string): MenuBarComponent | undefined;
+declare function isLazyApp(content: string): boolean;
+declare function getAppName(content: string): string | undefined;
+declare function registerComponents(entries: Record<string, AppRegistryEntry>): void;
+declare const CORE_REGISTRY: Record<string, AppRegistryEntry>;
+
+interface FdeDesktopProps {
+    children?: react__default.ReactNode;
+    fallback?: react__default.ReactNode;
+    theme?: PartialFdeTheme;
+    mantineTheme?: MantineThemeOverride;
+    fileSystem?: IFileSystem;
+    initialMode?: ThemeMode;
+    customApps?: Record<string, AppRegistryEntry>;
+    onError?: (error: Error) => void;
+    /** URL or import of the default wallpaper image */
+    defaultWallpaper?: string;
+    /** App ID to open on startup */
+    initialApp?: string;
+    /** Loaders to prefetch in the background after startup */
+    prefetchLoaders?: Array<{
+        id: string;
+        loader: () => Promise<unknown>;
+    }>;
 }
-interface SaveDialogOptions {
-    defaultName?: string;
-    defaultPath?: string;
+declare function FdeDesktop({ children, fallback, theme, mantineTheme, fileSystem, initialMode, customApps, onError, defaultWallpaper, initialApp, prefetchLoaders, }: FdeDesktopProps): react__default.ReactElement;
+
+declare const Window: FC<WindowProps>;
+
+declare const AppReadyProvider: FC<{
+    children: ReactNode;
+}>;
+
+interface AppReadyContextValue {
+    notifyReady: (contentData?: Record<string, unknown>) => void;
+    getContentData: () => Record<string, unknown> | undefined;
+}
+declare const useAppReady: () => AppReadyContextValue;
+
+declare const FilesAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const NotesAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const ImageViewerAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const PdfAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const MenuEditAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const UploaderAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const SettingsAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const DeviceInfoAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const CalendarAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const CreateItemAppLazy: react.LazyExoticComponent<react.FC<WindowContentProps>>;
+declare const NotesMenuBarLazy: MenuBarComponent;
+declare const MenuEditMenuBarLazy: MenuBarComponent;
+declare const SettingsMenuBarLazy: MenuBarComponent;
+declare const PdfMenuBarLazy: MenuBarComponent;
+declare const ImageViewerMenuBarLazy: MenuBarComponent;
+
+interface AppMenuBarProps {
+    elements: AppMenuElement[];
+}
+declare const AppMenuBar: FC<AppMenuBarProps>;
+
+interface TaskbarProps {
+    calendarSlot?: ReactNode;
+}
+declare const Taskbar: FC<TaskbarProps>;
+
+declare const LanguageSelector: FC;
+
+declare const Launcher: FC<LauncherProps>;
+
+declare const TaskbarContextMenu: FC<TaskbarContextMenuProps>;
+
+interface DesktopProps extends DesktopAreaProps {
+    wallpaper?: string;
+    backgroundColor?: string;
+}
+declare const Desktop: FC<DesktopProps>;
+
+declare const DesktopIcon: FC<DesktopIconProps>;
+
+interface DynamicMenuBarRendererProps {
+    component?: MenuBarComponent;
+    windowId: string;
+    contentData: Record<string, unknown> | undefined;
+    onExit: () => void;
+}
+declare const DynamicMenuBarRenderer: FC<DynamicMenuBarRendererProps>;
+
+declare const ContextMenu: FC<DesktopContextMenuProps>;
+
+interface CreateItemContextMenuProps {
+    owner: string;
+    parentId: string | null;
+    currentPath: string;
+}
+declare const CreateItemContextMenu: FC<CreateItemContextMenuProps>;
+
+declare const CalendarApp: FC<WindowContentProps>;
+
+declare const FilesApp: FC<WindowContentProps>;
+
+declare const NotesApp: FC<WindowContentProps>;
+
+declare const ImageViewerApp: FC<WindowContentProps>;
+
+declare const PdfApp: FC<WindowContentProps>;
+
+declare const MenuEditApp: FC<WindowContentProps>;
+
+declare const UploaderApp: FC<WindowContentProps>;
+
+declare const StorybookApp: FC<WindowContentProps>;
+
+declare const SettingsApp: FC<WindowContentProps>;
+
+declare const DeviceInfoApp: FC<WindowContentProps>;
+
+interface SettingsSection$1 {
+    id: 'wallpaper' | 'appearance' | 'launcher' | 'font' | 'language' | 'reset';
+    label: string;
+    fcIcon: string;
+    description: string;
+}
+declare const SETTINGS_SECTIONS: SettingsSection$1[];
+
+declare const NotesMenuBar: FC<MenuBarComponentProps>;
+
+declare const MenuEditMenuBar: FC<MenuBarComponentProps>;
+
+declare const SettingsMenuBar: FC<MenuBarComponentProps>;
+
+declare const PdfMenuBar: FC<MenuBarComponentProps>;
+
+declare const ImageViewerMenuBar: FC<MenuBarComponentProps>;
+
+interface AppIconProps {
+    fcIcon?: string;
+    fallback?: string;
+    iconUrl?: string;
+    size?: number;
+    color?: string;
+}
+declare const AppIcon: FC<AppIconProps>;
+
+interface VscIconProps {
+    name: string;
+    size?: number;
+    color?: string;
+}
+declare const VscIcon: FC<VscIconProps>;
+
+interface AppLoadingProps {
+    message?: string;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+}
+declare const AppLoading: FC<AppLoadingProps>;
+
+interface DirtyIndicatorProps {
+    size?: number;
+}
+declare const DirtyIndicator: FC<DirtyIndicatorProps>;
+
+declare const ContextMenuAnchor: FC<MenuPosition>;
+
+declare const FileIcon: FC<FileIconProps>;
+
+interface AppEmptyStateProps {
+    label?: string;
+}
+declare const AppEmptyState: FC<AppEmptyStateProps>;
+
+interface ColorPickerProps {
+    value: string;
+    onChange: (color: string) => void;
+    error?: string;
+    disabled?: boolean;
+}
+declare const ColorPicker: FC<ColorPickerProps>;
+
+declare const CreateItemApp: FC<WindowContentProps>;
+
+type DownloadStatus = 'idle' | 'downloading' | 'done' | 'error';
+interface DownloadState {
+    status: DownloadStatus;
+    loaded: number;
+    total: number | null;
+    percent: number | null;
+    error: string | null;
+}
+interface UseDownloadReturn extends DownloadState {
+    download: (url: string) => Promise<string | null>;
+    reset: () => void;
+}
+declare const useDownload: () => UseDownloadReturn;
+
+interface DownloadProgressProps {
+    state: DownloadState;
+    ariaLabel?: string;
+    minDisplayTime?: number;
+}
+declare const DownloadProgress: FC<DownloadProgressProps>;
+
+interface FilePickerAppProps {
     acceptedMimeTypes?: string[];
+    onConfirm: (node: FileNode) => void;
+    onCancel: () => void;
 }
-interface NotificationOptions {
+declare const FilePickerApp: FC<FilePickerAppProps>;
+interface FilePickerModalProps extends FilePickerAppProps {
+    opened: boolean;
+}
+declare const FilePickerModal: FC<FilePickerModalProps>;
+
+interface PickerModalProps {
+    opened: boolean;
+    children: ReactNode;
+    ariaLabelKey: string;
+    ariaLabelNs?: string;
+}
+declare const PickerModal: react.NamedExoticComponent<PickerModalProps>;
+
+interface IconColorPickerProps {
+    selectedIcon: string;
+    selectedColor: string;
+    onIconChange: (icon: string) => void;
+    onColorChange: (color: string) => void;
+    colorError?: string;
+}
+declare const IconColorPicker: FC<IconColorPickerProps>;
+
+interface SettingsSectionProps {
     title: string;
-    message: string;
-    type?: 'info' | 'success' | 'warning' | 'error';
-    duration?: number;
+    description?: string;
+    children: ReactNode;
 }
-type FdeEventType = 'window-opened' | 'window-closed' | 'window-focused' | 'window-minimized' | 'window-maximized' | 'file-opened' | 'file-saved' | 'theme-changed' | 'notification-shown';
-interface FdeEventPayloads {
-    'window-opened': {
-        windowId: string;
-        content: string;
-    };
-    'window-closed': {
-        windowId: string;
-    };
-    'window-focused': {
-        windowId: string;
-    };
-    'window-minimized': {
-        windowId: string;
-    };
-    'window-maximized': {
-        windowId: string;
-    };
-    'file-opened': {
-        path: string;
-        appId?: string;
-    };
-    'file-saved': {
-        path: string;
-        success: boolean;
-    };
-    'theme-changed': {
-        theme: string;
-    };
-    'notification-shown': {
-        notificationId: string;
-    };
+declare const SettingsSection: FC<SettingsSectionProps>;
+
+interface ExternalLinkAppConfig {
+    icon: string;
+    iconColor: string;
+    title: string;
+    url: string;
+    buttonLabel: string;
+    description?: string;
 }
-interface FdeDesktopAPI {
-    openApp: (appId: string, options?: OpenAppOptions) => void;
-    closeWindow: (windowId?: string) => void;
-    minimizeWindow: (windowId?: string) => void;
-    maximizeWindow: (windowId?: string) => void;
-    restoreWindow: (windowId?: string) => void;
-    focusWindow: (windowId?: string) => void;
-    openFile: (path: string, appId?: string) => void;
-    openFileDialog: (options?: FileDialogOptions) => Promise<string | null>;
-    saveFile: (content: string, options?: SaveDialogOptions) => Promise<boolean>;
-    saveFileDialog: (options?: SaveDialogOptions) => Promise<string | null>;
-    getTheme: () => Record<string, unknown>;
-    setTheme: (theme: Record<string, unknown>) => void;
-    showNotification: (options: NotificationOptions) => string;
-    hideNotification: (notificationId: string) => void;
-    getWindows: () => WindowEntity[];
-    getActiveWindow: () => WindowEntity | null;
-    getWindowById: (windowId: string) => WindowEntity | null;
-    fs: IFileSystem;
-    on: <T extends FdeEventType>(event: T, callback: (data: FdeEventPayloads[T]) => void) => () => void;
-    off: <T extends FdeEventType>(event: T, callback: (data: FdeEventPayloads[T]) => void) => void;
-    appReady: (appId: string) => void;
-    registerAppInstance: (appId: string, instance: unknown) => void;
+declare const ExternalLinkApp: FC<WindowContentProps & {
+    config: ExternalLinkAppConfig;
+}>;
+
+declare const SUPPORTED_LANGUAGES$1: readonly ["en", "es"];
+type SupportedLanguage$1 = (typeof SUPPORTED_LANGUAGES$1)[number];
+
+interface LanguageFlagProps {
+    lang: SupportedLanguage$1;
+    size?: number;
 }
-declare global {
-    interface Window {
-        __FDE_API__?: FdeDesktopAPI;
-    }
+declare const LanguageFlag: FC<LanguageFlagProps>;
+
+interface CollapsibleSectionProps {
+    title: string;
+    fcIcon?: string;
+    expanded: boolean;
+    onToggle: () => void;
+    children: ReactNode;
+    className?: string;
+    'aria-label'?: string;
 }
+declare const CollapsibleSection: FC<CollapsibleSectionProps>;
 
-declare function useFdeApi(): FdeDesktopAPI | null;
+interface CustomAppLoaderProps {
+    appId: string;
+    windowIcon?: string;
+    notifyReady?: WindowContentProps['notifyReady'];
+}
+declare const CustomAppLoader: FC<CustomAppLoaderProps>;
 
-declare const useNotifications: () => {
-    notifications: NotificationItem[];
-    notify: (title: string, message: string, options?: {
-        fcIcon?: string;
-        onClose?: () => void;
-    }) => string;
-    dismiss: (id: string) => void;
-    addNotification: (item: NotificationItem) => void;
-    removeNotification: (id: string) => void;
-};
+interface CustomAppLoadingScreenProps {
+    progress: LoadingProgress;
+    windowIcon?: string;
+}
+declare const CustomAppLoadingScreen: FC<CustomAppLoadingScreenProps>;
 
-declare const useSystemTheme: () => void;
+interface CustomAppOfflineProps {
+    appId: string;
+}
+declare const CustomAppOffline: FC<CustomAppOfflineProps>;
+
+interface CustomAppNotSupportedProps {
+    appId: string;
+}
+declare const CustomAppNotSupported: FC<CustomAppNotSupportedProps>;
+
+declare const registerCloseInterceptor: (windowId: string, interceptor: () => boolean) => void;
+declare const unregisterCloseInterceptor: (windowId: string) => void;
+declare const getCloseInterceptor: (windowId: string) => (() => boolean) | undefined;
+interface UseCloseInterceptorOptions {
+    isDirtyGetter: () => boolean;
+    windowId?: string;
+    onDiscard?: () => void;
+    onSave?: () => void;
+}
+declare function useCloseInterceptor({ isDirtyGetter, windowId, onDiscard, onSave, }: UseCloseInterceptorOptions): void;
+
+declare function useAppName(appId: string | undefined): string;
+
+declare function useFolderName(folder: {
+    id: string;
+    name: string;
+    isPredefined: boolean;
+}): string;
+
+declare const useClock: () => string;
 
 declare const useAnimationDuration: () => {
     duration: number;
@@ -674,9 +1099,35 @@ declare const useAnimationDuration: () => {
     easeOut: framer_motion.Transition;
 };
 
-declare function useAppName(appId: string | undefined): string;
+type IconLibrary = 'fi' | 'fc' | 'vsc';
+declare const useDynamicIcon: (name: string, library: IconLibrary) => IconType | null;
+declare const useDynamicIconElement: (name: string, library: IconLibrary, props?: IconBaseProps) => ReactElement | null;
+declare const useFiIcon: (name: string) => IconType | null;
+declare const useFcIcon: (name: string) => IconType | null;
+declare const useVscIcon: (name: string) => IconType | null;
+declare const useFiIconElement: (name: string, props?: IconBaseProps) => ReactElement | null;
+declare const useFcIconElement: (name: string, props?: IconBaseProps) => ReactElement | null;
+declare const useVscIconElement: (name: string, props?: IconBaseProps) => ReactElement | null;
 
-declare const useClock: () => string;
+declare const useTaskbarHeight: (opened: boolean) => {
+    menuRef: react.RefObject<HTMLDivElement | null>;
+    menuHeight: number;
+};
+
+type TaskbarMenuType = 'window' | 'panel' | 'launcher' | null;
+interface UseTaskbarContextMenuReturn {
+    activeMenu: TaskbarMenuType;
+    position: MenuPosition;
+    targetWindowId: string | null;
+    windowMenuOpened: boolean;
+    panelMenuOpened: boolean;
+    launcherMenuOpened: boolean;
+    openWindowMenu: (e: React.MouseEvent, windowId: string) => void;
+    openPanelMenu: (e: React.MouseEvent) => void;
+    openLauncherMenu: (e: React.MouseEvent) => void;
+    closeMenu: () => void;
+}
+declare const useTaskbarContextMenu: () => UseTaskbarContextMenuReturn;
 
 declare function useCollapsible(initialExpanded?: Set<string>): {
     expanded: Set<string>;
@@ -689,10 +1140,33 @@ declare function useCollapsible(initialExpanded?: Set<string>): {
     isExpanded: (id: string) => boolean;
 };
 
-interface MenuPosition {
-    x: number;
-    y: number;
+declare function useSearchFilter<T>(items: T[], searchQuery: string, getSearchableText: (item: T) => string | string[]): T[];
+
+interface RegistryContextValue {
+    register: (id: string, rect: DOMRect) => void;
+    unregister: (id: string) => void;
+    getRect: (id: string) => DOMRect | undefined;
 }
+declare const WindowButtonRegistryProvider: FC<{
+    children: ReactNode;
+}>;
+declare const useWindowButtonRegistry: () => RegistryContextValue;
+
+declare const AVAILABLE_FONTS: {
+    value: string;
+    label: string;
+    stack: string;
+}[];
+declare const FONT_STACKS: Record<string, string>;
+declare const GOOGLE_FONTS_HREF: Record<string, string>;
+
+/**
+ * Applies the currently selected font stack to the document root.
+ * Also re-injects <link> tags for all previously downloaded fonts on mount.
+ */
+declare const useApplyFont: () => void;
+
+declare const useAppUpdate: () => void;
 
 interface UseContextMenuReturn {
     opened: boolean;
@@ -702,141 +1176,68 @@ interface UseContextMenuReturn {
 }
 declare const useContextMenu: (offsetY?: number, appId?: string) => UseContextMenuReturn;
 
-interface DeviceInfo {
-    isMobile: boolean;
-    isTablet: boolean;
-    isDesktop: boolean;
-    isPortrait: boolean;
-    shouldShowWarning: boolean;
-    screenWidth: number;
-    screenHeight: number;
-}
-declare function useDeviceDetection(): DeviceInfo;
-
-type DownloadStatus = 'idle' | 'downloading' | 'done' | 'error';
-interface DownloadState {
-    status: DownloadStatus;
-    /** Bytes received so far */
-    loaded: number;
-    /** Total bytes, or null if Content-Length is not available */
-    total: number | null;
-    /** 0–100, or null when total is unknown */
-    percent: number | null;
-    error: string | null;
-}
-interface UseDownloadReturn extends DownloadState {
-    download: (url: string) => Promise<string | null>;
-    reset: () => void;
+type DragItemType = 'app' | 'file' | 'folder';
+type DropTargetType = 'launcher-folder' | 'filesystem-folder' | 'desktop' | 'available-apps';
+interface DragItemData {
+    type: DragItemType;
+    id: string;
+    name: string;
+    sourceId: string;
+    sourceType: DropTargetType;
+    metadata?: {
+        fcIcon?: string;
+        iconUrl?: string;
+        icon?: string;
+        iconColor?: string;
+    };
 }
-/**
- * Hook for tracking streamed HTTP downloads with real-time progress.
- * Returns a `download(url)` function that resolves with the response text
- * (or null on error) and updates progress state as data arrives.
- */
-declare const useDownload: () => UseDownloadReturn;
-
-type IconLibrary = 'fi' | 'fc' | 'vsc';
-declare const useDynamicIcon: (name: string, library: IconLibrary) => IconType | null;
-declare const useFiIcon: (name: string) => IconType | null;
-declare const useFcIcon: (name: string) => IconType | null;
-declare const useVscIcon: (name: string) => IconType | null;
-
-declare function useFolderName(folder: {
+interface DropTarget {
+    type: DropTargetType;
     id: string;
     name: string;
-    isPredefined: boolean;
-}): string;
-
-interface UseIsDirtyOptions<T> {
-    /** Mutable ref that holds the snapshot (used internally). */
-    snapshotRef: React.MutableRefObject<T | null>;
-    /** Function that returns the current state of the app. */
-    getCurrentState: () => T;
-    /** Optional initial snapshot – used when no stored snapshot exists. */
-    initialSnapshot?: T;
-    /** Optional callback invoked when the dirty flag changes. */
-    onChange?: (isDirty: boolean) => void;
-    /** Unique identifier for the app – used to persist the snapshot in the global store. */
-    appId?: string;
+    accepts: DragItemType[];
 }
-declare function useIsDirty<T>({ snapshotRef, getCurrentState, initialSnapshot, onChange, appId, }: UseIsDirtyOptions<T>): {
-    isDirty: boolean;
-    takeSnapshot: () => void;
-    reset: () => void;
-};
-
-interface UseJsDosOptions {
-    autoLoad?: {
-        url: string;
-        name?: string;
-    };
+interface DragDropContextValue {
+    activeItem: DragItemData | null;
+    overTarget: DropTarget | null;
 }
-interface UseJsDosReturn {
-    containerRef: RefObject<HTMLDivElement | null>;
-    isRunning: boolean;
-    isPaused: boolean;
-    isMuted: boolean;
-    volume: number;
-    isLoading: boolean;
-    error: string | null;
-    bundleName: string | null;
-    loadBundle: (url: string, name?: string) => Promise<void>;
-    exit: () => Promise<void>;
-    restart: () => Promise<void>;
-    pause: () => void;
-    resume: () => void;
-    mute: () => void;
-    unmute: () => void;
-    setVolume: (level: number) => void;
-}
-declare function useJsDos(options?: UseJsDosOptions): UseJsDosReturn;
-
-declare function useLanguageSync(): void;
-
-declare function useResolvedUrl(url: string | undefined): string | undefined;
-
-declare function useSearchFilter<T>(items: T[], searchQuery: string, getSearchableText: (item: T) => string | string[]): T[];
 
-declare const useTaskbarHeight: (opened: boolean) => {
-    menuRef: react.RefObject<HTMLDivElement | null>;
-    menuHeight: number;
-};
-
-type TaskbarMenuType = 'window' | 'panel' | 'launcher' | null;
-interface UseTaskbarContextMenuReturn {
-    activeMenu: TaskbarMenuType;
-    position: MenuPosition;
-    targetWindowId: string | null;
-    windowMenuOpened: boolean;
-    panelMenuOpened: boolean;
-    launcherMenuOpened: boolean;
-    openWindowMenu: (e: React.MouseEvent, windowId: string) => void;
-    openPanelMenu: (e: React.MouseEvent) => void;
-    openLauncherMenu: (e: React.MouseEvent) => void;
-    closeMenu: () => void;
+interface DragDropProviderProps {
+    children: ReactNode;
+    onDrop: (item: DragItemData, target: DropTarget) => void;
+    onCancel?: () => void;
 }
-declare const useTaskbarContextMenu: () => UseTaskbarContextMenuReturn;
+declare const DragDropProvider: FC<DragDropProviderProps>;
 
-interface RegistryContextValue {
-    register: (id: string, rect: DOMRect) => void;
-    unregister: (id: string) => void;
-    getRect: (id: string) => DOMRect | undefined;
+interface UseDraggableItemOptions {
+    item: DragItemData;
+    disabled?: boolean;
 }
-declare const useWindowButtonRegistry: () => RegistryContextValue;
+interface UseDraggableItemReturn {
+    attributes: React.HTMLAttributes<HTMLElement>;
+    listeners: Record<string, unknown> | undefined;
+    setNodeRef: (node: HTMLElement | null) => void;
+    isDragging: boolean;
+    transform: {
+        x: number;
+        y: number;
+    } | null;
+    style: React.CSSProperties;
+}
+declare function useDraggableItem(options: UseDraggableItemOptions): UseDraggableItemReturn;
 
-declare const AVAILABLE_FONTS: {
-    value: string;
-    label: string;
-    stack: string;
-}[];
-declare const FONT_STACKS: Record<string, string>;
-declare const GOOGLE_FONTS_HREF: Record<string, string>;
+interface UseDroppableAreaOptions {
+    target: DropTarget;
+    disabled?: boolean;
+}
+interface UseDroppableAreaReturn {
+    setNodeRef: (node: HTMLElement | null) => void;
+    isOver: boolean;
+    active: DragItemData | null;
+}
+declare function useDroppableArea(options: UseDroppableAreaOptions): UseDroppableAreaReturn;
 
-/**
- * Applies the currently selected font stack to the document root.
- * Also re-injects <link> tags for all previously downloaded fonts on mount.
- */
-declare const useApplyFont: () => void;
+declare function useDragDropState(): DragDropContextValue;
 
 interface FontDownloadProgress {
     status: 'idle' | 'downloading' | 'done' | 'error';
@@ -1031,166 +1432,302 @@ declare const useFontDownload: (font: string | null) => {
     promise: Promise<FontDownloadResult>;
 };
 
-interface AdaptiveDimensions {
-    defaultWidth: number;
-    defaultHeight: number;
-    minWidth: number;
-    minHeight: number;
-}
-declare function useAdaptiveDimensions(): AdaptiveDimensions;
-
-type AppReloadCallback = (appId: string) => void;
-type AppRegisteredCallback = (manifest: CustomAppManifest) => void;
-type AppUnregisteredCallback = (appId: string) => void;
-interface HMRCallbacks {
-    onReload: AppReloadCallback;
-    onRegistered?: AppRegisteredCallback;
-    onUnregistered?: AppUnregisteredCallback;
+interface UseIsDirtyOptions<T> {
+    /** Mutable ref that holds the snapshot (used internally). */
+    snapshotRef: React.MutableRefObject<T | null>;
+    /** Function that returns the current state of the app. */
+    getCurrentState: () => T;
+    /** Optional initial snapshot – used when no stored snapshot exists. */
+    initialSnapshot?: T;
+    /** Optional callback invoked when the dirty flag changes. */
+    onChange?: (isDirty: boolean) => void;
+    /** Unique identifier for the app – used to persist the snapshot in the global store. */
+    appId?: string;
 }
-declare function useCustomAppHMR(callbacksArg: HMRCallbacks): void;
+declare function useIsDirty<T>({ snapshotRef, getCurrentState, initialSnapshot, onChange, appId, }: UseIsDirtyOptions<T>): {
+    isDirty: boolean;
+    takeSnapshot: () => void;
+    reset: () => void;
+};
 
-type LoadingState = 'idle' | 'fetching' | 'compiling' | 'loading' | 'ready' | 'error';
+declare function useLanguageSync(): void;
 
-interface MenuItemAction {
-    type: 'item';
-    label: string;
-    icon?: string;
-    onClick: () => void;
-    disabled?: boolean;
-}
-interface MenuItemDivider {
-    type: 'divider';
-}
-interface MenuItemSlider {
-    type: 'slider';
-    label?: string;
-    min: number;
-    max: number;
-    value: number;
-    onChange: (value: number) => void;
-    labelFormat?: (value: number) => string;
-}
-type MenuItem = MenuItemAction | MenuItemDivider | MenuItemSlider;
-interface AppMenuDropdown {
-    type: 'menu';
-    label: string;
-    icon?: string;
-    items: MenuItem[];
-    rightSection?: ReactNode;
-}
-interface AppMenuCombobox {
-    type: 'combobox';
-    label?: string;
-    options: string[];
-    value: string;
-    onChange: (value: string) => void;
-}
-interface AppMenuSwitch {
-    type: 'switch';
-    label: string;
-    checked: boolean;
-    onChange: (value: boolean) => void;
-}
-interface AppMenuSlider {
-    type: 'slider';
-    label?: string;
-    min: number;
-    max: number;
-    value: number;
-    onChange: (value: number) => void;
-    marks?: {
-        value: number;
-        label?: string;
-    }[];
-    labelFormat?: (value: number) => string;
+declare class IndexedDBFileSystem implements IFileSystem {
+    private db;
+    private nodes;
+    private ready;
+    private initPromise;
+    private persistQueue;
+    private persistScheduled;
+    initialize(): Promise<void>;
+    private doInitialize;
+    private openDatabase;
+    private loadNodes;
+    private migrateFromLocalStorage;
+    isReady(): boolean;
+    reinitialize(): Promise<void>;
+    private persistAllNodes;
+    private schedulePersist;
+    private flushPersistQueue;
+    private persistNode;
+    private deleteNodeFromPersist;
+    saveBlob(blob: Blob): Promise<string>;
+    getBlob(url: string): Promise<Blob | null>;
+    toBlobUrl(url: string): Promise<string | null>;
+    clearBlobs(): Promise<void>;
+    readFile(_path: string): Promise<string>;
+    writeFile(_path: string, _content: string): Promise<void>;
+    getNode(id: string): FSNode | undefined;
+    getChildren(folderId: string): FSNode[];
+    getRootNodes(): FSNode[];
+    getAllNodes(): FSNode[];
+    isEmpty(): boolean;
+    createFile(name: string, content: string, parentId: string | null, url?: string): Promise<FileNode>;
+    createFolder(name: string, parentId: string | null, iconName?: string, iconColor?: string): Promise<FolderNode>;
+    updateFile(id: string, content: string): Promise<FileNode>;
+    move(id: string, newParentId: string | null): Promise<FSNode>;
+    delete(id: string): Promise<void>;
+    getManifestSha(): Promise<string | null>;
+    saveManifestSha(sha: string): Promise<void>;
+    clearAll(): Promise<void>;
+    seed(manifest: FsManifest): Promise<void>;
+    mergeSeed(manifest: FsManifest): Promise<void>;
+    private buildFolderMapFromManifest;
+    private addChildToFolder;
+    private removeChildFromParent;
+    private deleteRecursive;
 }
-interface AppMenuTextInput {
-    type: 'text-input';
-    placeholder?: string;
-    value: string;
-    onChange: (value: string) => void;
+
+declare function setApiBaseUrl(url: string): void;
+declare class DockerFileSystemAdapter implements IFileSystem {
+    private nodes;
+    private pathToId;
+    private ready;
+    private rootFolderId;
+    private initPromise;
+    constructor();
+    initialize(): Promise<void>;
+    private doInitialize;
+    reinitialize(): Promise<void>;
+    isReady(): boolean;
+    isEmpty(): boolean;
+    getNode(id: string): FSNode | undefined;
+    getChildren(folderId: string): FSNode[];
+    getRootNodes(): FSNode[];
+    getAllNodes(): FSNode[];
+    createFile(name: string, content: string, parentId: string | null, url?: string): Promise<FileNode>;
+    createFolder(name: string, parentId: string | null, iconName?: string, iconColor?: string): Promise<FolderNode>;
+    updateFile(id: string, content: string): Promise<FileNode>;
+    move(id: string, newParentId: string | null): Promise<FSNode>;
+    delete(id: string): Promise<void>;
+    readFile(path: string): Promise<string>;
+    writeFile(path: string, content: string): Promise<void>;
+    saveBlob(blob: Blob): Promise<string>;
+    getBlob(url: string): Promise<Blob | null>;
+    toBlobUrl(url: string): Promise<string | null>;
+    getManifestSha(): Promise<string | null>;
+    saveManifestSha(_sha: string): Promise<void>;
+    seed(_manifest: FsManifest): Promise<void>;
+    mergeSeed(_manifest: FsManifest): Promise<void>;
+    clearAll(): Promise<void>;
+    private getMimeType;
+    private getPathFromId;
+    private deleteRecursive;
+    private syncFromEntries;
+    private fetchReaddir;
+    private writeFileToServer;
+    private createDirOnServer;
+    private deleteFromServer;
 }
-interface AppMenuNumberInput {
-    type: 'number-input';
-    label?: string;
-    value: number;
-    onChange: (value: number) => void;
-    min?: number;
-    max?: number;
-    step?: number;
-    placeholder?: string;
+
+declare const fileSystem: IndexedDBFileSystem | DockerFileSystemAdapter;
+declare const resetFileSystem: () => void;
+declare const resetWindowManager: () => void;
+declare function resolveFileUrl(url: string, signal?: AbortSignal): Promise<string>;
+declare const useDesktopStore: zustand.UseBoundStore<Omit<zustand.StoreApi<DesktopState>, "setState" | "persist"> & {
+    setState(partial: DesktopState | Partial<DesktopState> | ((state: DesktopState) => DesktopState | Partial<DesktopState>), replace?: false | undefined): unknown;
+    setState(state: DesktopState | ((state: DesktopState) => DesktopState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<DesktopState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: DesktopState) => void) => () => void;
+        onFinishHydration: (fn: (state: DesktopState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<DesktopState, unknown, unknown>>;
+    };
+}>;
+
+declare const getPersistedThemeMode: () => ThemeMode | null;
+declare const useSettingsStore: zustand.UseBoundStore<Omit<zustand.StoreApi<ISettingsState>, "setState" | "persist"> & {
+    setState(partial: ISettingsState | Partial<ISettingsState> | ((state: ISettingsState) => ISettingsState | Partial<ISettingsState>), replace?: false | undefined): unknown;
+    setState(state: ISettingsState | ((state: ISettingsState) => ISettingsState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<ISettingsState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: ISettingsState) => void) => () => void;
+        onFinishHydration: (fn: (state: ISettingsState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<ISettingsState, unknown, unknown>>;
+    };
+}>;
+
+declare const useCustomAppStore: zustand.UseBoundStore<zustand.StoreApi<CustomAppState>>;
+
+interface AppTempMemoryState {
+    snapshots: Record<string, unknown>;
+    setSnapshot: (appId: string, snapshot: unknown) => void;
+    getSnapshot: (appId: string) => unknown | null;
+    clearSnapshot: (appId: string) => void;
 }
-interface AppMenuSelect {
-    type: 'select';
-    label?: string;
-    options: {
-        value: string;
-        label: string;
-    }[];
-    value: string;
-    onChange: (value: string) => void;
+declare const useAppTempMemoryStore: zustand.UseBoundStore<Omit<zustand.StoreApi<AppTempMemoryState>, "setState" | "persist"> & {
+    setState(partial: AppTempMemoryState | Partial<AppTempMemoryState> | ((state: AppTempMemoryState) => AppTempMemoryState | Partial<AppTempMemoryState>), replace?: false | undefined): unknown;
+    setState(state: AppTempMemoryState | ((state: AppTempMemoryState) => AppTempMemoryState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<AppTempMemoryState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: AppTempMemoryState) => void) => () => void;
+        onFinishHydration: (fn: (state: AppTempMemoryState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<AppTempMemoryState, unknown, unknown>>;
+    };
+}>;
+
+interface CloseModalState {
+    isOpen: boolean;
+    windowId: string | null;
+    onSave: (() => void) | null;
+    onDiscard: (() => void) | null;
 }
-interface AppMenuDirtyIndicator {
-    type: 'dirty-indicator';
+interface CloseModalActions {
+    openModal: (windowId: string, onSave: () => void, onDiscard: () => void) => void;
+    closeModal: () => void;
 }
-type AppMenuElement = AppMenuDropdown | AppMenuCombobox | AppMenuSwitch | AppMenuSlider | AppMenuTextInput | AppMenuNumberInput | AppMenuSelect | AppMenuDirtyIndicator;
+declare const useCloseModalStore: zustand.UseBoundStore<zustand.StoreApi<CloseModalState & CloseModalActions>>;
 
-interface WindowContentProps {
-    window?: WindowEntity;
-    notifyReady?: (contentData?: Record<string, unknown>) => void;
+interface AdaptiveDimensions {
+    defaultWidth: number;
+    defaultHeight: number;
+    minWidth: number;
+    minHeight: number;
 }
-type AppComponent = FC<WindowContentProps>;
-type MenuBarBuilder = (window: WindowEntity) => AppMenuElement[] | undefined;
-interface MenuBarComponentProps {
-    windowId: string;
-    onExit: () => void;
+declare function useAdaptiveDimensions(): AdaptiveDimensions;
+
+declare const useNotifications: () => {
+    notifications: NotificationItem[];
+    notify: (title: string, message: string, options?: {
+        fcIcon?: string;
+        onClose?: () => void;
+    }) => string;
+    dismiss: (id: string) => void;
+    addNotification: (item: NotificationItem) => void;
+    removeNotification: (id: string) => void;
+};
+
+declare const useSystemTheme: () => void;
+
+type OpenHookOptions = {
     contentData?: Record<string, unknown>;
+    position?: {
+        x: number;
+        y: number;
+    };
+};
+declare const useOpenApp: () => (appId: string, { contentData, position }?: OpenHookOptions) => void;
+
+declare function useFdeApi(): FdeDesktopAPI | null;
+
+declare function useResolvedUrl(url: string | undefined): string | undefined;
+
+interface DeviceInfo {
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+    isPortrait: boolean;
+    shouldShowWarning: boolean;
+    screenWidth: number;
+    screenHeight: number;
 }
-type MenuBarComponent = FC<MenuBarComponentProps>;
-interface AppRegistration {
-    component: AppComponent;
-    buildMenuBar?: MenuBarBuilder;
-    MenuBarComponent?: MenuBarComponent;
+declare function useDeviceDetection(): DeviceInfo;
+
+type AppReloadCallback = (appId: string) => void;
+type AppRegisteredCallback = (manifest: CustomAppManifest) => void;
+type AppUnregisteredCallback = (appId: string) => void;
+interface HMRCallbacks {
+    onReload: AppReloadCallback;
+    onRegistered?: AppRegisteredCallback;
+    onUnregistered?: AppUnregisteredCallback;
 }
+/**
+ * Reset connection state - useful for testing
+ * @internal
+ */
+declare function resetHMRState(): void;
+declare function checkHMREndpointExists(): Promise<boolean>;
+declare function useCustomAppHMR(callbacksArg: HMRCallbacks): void;
+declare function useCustomAppLifecycle(): void;
 
-type Runtime = 'browser' | 'docker' | 'electron';
 /**
- * Detects the current runtime environment.
- * - browser: Standard web browser
- * - docker: Running inside Docker container (detected via injected flag)
- * - electron: Electron desktop app
+ * Appends a dirty-indicator element to menu items if dirty.
+ * Returns a new array when dirty (immutable), or the original array when not dirty.
+ *
+ * @param items - The array of menu elements
+ * @param isDirty - Whether there are unsaved changes
+ * @returns The same array if not dirty, or a new array with dirty-indicator appended
+ *
+ * @example
+ * const items: AppMenuElement[] = [
+ *   { type: 'menu', label: 'File', items: [...] }
+ * ];
+ *
+ * return appendDirtyIndicator(items, isDirty);
  */
+declare function appendDirtyIndicator(items: AppMenuElement[], isDirty: boolean): AppMenuElement[];
+
+declare const injectFontLink: (font: string) => void;
+
+type Runtime = 'browser' | 'docker' | 'electron';
 declare function getRuntime(): Runtime;
 declare function isDocker(): boolean;
 declare function isElectron(): boolean;
 declare function isBrowser(): boolean;
-/**
- * Detects if running in development mode.
- * - Checks window.__IS_DEV__ flag (injected by Docker entrypoint)
- * - Falls back to hostname detection for local development
- */
 declare function isDev(): boolean;
 
 declare function generateUUID(): string;
 
-/**
- * Waits for a DOM element with the given ID to appear in the document.
- * Uses polling with 1 second intervals.
- *
- * @param containerId - The ID of the container element to wait for (without #)
- * @param timeout - Maximum time to wait in milliseconds (default: 5000)
- * @returns Promise that resolves with the container element
- * @throws Error if container is not found within timeout
- */
 declare function waitForContainer(containerId: string, timeout?: number): Promise<HTMLElement>;
 
+declare function setTestBaseUrl(url: string | null): void;
 declare function getBaseUrl(): string;
+declare function resetBaseUrlCache(): void;
 declare function resolveUrl(relativeUrl: string): string;
 
+declare const sortNodes: (nodes: FSNode[]) => FSNode[];
+declare const SortOptions: {
+    readonly BY_TYPE: "byType";
+    readonly BY_NAME: "byName";
+    readonly BY_DATE: "byDate";
+};
+type SortOption = (typeof SortOptions)[keyof typeof SortOptions];
+type DesktopSortMode = 'default' | 'name-asc' | 'name-desc' | 'type';
+declare function sortDesktopIcons(icons: DesktopIconEntity[], desktopAppsOrder?: readonly string[]): DesktopIconEntity[];
+declare const sortDesktopIconsByMode: (icons: DesktopIconEntity[], mode: DesktopSortMode) => DesktopIconEntity[];
+declare const sortNodesByMode: (nodes: FSNode[], mode: DesktopSortMode) => FSNode[];
+
 declare function formatBytes(bytes: number): string;
 
 declare function hashBlob(blob: Blob): Promise<string>;
 
+interface AppFileHandler {
+    appId: string;
+    mimeTypes: string[] | ((mimeType: string) => boolean);
+    transformContentData: (node: FileNode) => Record<string, unknown>;
+}
+declare const registerAppFileHandler: (handler: AppFileHandler) => void;
+declare const IMAGE_MIME_TYPES: Set<string>;
+declare const TEXT_MIME_TYPES: Set<string>;
 declare function getAppIdForMime(mimeType: string | undefined): string;
 declare function getAppIdForMime(node: FileNode): {
     appId: string;
@@ -1207,104 +1744,26 @@ type Breadcrumb = {
     id: string | null;
     name: string;
 };
-/**
- * Builds a breadcrumb trail from the root to the given folder.
- * Always starts with `{ id: null, name: 'Home' }`.
- */
 declare const buildBreadcrumbs: (currentFolderId: string | null, fsNodes: FSNode[]) => Breadcrumb[];
 
 declare const isNewerVersion: (latest: string, current: string) => boolean;
 
-/**
- * Clears all browser data: Service Workers, Cache API, IndexedDB, localStorage, sessionStorage.
- * Useful for tests and for the reset settings feature.
- */
 interface ClearBrowserDataOptions {
-    /** If true, keep IndexedDB databases (user files) */
     keepIndexedDB?: boolean;
-    /** If true, keep Service Workers registered */
     keepServiceWorker?: boolean;
-    /** If true, keep localStorage */
     keepLocalStorage?: boolean;
-    /** If true, keep sessionStorage */
     keepSessionStorage?: boolean;
 }
-/**
- * Clears all browser data with configurable options.
- *
- * @param options - Configuration options for what to keep
- *
- * @example
- * // Clear everything (full reset)
- * await clearBrowserData();
- *
- * @example
- * // Keep user files (IndexedDB)
- * await clearBrowserData({ keepIndexedDB: true });
- *
- * @example
- * // Keep everything except cache
- * await clearBrowserData({ keepIndexedDB: true, keepServiceWorker: true, keepLocalStorage: true });
- */
 declare function clearBrowserData(options?: ClearBrowserDataOptions): Promise<void>;
 
-declare const WelcomeApp: AppEntry;
-declare const StorybookApp: AppEntry;
-declare const LinkedinApp: AppEntry;
-declare const GithubApp: AppEntry;
-declare const TerminalApp: AppEntry;
-declare const CodeServerApp: AppEntry;
-declare const DosEmulatorApp: AppEntry;
-declare const DoomApp: AppEntry;
-declare const EXTRA_APPS: AppEntry[];
-declare const EXTRA_APP_IDS: string[];
-
-declare const APPS: AppEntry[];
-declare const DESKTOP_APPS_ORDER: string[];
-declare function registerCustomApps(apps: AppEntry[]): void;
-declare function registerDesktopApps(appIds: string[]): void;
-
-declare const APP_IDS: {
-    readonly WELCOME: "welcome";
-    readonly NOTEPAD: "notepad";
-    readonly UPLOADER: "uploader";
-    readonly FILES: "files";
-    readonly SETTINGS: "settings";
-    readonly PDF: "pdf";
-    readonly CALENDAR: "calendar";
-    readonly STORYBOOK: "storybook";
-    readonly LINKEDIN: "linkedin";
-    readonly GITHUB: "github";
-    readonly IMAGE_VIEWER: "image-viewer";
-    readonly DOS_EMULATOR: "dos-emulator";
-    readonly DOOM: "doom";
-    readonly TERMINAL: "terminal";
-    readonly CODE_SERVER: "code-server";
-    readonly DEVICE_INFO: "device-info";
-    readonly MENUEDIT: "menuedit";
-};
-
-declare const CUSTOM_APPS_FOLDER_ID = "launcher-folder-custom-apps";
-declare const DEFAULT_LAUNCHER_FOLDERS: LauncherFolder[];
-
-declare const BREAKPOINTS: {
-    readonly MOBILE: 768;
-    readonly TABLET: 1024;
-    readonly DESKTOP: 1280;
+declare const DEFAULT_WINDOW_DIMENSIONS: {
+    readonly defaultWidth: 800;
+    readonly defaultHeight: 600;
+    readonly minWidth: 640;
+    readonly minHeight: 480;
 };
-
-declare const TASKBAR_HEIGHT = 48;
-declare const ICON_COLUMN_WIDTH = 80;
-declare const ICON_ROW_HEIGHT = 80;
-declare const ICON_MARGIN = 20;
-declare const DEFAULT_VIEWPORT_WIDTH: 1280;
-declare const DEFAULT_VIEWPORT_HEIGHT: 800;
-
-declare const DEFAULT_THEME_COLORS: Record<ThemeMode, Theme>;
-
-declare const PRESET_COLORS: string[];
-
-declare const PRESET_ICONS: string[];
+declare const CORE_APPS: AppEntry[];
+declare const CORE_APP_IDS: string[];
 
 declare const ANIMATION_DURATION = 0.3;
 declare const createEaseIn: (duration: number) => Transition;
@@ -1401,37 +1860,94 @@ declare const centerWindowPosition: (viewportWidth: number, viewportHeight: numb
     y: number;
 };
 
-declare const createWindow: (input: WindowInput) => WindowEntity;
+declare const BREAKPOINTS: {
+    readonly MOBILE: 768;
+    readonly TABLET: 1024;
+    readonly DESKTOP: 1280;
+};
+type Breakpoint = (typeof BREAKPOINTS)[keyof typeof BREAKPOINTS];
 
-declare const createDesktopIcon: (input: DesktopIconInput) => DesktopIconEntity;
+declare const TASKBAR_HEIGHT = 48;
+declare const ICON_COLUMN_WIDTH = 80;
+declare const ICON_ROW_HEIGHT = 80;
+declare const ICON_MARGIN = 20;
+declare const DEFAULT_VIEWPORT_WIDTH: 1280;
+declare const DEFAULT_VIEWPORT_HEIGHT: 800;
 
-declare function initializeFdeApi(): void;
-declare function isFdeApiInitialized(): boolean;
+declare const APP_IDS: {
+    readonly WELCOME: "welcome";
+    readonly NOTEPAD: "notepad";
+    readonly UPLOADER: "uploader";
+    readonly FILES: "files";
+    readonly SETTINGS: "settings";
+    readonly PDF: "pdf";
+    readonly CALENDAR: "calendar";
+    readonly STORYBOOK: "storybook";
+    readonly LINKEDIN: "linkedin";
+    readonly GITHUB: "github";
+    readonly IMAGE_VIEWER: "image-viewer";
+    readonly DOS_EMULATOR: "dos-emulator";
+    readonly DOOM: "doom";
+    readonly TERMINAL: "terminal";
+    readonly CODE_SERVER: "code-server";
+    readonly DEVICE_INFO: "device-info";
+    readonly MENUEDIT: "menuedit";
+};
+declare const APP_ID_TO_TRANSLATION_KEY: Record<string, string>;
+type AppId = (typeof APP_IDS)[keyof typeof APP_IDS];
+declare const DESKTOP_APPS: AppId[];
 
-interface IWindowManager {
-    getAll(): WindowEntity[];
-    getById(id: string): WindowEntity | undefined;
-    open(input: WindowInput): WindowEntity;
-    close(id: string): void;
-    minimize(id: string): void;
-    maximize(id: string): void;
-    restore(id: string): void;
-    focus(id: string): void;
-    move(id: string, x: number, y: number): void;
-    resize(id: string, width: number, height: number): void;
-    loadWindows(windows: WindowEntity[]): void;
+declare const EXTRA_APPS: AppEntry[];
+declare const EXTRA_APP_IDS: string[];
+
+declare const PRESET_COLORS: string[];
+
+declare const DEFAULT_THEME_COLORS: Record<ThemeMode, Theme>;
+
+declare const PRESET_ICONS: string[];
+
+declare const CUSTOM_APPS_FOLDER_ID = "launcher-folder-custom-apps";
+declare const PREDEFINED_LAUNCHER_FOLDERS: LauncherFolder[];
+declare const DEFAULT_LAUNCHER_FOLDERS: LauncherFolder[];
+
+declare const APPS: AppEntry[];
+declare const DESKTOP_APPS_ORDER: string[];
+declare function registerCustomApps(apps: AppEntry[]): void;
+declare function registerDesktopApps(appIds: string[]): void;
+
+declare const GITHUB_RELEASES_REPO = "frannunpal/frannunpal.github.io";
+declare const GITHUB_LATEST_RELEASE_URL = "https://api.github.com/repos/frannunpal/frannunpal.github.io/releases/latest";
+
+declare const PROFILE: {
+    name: string;
+    title: string;
+    email: string;
+    phone: string;
+    location: string;
+    linkedin: string;
+    github: string;
+    cvUrls: {
+        en: string;
+        es: string;
+    };
+};
+
+declare global {
+    interface Window {
+        __FDE_IN_DOCKER__?: boolean;
+    }
 }
+declare const APP_VERSION: string;
+
+declare const getVersionString: () => string;
+declare const getEnvironment: () => string;
+declare const getReleaseType: () => string;
 
 declare class WindowManagerAdapter implements IWindowManager {
     private windows;
     private nextZIndex;
     private assignZIndex;
     reset(): void;
-    /**
-     * Restores persisted windows into the adapter and synchronizes the
-     * nextZIndex counter so that subsequent focus/open calls always produce
-     * a value strictly higher than any already-persisted zIndex.
-     */
     loadWindows(windows: WindowEntity[]): void;
     getAll(): WindowEntity[];
     getById(id: string): WindowEntity | undefined;
@@ -1446,12 +1962,58 @@ declare class WindowManagerAdapter implements IWindowManager {
     private updateWindow;
 }
 
+declare class DefaultThemeProvider implements IThemeProvider {
+    private mode;
+    private customColors;
+    constructor(initialMode?: ThemeMode);
+    getTheme(): FdeTheme;
+    setMode(mode: ThemeMode): void;
+    setCustomColors(colors: CustomThemeColors | null): void;
+    toggle(): void;
+}
+
 declare const toMantineTheme: (theme: Theme) => MantineThemeOverride;
 
+declare function initializeFdeApi(): void;
+declare function getFdeApi(): FdeDesktopAPI;
+declare function isFdeApiInitialized(): boolean;
+
 type AppLoader = () => Promise<unknown>;
 declare function prefetchApps(apps: Array<{
     id: string;
     loader: AppLoader;
 }>): void;
 
-export { ANIMATION_DURATION, APPS, APP_IDS, AVAILABLE_FONTS, type AppComponent, type AppEntry, type AppMenuElement, type AppRegistration, BREAKPOINTS, CORE_APPS, CORE_APP_IDS, CUSTOM_APPS_FOLDER_ID, CalendarApp, type ClipboardAction, type ClipboardState, CodeServerApp, type CreateFolderOptions, type CustomAppState, type CustomThemeColors, DEFAULT_LAUNCHER_FOLDERS, DEFAULT_THEME_COLORS, DEFAULT_VIEWPORT_HEIGHT, DEFAULT_VIEWPORT_WIDTH, DEFAULT_WINDOW_DIMENSIONS, DESKTOP_APPS_ORDER, type DesktopIconInput, type DesktopState, DeviceInfoApp, DockerFileSystemAdapter, DoomApp, DosEmulatorApp, EASE_IN, EASE_OUT, EXTRA_APPS, EXTRA_APP_IDS, FONT_STACKS, type FSNode, type FileNode, FilesApp, type FolderNode, type FsManifest, type FsManifestFile, GOOGLE_FONTS_HREF, GithubApp, ICON_COLUMN_WIDTH, ICON_MARGIN, ICON_ROW_HEIGHT, type IFileSystem, type ISettingsState, ImageViewerApp, IndexedDBFileSystem, LinkedinApp, type LoadingState, type MenuBarBuilder, type MenuBarComponent, type MenuBarComponentProps, MenuEditApp, type MenuPosition, type MountedAppState, NotepadApp, type NotificationItem, PRESET_COLORS, PRESET_ICONS, PdfApp, SettingsApp, StorybookApp, TASKBAR_HEIGHT, TerminalApp, UploaderApp, WelcomeApp, type WindowContentProps, type WindowEntity, type WindowInput, WindowManagerAdapter, type WindowState, buildBreadcrumbs, centerWindowPosition, clearBrowserData, createDesktopIcon, createEaseIn, createEaseOut, createLauncherFolder, createMaximizeTransition, createMinimizeVariant, createPanelVariants, createRestoreVariant, createWindow, createWindowVariants, fileSystem, formatBytes, generateUUID, getAppIdForMime, getBaseUrl, getFileExtension, getFourRandomColors, getMimeTypeFromExtension, getRuntime, hashBlob, initializeFdeApi, isBrowser, isDev, isDocker, isElectron, isFdeApiInitialized, isNewerVersion, maximizeTransition, minimizeVariant, openVariants, panelVariants, prefetchApps, randomWindowPosition, registerCustomApps, registerDesktopApps, resetFileSystem, resetWindowManager, resolveUrl, restoreVariant, sortDesktopIcons, sortDesktopIconsByMode, sortNodes, toMantineTheme, updateLauncherFolder, useAdaptiveDimensions, useAnimationDuration, useAppName, useAppTempMemoryStore, useApplyFont, useClock, useCollapsible, useContextMenu, useCustomAppHMR, useCustomAppStore, useDesktopStore, useDeviceDetection, useDownload, useDynamicIcon, useFcIcon, useFdeApi, useFiIcon, useFolderName, useFontDownload, useIsDirty, useJsDos, useLanguageSync, useNotifications, useOpenApp, useResolvedUrl, useSearchFilter, useSettingsStore, useSystemTheme, useTaskbarContextMenu, useTaskbarHeight, useVscIcon, useWindowButtonRegistry, waitForContainer, windowVariants };
+/**
+ * Storage Migration Utility
+ *
+ * Migrates legacy storage keys from 'fran-desktop' prefix to 'fde-desktop' prefix.
+ * This migration is idempotent and safe to run multiple times.
+ *
+ * Migration includes:
+ * - IndexedDB databases: fran-desktop-fs → fde-desktop-fs, fran-desktop-blobs → fde-desktop-blobs
+ * - localStorage keys: fran-desktop:* → fde-desktop:*
+ * - Zustand persist key: fran-desktop → fde-desktop
+ */
+interface MigrationResult {
+    indexedDB: {
+        fs: boolean;
+        blobs: boolean;
+    };
+    localStorage: {
+        keysMigrated: number;
+    };
+    version: number;
+}
+/**
+ * Runs the complete storage migration
+ *
+ * @returns MigrationResult with details about what was migrated
+ */
+declare function migrateStorage(): Promise<MigrationResult>;
+
+declare const SUPPORTED_LANGUAGES: readonly ["en", "es"];
+type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];
+declare const DEFAULT_LANGUAGE: SupportedLanguage;
+
+export { ANIMATION_DURATION, APPS, APP_IDS, APP_ID_TO_TRANSLATION_KEY, APP_VERSION, AVAILABLE_FONTS, type AdaptiveDimensions, type AppComponent, AppEmptyState, type AppEntry, type AppFileHandler, AppIcon, type AppId, AppLoading, type AppLoadingProps, AppMenuBar, type AppMenuElement, type AppReadyContextValue, AppReadyProvider, type AppRegistration, type AppRegistryEntry, type AppsManifest, BREAKPOINTS, type Breadcrumb, type Breakpoint, CORE_APPS, CORE_APP_IDS, CORE_REGISTRY, CUSTOM_APPS_FOLDER_ID, CalendarApp, CalendarAppLazy, type ClearBrowserDataOptions, type ClipboardAction, type ClipboardState, CollapsibleSection, ColorPicker, ContextMenu, ContextMenuAnchor, type CreateFolderOptions, CreateItemApp, CreateItemAppLazy, CreateItemContextMenu, CustomAppLoader, CustomAppLoadingScreen, type CustomAppManifest, CustomAppNotSupported, CustomAppOffline, type CustomAppState, type CustomThemeColors, DEFAULT_FDE_THEME, DEFAULT_LANGUAGE, DEFAULT_LAUNCHER_FOLDERS, DEFAULT_THEME_COLORS, DEFAULT_VIEWPORT_HEIGHT, DEFAULT_VIEWPORT_WIDTH, DEFAULT_WINDOW_DIMENSIONS, DESKTOP_APPS, DESKTOP_APPS_ORDER, DefaultThemeProvider, Desktop, type DesktopAreaProps, type DesktopContextMenuProps, DesktopIcon, type DesktopIconEntity, type DesktopIconInput, type DesktopIconProps, type DesktopProps, type DesktopSortMode$1 as DesktopSortMode, type DesktopState, type DesktopTheme, type DeviceInfo, DeviceInfoApp, DeviceInfoAppLazy, DirtyIndicator, DockerFileSystemAdapter, DownloadProgress, type DownloadState, type DownloadStatus, DragDropProvider, type DropTargetType, DynamicMenuBarRenderer, EASE_IN, EASE_OUT, EXTRA_APPS, EXTRA_APP_IDS, ExternalLinkApp, FONT_STACKS, type FSNode, type FdeContextValue, FdeDesktop, type FdeDesktopAPI, type FdeDesktopProps, type FdeEventPayloads, type FdeEventType, FdeProvider, type FdeProviderProps, type FdeTheme, type FileDialogOptions, FileIcon, type FileIconProps, type FileNode, FilePickerApp, FilePickerModal, type FileSystemNode, type FileSystemNodeType, FilesApp, FilesAppLazy, type FolderNode, PickerModal as FolderPicker, type FontDownloadProgress, type FsManifest, type FsManifestFile, GITHUB_LATEST_RELEASE_URL, GITHUB_RELEASES_REPO, GOOGLE_FONTS_HREF, ICON_COLUMN_WIDTH, ICON_MARGIN, ICON_ROW_HEIGHT, type IFileSystem, IMAGE_MIME_TYPES, type ISettingsState, type IThemeProvider, type IWindowManager, IconColorPicker, ImageViewerApp, ImageViewerAppLazy, ImageViewerMenuBar, ImageViewerMenuBarLazy, IndexedDBFileSystem, LanguageFlag, LanguageSelector, Launcher, type LauncherFolder, type LauncherFolderInput, type LauncherProps, type LoadingProgress, type LoadingState, type MenuBarBuilder, type MenuBarComponent, type MenuBarComponentProps, MenuEditApp, MenuEditAppLazy, MenuEditMenuBar, MenuEditMenuBarLazy, type MenuItem, type MenuPosition, type MountedAppState, NotesApp, NotesAppLazy, NotesMenuBar, NotesMenuBarLazy, type NotificationItem, type NotificationOptions, type OpenAppOptions, PREDEFINED_LAUNCHER_FOLDERS, PRESET_COLORS, PRESET_ICONS, PROFILE, type PartialFdeTheme, PdfApp, PdfAppLazy, PdfMenuBar, PdfMenuBarLazy, SETTINGS_SECTIONS, SUPPORTED_LANGUAGES, type SaveDialogOptions, SettingsApp, SettingsAppLazy, SettingsMenuBar, SettingsMenuBarLazy, type SettingsSection$1 as SettingsSection, SettingsSection as SettingsSectionComponent, type SortOption, SortOptions, StorybookApp, type SupportedLanguage$2 as SupportedLanguage, TASKBAR_HEIGHT, TEXT_MIME_TYPES, Taskbar, TaskbarContextMenu, type TaskbarContextMenuProps, type TaskbarMenuType, type TaskbarTheme, type Theme, type ThemeMode, ThemeProvider, type ThemeProviderProps, UploaderApp, UploaderAppLazy, type UseCloseInterceptorOptions, type UseDownloadReturn, type UseIsDirtyOptions, VscIcon, Window, WindowButtonRegistryProvider, type WindowContentProps, type WindowEntity, type WindowInput, type WindowLoading, WindowManagerAdapter, type WindowProps, type WindowState, type WindowTheme, appendDirtyIndicator, buildBreadcrumbs, centerWindowPosition, checkHMREndpointExists, clearBrowserData, clearManifestCache, convertToAppEntry, createDesktopIcon, createEaseIn, createEaseOut, createFile, createFolder, createLauncherFolder, createMaximizeTransition, createMinimizeVariant, createPanelVariants, createPredefinedLauncherFolder, createRestoreVariant, createWindow, createWindowVariants, fetchAppManifest, fileSystem, formatBytes, generateUUID, getAppComponent, getAppIdForMime, getAppName, getBaseUrl, getCachedManifest, getCloseInterceptor, getCustomAppById, getCustomApps, getEnvironment, getFdeApi, getFileExtension, getFourRandomColors, getMenuBarBuilder, getMenuBarComponent, getMimeTypeFromExtension, getPersistedThemeMode, getReleaseType, getRuntime, getVersionString, hashBlob, initRegistry, initializeFdeApi, injectFontLink, isBrowser, isCustomApp, isDev, isDocker, isElectron, isFdeApiInitialized, isLazyApp, isNewerVersion, maximizeTransition, mergeAppsWithCustomApps, migrateStorage, minimizeVariant, openVariants, panelVariants, prefetchApps, randomWindowPosition, registerAppFileHandler, registerCloseInterceptor, registerComponents, registerCustomApps, registerDesktopApps, removeFromManifestCache, resetBaseUrlCache, resetFileSystem, resetHMRState, resetWindowManager, resolveFileUrl, resolveUrl, restoreVariant, setApiBaseUrl, setTestBaseUrl, sortDesktopIcons, sortDesktopIconsByMode, sortNodes, sortNodesByMode, syncWithServer, toMantineTheme, unregisterCloseInterceptor, updateLauncherFolder, updateManifestCache, useAdaptiveDimensions, useAnimationDuration, useAppName, useAppReady, useAppTempMemoryStore, useAppUpdate, useApplyFont, useClock, useCloseInterceptor, useCloseModalStore, useCollapsible, useContextMenu, useCustomAppHMR, useCustomAppLifecycle, useCustomAppStore, useDesktopStore, useDeviceDetection, useDownload, useDragDropState, useDraggableItem, useDroppableArea, useDynamicIcon, useDynamicIconElement, useFcIcon, useFcIconElement, useFdeApi, useFdeContext, useFiIcon, useFiIconElement, useFolderName, useFontDownload, useIsDirty, useLanguageSync, useNotifications, useOpenApp, useResolvedUrl, useSearchFilter, useSettingsStore, useSystemTheme, useTaskbarContextMenu, useTaskbarHeight, useTheme, useThemeContext, useVscIcon, useVscIconElement, useWindowButtonRegistry, waitForContainer, windowVariants };