@tutti-os/workspace-file-manager 0.0.181 → 0.0.183

package/README.md

@@ -18,11 +18,12 @@ only a transport-agnostic data kernel. Shared session orchestration, preview
 flow, upload flow, activation flow, and React-facing interaction state may live
 here when they are part of the reusable file-manager experience across hosts.
 
-The shared surface owns host-neutral file preview classification,
-activation-target shaping, shared view-model derivation, and the host contract
-needed to drive those flows so different hosts can integrate primarily by
-implementing `WorkspaceFileManagerHost` instead of rebuilding workflow around
-the shared UI.
+The shared surface consumes host-neutral classification and loading lifecycle
+from `@tutti-os/workspace-file-preview`. This package owns file-manager-specific
+activation-target shaping, localized state projection, shared view-model
+derivation, and the host contract needed to drive those flows so different
+hosts can integrate primarily by implementing `WorkspaceFileManagerHost`
+instead of rebuilding workflow around the shared UI.
 
 The optional React surface persists the adjustable locations-sidebar and
 details-panel widths on the current device. Restored widths are clamped to the

package/dist/{chunk-KVP3Z2Y5.js → chunk-3CYSESCR.js}

@@ -1,110 +1,8 @@
-// src/services/internal/workspaceFileManagerStore.ts
-import { proxy } from "valtio";
-
 // src/services/workspaceFileManagerTypes.ts
 var workspaceFileManagerLogicalRoot = "/";
 var workspaceFileManagerPersistedStateSchemaVersion = 3;
 var workspaceFileManagerPreviousPersistedStateSchemaVersion = 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,
-  resolveWorkspaceVideoMimeType,
-  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 { formatTuttiShortDateTime } 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 formatTuttiShortDateTime(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);
@@ -205,30 +103,6 @@ function readWindowsDrive(path) {
   return /^[A-Za-z]:/.exec(path)?.[0] ?? "";
 }
 
-// src/services/internal/model/searchEntries.ts
-function workspaceFileSearchEntryToEntry(entry) {
-  return {
-    hasChildren: entry.kind === "directory",
-    kind: entry.kind,
-    mtimeMs: null,
-    name: entry.name,
-    path: entry.path,
-    sizeBytes: null
-  };
-}
-
-// 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/workspaceFileManagerLocations.ts
 function flattenWorkspaceFileLocations(sections) {
   return sections.flatMap((section) => section.locations);
@@ -266,6 +140,148 @@ function isWorkspaceFileExternalLocation(location) {
   return location?.kind === "external";
 }
 
+// src/services/internal/model/openWithApplicationsCache.ts
+import { resolveWorkspaceFileExtension } from "@tutti-os/workspace-file-preview";
+var openWithWarmupLimit = 8;
+function resolveWorkspaceFileOpenWithCacheKey(entry) {
+  const extension = resolveWorkspaceFileExtension(
+    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/workspaceFileManagerStore.ts
+import { proxy } from "valtio";
+
+// src/services/internal/model/fileKinds.ts
+import { resolveWorkspaceFileActivationTarget as resolveSharedWorkspaceFileActivationTarget } from "@tutti-os/workspace-file-preview";
+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
+  };
+}
+
+// src/services/internal/model/formatters.ts
+import { formatTuttiShortDateTime } 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 formatTuttiShortDateTime(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/searchEntries.ts
+function workspaceFileSearchEntryToEntry(entry) {
+  return {
+    hasChildren: entry.kind === "directory",
+    kind: entry.kind,
+    mtimeMs: null,
+    name: entry.name,
+    path: entry.path,
+    sizeBytes: null
+  };
+}
+
+// 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(
@@ -866,154 +882,102 @@ var WorkspaceFileManagerNavigationController = class {
 };
 
 // src/services/internal/workspaceFileManagerPreviewController.ts
+import {
+  createWorkspaceFilePreviewController,
+  formatWorkspacePreviewByteLimit,
+  workspaceFilePreviewMaxBytes
+} from "@tutti-os/workspace-file-preview";
 var WorkspaceFileManagerPreviewController = class {
   copy;
-  host;
-  isDisposed;
   resolveErrorMessage;
   store;
-  previewObjectUrl = null;
-  previewRequestSeq = 0;
+  previewController;
+  unsubscribePreview;
   constructor(input) {
     this.copy = input.copy;
-    this.host = input.host;
-    this.isDisposed = input.isDisposed;
     this.resolveErrorMessage = input.resolveErrorMessage;
     this.store = input.store;
+    this.previewController = createWorkspaceFilePreviewController({
+      read: input.host.readPreviewFile ? ({ entry }) => input.host.readPreviewFile(input.store.workspaceID, entry.path) : void 0,
+      toPreviewEntry: (entry) => entry
+    });
+    this.unsubscribePreview = this.previewController.subscribe(() => {
+      this.applyPreviewState(this.previewController.getSnapshot());
+    });
   }
   dispose() {
-    this.previewRequestSeq += 1;
-    this.revokePreviewObjectUrl();
+    this.unsubscribePreview();
+    this.previewController.dispose();
   }
   async syncPreviewState() {
-    const requestID = this.previewRequestSeq + 1;
-    this.previewRequestSeq = requestID;
-    this.revokePreviewObjectUrl();
     const selectedEntry = findWorkspaceFileEntry(
       this.store,
       this.store.selectedPath
     );
+    const settled = this.previewController.setEntry(selectedEntry);
+    await settled;
+    this.applyPreviewState(this.previewController.getSnapshot());
+  }
+  applyPreviewState(state) {
     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) {
+    switch (state.status) {
+      case "empty":
+        this.store.previewState = state;
         return;
-      }
-      const loadedState = createWorkspaceFilePreviewLoadedState({
-        bytes,
-        entry: selectedEntry,
-        target: activationTarget
-      });
-      if (loadedState.status === "image" || loadedState.status === "video") {
-        const objectUrl = URL.createObjectURL(
-          new Blob([loadedState.bytes], {
-            type: loadedState.contentType
-          })
-        );
-        if (this.isDisposed() || requestID !== this.previewRequestSeq) {
-          URL.revokeObjectURL(objectUrl);
+      case "directory":
+        this.store.previewState = state;
+        return;
+      case "loading":
+      case "text":
+      case "image":
+      case "video": {
+        const target = resolveWorkspaceFileActivationTarget(state.entry);
+        if (!target) {
+          this.store.previewState = {
+            entry: state.entry,
+            message: copy.t("previewUnsupported"),
+            status: "unsupported"
+          };
           return;
         }
-        this.previewObjectUrl = objectUrl;
-        this.store.previewState = {
-          entry: activationTarget,
-          objectUrl,
-          status: loadedState.status
+        this.store.previewState = state.status === "loading" ? { entry: target, status: "loading" } : state.status === "text" ? { content: state.content, entry: target, status: "text" } : {
+          entry: target,
+          objectUrl: state.objectUrl,
+          status: state.status
         };
         return;
       }
-      if (loadedState.status === "text") {
-        this.store.previewState = loadedState;
-        return;
-      }
-      if (loadedState.status === "html") {
-        this.store.previewState = loadedState;
-        return;
-      }
-      if (loadedState.status === "readonly") {
+      case "readonly":
         this.store.previewState = {
-          entry: selectedEntry,
+          entry: state.entry,
           message: resolveWorkspaceFileManagerPreviewReadonlyMessage(
             copy,
-            loadedState.reason,
-            loadedState.maxSizeBytes
+            state.reason,
+            state.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;
+      case "unsupported":
+        this.store.previewState = {
+          entry: state.entry,
+          message: copy.t("previewUnsupported"),
+          status: "unsupported"
+        };
+        return;
+      case "error":
+        this.store.previewState = {
+          entry: state.entry,
+          message: this.resolveErrorMessage(state.error, {
+            preview_file_too_large: copy.t("previewFileTooLarge", {
+              maxSize: formatWorkspacePreviewByteLimit(
+                workspaceFilePreviewMaxBytes
+              )
+            })
+          }),
+          status: "error"
+        };
     }
-    URL.revokeObjectURL(this.previewObjectUrl);
-    this.previewObjectUrl = null;
   }
 };
 function resolveWorkspaceFileManagerPreviewReadonlyMessage(copy, reason, maxSizeBytes) {
@@ -1241,63 +1205,6 @@ var WorkspaceFileManagerTreeController = class {
   }
 };
 
-// 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;
@@ -1358,7 +1265,6 @@ var DefaultWorkspaceFileManagerSession = class {
     this.previewController = new WorkspaceFileManagerPreviewController({
       copy: () => this.copy,
       host: input.host,
-      isDisposed: () => this.isDisposed,
       resolveErrorMessage: (error, overrides) => this.resolveErrorMessage(error, overrides),
       store: this.store
     });
@@ -2284,6 +2190,11 @@ function createWorkspaceFileManagerService() {
 }
 
 // src/services/workspaceFileEntryIconPolicy.ts
+import {
+  classifyWorkspaceFilePreviewKind,
+  resolveWorkspaceFileExtension as resolveWorkspaceFileExtension2,
+  resolveWorkspaceFileVisualKind
+} from "@tutti-os/workspace-file-preview";
 var defaultApplicationIconExtensions = /* @__PURE__ */ new Set([
   "ai",
   "dmg",
@@ -2326,12 +2237,12 @@ function shouldUseWorkspaceFileExtensionDocumentIcon(entry) {
     return false;
   }
   const visualKind = resolveWorkspaceFileVisualKind(entry);
-  const extension = resolveWorkspaceFileExtension(entry.name).toLowerCase();
+  const extension = resolveWorkspaceFileExtension2(entry.name).toLowerCase();
   return visualKind === "code" || visualKind === "markdown" || extensionDocumentIconExtensions.has(extension) || classifyWorkspaceFilePreviewKind(entry) === "text";
 }
 function shouldUseWorkspaceFileArchiveIcon(entry) {
   return entry.kind === "file" && archiveIconExtensions.has(
-    resolveWorkspaceFileExtension(entry.name).toLowerCase()
+    resolveWorkspaceFileExtension2(entry.name).toLowerCase()
   );
 }
 function isWorkspaceApplicationBundle(entry) {
@@ -2341,7 +2252,7 @@ function resolveWorkspaceFileDefaultApplicationIconExtension(entry) {
   if (entry.kind !== "file") {
     return null;
   }
-  const extension = resolveWorkspaceFileExtension(entry.name).toLowerCase();
+  const extension = resolveWorkspaceFileExtension2(entry.name).toLowerCase();
   return defaultApplicationIconExtensions.has(extension) ? extension : null;
 }
 function resolveWorkspaceFileEntryIconCacheKey(entry) {
@@ -2362,6 +2273,10 @@ function shouldResolveWorkspaceFileImageThumbnail(entry) {
 }
 
 // src/ui/workspaceFileManagerArrangeMode.ts
+import {
+  resolveWorkspaceFileExtension as resolveWorkspaceFileExtension3,
+  resolveWorkspaceFileVisualKind as resolveWorkspaceFileVisualKind2
+} from "@tutti-os/workspace-file-preview";
 var workspaceFileManagerArrangeModeStorageKey = "tutti.workspace-file-manager.arrange-mode";
 var workspaceFileManagerArrangeModes = /* @__PURE__ */ new Set([
   "none",
@@ -2464,7 +2379,7 @@ function resolveEntryKindGroup(entry) {
   if (entry.kind === "directory") {
     return "directory";
   }
-  return resolveWorkspaceFileVisualKind(entry);
+  return resolveWorkspaceFileVisualKind2(entry);
 }
 function resolveEntryApplicationGroup(entry) {
   if (entry.kind === "directory") {
@@ -2473,22 +2388,11 @@ function resolveEntryApplicationGroup(entry) {
   if (entry.name.trim().toLowerCase().endsWith(".app")) {
     return "application";
   }
-  return resolveWorkspaceFileExtension(entry.name) || resolveEntryKindGroup(entry);
+  return resolveWorkspaceFileExtension3(entry.name) || resolveEntryKindGroup(entry);
 }
 
 export {
-  classifyWorkspaceFilePreviewKind,
   resolveWorkspaceFileActivationTarget,
-  decodeWorkspaceTextFile,
-  isWorkspaceFileBrowserOpenable,
-  isWorkspaceTextFileTooLarge,
-  looksLikeBinaryText,
-  resolveWorkspaceFileExtension,
-  resolveWorkspaceFileVisualKind,
-  resolveWorkspaceImageMimeType,
-  resolveWorkspaceVideoMimeType,
-  workspaceFilePreviewMaxBytes,
-  workspaceFileTextMaxBytes,
   formatWorkspaceFileBytes,
   formatWorkspaceFileModifiedTime,
   splitWorkspaceFileName,
@@ -2516,4 +2420,4 @@ export {
   sortWorkspaceFileEntriesForArrangeMode,
   resolveWorkspaceFileEntryArrangeDateMs
 };
-//# sourceMappingURL=chunk-KVP3Z2Y5.js.map
+//# sourceMappingURL=chunk-3CYSESCR.js.map