@fde-desktop/fde-core 0.3.7 → 0.4.1

package/dist/chunk-6QOUYSEE.cjs

@@ -0,0 +1,2303 @@
+'use strict';
+
+var chunkZ5YGWL65_cjs = require('./chunk-Z5YGWL65.cjs');
+var uuid = require('uuid');
+var zustand = require('zustand');
+var middleware = require('zustand/middleware');
+
+function generateUUID() {
+  return uuid.v4();
+}
+
+// src/domain/entities/Window.ts
+var createWindow = (input) => ({
+  alwaysOnTop: false,
+  ...input,
+  id: generateUUID(),
+  isOpen: true,
+  state: "normal",
+  zIndex: 0
+});
+
+// src/domain/entities/DesktopIcon.ts
+var createDesktopIcon = (input) => ({
+  ...input,
+  id: generateUUID()
+});
+
+// src/domain/entities/LauncherFolder.ts
+var createLauncherFolder = (input) => ({
+  id: generateUUID(),
+  name: input.name,
+  fcIcon: input.fcIcon,
+  appIds: input.appIds ?? [],
+  isExpanded: input.isExpanded ?? false,
+  isPredefined: input.isPredefined ?? false,
+  order: input.order ?? 0
+});
+var createPredefinedLauncherFolder = (input) => ({
+  id: generateUUID(),
+  name: input.name,
+  fcIcon: input.fcIcon,
+  appIds: input.appIds ?? [],
+  isExpanded: input.isExpanded ?? false,
+  isPredefined: true,
+  order: input.order ?? 0
+});
+var updateLauncherFolder = (folder, updates) => ({
+  ...folder,
+  ...updates
+});
+
+// src/domain/entities/FileSystem.ts
+var createFolder = (name, parentId = null, options = {}) => ({
+  id: generateUUID(),
+  name,
+  type: "folder",
+  parentId,
+  children: [],
+  createdAt: /* @__PURE__ */ new Date(),
+  updatedAt: /* @__PURE__ */ new Date(),
+  ...options
+});
+var createFile = (name, content, parentId = null, mimeType, url) => ({
+  id: generateUUID(),
+  name,
+  type: "file",
+  content,
+  mimeType,
+  parentId,
+  createdAt: /* @__PURE__ */ new Date(),
+  updatedAt: /* @__PURE__ */ new Date(),
+  ...url !== void 0 ? { url } : {}
+});
+
+// src/infrastructure/adapters/WindowManagerAdapter.ts
+var ALWAYS_ON_TOP_OFFSET = 1e4;
+var WindowManagerAdapter = class {
+  windows = /* @__PURE__ */ new Map();
+  nextZIndex = 1;
+  assignZIndex(alwaysOnTop) {
+    const raw = this.nextZIndex++;
+    return alwaysOnTop ? ALWAYS_ON_TOP_OFFSET + raw : raw;
+  }
+  reset() {
+    this.windows.clear();
+    this.nextZIndex = 1;
+  }
+  loadWindows(windows) {
+    this.windows.clear();
+    let maxZIndex = 0;
+    for (const w of windows) {
+      this.windows.set(w.id, w);
+      const raw = w.alwaysOnTop ?? false ? w.zIndex - ALWAYS_ON_TOP_OFFSET : w.zIndex;
+      if (raw > maxZIndex) maxZIndex = raw;
+    }
+    this.nextZIndex = maxZIndex + 1;
+  }
+  getAll() {
+    return Array.from(this.windows.values());
+  }
+  getById(id) {
+    return this.windows.get(id);
+  }
+  open(input) {
+    const window2 = createWindow(input);
+    window2.zIndex = this.assignZIndex(window2.alwaysOnTop ?? false);
+    this.windows.set(window2.id, window2);
+    return window2;
+  }
+  close(id) {
+    this.windows.delete(id);
+  }
+  minimize(id) {
+    this.updateWindow(id, { state: "minimized" });
+  }
+  maximize(id) {
+    this.updateWindow(id, { state: "maximized" });
+  }
+  restore(id) {
+    this.updateWindow(id, { state: "normal" });
+  }
+  focus(id) {
+    const window2 = this.windows.get(id);
+    if (!window2) return;
+    const newZIndex = this.assignZIndex(window2.alwaysOnTop ?? false);
+    this.updateWindow(id, { zIndex: newZIndex });
+  }
+  move(id, x, y) {
+    this.updateWindow(id, { x, y });
+  }
+  resize(id, width, height) {
+    this.updateWindow(id, { width, height });
+  }
+  updateWindow(id, patch) {
+    const window2 = this.windows.get(id);
+    if (!window2) return;
+    this.windows.set(id, { ...window2, ...patch });
+  }
+};
+
+// src/utils/getMimeTypeFromExtension.ts
+var EXTENSION_MAP = {
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".markdown": "text/markdown",
+  ".pdf": "application/pdf",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".json": "application/json",
+  ".xml": "text/xml",
+  ".jsdos": "application/jsdos",
+  ".zip": "application/zip"
+};
+function getMimeTypeFromExtension(filename) {
+  const lastDot = filename.lastIndexOf(".");
+  if (lastDot === -1 || lastDot === filename.length - 1) return void 0;
+  const ext = filename.slice(lastDot).toLowerCase();
+  return EXTENSION_MAP[ext];
+}
+
+// src/utils/hashBlob.ts
+function djb2Hash(buffer) {
+  let hash = 5381;
+  for (let i = 0; i < buffer.length; i++) {
+    hash = (hash << 5) + hash ^ buffer[i];
+    hash = hash >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0") + buffer.length.toString(16).padStart(8, "0");
+}
+async function hashBlob(blob) {
+  const buffer = await blob.arrayBuffer();
+  const bytes = new Uint8Array(buffer);
+  if (crypto?.subtle) {
+    const hashBuffer = await crypto.subtle.digest("SHA-256", bytes);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  console.warn("[hashBlob] crypto.subtle unavailable (non-secure context), using fallback hash");
+  return djb2Hash(bytes);
+}
+
+// src/infrastructure/adapters/IndexedDBFileSystem.ts
+var DB_NAME = "fde-desktop-fs";
+var NODES_STORE = "nodes";
+var BLOBS_STORE = "blobs";
+var METADATA_STORE = "metadata";
+var DB_VERSION = 2;
+var IndexedDBFileSystem = class {
+  db = null;
+  nodes = /* @__PURE__ */ new Map();
+  ready = false;
+  initPromise = null;
+  persistQueue = [];
+  persistScheduled = false;
+  async initialize() {
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = this.doInitialize();
+    return this.initPromise;
+  }
+  async doInitialize() {
+    await this.openDatabase();
+    await this.loadNodes();
+    await this.migrateFromLocalStorage();
+    this.ready = true;
+  }
+  openDatabase() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(DB_NAME, DB_VERSION);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve();
+      };
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(NODES_STORE)) {
+          db.createObjectStore(NODES_STORE);
+        }
+        if (!db.objectStoreNames.contains(BLOBS_STORE)) {
+          db.createObjectStore(BLOBS_STORE);
+        }
+        if (!db.objectStoreNames.contains(METADATA_STORE)) {
+          db.createObjectStore(METADATA_STORE);
+        }
+      };
+    });
+  }
+  async loadNodes() {
+    if (!this.db) return;
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(NODES_STORE, "readonly");
+      const store = tx.objectStore(NODES_STORE);
+      const request = store.getAll();
+      request.onsuccess = () => {
+        const keys = tx.objectStore(NODES_STORE).getAllKeys();
+        keys.onsuccess = () => {
+          const nodeEntries = request.result;
+          const keyEntries = keys.result;
+          for (let i = 0; i < nodeEntries.length; i++) {
+            const key = String(keyEntries[i]);
+            this.nodes.set(key, nodeEntries[i]);
+          }
+          resolve();
+        };
+        keys.onerror = () => reject(keys.error);
+      };
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async migrateFromLocalStorage() {
+    const legacyKey = "fran-desktop:filesystem";
+    const legacyData = localStorage.getItem(legacyKey);
+    if (!legacyData) return;
+    if (this.nodes.size === 0) {
+      try {
+        const entries = JSON.parse(legacyData);
+        for (const [id, node] of entries) {
+          this.nodes.set(id, node);
+        }
+        await this.persistAllNodes();
+        localStorage.removeItem(legacyKey);
+      } catch {
+      }
+    }
+  }
+  isReady() {
+    return this.ready;
+  }
+  async reinitialize() {
+    if (!this.ready) {
+      await this.initialize();
+    }
+  }
+  persistAllNodes() {
+    if (!this.db) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(NODES_STORE, "readwrite");
+      const store = tx.objectStore(NODES_STORE);
+      for (const [id, node] of this.nodes.entries()) {
+        store.put(node, id);
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  schedulePersist() {
+    if (this.persistScheduled) return;
+    this.persistScheduled = true;
+    queueMicrotask(() => {
+      this.persistScheduled = false;
+      this.flushPersistQueue();
+    });
+  }
+  flushPersistQueue() {
+    if (!this.db || this.persistQueue.length === 0) return;
+    const items = [...this.persistQueue];
+    this.persistQueue = [];
+    const tx = this.db.transaction(NODES_STORE, "readwrite");
+    const store = tx.objectStore(NODES_STORE);
+    tx.onerror = () => {
+      console.error("IndexedDB write failed", tx.error);
+    };
+    for (const item of items) {
+      if (item.type === "set") {
+        store.put(item.value, item.key);
+      } else if (item.type === "delete") {
+        store.delete(item.key);
+      }
+    }
+  }
+  persistNode(id, node) {
+    this.persistQueue.push({ type: "set", key: id, value: node });
+    this.schedulePersist();
+  }
+  deleteNodeFromPersist(id) {
+    this.persistQueue.push({ type: "delete", key: id });
+    this.schedulePersist();
+  }
+  async saveBlob(blob) {
+    if (!this.db) await this.initialize();
+    const hash = await hashBlob(blob);
+    const existing = await this.getBlob(`idb://${hash}`);
+    if (existing) return `idb://${hash}`;
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(BLOBS_STORE, "readwrite");
+      const store = tx.objectStore(BLOBS_STORE);
+      const request = store.put(blob, hash);
+      request.onsuccess = () => resolve(`idb://${hash}`);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getBlob(url) {
+    if (!this.db) await this.initialize();
+    const hash = url.startsWith("idb://") ? url.slice("idb://".length) : url;
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(BLOBS_STORE, "readonly");
+      const store = tx.objectStore(BLOBS_STORE);
+      const request = store.get(hash);
+      request.onsuccess = () => resolve(request.result ?? null);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async toBlobUrl(url) {
+    if (!url.startsWith("idb://")) return null;
+    const blob = await this.getBlob(url);
+    if (!blob) return null;
+    return URL.createObjectURL(blob);
+  }
+  async clearBlobs() {
+    if (!this.db) return;
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(BLOBS_STORE, "readwrite");
+      const store = tx.objectStore(BLOBS_STORE);
+      const request = store.clear();
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async readFile(_path) {
+    return "";
+  }
+  async writeFile(_path, _content) {
+  }
+  getNode(id) {
+    return this.nodes.get(id);
+  }
+  getChildren(folderId) {
+    const folder = this.nodes.get(folderId);
+    if (!folder || folder.type !== "folder") return [];
+    return folder.children.map((childId) => this.nodes.get(childId)).filter((n) => n !== void 0);
+  }
+  getRootNodes() {
+    return Array.from(this.nodes.values()).filter((n) => n.parentId === null);
+  }
+  getAllNodes() {
+    return Array.from(this.nodes.values());
+  }
+  isEmpty() {
+    return this.nodes.size === 0;
+  }
+  async createFile(name, content, parentId, url) {
+    const mimeType = getMimeTypeFromExtension(name);
+    const file = createFile(name, content, parentId, mimeType, url);
+    this.nodes.set(file.id, file);
+    if (parentId) this.addChildToFolder(parentId, file.id);
+    this.persistNode(file.id, file);
+    return file;
+  }
+  async createFolder(name, parentId, iconName, iconColor) {
+    const folder = createFolder(name, parentId, { iconName, iconColor });
+    this.nodes.set(folder.id, folder);
+    if (parentId) this.addChildToFolder(parentId, folder.id);
+    this.persistNode(folder.id, folder);
+    return folder;
+  }
+  async updateFile(id, content) {
+    const node = this.nodes.get(id);
+    if (!node || node.type !== "file") throw new Error(`File not found: ${id}`);
+    const updated = { ...node, content, updatedAt: /* @__PURE__ */ new Date() };
+    this.nodes.set(id, updated);
+    this.persistNode(id, updated);
+    return updated;
+  }
+  async move(id, newParentId) {
+    const node = this.nodes.get(id);
+    if (!node) throw new Error(`Node not found: ${id}`);
+    if (newParentId === id) throw new Error("Cannot move a folder into itself");
+    if (newParentId !== null) {
+      let currentParentId = newParentId;
+      while (currentParentId !== null) {
+        if (currentParentId === id)
+          throw new Error("Cannot move a folder into one of its descendants");
+        const parentNode = this.nodes.get(currentParentId);
+        currentParentId = parentNode?.parentId ?? null;
+      }
+    }
+    if (node.parentId) this.removeChildFromParent(node);
+    const updated = { ...node, parentId: newParentId };
+    this.nodes.set(id, updated);
+    if (newParentId) this.addChildToFolder(newParentId, id);
+    this.persistNode(id, updated);
+    return updated;
+  }
+  async delete(id) {
+    const node = this.nodes.get(id);
+    if (!node) return;
+    if (node.type === "folder") this.deleteRecursive(node);
+    this.removeChildFromParent(node);
+    this.nodes.delete(id);
+    this.deleteNodeFromPersist(id);
+  }
+  async getManifestSha() {
+    if (!this.db) await this.initialize();
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(METADATA_STORE, "readonly");
+      const store = tx.objectStore(METADATA_STORE);
+      const request = store.get("manifestSha");
+      request.onsuccess = () => resolve(request.result ?? null);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async saveManifestSha(sha) {
+    if (!this.db) await this.initialize();
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(METADATA_STORE, "readwrite");
+      const store = tx.objectStore(METADATA_STORE);
+      const request = store.put(sha, "manifestSha");
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async clearAll() {
+    this.nodes.clear();
+    this.ready = false;
+    this.initPromise = null;
+    if (this.db) {
+      await Promise.all([
+        new Promise((resolve, reject) => {
+          const tx = this.db.transaction(NODES_STORE, "readwrite");
+          tx.objectStore(NODES_STORE).clear();
+          tx.oncomplete = () => resolve();
+          tx.onerror = () => reject(tx.error);
+        }),
+        new Promise((resolve, reject) => {
+          const tx = this.db.transaction(BLOBS_STORE, "readwrite");
+          tx.objectStore(BLOBS_STORE).clear();
+          tx.oncomplete = () => resolve();
+          tx.onerror = () => reject(tx.error);
+        }),
+        new Promise((resolve, reject) => {
+          const tx = this.db.transaction(METADATA_STORE, "readwrite");
+          tx.objectStore(METADATA_STORE).clear();
+          tx.oncomplete = () => resolve();
+          tx.onerror = () => reject(tx.error);
+        })
+      ]);
+      this.db.close();
+      this.db = null;
+    }
+  }
+  async seed(manifest) {
+    const folderMap = this.buildFolderMapFromManifest(manifest);
+    for (const f of manifest.files) {
+      const parent = folderMap.get(f.folder);
+      const file = createFile(f.name, "", parent?.id ?? null, f.mimeType, f.url);
+      this.nodes.set(file.id, file);
+      if (parent) {
+        const updated = { ...parent, children: [...parent.children, file.id] };
+        this.nodes.set(parent.id, updated);
+        folderMap.set(f.folder, updated);
+      }
+    }
+    await this.persistAllNodes();
+  }
+  async mergeSeed(manifest) {
+    const folderMap = this.buildFolderMapFromManifest(manifest, true);
+    for (const f of manifest.files) {
+      const parent = folderMap.get(f.folder);
+      if (!parent) continue;
+      const existingNode = this.getChildren(parent.id).find(
+        (n) => n.type === "file" && n.name === f.name
+      );
+      if (existingNode) {
+        if (existingNode.url !== f.url) {
+          const updated = { ...existingNode, url: f.url };
+          this.nodes.set(existingNode.id, updated);
+        }
+        continue;
+      }
+      const file = createFile(f.name, "", parent.id, f.mimeType, f.url);
+      this.nodes.set(file.id, file);
+      const updatedParent = { ...parent, children: [...parent.children, file.id] };
+      this.nodes.set(parent.id, updatedParent);
+      folderMap.set(f.folder, updatedParent);
+    }
+    await this.persistAllNodes();
+  }
+  buildFolderMapFromManifest(manifest, mergeMode = false) {
+    const folderMap = /* @__PURE__ */ new Map();
+    const allPaths = /* @__PURE__ */ new Set([...manifest.folders, ...manifest.files.map((f) => f.folder)]);
+    const sortedPaths = [...allPaths].sort((a, b) => a.split("/").length - b.split("/").length);
+    for (const path of sortedPaths) {
+      const parts = path.split("/");
+      const name = parts[parts.length - 1];
+      const parentPath = parts.length > 1 ? parts.slice(0, -1).join("/") : null;
+      const parentFolder = parentPath ? folderMap.get(parentPath) : null;
+      const parentId = parentFolder?.id ?? null;
+      if (mergeMode) {
+        const searchIn = parentId ? this.getChildren(parentId) : this.getRootNodes();
+        const existing = searchIn.find((n) => n.type === "folder" && n.name === name);
+        if (existing) {
+          folderMap.set(path, existing);
+          continue;
+        }
+      }
+      const folder = createFolder(name, parentId);
+      this.nodes.set(folder.id, folder);
+      folderMap.set(path, folder);
+      if (parentFolder) {
+        const updatedParent = {
+          ...parentFolder,
+          children: [...parentFolder.children, folder.id]
+        };
+        this.nodes.set(parentFolder.id, updatedParent);
+        folderMap.set(parentPath, updatedParent);
+      }
+    }
+    return folderMap;
+  }
+  addChildToFolder(folderId, childId) {
+    const folder = this.nodes.get(folderId);
+    if (!folder || folder.type !== "folder") return;
+    const updated = { ...folder, children: [...folder.children, childId] };
+    this.nodes.set(folderId, updated);
+    this.persistNode(folderId, updated);
+  }
+  removeChildFromParent(node) {
+    if (!node.parentId) return;
+    const parent = this.nodes.get(node.parentId);
+    if (!parent || parent.type !== "folder") return;
+    const updated = {
+      ...parent,
+      children: parent.children.filter((id) => id !== node.id)
+    };
+    this.nodes.set(node.parentId, updated);
+    this.persistNode(node.parentId, updated);
+  }
+  deleteRecursive(folder) {
+    for (const childId of folder.children) {
+      const child = this.nodes.get(childId);
+      if (!child) continue;
+      if (child.type === "folder") this.deleteRecursive(child);
+      this.nodes.delete(childId);
+      this.deleteNodeFromPersist(childId);
+    }
+  }
+};
+
+// src/infrastructure/adapters/DockerFileSystemAdapter.ts
+var API_BASE = "/api/fs";
+var FETCH_TIMEOUT = 6e4;
+async function fetchWithTimeout(url, options = {}, timeout = FETCH_TIMEOUT) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    return await fetch(url, { ...options, signal: controller.signal });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+var apiBaseUrl = API_BASE;
+function setApiBaseUrl(url) {
+  apiBaseUrl = url;
+}
+var DockerFileSystemAdapter = class {
+  nodes = /* @__PURE__ */ new Map();
+  pathToId = /* @__PURE__ */ new Map();
+  ready = false;
+  rootFolderId;
+  initPromise = null;
+  constructor() {
+    this.rootFolderId = generateUUID();
+    this.pathToId.set("/", this.rootFolderId);
+  }
+  async initialize() {
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = this.doInitialize();
+    return this.initPromise;
+  }
+  async doInitialize() {
+    try {
+      const response = await fetch(`${apiBaseUrl}?action=readdir&path=/`);
+      if (response.ok) {
+        const entries = await response.json();
+        await this.syncFromEntries(entries, null);
+      }
+    } catch (error) {
+      console.warn("[DockerFS] Failed to initialize from server:", error);
+    }
+    this.ready = true;
+  }
+  async reinitialize() {
+    this.ready = false;
+    this.nodes.clear();
+    this.pathToId.clear();
+    this.rootFolderId = generateUUID();
+    this.pathToId.set("/", this.rootFolderId);
+    this.initPromise = null;
+    await this.initialize();
+  }
+  isReady() {
+    return this.ready;
+  }
+  isEmpty() {
+    return this.nodes.size === 0;
+  }
+  getNode(id) {
+    return this.nodes.get(id);
+  }
+  getChildren(folderId) {
+    const children = [];
+    for (const node of this.nodes.values()) {
+      if (node.parentId === folderId) {
+        children.push(node);
+      }
+    }
+    return children;
+  }
+  getRootNodes() {
+    return Array.from(this.nodes.values()).filter((n) => n.parentId === null);
+  }
+  getAllNodes() {
+    return Array.from(this.nodes.values());
+  }
+  async createFile(name, content, parentId, url) {
+    const id = generateUUID();
+    const parentPath = parentId ? this.getPathFromId(parentId) : "/";
+    const filePath = parentPath ? `${parentPath}/${name}`.replace("//", "/") : `/${name}`;
+    const fileUrl = url ?? `/api/fs?action=file&path=${encodeURIComponent(filePath)}`;
+    const file = createFile(name, content, parentId, this.getMimeType(name), fileUrl);
+    const fileWithId = { ...file, id };
+    this.nodes.set(id, fileWithId);
+    this.pathToId.set(filePath, id);
+    try {
+      await this.writeFileToServer(filePath, content);
+    } catch (error) {
+      this.nodes.delete(id);
+      this.pathToId.delete(filePath);
+      throw error;
+    }
+    return fileWithId;
+  }
+  async createFolder(name, parentId, iconName, iconColor) {
+    const id = generateUUID();
+    const parentPath = parentId ? this.getPathFromId(parentId) : "/";
+    const folderPath = parentPath ? `${parentPath}/${name}`.replace("//", "/") : `/${name}`;
+    const options = {};
+    if (iconName) options.iconName = iconName;
+    if (iconColor) options.iconColor = iconColor;
+    const folder = createFolder(name, parentId, options);
+    const folderWithId = { ...folder, id };
+    this.nodes.set(id, folderWithId);
+    this.pathToId.set(folderPath, id);
+    try {
+      await this.createDirOnServer(folderPath, options);
+    } catch (error) {
+      this.nodes.delete(id);
+      this.pathToId.delete(folderPath);
+      throw error;
+    }
+    return folderWithId;
+  }
+  async updateFile(id, content) {
+    const node = this.nodes.get(id);
+    if (!node || node.type !== "file") {
+      throw new Error(`File not found: ${id}`);
+    }
+    const file = node;
+    const path = this.getPathFromId(id);
+    const updatedFile = { ...file, content, updatedAt: /* @__PURE__ */ new Date() };
+    this.nodes.set(id, updatedFile);
+    if (path) {
+      this.writeFileToServer(path, content).catch((error) => {
+        console.warn(`[DockerFS] Failed to update file on server:`, error);
+      });
+    }
+    return updatedFile;
+  }
+  async move(id, newParentId) {
+    const node = this.nodes.get(id);
+    if (!node) throw new Error(`Node not found: ${id}`);
+    if (newParentId === id) throw new Error("Cannot move a folder into itself");
+    if (newParentId !== null) {
+      let cur = newParentId;
+      while (cur !== null) {
+        if (cur === id) throw new Error("Cannot move a folder into one of its descendants");
+        cur = this.nodes.get(cur)?.parentId ?? null;
+      }
+    }
+    const oldPath = this.getPathFromId(id);
+    const newParentPath = newParentId ? this.getPathFromId(newParentId) : "/";
+    const newPath = newParentPath ? `${newParentPath}/${node.name}`.replace("//", "/") : `/${node.name}`;
+    if (!oldPath) throw new Error(`Cannot determine path for node ${id}`);
+    if (!newParentPath && newParentId !== null)
+      throw new Error(`Cannot determine parent path for ${newParentId}`);
+    const response = await fetchWithTimeout(
+      `${apiBaseUrl}?action=move&oldPath=${encodeURIComponent(oldPath)}&newPath=${encodeURIComponent(newPath)}`
+    );
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(errorData.error || `HTTP ${response.status}`);
+    }
+    const movedNode = { ...node, parentId: newParentId };
+    this.nodes.set(id, movedNode);
+    this.pathToId.delete(oldPath);
+    this.pathToId.set(newPath, id);
+    return movedNode;
+  }
+  async delete(id) {
+    const path = this.getPathFromId(id);
+    this.deleteRecursive(id);
+    if (path) {
+      try {
+        await this.deleteFromServer(path);
+      } catch (error) {
+        console.warn(`[DockerFS] Failed to delete ${path} on server:`, error);
+        throw error;
+      }
+    }
+  }
+  async readFile(path) {
+    try {
+      const response = await fetch(`${apiBaseUrl}?action=read&path=${encodeURIComponent(path)}`);
+      if (response.ok) {
+        const data = await response.json();
+        return data.content;
+      }
+    } catch (error) {
+      console.warn(`[DockerFS] Failed to read file ${path}:`, error);
+    }
+    return "";
+  }
+  async writeFile(path, content) {
+    await this.writeFileToServer(path, content);
+  }
+  async saveBlob(blob) {
+    const hash = await hashBlob(blob);
+    const ext = blob.type.split("/")[1] || "bin";
+    const path = `/.blobs/${hash}.${ext}`;
+    try {
+      await fetch(`${apiBaseUrl}?action=writeBinary&path=${encodeURIComponent(path)}`, {
+        method: "POST",
+        body: blob
+      });
+    } catch (error) {
+      console.warn(`[DockerFS] Failed to save blob ${path}:`, error);
+    }
+    return `/api/fs?action=file&path=${encodeURIComponent(path)}`;
+  }
+  async getBlob(url) {
+    if (!url.startsWith("/api/fs")) return null;
+    try {
+      const response = await fetch(url);
+      if (!response.ok) return null;
+      return await response.blob();
+    } catch {
+      return null;
+    }
+  }
+  async toBlobUrl(url) {
+    if (!url.startsWith("/api/fs")) return null;
+    try {
+      const response = await fetch(url);
+      if (!response.ok) return null;
+      const blob = await response.blob();
+      return URL.createObjectURL(blob);
+    } catch {
+      return null;
+    }
+  }
+  async getManifestSha() {
+    return null;
+  }
+  async saveManifestSha(_sha) {
+  }
+  seed(_manifest) {
+    return Promise.resolve();
+  }
+  mergeSeed(_manifest) {
+    return Promise.resolve();
+  }
+  async clearAll() {
+    this.nodes.clear();
+    this.pathToId.clear();
+    this.ready = false;
+    this.initPromise = null;
+    this.rootFolderId = generateUUID();
+    this.pathToId.set("/", this.rootFolderId);
+  }
+  getMimeType(filename) {
+    return getMimeTypeFromExtension(filename) || "application/octet-stream";
+  }
+  getPathFromId(id) {
+    if (!id) return null;
+    for (const [path, nodeId] of this.pathToId.entries()) {
+      if (nodeId === id) return path;
+    }
+    const node = this.nodes.get(id);
+    if (!node) return null;
+    if (!node.parentId) return `/${node.name}`;
+    const parentPath = this.getPathFromId(node.parentId);
+    return parentPath ? `${parentPath}/${node.name}` : null;
+  }
+  deleteRecursive(id) {
+    for (const child of this.getChildren(id)) {
+      this.deleteRecursive(child.id);
+    }
+    this.nodes.delete(id);
+    for (const [path, nodeId] of this.pathToId.entries()) {
+      if (nodeId === id) this.pathToId.delete(path);
+    }
+  }
+  async syncFromEntries(entries, parentId) {
+    for (const entry of entries) {
+      const id = generateUUID();
+      if (entry.type === "directory") {
+        const folder = createFolder(entry.name, parentId);
+        this.nodes.set(id, { ...folder, id });
+        this.pathToId.set(entry.path, id);
+        const children = await this.fetchReaddir(entry.path);
+        await this.syncFromEntries(children, id);
+      } else {
+        const url = `/api/fs?action=file&path=${encodeURIComponent(entry.path)}`;
+        const file = createFile(entry.name, "", parentId, this.getMimeType(entry.name), url);
+        this.nodes.set(id, { ...file, id });
+        this.pathToId.set(entry.path, id);
+      }
+    }
+  }
+  async fetchReaddir(path) {
+    try {
+      const response = await fetch(`${apiBaseUrl}?action=readdir&path=${encodeURIComponent(path)}`);
+      if (response.ok) return await response.json();
+    } catch (error) {
+      console.warn(`[DockerFS] Failed to readdir ${path}:`, error);
+    }
+    return [];
+  }
+  async writeFileToServer(path, content) {
+    const response = await fetch(`${apiBaseUrl}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path, content })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to write file ${path}: HTTP ${response.status}`);
+    }
+  }
+  async createDirOnServer(path, options) {
+    const response = await fetch(`${apiBaseUrl}`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path, ...options })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to create directory ${path}: HTTP ${response.status}`);
+    }
+  }
+  async deleteFromServer(path) {
+    try {
+      await fetch(`${apiBaseUrl}?path=${encodeURIComponent(path)}`, { method: "DELETE" });
+    } catch (error) {
+      console.warn(`[DockerFS] Failed to delete ${path}:`, error);
+    }
+  }
+};
+
+// src/constants/launcherFolders.ts
+var CUSTOM_APPS_FOLDER_ID = "launcher-folder-custom-apps";
+var PREDEFINED_LAUNCHER_FOLDERS = [
+  {
+    id: "launcher-folder-social-links",
+    name: "Social Links",
+    fcIcon: "VscAccount",
+    appIds: ["github", "linkedin"],
+    isExpanded: false,
+    isPredefined: true,
+    order: 0
+  },
+  {
+    id: "launcher-folder-office",
+    name: "Office and media",
+    fcIcon: "VscLibrary",
+    appIds: ["notepad", "pdf", "image-viewer"],
+    isExpanded: false,
+    isPredefined: true,
+    order: 1
+  },
+  {
+    id: "launcher-folder-programming",
+    name: "Programming",
+    fcIcon: "VscGitPullRequest",
+    appIds: ["terminal", "code-server", "device-info", "storybook"],
+    isExpanded: false,
+    isPredefined: true,
+    order: 2
+  },
+  {
+    id: "launcher-folder-games",
+    name: "Games",
+    fcIcon: "VscGame",
+    appIds: ["dos-emulator", "doom"],
+    isExpanded: false,
+    isPredefined: true,
+    order: 3
+  },
+  {
+    id: CUSTOM_APPS_FOLDER_ID,
+    name: "Custom Apps",
+    fcIcon: "VscExtensions",
+    appIds: [],
+    isExpanded: false,
+    isPredefined: true,
+    order: 4
+  }
+];
+var DEFAULT_LAUNCHER_FOLDERS = [...PREDEFINED_LAUNCHER_FOLDERS];
+
+// src/constants/customApps.ts
+var cachedManifest = null;
+var manifestFetchPromise = null;
+var lastManifestFetch = 0;
+var MANIFEST_CACHE_TTL = 5e3;
+var APPS_MANIFEST_URL = "/dist-apps/apps-manifest.json";
+async function fetchAppManifest(forceRefresh = false) {
+  const now = Date.now();
+  if (!forceRefresh && cachedManifest && now - lastManifestFetch < MANIFEST_CACHE_TTL) {
+    return cachedManifest;
+  }
+  if (manifestFetchPromise) {
+    return manifestFetchPromise;
+  }
+  const url = `${APPS_MANIFEST_URL}?t=${now}`;
+  manifestFetchPromise = fetch(url).then(async (response) => {
+    if (!response.ok) {
+      if (response.status === 404) {
+        console.warn("[CustomApps] No apps manifest found at", APPS_MANIFEST_URL);
+        return null;
+      }
+      throw new Error(`Failed to fetch manifest: ${response.status}`);
+    }
+    return response.json();
+  }).then((data) => {
+    cachedManifest = data;
+    lastManifestFetch = Date.now();
+    manifestFetchPromise = null;
+    console.log(`[CustomApps] Loaded manifest with ${data.apps.length} apps`);
+    return data;
+  }).catch((error) => {
+    console.error("[CustomApps] Error fetching manifest:", error);
+    manifestFetchPromise = null;
+    return null;
+  });
+  return manifestFetchPromise;
+}
+function getCachedManifest() {
+  return cachedManifest;
+}
+function clearManifestCache() {
+  cachedManifest = null;
+  lastManifestFetch = 0;
+}
+function updateManifestCache(manifest) {
+  if (!cachedManifest) {
+    cachedManifest = { version: "1.0.0", generated: (/* @__PURE__ */ new Date()).toISOString(), apps: [manifest] };
+    return;
+  }
+  const exists = cachedManifest.apps.some((a) => a.id === manifest.id);
+  if (exists) {
+    cachedManifest = {
+      ...cachedManifest,
+      apps: cachedManifest.apps.map((a) => a.id === manifest.id ? manifest : a)
+    };
+  } else {
+    cachedManifest = { ...cachedManifest, apps: [...cachedManifest.apps, manifest] };
+  }
+}
+function removeFromManifestCache(appId) {
+  if (cachedManifest) {
+    cachedManifest = {
+      ...cachedManifest,
+      apps: cachedManifest.apps.filter((a) => a.id !== appId)
+    };
+  }
+}
+async function getCustomApps() {
+  const manifest = await fetchAppManifest();
+  return manifest?.apps ?? [];
+}
+async function getCustomAppById(appId) {
+  const apps = await getCustomApps();
+  return apps.find((app) => app.id === appId);
+}
+function isCustomApp(appId) {
+  if (!cachedManifest) {
+    return false;
+  }
+  return cachedManifest.apps.some((app) => app.id === appId);
+}
+function convertToAppEntry(manifest) {
+  return {
+    id: manifest.id,
+    name: manifest.name,
+    icon: manifest.icon,
+    ...manifest.iconUrl && { iconUrl: manifest.iconUrl },
+    defaultWidth: manifest.window.defaultWidth,
+    defaultHeight: manifest.window.defaultHeight,
+    minWidth: manifest.window.minWidth !== false ? manifest.window.minWidth : void 0,
+    minHeight: manifest.window.minHeight !== false ? manifest.window.minHeight : void 0,
+    canMaximize: manifest.window.canMaximize,
+    alwaysOnTop: manifest.window.alwaysOnTop
+  };
+}
+function mergeAppsWithCustomApps(staticApps, customApps) {
+  const customIds = new Set(customApps.map((app) => app.id));
+  const staticAppsFiltered = staticApps.filter((app) => !customIds.has(app.id));
+  const mergedApps = customApps.map((manifest) => {
+    const entry = {
+      id: manifest.id,
+      name: manifest.name,
+      icon: manifest.icon,
+      defaultWidth: manifest.window.defaultWidth ?? 800,
+      defaultHeight: manifest.window.defaultHeight ?? 600,
+      minWidth: manifest.window.minWidth !== false ? manifest.window.minWidth : void 0,
+      minHeight: manifest.window.minHeight !== false ? manifest.window.minHeight : void 0,
+      canMaximize: manifest.window.canMaximize ?? true,
+      alwaysOnTop: manifest.window.alwaysOnTop ?? false
+    };
+    if (manifest.iconUrl) {
+      entry.iconUrl = manifest.iconUrl;
+    }
+    return entry;
+  });
+  return [...staticAppsFiltered, ...mergedApps];
+}
+async function syncWithServer(currentRegisteredApps) {
+  clearManifestCache();
+  const manifest = await fetchAppManifest(true);
+  if (!manifest) {
+    return { added: [], removed: [], manifest: null };
+  }
+  const currentIds = Object.keys(currentRegisteredApps);
+  const serverIds = manifest.apps.map((a) => a.id);
+  const added = manifest.apps.filter((a) => !currentIds.includes(a.id));
+  const removed = currentIds.filter((id) => !serverIds.includes(id));
+  return { added, removed, manifest };
+}
+
+// src/utils/sortNodes.ts
+var sortNodes = (nodes) => {
+  const folders = nodes.filter((n) => n.type === "folder");
+  const files = nodes.filter((n) => n.type === "file");
+  const byName = (a, b) => a.name.localeCompare(b.name);
+  return [...folders.sort(byName), ...files.sort(byName)];
+};
+var SortOptions = {
+  BY_TYPE: "byType",
+  BY_NAME: "byName",
+  BY_DATE: "byDate"
+};
+function getIconType(icon) {
+  if (!icon.nodeId) return "app";
+  return icon.appId === "files" ? "folder" : "file";
+}
+var TYPE_ORDER = { app: 0, folder: 1, file: 2 };
+function sortDesktopIcons(icons, desktopAppsOrder) {
+  return [...icons].sort((a, b) => {
+    const typeA = getIconType(a);
+    const typeB = getIconType(b);
+    if (typeA !== typeB) return TYPE_ORDER[typeA] - TYPE_ORDER[typeB];
+    if (typeA === "app") {
+      if (!desktopAppsOrder) return a.name.localeCompare(b.name);
+      const indexA = desktopAppsOrder.indexOf(a.appId);
+      const indexB = desktopAppsOrder.indexOf(b.appId);
+      const posA = indexA === -1 ? Infinity : indexA;
+      const posB = indexB === -1 ? Infinity : indexB;
+      return posA - posB;
+    }
+    return a.name.localeCompare(b.name);
+  });
+}
+var sortDesktopIconsByMode = (icons, mode) => {
+  switch (mode) {
+    case "default":
+      return sortDesktopIcons(icons);
+    case "name-asc":
+      return [...icons].sort((a, b) => a.name.localeCompare(b.name));
+    case "name-desc":
+      return [...icons].sort((a, b) => b.name.localeCompare(a.name));
+    case "type":
+      return [...icons].sort((a, b) => {
+        const typeA = getIconType(a);
+        const typeB = getIconType(b);
+        if (typeA !== typeB) return TYPE_ORDER[typeA] - TYPE_ORDER[typeB];
+        return a.name.localeCompare(b.name);
+      });
+    default:
+      return sortDesktopIcons(icons);
+  }
+};
+var sortNodesByMode = (nodes, mode) => {
+  switch (mode) {
+    case "default":
+    case "type":
+      return sortNodes(nodes);
+    case "name-asc":
+      return [...nodes].sort((a, b) => a.name.localeCompare(b.name));
+    case "name-desc":
+      return [...nodes].sort((a, b) => b.name.localeCompare(a.name));
+    default:
+      return sortNodes(nodes);
+  }
+};
+
+// src/constants/coreApps.ts
+var DEFAULT_WINDOW_DIMENSIONS = {
+  defaultWidth: 800,
+  defaultHeight: 600,
+  minWidth: 640,
+  minHeight: 480
+};
+var FilesApp = {
+  id: "files",
+  name: "FilesApp",
+  icon: "\u{1F4C1}",
+  fcIcon: "FcOpenedFolder",
+  hasContextMenu: true,
+  ...DEFAULT_WINDOW_DIMENSIONS
+};
+var SettingsApp = {
+  id: "settings",
+  name: "Settings",
+  icon: "\u2699\uFE0F",
+  fcIcon: "FcSettings",
+  singleWindow: true,
+  ...DEFAULT_WINDOW_DIMENSIONS
+};
+var NotepadApp = {
+  id: "notepad",
+  name: "Notepad",
+  icon: "\u{1F4DD}",
+  fcIcon: "FcEditImage",
+  ...DEFAULT_WINDOW_DIMENSIONS
+};
+var ImageViewerApp = {
+  id: "image-viewer",
+  name: "Image Viewer",
+  icon: "\u{1F5BC}\uFE0F",
+  fcIcon: "FcPicture",
+  defaultWidth: 700,
+  defaultHeight: 520,
+  minWidth: 640,
+  minHeight: 480
+};
+var PdfApp = {
+  id: "pdf",
+  name: "PDF Viewer",
+  icon: "\u{1F4C4}",
+  fcIcon: "FcDocument",
+  defaultWidth: 780,
+  defaultHeight: 580,
+  minWidth: 640,
+  minHeight: 480
+};
+var UploaderApp = {
+  id: "uploader",
+  name: "Uploader",
+  icon: "\u{1F4E4}",
+  fcIcon: "FcUpload",
+  ...DEFAULT_WINDOW_DIMENSIONS
+};
+var MenuEditApp = {
+  id: "menuedit",
+  name: "MenuEdit",
+  icon: "\u{1F4C1}",
+  fcIcon: "FcFolder",
+  singleWindow: true,
+  ...DEFAULT_WINDOW_DIMENSIONS
+};
+var DeviceInfoApp = {
+  id: "device-info",
+  name: "Device Info",
+  icon: "\u{1F4CA}",
+  fcIcon: "FcBarChart",
+  defaultWidth: 300,
+  defaultHeight: 400,
+  minWidth: 280,
+  minHeight: 350,
+  canMaximize: false,
+  alwaysOnTop: true,
+  singleWindow: true
+};
+var CalendarApp = {
+  id: "calendar",
+  name: "Calendar",
+  icon: "\u{1F4C5}",
+  fcIcon: "FcCalendar",
+  defaultWidth: 320,
+  defaultHeight: 370,
+  minWidth: false,
+  minHeight: false,
+  canMaximize: false,
+  singleWindow: true
+};
+var CORE_APPS = [
+  FilesApp,
+  SettingsApp,
+  NotepadApp,
+  ImageViewerApp,
+  PdfApp,
+  UploaderApp,
+  MenuEditApp,
+  DeviceInfoApp,
+  CalendarApp
+];
+var CORE_APP_IDS = CORE_APPS.map((app) => app.id);
+
+// src/constants/extraApps.ts
+var WelcomeApp = {
+  id: "welcome",
+  name: "Welcome",
+  icon: "\u{1F44B}",
+  fcIcon: "FcBusinessContact",
+  defaultWidth: 900,
+  defaultHeight: 700,
+  minWidth: 600,
+  minHeight: 500
+};
+var StorybookApp = {
+  id: "storybook",
+  name: "Storybook",
+  icon: "\u{1F4D6}",
+  fcIcon: "FcReading",
+  defaultWidth: 1100,
+  defaultHeight: 700,
+  minWidth: 640,
+  minHeight: 480
+};
+var LinkedinApp = {
+  id: "linkedin",
+  name: "LinkedinApp",
+  icon: "\u{1F517}",
+  fcIcon: "FiLinkedin",
+  iconColor: "#0A66C2",
+  defaultWidth: 1100,
+  defaultHeight: 700
+};
+var GithubApp = {
+  id: "github",
+  name: "GithubApp",
+  icon: "\u{1F517}",
+  fcIcon: "FiGithub",
+  iconColor: "#000",
+  defaultWidth: 640,
+  defaultHeight: 480
+};
+var TerminalApp = {
+  id: "terminal",
+  name: "Terminal",
+  icon: "\u{1F4BB}",
+  fcIcon: "FcCommandLine",
+  ...DEFAULT_WINDOW_DIMENSIONS
+};
+var CodeServerApp = {
+  id: "code-server",
+  name: "VS Code",
+  icon: "\u{1F4D8}",
+  fcIcon: "FcCodesandbox",
+  iconUrl: `${undefined.BASE_URL}vscode.svg`,
+  defaultWidth: 1200,
+  defaultHeight: 800,
+  minWidth: 800,
+  minHeight: 600
+};
+var DosEmulatorApp = {
+  id: "dos-emulator",
+  name: "DOS Emulator",
+  icon: "\u{1F3AE}",
+  fcIcon: "FcGamepad",
+  defaultWidth: 900,
+  defaultHeight: 700,
+  minWidth: 640,
+  minHeight: 480
+};
+var DoomApp = {
+  id: "doom",
+  name: "DOOM",
+  icon: "\u{1F52B}",
+  fcIcon: "FcVideoGame",
+  iconUrl: "doom.png",
+  defaultWidth: 900,
+  defaultHeight: 700,
+  minWidth: 640,
+  minHeight: 480,
+  autoLoad: { url: "Games/doom.jsdos", name: "DOOM" }
+};
+var EXTRA_APPS = [
+  WelcomeApp,
+  StorybookApp,
+  LinkedinApp,
+  GithubApp,
+  TerminalApp,
+  CodeServerApp,
+  DosEmulatorApp,
+  DoomApp
+];
+var EXTRA_APP_IDS = EXTRA_APPS.map((app) => app.id);
+
+// src/constants/apps.ts
+var APPS = [...CORE_APPS, ...EXTRA_APPS];
+var DESKTOP_APPS_ORDER = [
+  "welcome",
+  "uploader",
+  "terminal",
+  "code-server",
+  "storybook",
+  "settings",
+  "notepad",
+  "linkedin",
+  "github",
+  "files",
+  "doom"
+];
+function registerCustomApps(apps) {
+  for (const app of apps) {
+    if (!APPS.find((a) => a.id === app.id)) {
+      APPS.push(app);
+    }
+  }
+}
+function registerDesktopApps(appIds) {
+  for (const id of appIds) {
+    if (!DESKTOP_APPS_ORDER.includes(id)) {
+      DESKTOP_APPS_ORDER.push(id);
+    }
+  }
+}
+
+// src/utils/getAppIdForMime.ts
+var APP_FILE_HANDLERS = [];
+var registerAppFileHandler = (handler) => {
+  APP_FILE_HANDLERS.push(handler);
+};
+var IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/svg+xml",
+  "image/webp",
+  "image/bmp"
+]);
+var TEXT_MIME_TYPES = /* @__PURE__ */ new Set([
+  "text/plain",
+  "text/markdown",
+  "text/x-markdown",
+  "application/json"
+]);
+registerAppFileHandler({
+  appId: "pdf",
+  mimeTypes: ["application/pdf"],
+  transformContentData: (node) => ({ src: node.url ?? node.name })
+});
+registerAppFileHandler({
+  appId: "image-viewer",
+  mimeTypes: (mimeType) => IMAGE_MIME_TYPES.has(mimeType) || mimeType.startsWith("image/"),
+  transformContentData: (node) => ({ src: node.url ?? node.name })
+});
+registerAppFileHandler({
+  appId: "notepad",
+  mimeTypes: (mimeType) => TEXT_MIME_TYPES.has(mimeType) || mimeType.startsWith("text/"),
+  transformContentData: (node) => ({
+    url: node.url,
+    initialName: node.name,
+    fileId: node.id
+  })
+});
+registerAppFileHandler({
+  appId: "dos-emulator",
+  mimeTypes: ["application/jsdos", "application/zip", "application/x-zip-compressed"],
+  transformContentData: (node) => ({
+    autoLoad: { url: node.url ?? node.name, name: node.name }
+  })
+});
+function findHandler(mimeType) {
+  if (!mimeType) return null;
+  for (const handler of APP_FILE_HANDLERS) {
+    const matches = typeof handler.mimeTypes === "function" ? handler.mimeTypes(mimeType) : handler.mimeTypes.includes(mimeType);
+    if (matches) return handler;
+  }
+  return null;
+}
+function getAppIdForMime(input) {
+  if (typeof input === "string" || input === void 0) {
+    const handler2 = findHandler(input);
+    return handler2?.appId ?? "files";
+  }
+  const handler = findHandler(input.mimeType);
+  if (!handler) return null;
+  return {
+    appId: handler.appId,
+    contentData: handler.transformContentData(input)
+  };
+}
+var DEFAULT_APP_STATE = {
+  isLoaded: false,
+  isLoading: false,
+  isReady: false,
+  hasError: false,
+  error: void 0,
+  mountedAt: 0,
+  instance: void 0
+};
+var useCustomAppStore = zustand.create((set) => ({
+  mountedApps: {},
+  registeredApps: {},
+  hmrConnected: false,
+  hmrError: null,
+  devServerOffline: false,
+  hmrRetryCount: 0,
+  setAppLoading: (appId) => set((state) => ({
+    mountedApps: {
+      ...state.mountedApps,
+      [appId]: {
+        ...DEFAULT_APP_STATE,
+        isLoading: true,
+        mountedAt: Date.now()
+      }
+    }
+  })),
+  setAppLoaded: (appId) => set((state) => ({
+    mountedApps: {
+      ...state.mountedApps,
+      [appId]: {
+        ...state.mountedApps[appId] || DEFAULT_APP_STATE,
+        isLoaded: true,
+        isLoading: false,
+        hasError: false,
+        error: void 0
+      }
+    }
+  })),
+  setAppReady: (appId, instance) => set((state) => ({
+    mountedApps: {
+      ...state.mountedApps,
+      [appId]: {
+        ...state.mountedApps[appId] || DEFAULT_APP_STATE,
+        isReady: true,
+        isLoaded: true,
+        isLoading: false,
+        instance: instance ?? state.mountedApps[appId]?.instance
+      }
+    }
+  })),
+  setAppError: (appId, error) => set((state) => ({
+    mountedApps: {
+      ...state.mountedApps,
+      [appId]: {
+        ...state.mountedApps[appId] || DEFAULT_APP_STATE,
+        isLoaded: false,
+        isLoading: false,
+        isReady: false,
+        hasError: true,
+        error
+      }
+    }
+  })),
+  clearApp: (appId) => set((state) => {
+    const { [appId]: _, ...rest } = state.mountedApps;
+    return { mountedApps: rest };
+  }),
+  registerApp: (manifest) => set((state) => ({
+    registeredApps: {
+      ...state.registeredApps,
+      [manifest.id]: manifest
+    }
+  })),
+  unregisterApp: (appId) => set((state) => {
+    const { [appId]: _, ...rest } = state.registeredApps;
+    return { registeredApps: rest };
+  }),
+  setHmrConnected: (connected) => set({ hmrConnected: connected, devServerOffline: !connected }),
+  setHmrError: (error) => set({ hmrError: error }),
+  setDevServerOffline: (offline) => set({ devServerOffline: offline }),
+  incrementHmrRetry: () => set((state) => ({ hmrRetryCount: state.hmrRetryCount + 1 })),
+  resetHmrRetry: () => set({ hmrRetryCount: 0 })
+}));
+
+// src/utils/getBaseUrl.ts
+var BUILD_TIME_BASE_URL = undefined.BASE_URL || "/";
+var cachedBaseUrl = null;
+var testBaseUrl = null;
+function setTestBaseUrl(url) {
+  testBaseUrl = url;
+  cachedBaseUrl = null;
+}
+function getBaseUrl() {
+  if (cachedBaseUrl !== null) {
+    return cachedBaseUrl;
+  }
+  if (testBaseUrl !== null) {
+    cachedBaseUrl = testBaseUrl;
+    return cachedBaseUrl;
+  }
+  const baseElement = document.querySelector("base[href]");
+  if (baseElement) {
+    const href = baseElement.getAttribute("href");
+    if (href) {
+      cachedBaseUrl = href;
+      return href;
+    }
+  }
+  cachedBaseUrl = BUILD_TIME_BASE_URL;
+  return cachedBaseUrl;
+}
+function resetBaseUrlCache() {
+  cachedBaseUrl = null;
+}
+function resolveUrl(relativeUrl) {
+  if (!relativeUrl) {
+    return relativeUrl;
+  }
+  if (relativeUrl.startsWith("http://") || relativeUrl.startsWith("https://") || relativeUrl.startsWith("idb://") || relativeUrl.startsWith("blob:")) {
+    return relativeUrl;
+  }
+  if (relativeUrl.startsWith("/")) {
+    return relativeUrl;
+  }
+  const base = getBaseUrl();
+  const normalizedBase = base.endsWith("/") ? base : `${base}/`;
+  return normalizedBase + relativeUrl;
+}
+
+// src/constants/breakpoints.ts
+var BREAKPOINTS = {
+  MOBILE: 768,
+  TABLET: 1024,
+  DESKTOP: 1280
+};
+var DEFAULT_VIEWPORT = {
+  WIDTH: 1280,
+  HEIGHT: 800
+};
+
+// src/constants/layout.ts
+var TASKBAR_HEIGHT = 48;
+var ICON_COLUMN_WIDTH = 80;
+var ICON_ROW_HEIGHT = 80;
+var ICON_MARGIN = 20;
+var DEFAULT_VIEWPORT_WIDTH = DEFAULT_VIEWPORT.WIDTH;
+var DEFAULT_VIEWPORT_HEIGHT = DEFAULT_VIEWPORT.HEIGHT;
+var windowManager = new WindowManagerAdapter();
+function createFileSystemAdapter() {
+  if (chunkZ5YGWL65_cjs.isDocker()) {
+    console.log("[FileSystem] Using DockerFileSystemAdapter");
+    return new DockerFileSystemAdapter();
+  }
+  console.log("[FileSystem] Using IndexedDBFileSystem");
+  return new IndexedDBFileSystem();
+}
+var fileSystem = createFileSystemAdapter();
+var resetFileSystem = () => {
+  fileSystem.clearAll().catch(() => {
+  });
+};
+var resetWindowManager = () => windowManager.reset();
+async function resolveFileUrl(url, signal) {
+  if (url.startsWith("idb://")) {
+    const blob = await fileSystem.getBlob(url);
+    return blob ? blob.text() : "";
+  }
+  const src = url.startsWith("http") || url.startsWith("/") ? url : `${undefined.BASE_URL}${url}`;
+  const res = await fetch(src, { signal });
+  return res.ok ? res.text() : "";
+}
+var getDesktopFolderId = () => {
+  return fileSystem.getRootNodes().find((n) => n.type === "folder" && n.name === "Desktop")?.id ?? null;
+};
+var calculateNextFreeSlot = (icons, viewportHeight) => {
+  const occupied = new Set(icons.map((ic) => `${ic.x},${ic.y}`));
+  const maxRows = Math.max(1, Math.floor((viewportHeight - ICON_MARGIN) / ICON_ROW_HEIGHT));
+  for (let col = 0; ; col++) {
+    const x = ICON_MARGIN + col * ICON_COLUMN_WIDTH;
+    for (let row = 0; row < maxRows; row++) {
+      const y = ICON_MARGIN + row * ICON_ROW_HEIGHT;
+      if (!occupied.has(`${x},${y}`)) return { x, y };
+    }
+  }
+};
+var calculateSlotByIndex = (index, viewportHeight) => {
+  const maxRows = Math.max(1, Math.floor((viewportHeight - ICON_MARGIN) / ICON_ROW_HEIGHT));
+  const col = Math.floor(index / maxRows);
+  const row = index % maxRows;
+  return {
+    x: ICON_MARGIN + col * ICON_COLUMN_WIDTH,
+    y: ICON_MARGIN + row * ICON_ROW_HEIGHT
+  };
+};
+var appendDesktopIcon = (current, input, viewportHeight) => {
+  const pos = calculateNextFreeSlot(current, viewportHeight);
+  return [...current, createDesktopIcon({ ...input, ...pos })];
+};
+var syncDesktopIcons = () => {
+  const desktopFolderId = getDesktopFolderId();
+  if (!desktopFolderId || !fileSystem.isReady()) return;
+  const desktopChildren = fileSystem.getChildren(desktopFolderId);
+  const desktopNodeIds = new Set(desktopChildren.map((n) => n.id));
+  const desktopNodeNames = new Set(desktopChildren.map((n) => n.name));
+  const { icons, viewportHeight } = useDesktopStore.getState();
+  let updated = icons.filter(
+    (ic) => !ic.nodeId || desktopNodeIds.has(ic.nodeId) || desktopNodeNames.has(ic.name)
+  );
+  for (const node of desktopChildren) {
+    const existing = updated.find((ic) => ic.name === node.name);
+    if (!existing) {
+      const isFolder = node.type === "folder";
+      const folderNode = isFolder ? node : null;
+      const fileNode = !isFolder ? node : null;
+      const appId = isFolder ? "files" : fileNode ? getAppIdForMime(fileNode)?.appId ?? "" : "";
+      updated = appendDesktopIcon(
+        updated,
+        {
+          name: node.name,
+          icon: isFolder ? "\u{1F4C1}" : "\u{1F4C4}",
+          iconName: folderNode?.iconName,
+          iconColor: folderNode?.iconColor,
+          appId,
+          nodeId: node.id
+        },
+        viewportHeight
+      );
+    } else if (existing.nodeId !== node.id) {
+      updated = updated.map((ic) => ic.name === node.name ? { ...ic, nodeId: node.id } : ic);
+    }
+  }
+  const sorted = sortDesktopIcons(updated);
+  useDesktopStore.setState({
+    icons: sorted.map((icon, i) => ({ ...icon, ...calculateSlotByIndex(i, viewportHeight) }))
+  });
+};
+var useDesktopStore = zustand.create()(
+  middleware.persist(
+    (set, get) => ({
+      windows: [],
+      openWindow: (input) => {
+        const window2 = windowManager.open(input);
+        set((state) => ({ windows: [...state.windows, window2] }));
+      },
+      closeWindow: (id) => {
+        windowManager.close(id);
+        set((state) => ({ windows: state.windows.filter((w) => w.id !== id) }));
+      },
+      minimizeWindow: (id) => {
+        windowManager.minimize(id);
+        set((state) => ({
+          windows: state.windows.map((w) => w.id === id ? { ...w, state: "minimized" } : w)
+        }));
+      },
+      maximizeWindow: (id) => {
+        windowManager.maximize(id);
+        set((state) => ({
+          windows: state.windows.map((w) => w.id === id ? { ...w, state: "maximized" } : w)
+        }));
+      },
+      restoreWindow: (id) => {
+        windowManager.restore(id);
+        set((state) => ({
+          windows: state.windows.map((w) => w.id === id ? { ...w, state: "normal" } : w)
+        }));
+      },
+      focusWindow: (id) => {
+        windowManager.focus(id);
+        const updated = windowManager.getById(id);
+        if (!updated) return;
+        set((state) => ({
+          windows: state.windows.map((w) => w.id === id ? updated : w)
+        }));
+      },
+      moveWindow: (id, x, y) => {
+        windowManager.move(id, x, y);
+        set((state) => ({
+          windows: state.windows.map((w) => w.id === id ? { ...w, x, y } : w)
+        }));
+      },
+      resizeWindow: (id, width, height) => {
+        windowManager.resize(id, width, height);
+        set((state) => ({
+          windows: state.windows.map((w) => w.id === id ? { ...w, width, height } : w)
+        }));
+      },
+      icons: [],
+      addIcon: (input) => {
+        const icon = createDesktopIcon(input);
+        set((state) => ({ icons: [...state.icons, icon] }));
+      },
+      removeIcon: (id) => {
+        set((state) => ({ icons: state.icons.filter((i) => i.id !== id) }));
+      },
+      fsNodes: [],
+      desktopFolderId: null,
+      isFsReady: false,
+      initFs: async () => {
+        try {
+          if (fileSystem.isReady() && fileSystem.reinitialize) {
+            await fileSystem.reinitialize();
+          } else if (!fileSystem.isReady()) {
+            await fileSystem.initialize();
+          }
+          const manifest = await fetch(resolveUrl("fs-manifest.json")).then(
+            (r) => r.json()
+          );
+          const currentSha = manifest.sha ?? null;
+          const savedSha = await fileSystem.getManifestSha();
+          if (fileSystem.isEmpty()) {
+            await fileSystem.seed(manifest);
+            if (currentSha) {
+              await fileSystem.saveManifestSha(currentSha);
+            }
+          } else if (savedSha !== currentSha && currentSha !== null) {
+            await fileSystem.mergeSeed(manifest);
+            await fileSystem.saveManifestSha(currentSha);
+          }
+          set({
+            fsNodes: fileSystem.getAllNodes(),
+            desktopFolderId: getDesktopFolderId(),
+            isFsReady: true
+          });
+          if (!chunkZ5YGWL65_cjs.isBrowser()) {
+            let customAppsData = null;
+            try {
+              customAppsData = await fetchAppManifest();
+              if (customAppsData?.apps?.length) {
+                set({ customApps: customAppsData.apps });
+                for (const app of customAppsData.apps) {
+                  useCustomAppStore.getState().registerApp(app);
+                }
+              }
+              const serverAppIds = new Set(customAppsData?.apps?.map((a) => a.id) ?? []);
+              const staleAppIds = get().icons.filter(
+                (ic) => ic.appId && !APPS.find((a) => a.id === ic.appId) && !serverAppIds.has(ic.appId)
+              ).map((ic) => ic.appId);
+              if (staleAppIds.length > 0) {
+                set((state) => ({
+                  icons: state.icons.filter((ic) => !staleAppIds.includes(ic.appId)),
+                  customApps: state.customApps.filter((a) => !staleAppIds.includes(a.id))
+                }));
+              }
+            } catch (error) {
+              console.warn("[DesktopStore] Failed to load custom apps manifest:", error);
+            }
+          }
+          for (const appId of DESKTOP_APPS_ORDER) {
+            const app = APPS.find((a) => a.id === appId);
+            if (!app) continue;
+            if (!get().icons.some((ic) => ic.appId === appId)) {
+              set({
+                icons: appendDesktopIcon(
+                  get().icons,
+                  { name: app.name, icon: app.icon, appId },
+                  get().viewportHeight
+                )
+              });
+            }
+          }
+          if (!chunkZ5YGWL65_cjs.isBrowser()) {
+            const customApps = get().customApps;
+            if (customApps.length) {
+              for (const app of customApps) {
+                if (!get().icons.some((ic) => ic.appId === app.id)) {
+                  set({
+                    icons: appendDesktopIcon(
+                      get().icons,
+                      { name: app.name, icon: app.icon, appId: app.id },
+                      get().viewportHeight
+                    )
+                  });
+                }
+              }
+            }
+          }
+          const desktopFolderId = getDesktopFolderId();
+          if (!desktopFolderId) return;
+          const desktopFiles = fileSystem.getChildren(desktopFolderId);
+          desktopFiles.forEach((node) => {
+            if (node.type !== "file") return;
+            const existingIcon = get().icons.find((ic) => ic.name === node.name);
+            if (existingIcon) {
+              if (!existingIcon.nodeId) {
+                set({
+                  icons: get().icons.map(
+                    (ic) => ic.name === node.name ? { ...ic, nodeId: node.id } : ic
+                  )
+                });
+              }
+            } else {
+              set({
+                icons: appendDesktopIcon(
+                  get().icons,
+                  {
+                    name: node.name,
+                    icon: "\u{1F4C4}",
+                    appId: getAppIdForMime(node.mimeType),
+                    nodeId: node.id
+                  },
+                  get().viewportHeight
+                )
+              });
+            }
+          });
+          syncDesktopIcons();
+        } catch (error) {
+          console.error("Failed to initialize filesystem:", error);
+          set({ isFsReady: true });
+        }
+      },
+      createFile: async (name, content, parentId, url) => {
+        const file = await fileSystem.createFile(name, content, parentId, url);
+        const desktopFolderId = getDesktopFolderId();
+        const { icons, viewportHeight } = get();
+        const newIcons = parentId && parentId === desktopFolderId && !icons.some((ic) => ic.name === file.name) ? appendDesktopIcon(
+          icons,
+          {
+            name: file.name,
+            icon: "\u{1F4C4}",
+            appId: getAppIdForMime(file.mimeType),
+            nodeId: file.id
+          },
+          viewportHeight
+        ) : icons;
+        set({ fsNodes: fileSystem.getAllNodes(), icons: newIcons });
+        return file;
+      },
+      createFolder: async (name, parentId, iconName, iconColor) => {
+        const folder = await fileSystem.createFolder(name, parentId, iconName, iconColor);
+        const desktopFolderId = getDesktopFolderId();
+        const { icons, viewportHeight } = get();
+        const newIcons = parentId && parentId === desktopFolderId && !icons.some((ic) => ic.name === folder.name) ? appendDesktopIcon(
+          icons,
+          {
+            name: folder.name,
+            icon: "\u{1F4C1}",
+            iconName: folder.iconName,
+            iconColor: folder.iconColor,
+            appId: "files",
+            nodeId: folder.id
+          },
+          viewportHeight
+        ) : icons;
+        set({ fsNodes: fileSystem.getAllNodes(), icons: newIcons });
+        return folder;
+      },
+      updateFile: async (id, content) => {
+        await fileSystem.updateFile(id, content);
+        set({ fsNodes: fileSystem.getAllNodes() });
+      },
+      deleteNode: async (id) => {
+        const node = fileSystem.getNode(id);
+        await fileSystem.delete(id);
+        set({ fsNodes: fileSystem.getAllNodes() });
+        if (node?.type === "file" || node?.type === "folder") {
+          const desktopFolderId = getDesktopFolderId();
+          if (node.parentId && node.parentId === desktopFolderId) {
+            set((state) => ({
+              icons: state.icons.filter((ic) => ic.name !== node.name)
+            }));
+          }
+        }
+      },
+      moveNode: async (id, newParentId) => {
+        await fileSystem.move(id, newParentId);
+        set({ fsNodes: fileSystem.getAllNodes() });
+      },
+      setFsNodes: (nodes) => {
+        set({ fsNodes: nodes });
+      },
+      syncIcons: () => {
+        syncDesktopIcons();
+      },
+      clipboard: { content: [], action: null },
+      copyToClipboard: (nodes) => {
+        set({ clipboard: { content: nodes, action: "copy" } });
+      },
+      cutToClipboard: (nodes) => {
+        set({ clipboard: { content: nodes, action: "cut" } });
+      },
+      clearClipboard: () => {
+        set({ clipboard: { content: [], action: null } });
+      },
+      filesCurrentFolderId: null,
+      setFilesCurrentFolderId: (id) => {
+        set({ filesCurrentFolderId: id });
+      },
+      contextMenu: { x: 0, y: 0, owner: null },
+      openContextMenu: (x, y, owner, targetNodeId) => {
+        set({ contextMenu: { x, y, owner, targetNodeId } });
+      },
+      closeContextMenu: () => {
+        set({ contextMenu: { x: 0, y: 0, owner: null, targetNodeId: void 0 } });
+      },
+      mergeSeed: async (manifest) => {
+        await fileSystem.mergeSeed(manifest);
+        set({ fsNodes: fileSystem.getAllNodes(), desktopFolderId: getDesktopFolderId() });
+      },
+      mergeDesktopApps: (appIds) => {
+        for (const appId of appIds) {
+          const app = APPS.find((a) => a.id === appId);
+          if (!app) continue;
+          if (get().icons.some((ic) => ic.appId === appId)) continue;
+          set({
+            icons: appendDesktopIcon(
+              get().icons,
+              { name: app.name, icon: app.icon, appId },
+              get().viewportHeight
+            )
+          });
+        }
+        const desktopFolderId = getDesktopFolderId();
+        if (!desktopFolderId) return;
+        for (const node of fileSystem.getChildren(desktopFolderId)) {
+          if (node.type !== "file") continue;
+          if (get().icons.some((ic) => ic.name === node.name)) continue;
+          set({
+            icons: appendDesktopIcon(
+              get().icons,
+              {
+                name: node.name,
+                icon: "\u{1F4C4}",
+                appId: getAppIdForMime(node.mimeType),
+                nodeId: node.id
+              },
+              get().viewportHeight
+            )
+          });
+        }
+      },
+      reorderDesktopApps: (appIds) => {
+        const currentIcons = get().icons;
+        const appIcons = [];
+        const fileIcons = [];
+        for (const icon of currentIcons) {
+          if (icon.appId && !icon.nodeId) {
+            appIcons.push(icon);
+          } else {
+            fileIcons.push(icon);
+          }
+        }
+        const reorderedAppIcons = [];
+        for (const appId of appIds) {
+          const existingIndex = appIcons.findIndex((ic) => ic.appId === appId);
+          if (existingIndex !== -1) {
+            reorderedAppIcons.push(appIcons[existingIndex]);
+          }
+        }
+        for (const icon of appIcons) {
+          if (!reorderedAppIcons.includes(icon)) {
+            reorderedAppIcons.push(icon);
+          }
+        }
+        let currentY = ICON_MARGIN;
+        let currentX = ICON_MARGIN;
+        const viewportHeight = get().viewportHeight;
+        const rowsBeforeFileIcons = Math.max(
+          1,
+          Math.floor((viewportHeight - TASKBAR_HEIGHT - ICON_MARGIN) / ICON_ROW_HEIGHT)
+        );
+        for (let i = 0; i < reorderedAppIcons.length; i++) {
+          const row = Math.floor(i / 1);
+          if (row >= rowsBeforeFileIcons && row > 0) {
+            currentX += ICON_COLUMN_WIDTH;
+            currentY = ICON_MARGIN;
+          }
+          reorderedAppIcons[i] = {
+            ...reorderedAppIcons[i],
+            x: currentX,
+            y: currentY
+          };
+          currentY += ICON_ROW_HEIGHT;
+        }
+        const allIcons = [...reorderedAppIcons, ...fileIcons];
+        set({ icons: allIcons });
+      },
+      notifications: [],
+      addNotification: (item) => {
+        set((state) => ({ notifications: [...state.notifications, item] }));
+      },
+      removeNotification: (id) => {
+        set((state) => ({ notifications: state.notifications.filter((n) => n.id !== id) }));
+      },
+      viewportWidth: DEFAULT_VIEWPORT_WIDTH,
+      viewportHeight: DEFAULT_VIEWPORT_HEIGHT,
+      isViewportInitialized: false,
+      setViewportSize: (width, height) => {
+        const oldWidth = get().viewportWidth;
+        const oldHeight = get().viewportHeight;
+        const isInitialized = get().isViewportInitialized;
+        if (oldWidth === width && oldHeight === height) return;
+        set({ viewportWidth: width, viewportHeight: height });
+        if (!isInitialized) {
+          set({ isViewportInitialized: true });
+          return;
+        }
+        if (oldHeight !== height) {
+          const currentMaxRows = Math.max(
+            1,
+            Math.floor((oldHeight - ICON_MARGIN) / ICON_ROW_HEIGHT)
+          );
+          const newMaxRows = Math.max(1, Math.floor((height - ICON_MARGIN) / ICON_ROW_HEIGHT));
+          if (currentMaxRows !== newMaxRows) {
+            const icons = get().icons;
+            const repositioned = icons.map((icon, index) => {
+              const col = Math.floor(index / newMaxRows);
+              const row = index % newMaxRows;
+              return {
+                ...icon,
+                x: ICON_MARGIN + col * ICON_COLUMN_WIDTH,
+                y: ICON_MARGIN + row * ICON_ROW_HEIGHT
+              };
+            });
+            set({ icons: repositioned });
+          }
+        }
+        const isMobile = width < 768;
+        const windows = get().windows.map((win) => {
+          if (win.state !== "normal") return win;
+          if (isMobile) {
+            return { ...win, x: 0, y: 0, width, height, minWidth: void 0, minHeight: void 0 };
+          }
+          const ratioX = oldWidth > 0 ? width / oldWidth : 1;
+          const ratioY = oldHeight > 0 ? height / oldHeight : 1;
+          let newX = Math.round(win.x * ratioX);
+          let newY = Math.round(win.y * ratioY);
+          let newW = win.width;
+          let newH = win.height;
+          if (newW > width) newW = width;
+          if (newH > height) newH = height;
+          newX = Math.max(0, Math.min(newX, width - Math.min(newW, 100)));
+          newY = Math.max(0, Math.min(newY, height - Math.min(newH, 40)));
+          return { ...win, x: newX, y: newY, width: newW, height: newH };
+        });
+        for (const win of windows) {
+          windowManager.move(win.id, win.x, win.y);
+          windowManager.resize(win.id, win.width, win.height);
+        }
+        set({ windows });
+      },
+      desktopSortMode: "default",
+      filesSortMode: "default",
+      setDesktopSortMode: (mode) => {
+        set({ desktopSortMode: mode });
+        const icons = get().icons;
+        const sorted = sortDesktopIconsByMode(icons, mode);
+        const vh = get().viewportHeight;
+        set({
+          icons: sorted.map((icon, i) => ({
+            ...icon,
+            ...calculateSlotByIndex(i, vh)
+          }))
+        });
+      },
+      setFilesSortMode: (mode) => {
+        set({ filesSortMode: mode });
+      },
+      launcherFolders: DEFAULT_LAUNCHER_FOLDERS,
+      setLauncherFolders: (folders) => {
+        set({ launcherFolders: folders });
+      },
+      createLauncherFolder: (input) => {
+        const folder = createLauncherFolder(input);
+        set((state) => ({
+          launcherFolders: [...state.launcherFolders, folder].sort((a, b) => a.order - b.order)
+        }));
+        return folder;
+      },
+      updateLauncherFolder: (id, updates) => {
+        set((state) => ({
+          launcherFolders: state.launcherFolders.map(
+            (f) => f.id === id ? updateLauncherFolder(f, updates) : f
+          )
+        }));
+      },
+      deleteLauncherFolder: (id) => {
+        set((state) => ({
+          launcherFolders: state.launcherFolders.filter((f) => f.id !== id || f.isPredefined)
+        }));
+      },
+      moveLauncherFolder: (id, newOrder) => {
+        set((state) => ({
+          launcherFolders: state.launcherFolders.map((f) => f.id === id ? { ...f, order: newOrder } : f).sort((a, b) => a.order - b.order)
+        }));
+      },
+      addAppToFolder: (appId, folderId) => {
+        set((state) => ({
+          launcherFolders: state.launcherFolders.map(
+            (f) => f.id === folderId && !f.appIds.includes(appId) ? { ...f, appIds: [...f.appIds, appId] } : f
+          )
+        }));
+      },
+      removeAppFromFolder: (appId, folderId) => {
+        set((state) => ({
+          launcherFolders: state.launcherFolders.map(
+            (f) => f.id === folderId ? { ...f, appIds: f.appIds.filter((id) => id !== appId) } : f
+          )
+        }));
+      },
+      customApps: [],
+      setCustomApps: (apps) => {
+        set({ customApps: apps });
+      },
+      handleCustomAppRegistered: (manifest) => {
+        set((state) => {
+          const exists = state.customApps.some((a) => a.id === manifest.id);
+          return {
+            customApps: exists ? state.customApps.map((a) => a.id === manifest.id ? manifest : a) : [...state.customApps, manifest]
+          };
+        });
+        const existingIcon = get().icons.find((ic) => ic.appId === manifest.id);
+        if (!existingIcon) {
+          set((state) => ({
+            icons: appendDesktopIcon(
+              state.icons,
+              {
+                name: manifest.name,
+                icon: manifest.icon || "FcDataSheet",
+                appId: manifest.id
+              },
+              state.viewportHeight
+            )
+          }));
+        }
+      },
+      handleCustomAppUnregistered: (appId) => {
+        set((state) => ({
+          customApps: state.customApps.filter((a) => a.id !== appId)
+        }));
+        set((state) => ({
+          icons: state.icons.filter((ic) => ic.appId !== appId)
+        }));
+        get().windows.filter((w) => w.content === appId).forEach((w) => get().closeWindow(w.id));
+        useCustomAppStore.getState().clearApp(appId);
+      }
+    }),
+    {
+      name: "fde-desktop",
+      storage: middleware.createJSONStorage(() => localStorage),
+      partialize: (state) => ({
+        windows: state.windows,
+        icons: state.icons,
+        customApps: state.customApps,
+        desktopSortMode: state.desktopSortMode,
+        filesSortMode: state.filesSortMode,
+        launcherFolders: state.launcherFolders,
+        viewportWidth: state.viewportWidth,
+        viewportHeight: state.viewportHeight
+      }),
+      merge: (persisted, current) => {
+        const p = persisted;
+        const TRANSIENT_WINDOWS = ["createItem"];
+        const mergedWindows = (p.windows ?? []).filter((w) => !TRANSIENT_WINDOWS.includes(w.content)).map((w) => {
+          const app = APPS.find((a) => a.id === w.content);
+          const customApp = (p.customApps ?? current.customApps)?.find((a) => a.id === w.content);
+          return {
+            ...w,
+            icon: w.icon ?? app?.icon ?? customApp?.icon,
+            fcIcon: w.fcIcon ?? app?.fcIcon,
+            iconUrl: w.iconUrl ?? app?.iconUrl,
+            iconColor: app?.iconColor,
+            canMaximize: app?.canMaximize ?? customApp?.window?.canMaximize,
+            minWidth: app?.minWidth === false || customApp?.window?.minWidth === false ? void 0 : app?.minWidth ?? customApp?.window?.minWidth ?? DEFAULT_WINDOW_DIMENSIONS.minWidth,
+            minHeight: app?.minHeight === false || customApp?.window?.minHeight === false ? void 0 : app?.minHeight ?? customApp?.window?.minHeight ?? DEFAULT_WINDOW_DIMENSIONS.minHeight
+          };
+        });
+        windowManager.loadWindows(mergedWindows);
+        const predefinedIds = new Set(DEFAULT_LAUNCHER_FOLDERS.map((f) => f.id));
+        const customFolders = (p.launcherFolders ?? []).filter((f) => !predefinedIds.has(f.id));
+        const mergedLauncherFolders = [...DEFAULT_LAUNCHER_FOLDERS, ...customFolders].sort(
+          (a, b) => a.order - b.order
+        );
+        const hasPersistedViewport = p.viewportWidth != null && p.viewportHeight != null;
+        return {
+          ...current,
+          ...p,
+          windows: mergedWindows,
+          launcherFolders: mergedLauncherFolders,
+          viewportWidth: p.viewportWidth ?? current.viewportWidth,
+          viewportHeight: p.viewportHeight ?? current.viewportHeight,
+          isViewportInitialized: hasPersistedViewport ? true : current.isViewportInitialized
+        };
+      }
+    }
+  )
+);
+if (typeof window !== "undefined") {
+  window.__DESKTOP_STATE__ = useDesktopStore.getState();
+  useDesktopStore.subscribe((state) => {
+    window.__DESKTOP_STATE__ = state;
+  });
+}
+
+Object.defineProperty(exports, "v4", {
+  enumerable: true,
+  get: function () { return uuid.v4; }
+});
+exports.APPS = APPS;
+exports.BREAKPOINTS = BREAKPOINTS;
+exports.CORE_APPS = CORE_APPS;
+exports.CORE_APP_IDS = CORE_APP_IDS;
+exports.CUSTOM_APPS_FOLDER_ID = CUSTOM_APPS_FOLDER_ID;
+exports.DEFAULT_LAUNCHER_FOLDERS = DEFAULT_LAUNCHER_FOLDERS;
+exports.DEFAULT_VIEWPORT_HEIGHT = DEFAULT_VIEWPORT_HEIGHT;
+exports.DEFAULT_VIEWPORT_WIDTH = DEFAULT_VIEWPORT_WIDTH;
+exports.DEFAULT_WINDOW_DIMENSIONS = DEFAULT_WINDOW_DIMENSIONS;
+exports.DESKTOP_APPS_ORDER = DESKTOP_APPS_ORDER;
+exports.DockerFileSystemAdapter = DockerFileSystemAdapter;
+exports.EXTRA_APPS = EXTRA_APPS;
+exports.EXTRA_APP_IDS = EXTRA_APP_IDS;
+exports.ICON_COLUMN_WIDTH = ICON_COLUMN_WIDTH;
+exports.ICON_MARGIN = ICON_MARGIN;
+exports.ICON_ROW_HEIGHT = ICON_ROW_HEIGHT;
+exports.IMAGE_MIME_TYPES = IMAGE_MIME_TYPES;
+exports.IndexedDBFileSystem = IndexedDBFileSystem;
+exports.PREDEFINED_LAUNCHER_FOLDERS = PREDEFINED_LAUNCHER_FOLDERS;
+exports.SortOptions = SortOptions;
+exports.TASKBAR_HEIGHT = TASKBAR_HEIGHT;
+exports.TEXT_MIME_TYPES = TEXT_MIME_TYPES;
+exports.WindowManagerAdapter = WindowManagerAdapter;
+exports.clearManifestCache = clearManifestCache;
+exports.convertToAppEntry = convertToAppEntry;
+exports.createDesktopIcon = createDesktopIcon;
+exports.createFile = createFile;
+exports.createFolder = createFolder;
+exports.createLauncherFolder = createLauncherFolder;
+exports.createPredefinedLauncherFolder = createPredefinedLauncherFolder;
+exports.createWindow = createWindow;
+exports.fetchAppManifest = fetchAppManifest;
+exports.fileSystem = fileSystem;
+exports.generateUUID = generateUUID;
+exports.getAppIdForMime = getAppIdForMime;
+exports.getBaseUrl = getBaseUrl;
+exports.getCachedManifest = getCachedManifest;
+exports.getCustomAppById = getCustomAppById;
+exports.getCustomApps = getCustomApps;
+exports.getMimeTypeFromExtension = getMimeTypeFromExtension;
+exports.hashBlob = hashBlob;
+exports.isCustomApp = isCustomApp;
+exports.mergeAppsWithCustomApps = mergeAppsWithCustomApps;
+exports.registerAppFileHandler = registerAppFileHandler;
+exports.registerCustomApps = registerCustomApps;
+exports.registerDesktopApps = registerDesktopApps;
+exports.removeFromManifestCache = removeFromManifestCache;
+exports.resetBaseUrlCache = resetBaseUrlCache;
+exports.resetFileSystem = resetFileSystem;
+exports.resetWindowManager = resetWindowManager;
+exports.resolveFileUrl = resolveFileUrl;
+exports.resolveUrl = resolveUrl;
+exports.setApiBaseUrl = setApiBaseUrl;
+exports.setTestBaseUrl = setTestBaseUrl;
+exports.sortDesktopIcons = sortDesktopIcons;
+exports.sortDesktopIconsByMode = sortDesktopIconsByMode;
+exports.sortNodes = sortNodes;
+exports.sortNodesByMode = sortNodesByMode;
+exports.syncWithServer = syncWithServer;
+exports.updateLauncherFolder = updateLauncherFolder;
+exports.updateManifestCache = updateManifestCache;
+exports.useCustomAppStore = useCustomAppStore;
+exports.useDesktopStore = useDesktopStore;