@tutti-os/workspace-file-manager 0.0.1

package/dist/chunk-IMOFXYBB.js

@@ -0,0 +1,1759 @@
+// src/services/internal/workspaceFileManagerStore.ts
+import { proxy } from "valtio";
+
+// src/services/workspaceFileManagerTypes.ts
+var workspaceFileManagerLogicalRoot = "/";
+var workspaceFileManagerPersistedStateSchemaVersion = 2;
+
+// src/services/internal/model/fileKinds.ts
+import {
+  classifyWorkspaceFilePreviewKind as classifySharedWorkspaceFilePreviewKind,
+  resolveWorkspaceFileActivationTarget as resolveSharedWorkspaceFileActivationTarget,
+  resolveWorkspaceFilePreviewReadiness as resolveSharedWorkspaceFilePreviewReadiness
+} from "@tutti-os/workspace-file-preview";
+import {
+  copyWorkspaceFilePreviewBytes,
+  createWorkspaceFilePreviewLoadedState,
+  decodeWorkspaceTextFile,
+  formatWorkspacePreviewByteLimit,
+  isWorkspaceFileBrowserOpenable,
+  isWorkspacePreviewFileTooLarge,
+  isWorkspaceTextFileTooLarge,
+  looksLikeBinaryText,
+  normalizeWorkspaceFilePreviewBytes,
+  resolveWorkspaceFileExtension,
+  resolveWorkspaceFileVisualKind,
+  resolveWorkspaceImageMimeType,
+  workspaceFilePreviewMaxBytes,
+  workspaceFileTextMaxBytes
+} from "@tutti-os/workspace-file-preview";
+function classifyWorkspaceFilePreviewKind(entry) {
+  return classifySharedWorkspaceFilePreviewKind(entry);
+}
+function resolveWorkspaceFileActivationTarget(entry) {
+  const target = resolveSharedWorkspaceFileActivationTarget(entry);
+  if (!target) {
+    return null;
+  }
+  return {
+    fileKind: target.fileKind,
+    mtimeMs: target.mtimeMs ?? null,
+    name: target.name,
+    path: target.path,
+    sizeBytes: target.sizeBytes ?? null
+  };
+}
+function resolveWorkspaceFilePreviewReadiness(entry) {
+  const readiness = resolveSharedWorkspaceFilePreviewReadiness(entry);
+  if (readiness.status !== "ready") {
+    return readiness;
+  }
+  return {
+    entry,
+    status: "ready",
+    target: {
+      fileKind: readiness.target.fileKind,
+      mtimeMs: readiness.target.mtimeMs ?? null,
+      name: readiness.target.name,
+      path: readiness.target.path,
+      sizeBytes: readiness.target.sizeBytes ?? null
+    }
+  };
+}
+
+// src/services/internal/model/formatters.ts
+import { formatNextopShortDateTime } from "@tutti-os/ui-system/date-format";
+function formatWorkspaceFileBytes(sizeBytes) {
+  if (sizeBytes === null || !Number.isFinite(sizeBytes)) {
+    return "--";
+  }
+  if (sizeBytes < 1024) {
+    return `${sizeBytes} B`;
+  }
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = sizeBytes / 1024;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+  return `${value >= 10 ? value.toFixed(1) : value.toFixed(2)} ${units[unitIndex]}`;
+}
+function formatWorkspaceFileModifiedTime(mtimeMs, locale) {
+  if (mtimeMs === null || !Number.isFinite(mtimeMs) || mtimeMs <= 0) {
+    return "--";
+  }
+  return formatNextopShortDateTime(mtimeMs, locale);
+}
+function splitWorkspaceFileName(name) {
+  const extensionIndex = name.lastIndexOf(".");
+  const hasExtension = extensionIndex > 0 && extensionIndex < name.length - 1;
+  if (hasExtension) {
+    return {
+      end: name.slice(extensionIndex),
+      start: name.slice(0, extensionIndex)
+    };
+  }
+  if (name.length <= 24) {
+    return { end: "", start: name };
+  }
+  return {
+    end: name.slice(-10),
+    start: name.slice(0, -10)
+  };
+}
+
+// src/services/internal/model/paths.ts
+function normalizeWorkspaceFilePath(value, rootPath) {
+  const root = normalizeWorkspaceFileAbsolutePath(rootPath);
+  const raw = String(value ?? "").trim().replaceAll("\\", "/");
+  if (!raw) {
+    return root;
+  }
+  if (!raw.startsWith("/") && root) {
+    return normalizeWorkspaceFileAbsolutePath(`${root}/${raw}`);
+  }
+  return normalizeWorkspaceFileAbsolutePath(raw);
+}
+function normalizeWorkspaceFileAbsolutePath(value) {
+  const raw = String(value ?? "").trim().replaceAll("\\", "/");
+  if (!raw) {
+    return workspaceFileManagerLogicalRoot;
+  }
+  const segments = raw.split("/").filter(Boolean).filter((segment) => segment !== ".");
+  const result = [];
+  for (const segment of segments) {
+    if (segment === "..") {
+      result.pop();
+      continue;
+    }
+    result.push(segment);
+  }
+  if (result.length === 0) {
+    return workspaceFileManagerLogicalRoot;
+  }
+  return `/${result.join("/")}`;
+}
+function workspaceFileName(path) {
+  return normalizeWorkspaceFilePath(path).split("/").filter(Boolean).at(-1) ?? "workspace";
+}
+function workspaceFileDirectory(path, rootPath) {
+  const root = normalizeWorkspaceFilePath(rootPath);
+  const normalized = normalizeWorkspaceFilePath(path, root);
+  if (normalized === root) {
+    return root;
+  }
+  const parts = normalized.split("/").filter(Boolean);
+  parts.pop();
+  if (parts.length === 0) {
+    return root;
+  }
+  const directory = `/${parts.join("/")}`;
+  if (root !== workspaceFileManagerLogicalRoot) {
+    return isWorkspaceFilePathWithinRoot(directory, root) ? directory : root;
+  }
+  return directory;
+}
+function workspaceFilePathHasHiddenSegment(path) {
+  return normalizeWorkspaceFilePath(path).split("/").filter(Boolean).some((segment) => segment.startsWith("."));
+}
+function sortWorkspaceEntries(entries) {
+  return [...entries].sort((left, right) => {
+    if (left.kind !== right.kind) {
+      return left.kind === "directory" ? -1 : 1;
+    }
+    return left.name.localeCompare(right.name, void 0, {
+      sensitivity: "base"
+    });
+  });
+}
+function buildWorkspaceFileBreadcrumbs(path, rootLabel, rootPath) {
+  const root = normalizeWorkspaceFilePath(rootPath);
+  const current = normalizeWorkspaceFilePath(path, root);
+  const relative = current === root ? "" : current.slice(root.length).replace(/^\//, "");
+  const breadcrumbs = [
+    { label: rootLabel, path: root }
+  ];
+  let cursor = root;
+  for (const segment of relative.split("/").filter(Boolean)) {
+    cursor = `${cursor}/${segment}`.replace(/\/+/g, "/");
+    breadcrumbs.push({ label: segment, path: cursor });
+  }
+  return breadcrumbs;
+}
+function isWorkspaceFilePathWithinRoot(path, rootPath) {
+  const root = normalizeWorkspaceFilePath(rootPath);
+  const normalized = normalizeWorkspaceFilePath(path, root);
+  return root === workspaceFileManagerLogicalRoot || normalized === root || normalized.startsWith(`${root}/`);
+}
+
+// src/services/internal/model/validation.ts
+function validateWorkspaceFileEntryName(name) {
+  const trimmed = name.trim();
+  if (!trimmed) {
+    return "required";
+  }
+  if (trimmed.includes("/") || trimmed.includes("\\") || trimmed === "." || trimmed === "..") {
+    return "invalid";
+  }
+  return null;
+}
+
+// src/services/internal/workspaceFileManagerStore.ts
+function createWorkspaceFileManagerStore(input) {
+  const persistedState = normalizeWorkspaceFileManagerPersistedState(
+    input.persistedState
+  );
+  const initialDirectoryPath = normalizeWorkspaceFilePath(
+    input.initialDirectoryPath
+  );
+  return proxy({
+    busyAction: null,
+    capabilities: input.capabilities,
+    contextMenu: null,
+    contextMenuEntryPath: null,
+    createDialog: null,
+    currentDirectoryPath: persistedState?.currentDirectoryPath ?? initialDirectoryPath ?? workspaceFileManagerLogicalRoot,
+    deleteDialog: null,
+    inlineRenameEntryPath: null,
+    inlineRenameValidation: null,
+    dragDepth: 0,
+    entries: [],
+    error: null,
+    isLoading: false,
+    isMutating: false,
+    isSearching: false,
+    navigationBackStack: persistedState?.navigationBackStack ?? [],
+    navigationForwardStack: persistedState?.navigationForwardStack ?? [],
+    pendingDirectoryPath: null,
+    previewState: { status: "empty" },
+    root: workspaceFileManagerLogicalRoot,
+    searchEntries: [],
+    searchError: null,
+    searchQuery: "",
+    selectedPath: null,
+    unsupportedDialog: null,
+    importConflictDialog: null,
+    workspaceID: input.workspaceID
+  });
+}
+function getWorkspaceFileManagerPersistedState(state) {
+  return {
+    currentDirectoryPath: normalizeWorkspaceFilePath(
+      state.currentDirectoryPath,
+      state.root
+    ),
+    navigationBackStack: normalizePersistedStack(
+      state.navigationBackStack,
+      state.root
+    ),
+    navigationForwardStack: normalizePersistedStack(
+      state.navigationForwardStack,
+      state.root
+    ),
+    schemaVersion: workspaceFileManagerPersistedStateSchemaVersion
+  };
+}
+function normalizeWorkspaceFileManagerPersistedState(value) {
+  if (!isPersistedStateRecord(value) || value.schemaVersion !== workspaceFileManagerPersistedStateSchemaVersion || typeof value.currentDirectoryPath !== "string" || !isStringArray(value.navigationBackStack) || !isStringArray(value.navigationForwardStack)) {
+    return null;
+  }
+  return {
+    currentDirectoryPath: normalizeWorkspaceFilePath(
+      value.currentDirectoryPath
+    ),
+    navigationBackStack: normalizePersistedStack(value.navigationBackStack),
+    navigationForwardStack: normalizePersistedStack(
+      value.navigationForwardStack
+    ),
+    schemaVersion: workspaceFileManagerPersistedStateSchemaVersion
+  };
+}
+function isPersistedStateRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function normalizePersistedStack(values, root) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  return values.map(
+    (value) => typeof value === "string" ? normalizeWorkspaceFilePath(value, root) : null
+  ).filter((value) => value !== null);
+}
+
+// src/services/internal/workspaceFileManagerSession.ts
+import { subscribe } from "valtio/vanilla";
+
+// src/services/internal/workspaceFileManagerActivationController.ts
+var WorkspaceFileManagerActivationController = class {
+  copy;
+  host;
+  loadDirectory;
+  resolveErrorMessage;
+  store;
+  constructor(input) {
+    this.copy = input.copy;
+    this.host = input.host;
+    this.loadDirectory = input.loadDirectory;
+    this.resolveErrorMessage = input.resolveErrorMessage;
+    this.store = input.store;
+  }
+  async activateFile(request) {
+    const copy = this.copy();
+    if (!this.host.activateFile) {
+      return {
+        disposition: "unsupported",
+        message: copy.t("unsupportedViewBody", { name: request.entry.name }),
+        title: copy.t("unsupportedViewTitle")
+      };
+    }
+    try {
+      const result = await this.host.activateFile(
+        request,
+        this.store.workspaceID
+      );
+      if (result.disposition !== "fallback" || !result.actions) {
+        return result;
+      }
+      const fallbackActionKinds = new Set(
+        result.actions.map((action) => action.kind)
+      );
+      return {
+        ...result,
+        actions: result.actions.map(
+          (action) => this.wrapFallbackAction(action, copy)
+        ),
+        message: result.message ?? (fallbackActionKinds.has("download") ? copy.t("previewUnavailableDownloadBody", {
+          name: request.entry.name
+        }) : copy.t("previewUnavailableOpenBody", {
+          name: request.entry.name
+        })),
+        title: result.title ?? copy.t("previewUnavailableTitle")
+      };
+    } catch (error) {
+      return {
+        actions: [
+          {
+            kind: "open",
+            label: copy.t("retryLabel"),
+            onSelect: async () => this.activateFile(request)
+          }
+        ],
+        disposition: "unsupported",
+        message: this.resolveErrorMessage(error),
+        title: copy.t("openFailedTitle")
+      };
+    }
+  }
+  async handleFallbackAction(action) {
+    if (action.kind === "none" || !action.onSelect) {
+      return;
+    }
+    const entryPath = this.store.unsupportedDialog?.entryPath ?? null;
+    const entry = entryPath ? this.findEntry(entryPath) : null;
+    this.store.busyAction = "view";
+    try {
+      const result = await action.onSelect();
+      if (!entry) {
+        this.store.unsupportedDialog = null;
+        return;
+      }
+      this.applyActivationResult(result, entry);
+    } finally {
+      this.store.busyAction = null;
+    }
+  }
+  async openEntry(entry) {
+    this.store.contextMenu = null;
+    if (entry.kind === "directory") {
+      this.store.pendingDirectoryPath = entry.path;
+      try {
+        await this.loadDirectory(entry.path);
+      } finally {
+        if (this.store.pendingDirectoryPath === entry.path) {
+          this.store.pendingDirectoryPath = null;
+        }
+      }
+      return;
+    }
+    this.store.busyAction = "view";
+    try {
+      const result = await this.activateFile({
+        entry,
+        target: resolveWorkspaceFileActivationTarget(entry)
+      });
+      this.applyActivationResult(result, entry);
+    } finally {
+      this.store.busyAction = null;
+    }
+  }
+  applyActivationResult(result, entry) {
+    if (!result || result.disposition === "handled") {
+      this.store.unsupportedDialog = null;
+      return;
+    }
+    this.store.importConflictDialog = null;
+    this.store.unsupportedDialog = {
+      actions: result.actions ?? null,
+      entryPath: entry.path,
+      kind: "view",
+      message: result.message,
+      title: result.title
+    };
+  }
+  findEntry(entryPath) {
+    return this.store.entries.find((entry) => entry.path === entryPath) ?? null;
+  }
+  wrapFallbackAction(action, copy) {
+    if (action.kind === "none" || !action.onSelect) {
+      return action;
+    }
+    return {
+      ...action,
+      onSelect: async () => {
+        try {
+          return await action.onSelect();
+        } catch (error) {
+          return {
+            actions: [
+              this.wrapFallbackAction(
+                {
+                  ...action,
+                  label: copy.t("retryLabel")
+                },
+                copy
+              )
+            ],
+            disposition: "unsupported",
+            message: this.resolveErrorMessage(error),
+            title: action.kind === "download" ? copy.t("downloadFailedTitle") : copy.t("openFailedTitle")
+          };
+        }
+      }
+    };
+  }
+};
+
+// src/services/internal/workspaceFileManagerMutationController.ts
+var WorkspaceFileManagerMutationController = class {
+  host;
+  onErrorMessage;
+  refresh;
+  resolveErrorMessage;
+  store;
+  constructor(input) {
+    this.host = input.host;
+    this.onErrorMessage = input.onErrorMessage;
+    this.refresh = input.refresh;
+    this.resolveErrorMessage = input.resolveErrorMessage;
+    this.store = input.store;
+  }
+  async createDirectory(path) {
+    if (!this.host.createDirectory) {
+      return;
+    }
+    await this.mutate(
+      "create",
+      () => this.host.createDirectory?.({
+        path: normalizeWorkspaceFilePath(path, this.store.root),
+        workspaceID: this.store.workspaceID
+      }) ?? Promise.resolve()
+    );
+  }
+  async createFile(path) {
+    if (!this.host.createFile) {
+      return;
+    }
+    await this.mutate(
+      "create",
+      () => this.host.createFile?.({
+        path: normalizeWorkspaceFilePath(path, this.store.root),
+        workspaceID: this.store.workspaceID
+      }) ?? Promise.resolve()
+    );
+  }
+  async deleteSelected() {
+    if (!this.host.deleteEntry || !this.store.selectedPath) {
+      return;
+    }
+    const entry = this.store.entries.find(
+      (candidate) => candidate.path === this.store.selectedPath
+    );
+    await this.mutate(
+      "delete",
+      () => this.host.deleteEntry?.({
+        kind: entryKindForDelete(entry?.kind),
+        path: this.store.selectedPath ?? "",
+        workspaceID: this.store.workspaceID
+      }) ?? Promise.resolve()
+    );
+    this.store.selectedPath = null;
+  }
+  async moveEntry(entry, targetDirectoryPath) {
+    if (!this.host.moveEntry || entry.kind === "unknown") {
+      return;
+    }
+    const entryKind = entry.kind;
+    const normalizedTargetDirectoryPath = normalizeWorkspaceFilePath(
+      targetDirectoryPath,
+      this.store.root
+    );
+    if (entry.path === normalizedTargetDirectoryPath) {
+      return;
+    }
+    if (entry.kind === "directory" && normalizedTargetDirectoryPath.startsWith(`${entry.path}/`)) {
+      return;
+    }
+    if (workspaceFileDirectory(entry.path, this.store.root) === normalizedTargetDirectoryPath) {
+      return;
+    }
+    let movedPath = null;
+    await this.mutate("move", async () => {
+      const movedEntry = await this.host.moveEntry?.({
+        kind: entryKind,
+        path: entry.path,
+        targetDirectoryPath: normalizedTargetDirectoryPath,
+        workspaceID: this.store.workspaceID
+      }) ?? null;
+      movedPath = movedEntry?.path ?? null;
+    });
+    this.store.selectedPath = movedPath;
+  }
+  async renameEntry(entry, newName) {
+    if (!this.host.renameEntry) {
+      return;
+    }
+    let renamedPath = null;
+    await this.mutate("rename", async () => {
+      const renamedEntry = await this.host.renameEntry?.({
+        newName: newName.trim(),
+        path: entry.path,
+        workspaceID: this.store.workspaceID
+      }) ?? null;
+      renamedPath = renamedEntry?.path ?? null;
+    });
+    this.store.selectedPath = renamedPath;
+  }
+  async mutate(actionKind, operation) {
+    this.store.isMutating = true;
+    this.store.error = null;
+    try {
+      await operation();
+      await this.refresh();
+    } catch (error) {
+      const message = this.resolveErrorMessage(error);
+      const handled = this.onErrorMessage?.({
+        actionKind,
+        error,
+        message
+      });
+      if (!handled) {
+        this.store.error = message;
+      }
+    } finally {
+      this.store.isMutating = false;
+    }
+  }
+};
+function entryKindForDelete(kind) {
+  if (kind === "file" || kind === "directory") {
+    return kind;
+  }
+  return null;
+}
+
+// src/services/internal/workspaceFileManagerNavigationController.ts
+var WorkspaceFileManagerNavigationController = class {
+  host;
+  resolveErrorMessage;
+  store;
+  requestSeq = 0;
+  constructor(input) {
+    this.host = input.host;
+    this.resolveErrorMessage = input.resolveErrorMessage;
+    this.store = input.store;
+  }
+  async goBack() {
+    const previous = this.store.navigationBackStack.pop();
+    if (!previous) {
+      return;
+    }
+    this.store.navigationForwardStack.push(this.store.currentDirectoryPath);
+    await this.replaceDirectory(previous);
+  }
+  async goForward() {
+    const next = this.store.navigationForwardStack.pop();
+    if (!next) {
+      return;
+    }
+    this.store.navigationBackStack.push(this.store.currentDirectoryPath);
+    await this.replaceDirectory(next);
+  }
+  async loadDirectory(path = this.store.currentDirectoryPath) {
+    const normalizedPath = normalizeWorkspaceFilePath(path, this.store.root);
+    const requestID = ++this.requestSeq;
+    this.store.isLoading = true;
+    this.store.error = null;
+    try {
+      const listing = await this.host.listDirectory({
+        includeHidden: workspaceFilePathHasHiddenSegment(normalizedPath),
+        path: this.resolveRequestPath(normalizedPath),
+        workspaceID: this.store.workspaceID
+      });
+      if (requestID !== this.requestSeq) {
+        return;
+      }
+      const previousDirectoryPath = this.store.currentDirectoryPath;
+      if (previousDirectoryPath !== listing.directoryPath && previousDirectoryPath !== "/") {
+        this.store.navigationBackStack.push(this.store.currentDirectoryPath);
+        this.store.navigationForwardStack = [];
+      }
+      this.store.root = normalizeWorkspaceFilePath(listing.root);
+      this.store.currentDirectoryPath = listing.directoryPath;
+      this.store.entries = sortWorkspaceEntries(listing.entries);
+      this.store.selectedPath = null;
+    } catch (error) {
+      if (requestID === this.requestSeq) {
+        this.store.error = this.resolveErrorMessage(error);
+      }
+    } finally {
+      if (requestID === this.requestSeq) {
+        this.store.isLoading = false;
+      }
+    }
+  }
+  async refresh() {
+    await this.loadDirectory(this.store.currentDirectoryPath);
+  }
+  async revealPath(path) {
+    const normalizedPath = normalizeWorkspaceFilePath(path, this.store.root);
+    const directoryPath = workspaceFileDirectory(
+      normalizedPath,
+      this.store.root
+    );
+    const requestID = ++this.requestSeq;
+    this.store.isLoading = true;
+    this.store.error = null;
+    try {
+      const listing = await this.host.listDirectory({
+        includeHidden: workspaceFilePathHasHiddenSegment(normalizedPath),
+        path: this.resolveRequestPath(directoryPath),
+        workspaceID: this.store.workspaceID
+      });
+      if (requestID !== this.requestSeq) {
+        return;
+      }
+      const previousDirectoryPath = this.store.currentDirectoryPath;
+      if (previousDirectoryPath !== listing.directoryPath && previousDirectoryPath !== "/") {
+        this.store.navigationBackStack.push(this.store.currentDirectoryPath);
+        this.store.navigationForwardStack = [];
+      }
+      this.store.root = normalizeWorkspaceFilePath(listing.root);
+      this.store.currentDirectoryPath = listing.directoryPath;
+      this.store.entries = sortWorkspaceEntries(listing.entries);
+      this.store.selectedPath = normalizedPath;
+    } catch (error) {
+      if (requestID === this.requestSeq) {
+        this.store.error = this.resolveErrorMessage(error);
+      }
+    } finally {
+      if (requestID === this.requestSeq) {
+        this.store.isLoading = false;
+      }
+    }
+  }
+  async replaceDirectory(path) {
+    const normalizedPath = normalizeWorkspaceFilePath(path, this.store.root);
+    const requestID = ++this.requestSeq;
+    this.store.isLoading = true;
+    this.store.error = null;
+    try {
+      const listing = await this.host.listDirectory({
+        includeHidden: workspaceFilePathHasHiddenSegment(normalizedPath),
+        path: this.resolveRequestPath(normalizedPath),
+        workspaceID: this.store.workspaceID
+      });
+      if (requestID !== this.requestSeq) {
+        return;
+      }
+      this.store.root = normalizeWorkspaceFilePath(listing.root);
+      this.store.currentDirectoryPath = listing.directoryPath;
+      this.store.entries = sortWorkspaceEntries(listing.entries);
+      this.store.selectedPath = null;
+    } catch (error) {
+      if (requestID === this.requestSeq) {
+        this.store.error = this.resolveErrorMessage(error);
+      }
+    } finally {
+      if (requestID === this.requestSeq) {
+        this.store.isLoading = false;
+      }
+    }
+  }
+  resolveRequestPath(path) {
+    if (this.store.root === "/" && path === "/") {
+      return "";
+    }
+    return path;
+  }
+};
+
+// src/services/internal/workspaceFileManagerPreviewController.ts
+var WorkspaceFileManagerPreviewController = class {
+  copy;
+  host;
+  isDisposed;
+  resolveErrorMessage;
+  store;
+  previewObjectUrl = null;
+  previewRequestSeq = 0;
+  constructor(input) {
+    this.copy = input.copy;
+    this.host = input.host;
+    this.isDisposed = input.isDisposed;
+    this.resolveErrorMessage = input.resolveErrorMessage;
+    this.store = input.store;
+  }
+  dispose() {
+    this.previewRequestSeq += 1;
+    this.revokePreviewObjectUrl();
+  }
+  async syncPreviewState() {
+    const requestID = this.previewRequestSeq + 1;
+    this.previewRequestSeq = requestID;
+    this.revokePreviewObjectUrl();
+    const selectedEntry = this.store.entries.find(
+      (entry) => entry.path === this.store.selectedPath
+    ) ?? null;
+    const copy = this.copy();
+    if (!selectedEntry) {
+      this.store.previewState = { status: "empty" };
+      return;
+    }
+    const readiness = resolveWorkspaceFilePreviewReadiness(selectedEntry);
+    if (readiness.status === "directory") {
+      this.store.previewState = {
+        entry: selectedEntry,
+        status: "directory"
+      };
+      return;
+    }
+    if (readiness.status === "unsupported") {
+      this.store.previewState = {
+        entry: selectedEntry,
+        message: copy.t("previewUnsupported"),
+        status: "unsupported"
+      };
+      return;
+    }
+    if (readiness.status === "readonly") {
+      this.store.previewState = {
+        entry: selectedEntry,
+        message: resolveWorkspaceFileManagerPreviewReadonlyMessage(
+          copy,
+          readiness.reason,
+          readiness.maxSizeBytes
+        ),
+        status: "readonly"
+      };
+      return;
+    }
+    const activationTarget = readiness.target;
+    this.store.previewState = {
+      entry: activationTarget,
+      status: "loading"
+    };
+    if (!this.host.readPreviewFile) {
+      this.store.previewState = {
+        entry: selectedEntry,
+        message: copy.t("previewUnsupported"),
+        status: "unsupported"
+      };
+      return;
+    }
+    try {
+      const bytes = normalizeWorkspaceFilePreviewBytes(
+        await this.host.readPreviewFile(
+          this.store.workspaceID,
+          selectedEntry.path
+        )
+      );
+      if (this.isDisposed() || requestID !== this.previewRequestSeq) {
+        return;
+      }
+      const loadedState = createWorkspaceFilePreviewLoadedState({
+        bytes,
+        entry: selectedEntry,
+        target: activationTarget
+      });
+      if (loadedState.status === "image") {
+        const objectUrl = URL.createObjectURL(
+          new Blob([loadedState.bytes], {
+            type: loadedState.contentType
+          })
+        );
+        if (this.isDisposed() || requestID !== this.previewRequestSeq) {
+          URL.revokeObjectURL(objectUrl);
+          return;
+        }
+        this.previewObjectUrl = objectUrl;
+        this.store.previewState = {
+          entry: activationTarget,
+          objectUrl,
+          status: "image"
+        };
+        return;
+      }
+      if (loadedState.status === "text") {
+        this.store.previewState = loadedState;
+        return;
+      }
+      if (loadedState.status === "readonly") {
+        this.store.previewState = {
+          entry: selectedEntry,
+          message: resolveWorkspaceFileManagerPreviewReadonlyMessage(
+            copy,
+            loadedState.reason,
+            loadedState.maxSizeBytes
+          ),
+          status: "readonly"
+        };
+      }
+    } catch (error) {
+      if (this.isDisposed() || requestID !== this.previewRequestSeq) {
+        return;
+      }
+      this.store.previewState = {
+        entry: selectedEntry,
+        message: this.resolveErrorMessage(error, {
+          preview_file_too_large: copy.t("previewFileTooLarge", {
+            maxSize: formatWorkspacePreviewByteLimit(
+              workspaceFilePreviewMaxBytes
+            )
+          })
+        }),
+        status: "error"
+      };
+    }
+  }
+  revokePreviewObjectUrl() {
+    if (!this.previewObjectUrl) {
+      return;
+    }
+    URL.revokeObjectURL(this.previewObjectUrl);
+    this.previewObjectUrl = null;
+  }
+};
+function resolveWorkspaceFileManagerPreviewReadonlyMessage(copy, reason, maxSizeBytes) {
+  switch (reason) {
+    case "binary":
+      return copy.t("previewBinary");
+    case "decode_failed":
+      return copy.t("previewDecodeFailed");
+    case "file_too_large":
+      return copy.t("previewFileTooLarge", {
+        maxSize: formatWorkspacePreviewByteLimit(maxSizeBytes ?? 0)
+      });
+    case "text_too_large":
+      return copy.t("previewTooLarge", {
+        maxSize: formatWorkspacePreviewByteLimit(maxSizeBytes ?? 0)
+      });
+  }
+}
+
+// src/services/internal/workspaceFileManagerImportController.ts
+var WorkspaceFileManagerImportController = class {
+  applyHostActionResult;
+  copy;
+  host;
+  refresh;
+  resolveErrorMessage;
+  store;
+  constructor(input) {
+    this.applyHostActionResult = input.applyHostActionResult;
+    this.copy = input.copy;
+    this.host = input.host;
+    this.refresh = input.refresh;
+    this.resolveErrorMessage = input.resolveErrorMessage;
+    this.store = input.store;
+  }
+  async confirmImportConflict() {
+    const importConflictDialog = this.store.importConflictDialog;
+    if (!importConflictDialog?.onConfirm) {
+      return;
+    }
+    this.store.busyAction = "import";
+    try {
+      const result = await importConflictDialog.onConfirm();
+      this.store.importConflictDialog = null;
+      this.applyHostActionResult(result, { kind: "import" });
+    } finally {
+      this.store.busyAction = null;
+    }
+  }
+  async importDroppedFiles(dataTransfer, targetDirectoryPath) {
+    if (!this.host.resolveDroppedPaths || !this.host.importPaths) {
+      const result = {
+        message: this.copy().t("unsupportedImportBody"),
+        supported: false,
+        title: this.copy().t("unsupportedImportTitle")
+      };
+      this.applyHostActionResult(result, { kind: "import" });
+      return result;
+    }
+    const sourcePaths = this.host.resolveDroppedPaths(dataTransfer);
+    if (sourcePaths.length === 0) {
+      return { supported: true };
+    }
+    this.store.busyAction = "import";
+    try {
+      const result = await this.wrapImportAction(
+        () => this.host.importPaths?.(
+          this.store.workspaceID,
+          targetDirectoryPath,
+          sourcePaths
+        ) ?? Promise.resolve({ supported: true })
+      );
+      this.applyHostActionResult(result, { kind: "import" });
+      return result;
+    } finally {
+      this.store.busyAction = null;
+    }
+  }
+  async importFiles(targetDirectoryPath) {
+    if (!this.host.importFiles) {
+      const result = {
+        message: this.copy().t("unsupportedImportBody"),
+        supported: false,
+        title: this.copy().t("unsupportedImportTitle")
+      };
+      this.applyHostActionResult(result, { kind: "import" });
+      return result;
+    }
+    this.store.busyAction = "import";
+    try {
+      const result = await this.wrapImportAction(
+        () => this.host.importFiles?.(
+          this.store.workspaceID,
+          targetDirectoryPath
+        ) ?? Promise.resolve({ supported: true })
+      );
+      this.applyHostActionResult(result, { kind: "import" });
+      return result;
+    } finally {
+      this.store.busyAction = null;
+    }
+  }
+  async wrapImportAction(action) {
+    try {
+      const result = await action();
+      if (result.importConflict) {
+        const importConflict = result.importConflict;
+        const importConflictConfirm = importConflict.onConfirm;
+        return {
+          ...result,
+          importConflict: {
+            ...importConflict,
+            onConfirm: importConflictConfirm ? async () => {
+              const confirmResult = await importConflictConfirm();
+              await this.refresh();
+              return confirmResult;
+            } : void 0
+          }
+        };
+      }
+      await this.refresh();
+      return result;
+    } catch (error) {
+      return {
+        message: this.resolveErrorMessage(error),
+        supported: false,
+        title: this.copy().t("importFailedTitle")
+      };
+    }
+  }
+};
+
+// src/services/internal/model/openWithApplicationsCache.ts
+import { resolveWorkspaceFileExtension as resolveWorkspaceFileExtension2 } from "@tutti-os/workspace-file-preview";
+var openWithWarmupLimit = 8;
+function resolveWorkspaceFileOpenWithCacheKey(entry) {
+  const extension = resolveWorkspaceFileExtension2(
+    entry.path || entry.name || ""
+  );
+  return `${entry.kind}:${extension || "(no-ext)"}`;
+}
+var WorkspaceFileOpenWithApplicationsCache = class {
+  applicationsByKey = /* @__PURE__ */ new Map();
+  inflightByKey = /* @__PURE__ */ new Map();
+  warmupScheduledKeys = /* @__PURE__ */ new Set();
+  get(key) {
+    return this.applicationsByKey.get(key) ?? null;
+  }
+  async resolve(key, load) {
+    const cached = this.applicationsByKey.get(key);
+    if (cached) {
+      return cached;
+    }
+    const inflight = this.inflightByKey.get(key);
+    if (inflight) {
+      return inflight;
+    }
+    const promise = load().then((applications) => {
+      this.applicationsByKey.set(key, applications);
+      this.inflightByKey.delete(key);
+      return applications;
+    }).catch((error) => {
+      this.inflightByKey.delete(key);
+      throw error;
+    });
+    this.inflightByKey.set(key, promise);
+    return promise;
+  }
+  scheduleWarmup(entries, load) {
+    let scheduled = 0;
+    const seenKeys = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      if (entry.kind !== "file" || scheduled >= openWithWarmupLimit) {
+        continue;
+      }
+      const key = resolveWorkspaceFileOpenWithCacheKey(entry);
+      if (seenKeys.has(key) || this.applicationsByKey.has(key) || this.inflightByKey.has(key) || this.warmupScheduledKeys.has(key)) {
+        continue;
+      }
+      seenKeys.add(key);
+      this.warmupScheduledKeys.add(key);
+      scheduled += 1;
+      void load(entry).finally(() => {
+        this.warmupScheduledKeys.delete(key);
+      });
+    }
+  }
+};
+
+// src/services/internal/workspaceFileManagerSession.ts
+var DefaultWorkspaceFileManagerSession = class {
+  store;
+  host;
+  hasInitialized = false;
+  initializePromise = null;
+  isActive = false;
+  isDisposed = false;
+  lastObservedEntries;
+  lastObservedPersistedState;
+  lastObservedSelectedPath;
+  lastRevealRequestID = null;
+  onHostActionMessage;
+  onMutationErrorMessage;
+  searchRequestSeq = 0;
+  activationController;
+  copy;
+  mutationController;
+  navigationController;
+  previewController;
+  persistence;
+  unsubscribeStore = null;
+  importController;
+  openWithApplicationsCache = new WorkspaceFileOpenWithApplicationsCache();
+  constructor(input) {
+    this.copy = input.copy;
+    this.host = input.host;
+    this.onHostActionMessage = input.onHostActionMessage;
+    this.onMutationErrorMessage = input.onMutationErrorMessage;
+    this.persistence = input.persistence;
+    this.store = input.store;
+    this.navigationController = new WorkspaceFileManagerNavigationController({
+      host: input.host,
+      resolveErrorMessage: (error) => this.resolveErrorMessage(error),
+      store: this.store
+    });
+    this.activationController = new WorkspaceFileManagerActivationController({
+      copy: () => this.copy,
+      host: input.host,
+      loadDirectory: (path) => this.navigationController.loadDirectory(path),
+      resolveErrorMessage: (error, overrides) => this.resolveErrorMessage(error, overrides),
+      store: this.store
+    });
+    this.mutationController = new WorkspaceFileManagerMutationController({
+      host: input.host,
+      onErrorMessage: (message) => this.onMutationErrorMessage?.(message),
+      refresh: () => this.refresh(),
+      resolveErrorMessage: (error) => this.resolveErrorMessage(error),
+      store: this.store
+    });
+    this.previewController = new WorkspaceFileManagerPreviewController({
+      copy: () => this.copy,
+      host: input.host,
+      isDisposed: () => this.isDisposed,
+      resolveErrorMessage: (error, overrides) => this.resolveErrorMessage(error, overrides),
+      store: this.store
+    });
+    this.importController = new WorkspaceFileManagerImportController({
+      applyHostActionResult: (result, fallback) => this.applyHostActionResult(result, fallback),
+      copy: () => this.copy,
+      host: input.host,
+      refresh: () => this.refresh(),
+      resolveErrorMessage: (error) => this.resolveErrorMessage(error),
+      store: this.store
+    });
+    this.lastObservedEntries = this.store.entries;
+    this.lastObservedPersistedState = serializePersistedState(
+      this.getPersistedState()
+    );
+    this.lastObservedSelectedPath = this.store.selectedPath;
+  }
+  async activateFile(request) {
+    return this.activationController.activateFile(request);
+  }
+  async applyRevealIntent(intent) {
+    if (!intent?.path || !intent.requestID) {
+      return;
+    }
+    if (intent.requestID === this.lastRevealRequestID) {
+      return;
+    }
+    this.lastRevealRequestID = intent.requestID;
+    await this.revealPath(intent.path);
+  }
+  closeContextMenu() {
+    this.store.contextMenu = null;
+    this.store.contextMenuEntryPath = null;
+  }
+  closeCreateDialog() {
+    if (this.store.busyAction === "create") {
+      return;
+    }
+    this.store.createDialog = null;
+  }
+  closeDeleteDialog() {
+    if (this.store.busyAction === "delete") {
+      return;
+    }
+    this.store.deleteDialog = null;
+  }
+  cancelInlineRename() {
+    if (this.store.busyAction === "rename") {
+      return;
+    }
+    this.store.inlineRenameEntryPath = null;
+    this.store.inlineRenameValidation = null;
+  }
+  closeTransientUi() {
+    this.store.contextMenu = null;
+    this.store.contextMenuEntryPath = null;
+    if (this.store.busyAction !== null) {
+      return;
+    }
+    this.store.createDialog = null;
+    this.store.deleteDialog = null;
+    this.store.inlineRenameEntryPath = null;
+    this.store.inlineRenameValidation = null;
+    this.store.unsupportedDialog = null;
+    this.store.importConflictDialog = null;
+  }
+  closeUnsupportedDialog() {
+    if (this.store.busyAction === "view") {
+      return;
+    }
+    this.store.unsupportedDialog = null;
+  }
+  closeImportConflictDialog() {
+    if (this.store.busyAction === "import") {
+      return;
+    }
+    this.store.importConflictDialog = null;
+  }
+  async confirmCreateDialog() {
+    const createDialog = this.store.createDialog;
+    if (!createDialog) {
+      return;
+    }
+    const validation = validateWorkspaceFileEntryName(createDialog.name);
+    if (validation) {
+      this.store.createDialog = {
+        ...createDialog,
+        errorMessage: validation === "required" ? this.copy.t("createNameRequired") : this.copy.t("createNameInvalid")
+      };
+      return;
+    }
+    const path = `${this.store.currentDirectoryPath}/${createDialog.name.trim()}`.replaceAll(
+      /\/+/g,
+      "/"
+    );
+    this.store.busyAction = "create";
+    try {
+      if (createDialog.kind === "directory") {
+        await this.createDirectory(path);
+      } else {
+        await this.createFile(path);
+      }
+      this.store.createDialog = null;
+    } finally {
+      this.store.busyAction = null;
+    }
+  }
+  async confirmDeleteDialog() {
+    const deleteDialog = this.store.deleteDialog;
+    if (!deleteDialog) {
+      return;
+    }
+    this.store.busyAction = "delete";
+    try {
+      this.store.selectedPath = deleteDialog.entryPath;
+      await this.deleteSelected();
+      this.store.deleteDialog = null;
+    } finally {
+      this.store.busyAction = null;
+    }
+  }
+  async confirmInlineRename(newName) {
+    const inlineRenameEntryPath = this.store.inlineRenameEntryPath;
+    if (!inlineRenameEntryPath) {
+      return true;
+    }
+    const entry = this.store.entries.find(
+      (candidate) => candidate.path === inlineRenameEntryPath
+    );
+    if (!entry) {
+      this.store.inlineRenameEntryPath = null;
+      this.store.inlineRenameValidation = null;
+      return true;
+    }
+    const trimmedName = newName.trim();
+    if (trimmedName === entry.name) {
+      this.store.inlineRenameEntryPath = null;
+      this.store.inlineRenameValidation = null;
+      return true;
+    }
+    const validation = validateWorkspaceFileEntryName(trimmedName);
+    if (validation) {
+      this.store.inlineRenameValidation = validation;
+      return false;
+    }
+    this.store.inlineRenameValidation = null;
+    this.store.busyAction = "rename";
+    try {
+      await this.mutationController.renameEntry(entry, trimmedName);
+      this.store.inlineRenameEntryPath = null;
+      return true;
+    } finally {
+      this.store.busyAction = null;
+    }
+  }
+  async confirmImportConflict() {
+    await this.importController.confirmImportConflict();
+  }
+  async createDirectory(path) {
+    await this.mutationController.createDirectory(path);
+  }
+  async createFile(path) {
+    await this.mutationController.createFile(path);
+  }
+  async deleteSelected() {
+    await this.mutationController.deleteSelected();
+  }
+  decrementDragDepth() {
+    this.store.dragDepth = this.store.dragDepth <= 1 ? 0 : this.store.dragDepth - 1;
+  }
+  dispose() {
+    this.isDisposed = true;
+    this.hasInitialized = false;
+    this.initializePromise = null;
+    this.isActive = false;
+    this.searchRequestSeq += 1;
+    this.store.isSearching = false;
+    this.unsubscribeStore?.();
+    this.unsubscribeStore = null;
+    this.previewController.dispose();
+  }
+  async goBack() {
+    await this.navigationController.goBack();
+  }
+  async goForward() {
+    await this.navigationController.goForward();
+  }
+  getPersistedState() {
+    return getWorkspaceFileManagerPersistedState(this.store);
+  }
+  async handleActivationFallbackAction(action) {
+    await this.activationController.handleFallbackAction(action);
+  }
+  async exportEntry(entry) {
+    if (!this.host.exportEntry) {
+      return { supported: false };
+    }
+    this.store.busyAction = "export";
+    this.store.error = null;
+    try {
+      const result = await this.host.exportEntry({
+        entry,
+        workspaceID: this.store.workspaceID
+      });
+      this.applyHostActionResult(result, {
+        actionKind: "export",
+        entry,
+        kind: "view"
+      });
+      return result;
+    } catch (error) {
+      const result = {
+        message: this.resolveErrorMessage(error),
+        supported: false,
+        title: this.copy.t("downloadFailedTitle")
+      };
+      this.applyHostActionResult(result, {
+        actionKind: "export",
+        entry,
+        kind: "view"
+      });
+      return result;
+    } finally {
+      this.store.busyAction = null;
+    }
+  }
+  incrementDragDepth() {
+    if (!this.isActive) {
+      return;
+    }
+    this.store.dragDepth += 1;
+  }
+  async initialize() {
+    if (this.hasInitialized) {
+      return;
+    }
+    if (this.initializePromise) {
+      await this.initializePromise;
+      return;
+    }
+    this.isDisposed = false;
+    this.initializePromise = (async () => {
+      this.observeStore();
+      if (!this.hasLoadedDirectoryState()) {
+        await this.navigationController.loadDirectory();
+      }
+      await this.previewController.syncPreviewState();
+      this.hasInitialized = true;
+    })();
+    try {
+      await this.initializePromise;
+    } finally {
+      this.initializePromise = null;
+    }
+  }
+  async loadDirectory(path = this.store.currentDirectoryPath) {
+    await this.navigationController.loadDirectory(path);
+  }
+  openContextMenu(input) {
+    this.store.contextMenuEntryPath = input.entryPath;
+    this.store.contextMenu = input;
+  }
+  openCreateDirectoryDialog() {
+    this.store.contextMenu = null;
+    this.store.contextMenuEntryPath = null;
+    this.store.createDialog = {
+      errorMessage: null,
+      kind: "directory",
+      name: ""
+    };
+  }
+  openCreateFileDialog() {
+    this.store.contextMenu = null;
+    this.store.contextMenuEntryPath = null;
+    this.store.createDialog = {
+      errorMessage: null,
+      kind: "file",
+      name: ""
+    };
+  }
+  openDeleteDialog(entry) {
+    this.store.contextMenu = null;
+    this.store.contextMenuEntryPath = null;
+    this.store.deleteDialog = {
+      entryPath: entry.path
+    };
+  }
+  startInlineRename(entry) {
+    this.store.contextMenu = null;
+    this.store.contextMenuEntryPath = null;
+    this.store.inlineRenameEntryPath = entry.path;
+    this.store.inlineRenameValidation = null;
+    this.store.selectedPath = entry.path;
+  }
+  async copyToClipboard(entry) {
+    if (!this.host.copyEntriesToClipboard) {
+      return;
+    }
+    await this.host.copyEntriesToClipboard({
+      paths: [entry.path],
+      workspaceID: this.store.workspaceID
+    });
+  }
+  getCachedOpenWithApplications(entry) {
+    if (!this.host.listOpenWithApplications) {
+      return null;
+    }
+    return this.openWithApplicationsCache.get(
+      resolveWorkspaceFileOpenWithCacheKey(entry)
+    );
+  }
+  async listOpenWithApplications(entry) {
+    if (!this.host.listOpenWithApplications) {
+      return [];
+    }
+    return this.openWithApplicationsCache.resolve(
+      resolveWorkspaceFileOpenWithCacheKey(entry),
+      () => this.host.listOpenWithApplications({
+        path: entry.path,
+        workspaceID: this.store.workspaceID
+      })
+    );
+  }
+  async openEntry(entry) {
+    await this.activationController.openEntry(entry);
+  }
+  async openFileWithApplication(entry, applicationPath) {
+    if (!this.host.openFileWithApplication) {
+      return;
+    }
+    this.store.contextMenu = null;
+    this.store.contextMenuEntryPath = null;
+    await this.host.openFileWithApplication({
+      applicationPath,
+      path: entry.path,
+      workspaceID: this.store.workspaceID
+    });
+  }
+  async openFileInAppBrowser(entry) {
+    if (!this.host.openFileInAppBrowser) {
+      return;
+    }
+    this.store.contextMenu = null;
+    this.store.contextMenuEntryPath = null;
+    await this.host.openFileInAppBrowser({
+      path: entry.path,
+      workspaceID: this.store.workspaceID
+    });
+  }
+  async openFileInDefaultBrowser(entry) {
+    if (!this.host.openFileInDefaultBrowser) {
+      return;
+    }
+    this.store.contextMenu = null;
+    this.store.contextMenuEntryPath = null;
+    await this.host.openFileInDefaultBrowser({
+      path: entry.path,
+      workspaceID: this.store.workspaceID
+    });
+  }
+  async openFileWithOtherApplication(entry) {
+    if (!this.host.openFileWithOtherApplication) {
+      return;
+    }
+    this.store.contextMenu = null;
+    this.store.contextMenuEntryPath = null;
+    await this.host.openFileWithOtherApplication({
+      applicationPickerPrompt: this.copy.t("openWithOtherPickerPrompt"),
+      path: entry.path,
+      workspaceID: this.store.workspaceID
+    });
+  }
+  async revealEntry(entry) {
+    if (!this.host.revealEntry) {
+      return;
+    }
+    this.store.contextMenu = null;
+    this.store.contextMenuEntryPath = null;
+    await this.host.revealEntry({
+      path: entry.path,
+      workspaceID: this.store.workspaceID
+    });
+  }
+  async moveEntry(entry, targetDirectoryPath) {
+    this.store.busyAction = "move";
+    try {
+      await this.mutationController.moveEntry(entry, targetDirectoryPath);
+    } finally {
+      this.store.busyAction = null;
+    }
+  }
+  async refresh() {
+    await this.navigationController.refresh();
+  }
+  async revealPath(path) {
+    await this.navigationController.revealPath(path);
+  }
+  resetDragDepth() {
+    this.store.dragDepth = 0;
+  }
+  async search(query) {
+    const requestID = ++this.searchRequestSeq;
+    this.store.searchQuery = query;
+    this.store.searchError = null;
+    if (!this.host.search || query.trim() === "") {
+      this.store.searchEntries = [];
+      this.store.isSearching = false;
+      return;
+    }
+    this.store.isSearching = true;
+    try {
+      const result = await this.host.search({
+        query,
+        workspaceID: this.store.workspaceID
+      });
+      if (this.isDisposed || requestID !== this.searchRequestSeq) {
+        return;
+      }
+      this.store.searchEntries = result.entries;
+    } catch (error) {
+      if (!this.isDisposed && requestID === this.searchRequestSeq) {
+        this.store.searchError = this.resolveErrorMessage(error);
+      }
+    } finally {
+      if (!this.isDisposed && requestID === this.searchRequestSeq) {
+        this.store.isSearching = false;
+      }
+    }
+  }
+  select(path) {
+    const nextSelectedPath = path ? normalizeWorkspaceFilePath(path, this.store.root) : null;
+    if (this.store.selectedPath === nextSelectedPath) {
+      return;
+    }
+    this.store.selectedPath = nextSelectedPath;
+  }
+  setActive(active) {
+    if (this.isActive === active) {
+      return;
+    }
+    this.isActive = active;
+    if (active) {
+      return;
+    }
+    this.store.contextMenu = null;
+    this.store.contextMenuEntryPath = null;
+    this.store.dragDepth = 0;
+  }
+  setI18nRuntime(copy) {
+    if (this.copy === copy) {
+      return;
+    }
+    this.copy = copy;
+    void this.previewController.syncPreviewState();
+  }
+  updateCreateDialogName(name) {
+    if (!this.store.createDialog) {
+      return;
+    }
+    this.store.createDialog = {
+      ...this.store.createDialog,
+      errorMessage: null,
+      name
+    };
+  }
+  clearInlineRenameValidation() {
+    this.store.inlineRenameValidation = null;
+  }
+  async importDroppedFiles(dataTransfer, targetDirectoryPath) {
+    return this.importController.importDroppedFiles(
+      dataTransfer,
+      targetDirectoryPath
+    );
+  }
+  async importFiles(targetDirectoryPath) {
+    return this.importController.importFiles(targetDirectoryPath);
+  }
+  applyHostActionResult(result, fallback) {
+    if (!result) {
+      return;
+    }
+    this.notifyHostActionMessages(result, fallback);
+    if (result.importConflict) {
+      this.store.unsupportedDialog = null;
+      this.store.importConflictDialog = result.importConflict;
+      return;
+    }
+    if (result.supported === false) {
+      this.store.importConflictDialog = null;
+      this.store.unsupportedDialog = {
+        entryPath: "entry" in fallback ? fallback.entry.path : null,
+        kind: fallback.kind,
+        message: result.message,
+        title: result.title
+      };
+      return;
+    }
+    this.store.unsupportedDialog = null;
+    this.store.importConflictDialog = null;
+  }
+  hasLoadedDirectoryState() {
+    return this.store.error !== null || this.store.entries.length > 0 || this.store.selectedPath !== null;
+  }
+  notifyHostActionMessages(result, fallback) {
+    if (!this.onHostActionMessage) {
+      return;
+    }
+    const entry = "entry" in fallback ? fallback.entry : null;
+    const actionKind = fallback.actionKind ?? (fallback.kind === "import" ? "import" : "export");
+    if (result.cancelledMessage?.trim()) {
+      this.notifyHostActionMessage(actionKind, entry, "cancelled", result);
+      return;
+    }
+    if (result.supported === false || result.importConflict) {
+      return;
+    }
+    if (result.completedMessage?.trim()) {
+      this.notifyHostActionMessage(actionKind, entry, "completed", result);
+      return;
+    }
+    this.notifyHostActionMessage(actionKind, entry, "started", result);
+  }
+  notifyHostActionMessage(actionKind, entry, status, result) {
+    const messageByStatus = {
+      cancelled: "cancelledMessage",
+      completed: "completedMessage",
+      started: "startedMessage"
+    };
+    const message = result[messageByStatus[status]]?.trim();
+    if (!message) {
+      return;
+    }
+    this.onHostActionMessage?.({
+      actionKind,
+      entry,
+      message,
+      status
+    });
+  }
+  observeStore() {
+    if (this.unsubscribeStore) {
+      return;
+    }
+    this.lastObservedEntries = this.store.entries;
+    this.lastObservedSelectedPath = this.store.selectedPath;
+    this.unsubscribeStore = subscribe(this.store, () => {
+      if (this.isDisposed) {
+        return;
+      }
+      if (this.lastObservedEntries === this.store.entries && this.lastObservedSelectedPath === this.store.selectedPath) {
+        this.savePersistedStateIfChanged();
+        return;
+      }
+      this.lastObservedEntries = this.store.entries;
+      this.lastObservedSelectedPath = this.store.selectedPath;
+      this.savePersistedStateIfChanged();
+      void this.previewController.syncPreviewState();
+      this.warmOpenWithApplicationsCache(this.store.entries);
+    });
+  }
+  warmOpenWithApplicationsCache(entries) {
+    if (!this.host.listOpenWithApplications || this.store.isLoading) {
+      return;
+    }
+    this.openWithApplicationsCache.scheduleWarmup(
+      entries,
+      (entry) => this.listOpenWithApplications(entry)
+    );
+  }
+  savePersistedStateIfChanged() {
+    if (!this.persistence?.save) {
+      return;
+    }
+    const nextState = this.getPersistedState();
+    const serialized = serializePersistedState(nextState);
+    if (serialized === this.lastObservedPersistedState) {
+      return;
+    }
+    this.lastObservedPersistedState = serialized;
+    this.persistence.save(nextState);
+  }
+  resolveErrorMessage(error, overrides = {}) {
+    const filteredOverrides = Object.fromEntries(
+      Object.entries(overrides).filter((entry) => entry[1] !== void 0)
+    );
+    if (this.host.resolveErrorMessage) {
+      return this.host.resolveErrorMessage(error, filteredOverrides);
+    }
+    if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") {
+      const override = filteredOverrides[error.code];
+      if (override) {
+        return override;
+      }
+    }
+    return this.copy.t("unknownErrorMessage");
+  }
+};
+function serializePersistedState(state) {
+  return JSON.stringify(state);
+}
+
+// src/services/internal/workspaceFileManagerService.ts
+var DefaultWorkspaceFileManagerService = class {
+  createSession(input) {
+    const capabilities = capabilitiesFromHost(input);
+    const store = createWorkspaceFileManagerStore({
+      capabilities,
+      initialDirectoryPath: input.initialDirectoryPath,
+      persistedState: normalizeWorkspaceFileManagerPersistedState(
+        input.persistedState ?? input.persistence?.load?.()
+      ),
+      workspaceID: input.workspaceID
+    });
+    return new DefaultWorkspaceFileManagerSession({
+      copy: input.i18n,
+      host: input.host,
+      onHostActionMessage: input.onHostActionMessage,
+      onMutationErrorMessage: input.onMutationErrorMessage,
+      persistence: input.persistence,
+      store
+    });
+  }
+};
+function capabilitiesFromHost(input) {
+  return {
+    canCopy: input.host.copyEntriesToClipboard !== void 0,
+    canCreateDirectory: input.host.createDirectory !== void 0,
+    canCreateFile: input.host.createFile !== void 0,
+    canDelete: input.host.deleteEntry !== void 0,
+    canExport: input.host.exportEntry !== void 0,
+    canImportFromDrop: input.host.resolveDroppedPaths !== void 0 && input.host.importPaths !== void 0,
+    canImportFromPicker: input.host.importFiles !== void 0,
+    canMove: input.host.moveEntry !== void 0,
+    canOpenInAppBrowser: input.host.openFileInAppBrowser !== void 0,
+    canOpenInDefaultBrowser: input.host.openFileInDefaultBrowser !== void 0,
+    canOpenWith: input.host.listOpenWithApplications !== void 0,
+    canPickOtherOpenWithApplication: input.host.openFileWithOtherApplication !== void 0,
+    canRevealInFolder: input.host.revealEntry !== void 0,
+    canRename: input.host.renameEntry !== void 0,
+    canSearch: input.host.search !== void 0
+  };
+}
+
+// src/services/createWorkspaceFileManagerService.ts
+function createWorkspaceFileManagerService() {
+  return new DefaultWorkspaceFileManagerService();
+}
+
+export {
+  classifyWorkspaceFilePreviewKind,
+  resolveWorkspaceFileActivationTarget,
+  decodeWorkspaceTextFile,
+  isWorkspaceFileBrowserOpenable,
+  isWorkspaceTextFileTooLarge,
+  looksLikeBinaryText,
+  resolveWorkspaceFileExtension,
+  resolveWorkspaceFileVisualKind,
+  resolveWorkspaceImageMimeType,
+  workspaceFilePreviewMaxBytes,
+  workspaceFileTextMaxBytes,
+  formatWorkspaceFileBytes,
+  formatWorkspaceFileModifiedTime,
+  splitWorkspaceFileName,
+  normalizeWorkspaceFilePath,
+  workspaceFileName,
+  buildWorkspaceFileBreadcrumbs,
+  createWorkspaceFileManagerService
+};
+//# sourceMappingURL=chunk-IMOFXYBB.js.map