@ai-matrx/media 0.8.0 → 0.9.1

package/dist/files/engine/redux/thunks.js

@@ -0,0 +1,1684 @@
+"use client";
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { supabase } from "../host/supabase.js";
+import { filesDb, FILE_VERSIONS_TABLE_COLUMNS } from "../filesDb.js";
+import { pgErrorToError } from "@ai-matrx/data";
+import * as Files from "../api/files.js";
+import {
+  claimUpload,
+  uploadDedupKey
+} from "../upload/uploadDedupGuard.js";
+import * as Folders from "../api/folders.js";
+import * as Permissions from "../api/permissions.js";
+import * as Versions from "../api/versions.js";
+import {
+  createShareLink as createCanonicalShareLink,
+  listShareLinks as listCanonicalShareLinks,
+  revokeShareLink as revokeCanonicalShareLink
+} from "../host/share-links.js";
+import {
+  restoreFileDirect,
+  restoreFolderDirect,
+  softDeleteFileDirect,
+  softDeleteFolderDirect
+} from "../api/direct.js";
+import { fileHandler } from "../handler/handler.js";
+import { newRequestId } from "../host/python-client.js";
+import { extractErrorMessage } from "@ai-matrx/data/net";
+import {
+  apiFileRecordToCloudFile,
+  dbRowToCloudFilePermission,
+  dbRowToCloudFileVersion,
+  dbRowToCloudFolder,
+  canonicalShareLinkToCloudShareLink,
+  parseCloudTreeRows,
+  rpcPermissionRowToCloudFilePermission
+} from "./converters.js";
+import {
+  areCloudFileFieldsLoaded,
+  FILE_DB_RECORD_FIELDS,
+  fileHintToCloudFilePartial,
+  needsOnlyRenderFields
+} from "./file-hydration.js";
+import {
+  registerRequest,
+  releaseRequest,
+  beginResourceOp,
+  isLatestResourceOp,
+  hasInFlight
+} from "./request-ledger.js";
+import { toast } from "../host/toast.js";
+import { buildTreeState } from "./tree-utils.js";
+import {
+  isUserVisibleFilePath,
+  isUserVisibleFolderPath
+} from "../utils/user-visible.js";
+import {
+  hasMatchingFileTreeSession,
+  runFileTreeSessionOperation
+} from "./file-tree-auth-boundary.js";
+import {
+  isFileTreeLoadDeferred,
+  runWithFileTreeLoadTimeout
+} from "./file-tree-timeout.js";
+import {
+  invalidate as invalidateBlobCache,
+  replaceWithSavedBytes
+} from "../hooks/blob-cache.js";
+import { invalidateOfficeExtraction } from "../hooks/office-extraction-cache.js";
+import {
+  addFilePendingRequest,
+  attachChildToFolder,
+  clearUpload,
+  detachChildFromFolder,
+  markFileSaved,
+  markFolderFullyLoaded,
+  removeFile,
+  removeFilePendingRequest,
+  removeFolder,
+  removePermissionForResource,
+  removeShareLink,
+  replaceTree,
+  rollbackFileOptimisticUpdate,
+  setFileError,
+  setFileField,
+  setFileLoading,
+  setTreeStatus,
+  trackUploadStart,
+  updateUploadProgress,
+  updateUploadStatus,
+  upsertFile,
+  upsertFiles,
+  upsertFolder,
+  upsertFolders,
+  upsertPermissionsForResource,
+  upsertShareLinksForResource,
+  upsertVersionsForFile
+} from "./slice.js";
+import { getFileFromState } from "./selectors.js";
+import { getClaimsUser } from "../host/supabase.js";
+const fileFieldHydrationInFlight = /* @__PURE__ */ new Map();
+async function fetchCloudFileFields(fileId, fields) {
+  const key = `${fileId}:${[...fields].sort().join(",")}`;
+  const existing = fileFieldHydrationInFlight.get(key);
+  if (existing) return existing;
+  const request = (async () => {
+    const { data } = await Files.getFileMetadata(fileId);
+    const record = apiFileRecordToCloudFile(data);
+    if (record.deletedAt) return null;
+    if (needsOnlyRenderFields(fields)) {
+      return {
+        id: record.id,
+        fileName: record.fileName,
+        mimeType: record.mimeType,
+        fileSize: record.fileSize,
+        visibility: record.visibility
+      };
+    }
+    return record;
+  })().finally(() => fileFieldHydrationInFlight.delete(key));
+  fileFieldHydrationInFlight.set(key, request);
+  return request;
+}
+const ensureCloudFileFields = createAsyncThunk(
+  "cloudFiles/ensureCloudFileFields",
+  async ({ fileId, fields = FILE_DB_RECORD_FIELDS, hint }, { dispatch, getState }) => {
+    dispatch(upsertFile(fileHintToCloudFilePartial(fileId, hint)));
+    if (areCloudFileFieldsLoaded(getFileFromState(getState(), fileId), fields)) {
+      return "ready";
+    }
+    dispatch(setFileLoading({ id: fileId, loading: true }));
+    dispatch(setFileError({ id: fileId, error: null }));
+    try {
+      const partial = await fetchCloudFileFields(fileId, fields);
+      if (!partial) return "missing";
+      dispatch(upsertFile(partial));
+      return "ready";
+    } catch (error) {
+      const normalized = pgErrorToError(error);
+      dispatch(setFileError({ id: fileId, error: normalized.message }));
+      throw normalized;
+    } finally {
+      dispatch(setFileLoading({ id: fileId, loading: false }));
+    }
+  }
+);
+const TREE_PAGE_SIZE = 5e3;
+const TREE_MAX_PAGES = 20;
+let _treeInFlight = null;
+let _treeInFlightUserId = null;
+const loadUserFileTree = createAsyncThunk("cloudFiles/loadUserFileTree", async ({ userId }, { dispatch, getState }) => {
+  if (!await hasMatchingFileTreeSession(userId)) return;
+  if (_treeInFlight && _treeInFlightUserId === userId) return _treeInFlight;
+  const run = (async () => {
+    dispatch(setTreeStatus({ status: "loading" }));
+    try {
+      const rows = await runWithFileTreeLoadTimeout(async (signal) => {
+        const rows2 = [];
+        for (let page = 0; page < TREE_MAX_PAGES; page += 1) {
+          const { data, error } = await runFileTreeSessionOperation(
+            () => supabase.rpc("get_user_file_tree", {
+              p_user_id: userId,
+              p_limit: TREE_PAGE_SIZE,
+              p_offset: page * TREE_PAGE_SIZE,
+              p_include_folders: true,
+              p_include_deleted: false
+            }).abortSignal(signal)
+          );
+          if (error) {
+            if (!signal.aborted) {
+              dispatch(
+                setTreeStatus({ status: "error", error: error.message })
+              );
+            }
+            throw error;
+          }
+          const pageRows = parseCloudTreeRows(data);
+          rows2.push(...pageRows);
+          if (pageRows.length < TREE_PAGE_SIZE) break;
+        }
+        return rows2;
+      });
+      const files = [];
+      const folders = [];
+      for (const row of rows) {
+        if (row.kind === "file") {
+          files.push({
+            id: row.id,
+            ownerId: row.owner_id,
+            filePath: row.file_path,
+            fileName: row.file_name,
+            parentFolderId: row.parent_folder_id,
+            mimeType: row.mime_type,
+            // Phase 0 rename: `file_size` → `size_bytes`. The
+            // `CloudTreeFileRow` shape and Supabase row both carry the new
+            // name now. See docs/PYTHON_UPDATES.md §3.
+            fileSize: row.size_bytes,
+            visibility: row.visibility,
+            currentVersion: row.current_version,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            deletedAt: row.deleted_at,
+            originDeviceId: row.origin_device_id,
+            metadata: row.metadata
+          });
+        } else {
+          folders.push({
+            id: row.id,
+            ownerId: row.owner_id,
+            folderPath: row.folder_path,
+            folderName: row.folder_name,
+            parentId: row.parent_id,
+            visibility: row.visibility,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            deletedAt: row.deleted_at,
+            metadata: row.metadata
+          });
+        }
+      }
+      dispatch(upsertFiles(files));
+      dispatch(upsertFolders(folders));
+      const prior = getState().cloudFiles;
+      for (const [id, rec] of Object.entries(prior.filesById)) {
+        if (rec && !isUserVisibleFilePath(rec.filePath)) {
+          dispatch(removeFile({ id }));
+        }
+      }
+      for (const [id, rec] of Object.entries(prior.foldersById)) {
+        if (rec && rec.source.kind === "real" && !isUserVisibleFolderPath(rec.folderPath)) {
+          dispatch(removeFolder({ id }));
+        }
+      }
+      const fileIds = files.map((f) => f.id).filter(Boolean);
+      const folderIds = folders.map((f) => f.id).filter(Boolean);
+      const tree = buildTreeState({
+        fileIds,
+        folderIds,
+        filesById: Object.fromEntries(
+          files.map((f) => [
+            f.id,
+            {
+              id: f.id,
+              ownerId: f.ownerId,
+              filePath: f.filePath,
+              fileName: f.fileName,
+              mimeType: f.mimeType ?? null,
+              fileSize: f.fileSize ?? null,
+              checksum: null,
+              visibility: f.visibility,
+              currentVersion: f.currentVersion,
+              parentFolderId: f.parentFolderId ?? null,
+              metadata: f.metadata ?? {},
+              createdAt: f.createdAt,
+              updatedAt: f.updatedAt,
+              deletedAt: f.deletedAt,
+              // Tree-spine reconstruction is internal — the computed URL fields
+              // and the Phase-1b backend thumbnail_url are only populated when
+              // records arrive via the REST API. Default all to null here; the
+              // file grid (`MediaThumbnail`) falls through to `useFileAsset` →
+              // `Asset.variants["thumbnail_url"]` when these are absent.
+              publicUrl: null,
+              url: null,
+              cdnUrl: null,
+              downloadUrl: null,
+              thumbnailUrl: null,
+              source: { kind: "real" },
+              _dirty: false,
+              _dirtyFields: {},
+              _fieldHistory: {},
+              _loadedFields: {},
+              _loading: false,
+              _error: null,
+              _pendingRequestIds: []
+            }
+          ])
+        ),
+        foldersById: Object.fromEntries(
+          folders.map((f) => [
+            f.id,
+            {
+              id: f.id,
+              ownerId: f.ownerId,
+              folderPath: f.folderPath,
+              folderName: f.folderName,
+              parentId: f.parentId ?? null,
+              visibility: f.visibility,
+              metadata: f.metadata ?? {},
+              createdAt: f.createdAt,
+              updatedAt: f.updatedAt,
+              deletedAt: f.deletedAt,
+              // Tree-spine reconstruction is internal — public_url is only
+              // populated when records arrive via the API. Default to null
+              // here; surfaces that need a CDN URL fetch via useFileSrc.
+              publicUrl: null,
+              source: { kind: "real" },
+              _dirty: false,
+              _dirtyFields: {},
+              _fieldHistory: {},
+              _loadedFields: {},
+              _loading: false,
+              _error: null,
+              _pendingRequestIds: []
+            }
+          ])
+        )
+      });
+      dispatch(
+        replaceTree({
+          rootFolderIds: tree.rootFolderIds,
+          rootFileIds: tree.rootFileIds,
+          childrenByFolderId: tree.childrenByFolderId,
+          // This RPC returns the complete discoverable tree, not one lazy level.
+          // Mark every real folder so navigation never re-downloads up to 100k
+          // rows merely because the user opened a different folder.
+          fullyLoadedFolderIds: Object.fromEntries(
+            folderIds.map((id) => [id, true])
+          )
+        })
+      );
+    } catch (error) {
+      if (isFileTreeLoadDeferred(error)) {
+        dispatch(setTreeStatus({ status: "idle" }));
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : "Could not load your file library.";
+      dispatch(setTreeStatus({ status: "error", error: message }));
+      throw error;
+    }
+  })();
+  _treeInFlight = run;
+  _treeInFlightUserId = userId;
+  try {
+    await run;
+  } finally {
+    if (_treeInFlight === run) {
+      _treeInFlight = null;
+      _treeInFlightUserId = null;
+    }
+  }
+});
+const reconcileTree = createAsyncThunk("cloudFiles/reconcileTree", async ({ userId }, { dispatch }) => {
+  await dispatch(loadUserFileTree({ userId })).unwrap();
+});
+const loadFolderContents = createAsyncThunk("cloudFiles/loadFolderContents", async ({ folderId }, { dispatch }) => {
+  if (folderId.startsWith("vfs:")) return;
+  const { data, error } = await getClaimsUser(supabase);
+  if (error) throw error;
+  if (!data.user?.id)
+    throw new Error("Cannot load folder contents without a user");
+  await dispatch(loadUserFileTree({ userId: data.user.id })).unwrap();
+  dispatch(markFolderFullyLoaded({ folderId }));
+});
+function isVirtualResourceId(id) {
+  return id.startsWith("vfs:");
+}
+const loadFileVersions = createAsyncThunk("cloudFiles/loadFileVersions", async ({ fileId }, { dispatch }) => {
+  if (isVirtualResourceId(fileId)) return;
+  const { data, error } = await filesDb(supabase).from("file_versions").select(FILE_VERSIONS_TABLE_COLUMNS).eq("file_id", fileId).order("version_number", { ascending: false });
+  if (error) throw pgErrorToError(error);
+  const versions = (data ?? []).map(
+    dbRowToCloudFileVersion
+  );
+  dispatch(upsertVersionsForFile({ fileId, versions }));
+});
+const loadPermissions = createAsyncThunk("cloudFiles/loadPermissions", async ({ resourceId }, { dispatch }) => {
+  if (isVirtualResourceId(resourceId)) return;
+  const { data, error } = await supabase.schema("iam").from("permissions").select("*").eq("resource_type", "file").eq("resource_id", resourceId);
+  if (error) throw pgErrorToError(error);
+  const permissions = (data ?? []).map(
+    dbRowToCloudFilePermission
+  );
+  dispatch(upsertPermissionsForResource({ resourceId, permissions }));
+});
+const loadShareLinks = createAsyncThunk(
+  "cloudFiles/loadShareLinks",
+  async ({ resourceId, resourceType = "file" }, { dispatch }) => {
+    if (isVirtualResourceId(resourceId)) return;
+    const links = await listCanonicalShareLinks(resourceType, resourceId);
+    const shareLinks = links.filter((l) => l.isActive).map(
+      (l) => canonicalShareLinkToCloudShareLink(l, resourceType, resourceId)
+    );
+    dispatch(upsertShareLinksForResource({ resourceId, shareLinks }));
+  }
+);
+const createFolder = createAsyncThunk("cloudFiles/createFolder", async (arg, { dispatch, getState }) => {
+  const folderName = arg.folderName.trim();
+  if (!folderName) {
+    throw new Error("Folder name cannot be empty.");
+  }
+  if (/[/\\]/.test(folderName)) {
+    throw new Error("Folder names cannot contain '/' or '\\'.");
+  }
+  if (/[\x00-\x1f\x7f]/.test(folderName)) {
+    throw new Error("Folder names cannot contain control characters.");
+  }
+  if (folderName.endsWith(".")) {
+    throw new Error("Folder names cannot end with '.'.");
+  }
+  {
+    const state = getState().cloudFiles;
+    const lowered = folderName.toLowerCase();
+    const collision = Object.values(state.foldersById).some(
+      (f) => !!f && !f.deletedAt && (f.parentId ?? null) === (arg.parentId ?? null) && f.folderName.toLowerCase() === lowered
+    );
+    if (collision) {
+      throw new Error(
+        `A folder named '${folderName}' already exists in this location.`
+      );
+    }
+  }
+  const requestId = newRequestId();
+  registerRequest({
+    requestId,
+    kind: "folder-create",
+    resourceId: null,
+    resourceType: "folder"
+  });
+  let folderPath = folderName;
+  if (arg.parentId !== null) {
+    const parent = getState().cloudFiles.foldersById[arg.parentId];
+    if (!parent) {
+      throw new Error(
+        "We couldn't create the folder here \u2014 this view is out of date. Refresh and try again."
+      );
+    }
+    folderPath = `${parent.folderPath}/${folderName}`;
+  }
+  const body = {
+    folder_path: folderPath,
+    visibility: arg.visibility ?? "personal",
+    metadata: arg.metadata ?? null
+  };
+  try {
+    const { data: row } = await Folders.createFolder(body, { requestId });
+    const folder = dbRowToCloudFolder(row);
+    dispatch(upsertFolder(folder));
+    dispatch(
+      attachChildToFolder({
+        parentFolderId: folder.parentId,
+        kind: "folder",
+        id: folder.id
+      })
+    );
+    return folder.id;
+  } catch (err) {
+    if (true) {
+      const e = err;
+      console.error("[createFolder] backend error", {
+        status: e.status ?? null,
+        code: e.code,
+        detail: e.detail,
+        userMessage: e.userMessage,
+        details: e.details,
+        sentBody: body
+      });
+    }
+    throw err;
+  } finally {
+    releaseRequest(requestId);
+  }
+});
+const updateFolder = createAsyncThunk("cloudFiles/updateFolder", async (arg, { dispatch, getState }) => {
+  const state = getState();
+  const folder = state.cloudFiles.foldersById[arg.folderId];
+  if (!folder)
+    throw new Error(
+      "We couldn't update that folder \u2014 this view is out of date. Refresh and try again."
+    );
+  const requestId = newRequestId();
+  registerRequest({
+    requestId,
+    kind: "folder-update",
+    resourceId: arg.folderId,
+    resourceType: "folder"
+  });
+  const patch = arg.patch;
+  const optimistic = {
+    ...folder,
+    ...patch.folderName !== void 0 ? { folderName: patch.folderName } : {},
+    ...patch.parentId !== void 0 ? { parentId: patch.parentId } : {},
+    ...patch.visibility !== void 0 ? { visibility: patch.visibility } : {},
+    ...patch.metadata !== void 0 ? { metadata: patch.metadata } : {}
+  };
+  dispatch(upsertFolder(optimistic));
+  if (patch.parentId !== void 0 && patch.parentId !== folder.parentId) {
+    dispatch(
+      detachChildFromFolder({
+        parentFolderId: folder.parentId,
+        kind: "folder",
+        id: folder.id
+      })
+    );
+    dispatch(
+      attachChildToFolder({
+        parentFolderId: patch.parentId,
+        kind: "folder",
+        id: folder.id
+      })
+    );
+  }
+  let targetFolderPath;
+  if (patch.folderName !== void 0 || patch.parentId !== void 0) {
+    const newName = patch.folderName ?? folder.folderName;
+    const newParentId = patch.parentId !== void 0 ? patch.parentId : folder.parentId;
+    if (newParentId) {
+      const newParent = state.cloudFiles.foldersById[newParentId];
+      if (!newParent) {
+        throw new Error(
+          "We couldn't move the folder there \u2014 this view is out of date. Refresh and try again."
+        );
+      }
+      targetFolderPath = `${newParent.folderPath}/${newName}`;
+    } else {
+      targetFolderPath = newName;
+    }
+  }
+  try {
+    const { data: row } = await Folders.patchFolder(
+      arg.folderId,
+      {
+        folder_path: targetFolderPath,
+        visibility: patch.visibility,
+        metadata: patch.metadata ?? null
+      },
+      { requestId }
+    );
+    dispatch(upsertFolder(dbRowToCloudFolder(row)));
+  } catch (err) {
+    dispatch(upsertFolder(toCloudFolderPartial(folder)));
+    if (patch.parentId !== void 0 && patch.parentId !== folder.parentId) {
+      dispatch(
+        detachChildFromFolder({
+          parentFolderId: patch.parentId,
+          kind: "folder",
+          id: folder.id
+        })
+      );
+      dispatch(
+        attachChildToFolder({
+          parentFolderId: folder.parentId,
+          kind: "folder",
+          id: folder.id
+        })
+      );
+    }
+    throw err;
+  } finally {
+    releaseRequest(requestId);
+  }
+});
+const deleteFolder = createAsyncThunk("cloudFiles/deleteFolder", async (arg, { dispatch, getState }) => {
+  const state = getState();
+  const folder = state.cloudFiles.foldersById[arg.folderId];
+  if (!folder) return;
+  const requestId = newRequestId();
+  registerRequest({
+    requestId,
+    kind: "folder-delete",
+    resourceId: arg.folderId,
+    resourceType: "folder"
+  });
+  try {
+    await softDeleteFolderDirect(arg.folderId);
+    dispatch(removeFolder({ id: arg.folderId }));
+  } finally {
+    releaseRequest(requestId);
+  }
+});
+const ensureFolderPath = createAsyncThunk("cloudFiles/ensureFolderPath", async (arg, { dispatch, getState }) => {
+  const normalizedPath = arg.folderPath.split("/").map((s) => s.trim()).filter(Boolean).join("/");
+  if (!normalizedPath) {
+    throw new Error("folderPath cannot be empty.");
+  }
+  const existing = Object.values(getState().cloudFiles.foldersById).find(
+    (folder) => folder.folderPath === normalizedPath && !folder.deletedAt
+  );
+  if (existing) {
+    return existing.id;
+  }
+  const requestId = newRequestId();
+  registerRequest({
+    requestId,
+    kind: "folder-create",
+    resourceId: null,
+    resourceType: "folder"
+  });
+  try {
+    const { data: row } = await Folders.ensureFolderPath(
+      normalizedPath,
+      arg.visibility ?? "personal",
+      { requestId }
+    );
+    const folder = dbRowToCloudFolder(row);
+    dispatch(upsertFolder(folder));
+    dispatch(
+      attachChildToFolder({
+        parentFolderId: folder.parentId,
+        kind: "folder",
+        id: folder.id
+      })
+    );
+    return folder.id;
+  } finally {
+    releaseRequest(requestId);
+  }
+});
+function announceUploadFailures(failed) {
+  if (failed.length === 0) return;
+  const reasons = Array.from(
+    new Set(failed.map((f) => f.error).filter((e) => e && e.trim().length > 0))
+  );
+  const title = failed.length === 1 ? `Couldn't upload ${failed[0].name}` : `Couldn't upload ${failed.length} files`;
+  toast.error(title, {
+    // The server's own sentence, never a sentence of ours. When several
+    // distinct things went wrong, each one gets said.
+    description: reasons.length > 0 ? reasons.join(" \xB7 ") : "The server refused the upload and gave no reason.",
+    id: `upload-failed:${failed.map((f) => f.name).join("|")}`,
+    duration: 12e3
+  });
+}
+const uploadFiles = createAsyncThunk("cloudFiles/uploadFiles", async (arg, { dispatch, getState }) => {
+  const concurrency = Math.max(1, arg.concurrency ?? 3);
+  const uploaded = [];
+  const failed = [];
+  const state = getState();
+  let prefix = "";
+  if (arg.folderPath) {
+    prefix = `${arg.folderPath.replace(/^\/+|\/+$/g, "")}/`;
+  } else if (arg.parentFolderId) {
+    const parentFolder = state.cloudFiles.foldersById[arg.parentFolderId];
+    if (parentFolder) {
+      prefix = `${parentFolder.folderPath}/`;
+    }
+  }
+  const existingNames = (() => {
+    const out = /* @__PURE__ */ new Set();
+    const targetPrefix = prefix;
+    for (const f of Object.values(state.cloudFiles.filesById)) {
+      if (!f) continue;
+      if (f.deletedAt) continue;
+      if (!f.filePath) continue;
+      const normalized = f.filePath.replace(/^\/+/, "");
+      if (!normalized.startsWith(targetPrefix)) continue;
+      const tail = normalized.slice(targetPrefix.length);
+      if (tail.includes("/")) continue;
+      if (tail) out.add(tail.toLowerCase());
+    }
+    return out;
+  })();
+  function uniqueName(originalName) {
+    const lowered = originalName.toLowerCase();
+    if (!existingNames.has(lowered)) {
+      existingNames.add(lowered);
+      return originalName;
+    }
+    const dot = originalName.lastIndexOf(".");
+    const isHidden = originalName.startsWith(".");
+    const stem = dot > 0 && !isHidden ? originalName.slice(0, dot) : originalName;
+    const ext = dot > 0 && !isHidden ? originalName.slice(dot) : "";
+    for (let i = 1; i < 1e3; i++) {
+      const candidate = `${stem} (${i})${ext}`;
+      if (!existingNames.has(candidate.toLowerCase())) {
+        existingNames.add(candidate.toLowerCase());
+        return candidate;
+      }
+    }
+    return originalName;
+  }
+  const overrides = arg.filenameOverrides ?? {};
+  const skipSet = new Set(arg.skipIndices ?? []);
+  const forceNewCopySet = new Set(arg.forceNewCopyIndices ?? []);
+  for (const [, name] of Object.entries(overrides)) {
+    if (typeof name === "string") existingNames.add(name.toLowerCase());
+  }
+  const queue = arg.files.map((file, index) => ({ index, file })).filter(({ index }) => !skipSet.has(index));
+  async function worker() {
+    while (queue.length) {
+      const next = queue.shift();
+      if (!next) return;
+      const { file, index } = next;
+      const overrideName = overrides[index];
+      const forcedCopy = forceNewCopySet.has(index);
+      const dedupKey = !overrideName && !forcedCopy ? uploadDedupKey(prefix, file.name, file.size) : null;
+      let dedupClaim = null;
+      if (dedupKey) {
+        const claim = claimUpload(dedupKey);
+        if (claim.shared) {
+          try {
+            const outcome = await claim.promise;
+            uploaded.push(outcome.fileId);
+            continue;
+          } catch {
+          }
+        } else {
+          dedupClaim = claim;
+        }
+      }
+      const requestId = newRequestId();
+      const targetName = typeof overrideName === "string" && overrideName ? overrideName : uniqueName(file.name);
+      dispatch(
+        trackUploadStart({
+          requestId,
+          fileName: targetName,
+          fileSize: file.size,
+          parentFolderId: arg.parentFolderId ?? null,
+          folderPath: arg.folderPath ?? null
+        })
+      );
+      registerRequest({
+        requestId,
+        kind: "upload",
+        resourceId: null,
+        resourceType: "file"
+      });
+      try {
+        const { data } = await Files.uploadFileWithProgress(
+          {
+            file,
+            filePath: `${prefix}${targetName}`,
+            visibility: arg.visibility ?? "personal",
+            shareWith: arg.shareWith,
+            shareLevel: arg.shareLevel,
+            changeSummary: arg.changeSummary,
+            metadata: arg.metadata,
+            options: arg.options,
+            ...forceNewCopySet.has(index) ? {
+              intent: "force_new_copy",
+              reason: "User selected Make a copy in the duplicate upload dialog"
+            } : {}
+          },
+          (ev) => dispatch(
+            updateUploadProgress({
+              requestId,
+              bytesUploaded: ev.loaded
+            })
+          ),
+          {
+            requestId,
+            // Idempotency key — same value across automatic retries of the
+            // same intended upload. The backend stores it in
+            // `metadata._idempotency_key` so retries don't create duplicate
+            // version rows. We reuse `requestId` because it's generated
+            // once per intended upload, before any retry.
+            idempotencyKey: requestId
+          }
+        );
+        dispatch(
+          upsertFile(
+            apiFileRecordToCloudFile({
+              id: data.file_id,
+              owner_id: "",
+              file_path: data.file_path,
+              file_name: data.file_path.split("/").pop() ?? targetName,
+              mime_type: file.type || null,
+              // Phase 0 rename — see docs/PYTHON_UPDATES.md §3.
+              size_bytes: data.size_bytes,
+              checksum: data.checksum,
+              visibility: arg.visibility ?? "personal",
+              current_version: data.version_number,
+              parent_folder_id: arg.parentFolderId ?? null,
+              metadata: arg.metadata ?? {},
+              // P1-7: stamp the optimistic row with the current time instead of
+              // null. The upload just happened, so "now" is accurate for the
+              // recents filter / "sort by modified" until the realtime echo
+              // delivers the authoritative server timestamp. Null sorted the
+              // freshly-uploaded file to the wrong end of the list.
+              created_at: (/* @__PURE__ */ new Date()).toISOString(),
+              updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+              deleted_at: null
+            })
+          )
+        );
+        invalidateBlobCache(data.file_id);
+        invalidateOfficeExtraction(data.file_id);
+        dispatch(
+          attachChildToFolder({
+            parentFolderId: arg.parentFolderId ?? null,
+            kind: "file",
+            id: data.file_id
+          })
+        );
+        dispatch(
+          updateUploadStatus({
+            requestId,
+            status: "success",
+            fileId: data.file_id
+          })
+        );
+        uploaded.push(data.file_id);
+        dedupClaim?.settle(
+          Promise.resolve({ fileId: data.file_id, filePath: data.file_path })
+        );
+      } catch (err) {
+        const message = extractErrorMessage(err);
+        dispatch(
+          updateUploadStatus({
+            requestId,
+            status: "error",
+            error: message
+          })
+        );
+        failed.push({ name: file.name, error: message });
+        dedupClaim?.settle(Promise.reject(err));
+      } finally {
+        releaseRequest(requestId);
+      }
+    }
+  }
+  await Promise.all(
+    Array.from(
+      { length: Math.min(concurrency, arg.files.length) },
+      () => worker()
+    )
+  );
+  announceUploadFailures(failed);
+  return { uploaded, failed };
+});
+const clearUploadEntry = createAsyncThunk("cloudFiles/clearUpload", async ({ requestId }, { dispatch }) => {
+  dispatch(clearUpload({ requestId }));
+});
+const renameFile = createAsyncThunk(
+  "cloudFiles/rename",
+  async ({ fileId, newName }, { dispatch, getState }) => {
+    const record = getFileFromState(getState(), fileId);
+    if (!record)
+      throw new Error(
+        "We couldn't find that file in this view. Refresh and try again."
+      );
+    const requestId = newRequestId();
+    const seq = beginResourceOp(fileId);
+    const snapshot = {
+      fileName: record.fileName,
+      filePath: record.filePath
+    };
+    const pathParts = record.filePath.split("/");
+    pathParts[pathParts.length - 1] = newName;
+    const newPath = pathParts.join("/");
+    dispatch(setFileField({ id: fileId, field: "fileName", value: newName }));
+    dispatch(setFileField({ id: fileId, field: "filePath", value: newPath }));
+    dispatch(addFilePendingRequest({ id: fileId, requestId }));
+    registerRequest({
+      requestId,
+      kind: "rename",
+      resourceId: fileId,
+      resourceType: "file"
+    });
+    try {
+      const { data } = await Files.renameFile(
+        fileId,
+        { new_path: newPath },
+        { requestId }
+      );
+      if (isLatestResourceOp(fileId, seq)) {
+        dispatch(upsertFile(apiFileRecordToCloudFile(data)));
+        dispatch(markFileSaved({ id: fileId }));
+      }
+    } catch (err) {
+      if (isLatestResourceOp(fileId, seq)) {
+        dispatch(rollbackFileOptimisticUpdate({ id: fileId, snapshot }));
+        const msg = extractErrorMessage(err);
+        dispatch(setFileError({ id: fileId, error: msg }));
+      }
+      throw err;
+    } finally {
+      dispatch(removeFilePendingRequest({ id: fileId, requestId }));
+      releaseRequest(requestId);
+    }
+  }
+);
+const moveFile = createAsyncThunk(
+  "cloudFiles/move",
+  async ({ fileId, newParentFolderId }, { dispatch, getState }) => {
+    const record = getFileFromState(getState(), fileId);
+    if (!record)
+      throw new Error(
+        "We couldn't find that file in this view. Refresh and try again."
+      );
+    const oldParentId = record.parentFolderId;
+    const requestId = newRequestId();
+    const seq = beginResourceOp(fileId);
+    const snapshot = {
+      parentFolderId: oldParentId
+    };
+    dispatch(
+      setFileField({
+        id: fileId,
+        field: "parentFolderId",
+        value: newParentFolderId
+      })
+    );
+    dispatch(
+      detachChildFromFolder({
+        parentFolderId: oldParentId,
+        kind: "file",
+        id: fileId
+      })
+    );
+    dispatch(
+      attachChildToFolder({
+        parentFolderId: newParentFolderId,
+        kind: "file",
+        id: fileId
+      })
+    );
+    dispatch(addFilePendingRequest({ id: fileId, requestId }));
+    registerRequest({
+      requestId,
+      kind: "move",
+      resourceId: fileId,
+      resourceType: "file"
+    });
+    try {
+      const targetFolder = newParentFolderId === null ? null : getState().cloudFiles.foldersById[newParentFolderId] ?? null;
+      const targetPrefix = targetFolder ? `${targetFolder.folderPath}/` : "";
+      const newPath = `${targetPrefix}${record.fileName}`;
+      const { data } = await Files.renameFile(
+        fileId,
+        { new_path: newPath },
+        { requestId }
+      );
+      if (isLatestResourceOp(fileId, seq)) {
+        dispatch(upsertFile(apiFileRecordToCloudFile(data)));
+        dispatch(markFileSaved({ id: fileId }));
+      }
+    } catch (err) {
+      if (isLatestResourceOp(fileId, seq)) {
+        dispatch(
+          detachChildFromFolder({
+            parentFolderId: newParentFolderId,
+            kind: "file",
+            id: fileId
+          })
+        );
+        dispatch(
+          attachChildToFolder({
+            parentFolderId: oldParentId,
+            kind: "file",
+            id: fileId
+          })
+        );
+        dispatch(rollbackFileOptimisticUpdate({ id: fileId, snapshot }));
+        const msg = extractErrorMessage(err);
+        dispatch(setFileError({ id: fileId, error: msg }));
+      }
+      throw err;
+    } finally {
+      dispatch(removeFilePendingRequest({ id: fileId, requestId }));
+      releaseRequest(requestId);
+    }
+  }
+);
+const updateFileMetadata = createAsyncThunk(
+  "cloudFiles/updateMetadata",
+  async ({ fileId, patch }, { dispatch, getState }) => {
+    const record = getFileFromState(getState(), fileId);
+    if (!record)
+      throw new Error(
+        "We couldn't find that file in this view. Refresh and try again."
+      );
+    const requestId = newRequestId();
+    const seq = beginResourceOp(fileId);
+    const snapshot = {
+      visibility: record.visibility,
+      metadata: record.metadata
+    };
+    if (patch.visibility !== void 0) {
+      dispatch(
+        setFileField({
+          id: fileId,
+          field: "visibility",
+          value: patch.visibility
+        })
+      );
+    }
+    if (patch.metadata !== void 0) {
+      dispatch(
+        setFileField({
+          id: fileId,
+          field: "metadata",
+          value: patch.metadata
+        })
+      );
+    }
+    dispatch(addFilePendingRequest({ id: fileId, requestId }));
+    registerRequest({
+      requestId,
+      kind: "update",
+      resourceId: fileId,
+      resourceType: "file"
+    });
+    try {
+      const { data } = await Files.patchFile(
+        fileId,
+        {
+          visibility: patch.visibility,
+          metadata: patch.metadata
+        },
+        { requestId }
+      );
+      if (isLatestResourceOp(fileId, seq)) {
+        dispatch(upsertFile(apiFileRecordToCloudFile(data)));
+        dispatch(markFileSaved({ id: fileId }));
+      }
+    } catch (err) {
+      if (isLatestResourceOp(fileId, seq)) {
+        dispatch(rollbackFileOptimisticUpdate({ id: fileId, snapshot }));
+        const msg = extractErrorMessage(err);
+        dispatch(setFileError({ id: fileId, error: msg }));
+      }
+      throw err;
+    } finally {
+      dispatch(removeFilePendingRequest({ id: fileId, requestId }));
+      releaseRequest(requestId);
+    }
+  }
+);
+const deleteFile = createAsyncThunk(
+  "cloudFiles/delete",
+  async ({ fileId }, { dispatch, getState }) => {
+    const record = getFileFromState(getState(), fileId);
+    if (!record) return;
+    const parentFolderId = record.parentFolderId;
+    const requestId = newRequestId();
+    dispatch(removeFile({ id: fileId }));
+    dispatch(
+      detachChildFromFolder({
+        parentFolderId,
+        kind: "file",
+        id: fileId
+      })
+    );
+    invalidateBlobCache(fileId);
+    invalidateOfficeExtraction(fileId);
+    registerRequest({
+      requestId,
+      kind: "delete",
+      resourceId: fileId,
+      resourceType: "file"
+    });
+    try {
+      await softDeleteFileDirect(fileId);
+    } catch (err) {
+      dispatch(upsertFile(toCloudFilePartial(record)));
+      dispatch(
+        attachChildToFolder({
+          parentFolderId,
+          kind: "file",
+          id: fileId
+        })
+      );
+      throw err;
+    } finally {
+      releaseRequest(requestId);
+    }
+  }
+);
+function toCloudFilePartial(record) {
+  const {
+    _dirty,
+    _dirtyFields,
+    _fieldHistory,
+    _loadedFields,
+    _loading,
+    _error,
+    _pendingRequestIds,
+    ...domain
+  } = record;
+  return domain;
+}
+function toCloudFolderPartial(record) {
+  const {
+    _dirty,
+    _dirtyFields,
+    _fieldHistory,
+    _loadedFields,
+    _loading,
+    _error,
+    _pendingRequestIds,
+    ...domain
+  } = record;
+  return domain;
+}
+const loadTrash = createAsyncThunk(
+  "cloudFiles/loadTrash",
+  async ({ userId }, { dispatch }) => {
+    const rows = [];
+    for (let page = 0; page < TREE_MAX_PAGES; page += 1) {
+      const { data, error } = await supabase.rpc("get_user_file_tree", {
+        p_user_id: userId,
+        p_limit: TREE_PAGE_SIZE,
+        p_offset: page * TREE_PAGE_SIZE,
+        p_include_folders: true,
+        p_include_deleted: true
+      });
+      if (error) throw error;
+      const pageRows = parseCloudTreeRows(data);
+      rows.push(...pageRows);
+      if (pageRows.length < TREE_PAGE_SIZE) break;
+    }
+    const files = [];
+    const folders = [];
+    for (const row of rows) {
+      if (!row.deleted_at) continue;
+      if (row.kind === "file") {
+        files.push({
+          id: row.id,
+          ownerId: row.owner_id,
+          filePath: row.file_path,
+          fileName: row.file_name,
+          parentFolderId: row.parent_folder_id,
+          mimeType: row.mime_type,
+          fileSize: row.size_bytes,
+          visibility: row.visibility,
+          currentVersion: row.current_version,
+          createdAt: row.created_at,
+          updatedAt: row.updated_at,
+          deletedAt: row.deleted_at,
+          originDeviceId: row.origin_device_id
+        });
+      } else {
+        folders.push({
+          id: row.id,
+          ownerId: row.owner_id,
+          folderPath: row.folder_path,
+          folderName: row.folder_name,
+          parentId: row.parent_id,
+          visibility: row.visibility,
+          createdAt: row.created_at,
+          updatedAt: row.updated_at,
+          deletedAt: row.deleted_at
+        });
+      }
+    }
+    dispatch(upsertFiles(files));
+    dispatch(upsertFolders(folders));
+  }
+);
+const restoreFile = createAsyncThunk(
+  "cloudFiles/restoreFile",
+  async ({ fileId }, { dispatch, getState }) => {
+    const record = getFileFromState(getState(), fileId);
+    if (!record?.deletedAt) return;
+    const requestId = newRequestId();
+    dispatch(upsertFile({ ...toCloudFilePartial(record), deletedAt: null }));
+    dispatch(
+      attachChildToFolder({
+        parentFolderId: record.parentFolderId,
+        kind: "file",
+        id: fileId
+      })
+    );
+    registerRequest({
+      requestId,
+      kind: "file-restore",
+      resourceId: fileId,
+      resourceType: "file"
+    });
+    try {
+      await restoreFileDirect(fileId);
+    } catch (err) {
+      dispatch(upsertFile(toCloudFilePartial(record)));
+      dispatch(
+        detachChildFromFolder({
+          parentFolderId: record.parentFolderId,
+          kind: "file",
+          id: fileId
+        })
+      );
+      throw err;
+    } finally {
+      releaseRequest(requestId);
+    }
+  }
+);
+const restoreFolder = createAsyncThunk("cloudFiles/restoreFolder", async ({ folderId }, { dispatch, getState }) => {
+  const folder = getState().cloudFiles.foldersById[folderId];
+  if (!folder?.deletedAt) return;
+  await restoreFolderDirect(folderId);
+  dispatch(upsertFolder({ ...toCloudFolderPartial(folder), deletedAt: null }));
+  const userId = folder.ownerId;
+  await dispatch(loadUserFileTree({ userId }));
+  await dispatch(loadTrash({ userId }));
+});
+const restoreVersion = createAsyncThunk(
+  "cloudFiles/restoreVersion",
+  async ({ fileId, versionNumber }, { dispatch }) => {
+    if (isVirtualResourceId(fileId)) return;
+    dispatch(setFileLoading({ id: fileId, loading: true }));
+    const requestId = newRequestId();
+    registerRequest({
+      requestId,
+      kind: "restore-version",
+      resourceId: fileId,
+      resourceType: "file"
+    });
+    try {
+      const { data } = await Versions.restoreVersion(fileId, versionNumber, {
+        requestId
+      });
+      dispatch(upsertFile(apiFileRecordToCloudFile(data)));
+      invalidateBlobCache(fileId);
+      invalidateOfficeExtraction(fileId);
+      await dispatch(loadFileVersions({ fileId })).unwrap();
+    } finally {
+      dispatch(setFileLoading({ id: fileId, loading: false }));
+      releaseRequest(requestId);
+    }
+  }
+);
+const saveFileNewVersion = createAsyncThunk(
+  "cloudFiles/saveFileNewVersion",
+  async ({ fileId, content, changeSummary }, { dispatch, getState }) => {
+    if (isVirtualResourceId(fileId)) {
+      throw new Error(
+        "saveFileNewVersion is for stored files; virtual files save through writeAny."
+      );
+    }
+    let record = getState().cloudFiles.filesById[fileId];
+    if (!record?.fileName) {
+      const { data } = await Files.getFileMetadata(fileId);
+      const fresh = apiFileRecordToCloudFile(data);
+      dispatch(upsertFile(fresh));
+      record = fresh;
+    }
+    const mimeType = record.mimeType ?? "text/plain";
+    const body = typeof content === "string" ? new Blob([content], { type: mimeType }) : content;
+    const upload = new File([body], record.fileName, { type: mimeType });
+    dispatch(setFileLoading({ id: fileId, loading: true }));
+    const requestId = newRequestId();
+    registerRequest({
+      requestId,
+      kind: "upload",
+      resourceId: fileId,
+      resourceType: "file"
+    });
+    try {
+      const reqOpts = { requestId, idempotencyKey: requestId };
+      const summary = changeSummary ?? "Edited in place";
+      const { data } = await Files.uploadNewVersion(
+        fileId,
+        { file: upload, changeSummary: summary },
+        reqOpts
+      );
+      if (data.file_id !== fileId || data.is_new) {
+        throw new Error(
+          `Saving "${record.fileName}" did not update it \u2014 the files service wrote a separate file (${data.file_path}, id ${data.file_id}) instead of version ${record.currentVersion + 1}. Your original is unchanged; remove the extra file from the folder.`
+        );
+      }
+      dispatch(
+        upsertFile({
+          id: fileId,
+          currentVersion: data.version_number,
+          fileSize: data.size_bytes,
+          checksum: data.checksum,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+      replaceWithSavedBytes(fileId, body, data.version_number);
+      invalidateOfficeExtraction(fileId);
+      void dispatch(loadFileVersions({ fileId })).unwrap().catch((err) => {
+        console.error(
+          "[saveFileNewVersion] saved, but the version list did not refresh:",
+          err
+        );
+      });
+      return { fileId, versionNumber: data.version_number };
+    } finally {
+      dispatch(setFileLoading({ id: fileId, loading: false }));
+      releaseRequest(requestId);
+    }
+  }
+);
+function requireByGranteeType(granteeType) {
+  if (granteeType === "public") {
+    throw new Error(
+      "Public access is toggled via the resource's visibility, not the by-grantee grant/revoke path."
+    );
+  }
+  return granteeType ?? "user";
+}
+const grantPermission = createAsyncThunk("cloudFiles/grantPermission", async (arg, { dispatch }) => {
+  if (isVirtualResourceId(arg.resourceId)) {
+    throw new Error("Sharing isn't available for this source yet.");
+  }
+  const requestId = newRequestId();
+  registerRequest({
+    requestId,
+    kind: "grant-permission",
+    resourceId: arg.resourceId,
+    resourceType: arg.resourceType
+  });
+  try {
+    const body = {
+      grantee_id: arg.granteeId,
+      level: arg.level,
+      grantee_type: requireByGranteeType(arg.granteeType),
+      expires_at: arg.expiresAt ?? null
+    };
+    const { data } = arg.resourceType === "folder" ? await Permissions.grantFolderPermission(arg.resourceId, body, {
+      requestId
+    }) : await Permissions.grantFilePermission(arg.resourceId, body, {
+      requestId
+    });
+    dispatch(
+      upsertPermissionsForResource({
+        resourceId: arg.resourceId,
+        permissions: [rpcPermissionRowToCloudFilePermission(data)]
+      })
+    );
+    void dispatch(loadPermissions({ resourceId: arg.resourceId }));
+  } finally {
+    releaseRequest(requestId);
+  }
+});
+const revokePermission = createAsyncThunk("cloudFiles/revokePermission", async (arg, { dispatch }) => {
+  if (isVirtualResourceId(arg.resourceId)) {
+    throw new Error("Sharing isn't available for this source yet.");
+  }
+  const requestId = newRequestId();
+  registerRequest({
+    requestId,
+    kind: "revoke-permission",
+    resourceId: arg.resourceId,
+    resourceType: arg.resourceType
+  });
+  try {
+    const granteeType = requireByGranteeType(arg.granteeType);
+    if (arg.resourceType === "folder") {
+      await Permissions.revokeFolderPermission(
+        arg.resourceId,
+        arg.granteeId,
+        { granteeType },
+        { requestId }
+      );
+    } else {
+      await Permissions.revokeFilePermission(
+        arg.resourceId,
+        arg.granteeId,
+        { granteeType },
+        { requestId }
+      );
+    }
+    dispatch(
+      removePermissionForResource({
+        resourceId: arg.resourceId,
+        granteeId: arg.granteeId,
+        granteeType
+      })
+    );
+  } finally {
+    releaseRequest(requestId);
+  }
+});
+const createShareLink = createAsyncThunk("cloudFiles/createShareLink", async (arg, { dispatch, getState }) => {
+  if (isVirtualResourceId(arg.resourceId)) {
+    throw new Error("Share links aren't available for this source yet.");
+  }
+  if (hasInFlight(arg.resourceId, "create-share-link")) {
+    throw new Error("A share link is already being created for this item.");
+  }
+  const requestId = newRequestId();
+  registerRequest({
+    requestId,
+    kind: "create-share-link",
+    resourceId: arg.resourceId,
+    resourceType: arg.resourceType
+  });
+  try {
+    const created = await createCanonicalShareLink({
+      resourceType: arg.resourceType,
+      resourceId: arg.resourceId,
+      permissionLevel: arg.permissionLevel,
+      expiresAt: arg.expiresAt ?? null,
+      maxUses: arg.maxUses ?? null
+    });
+    if (!created.success || !created.token) {
+      throw new Error(created.error ?? "Failed to create share link");
+    }
+    await dispatch(
+      loadShareLinks({
+        resourceId: arg.resourceId,
+        resourceType: arg.resourceType
+      })
+    ).unwrap();
+    const link = (getState().cloudFiles.shareLinksByResourceId[arg.resourceId] ?? []).find((l) => l.shareToken === created.token);
+    if (!link) {
+      throw new Error("Share link was created but could not be loaded back");
+    }
+    return link;
+  } finally {
+    releaseRequest(requestId);
+  }
+});
+const revokeShareLink = createAsyncThunk("cloudFiles/revokeShareLink", async ({ linkId }, { dispatch }) => {
+  const requestId = newRequestId();
+  registerRequest({
+    requestId,
+    kind: "revoke-share-link",
+    resourceId: null,
+    resourceType: null
+  });
+  try {
+    const result = await revokeCanonicalShareLink(linkId);
+    if (!result.success) {
+      throw new Error(result.error ?? "Failed to revoke share link");
+    }
+    dispatch(removeShareLink({ linkId }));
+  } finally {
+    releaseRequest(requestId);
+  }
+});
+const getFileUrl = createAsyncThunk("cloudFiles/getFileUrl", async ({ fileId }) => {
+  if (isVirtualResourceId(fileId)) {
+    throw new Error("Byte URLs aren't available for virtual sources");
+  }
+  const url = await fileHandler.use({ kind: "file_id", fileId }).as({ kind: "html_src" });
+  if (!url) {
+    throw new Error(`Could not resolve a URL for file ${fileId}`);
+  }
+  return { url };
+});
+function toastBulkPartialFailure(result, verb) {
+  if (result.failed > 0) {
+    const total = result.succeeded + result.failed;
+    toast.error(`Couldn't ${verb} ${result.failed} of ${total} items`, {
+      description: result.succeeded > 0 ? `${result.succeeded} succeeded. The rest were restored.` : "All items were restored."
+    });
+  }
+}
+const bulkDeleteFiles = createAsyncThunk("cloudFiles/bulkDeleteFiles", async (arg, { dispatch, getState }) => {
+  if (arg.fileIds.length === 0) {
+    return { results: [], succeeded: 0, failed: 0 };
+  }
+  const state = getState();
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const id of arg.fileIds) {
+    const file = state.cloudFiles.filesById[id];
+    if (file) snapshots.set(id, file);
+  }
+  const requestId = newRequestId();
+  registerRequest({
+    requestId,
+    kind: "bulk-delete-files",
+    resourceId: null,
+    resourceType: "file"
+  });
+  for (const id of arg.fileIds) {
+    dispatch(removeFile({ id }));
+    invalidateBlobCache(id);
+    invalidateOfficeExtraction(id);
+  }
+  try {
+    const { data } = await Files.bulkDeleteFiles(
+      { file_ids: arg.fileIds },
+      { requestId }
+    );
+    const result = data ?? {
+      results: arg.fileIds.map((id) => ({ id, ok: true, error: null })),
+      succeeded: arg.fileIds.length,
+      failed: 0
+    };
+    for (const r of result.results) {
+      if (r.ok) continue;
+      const snap = snapshots.get(r.id);
+      if (snap) dispatch(upsertFile(snap));
+    }
+    toastBulkPartialFailure(result, "delete");
+    return result;
+  } catch (err) {
+    for (const snap of snapshots.values()) dispatch(upsertFile(snap));
+    throw err;
+  } finally {
+    releaseRequest(requestId);
+  }
+});
+const bulkMoveFiles = createAsyncThunk("cloudFiles/bulkMoveFiles", async (arg, { dispatch, getState }) => {
+  if (arg.fileIds.length === 0) {
+    return { results: [], succeeded: 0, failed: 0 };
+  }
+  const state = getState();
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const id of arg.fileIds) {
+    const file = state.cloudFiles.filesById[id];
+    if (file) snapshots.set(id, file);
+  }
+  const requestId = newRequestId();
+  registerRequest({
+    requestId,
+    kind: "bulk-move-files",
+    resourceId: null,
+    resourceType: "file"
+  });
+  for (const [id, file] of snapshots) {
+    if (file.parentFolderId === arg.newParentFolderId) continue;
+    dispatch(
+      detachChildFromFolder({
+        parentFolderId: file.parentFolderId,
+        kind: "file",
+        id
+      })
+    );
+    dispatch(
+      attachChildToFolder({
+        parentFolderId: arg.newParentFolderId,
+        kind: "file",
+        id
+      })
+    );
+    dispatch(upsertFile({ ...file, parentFolderId: arg.newParentFolderId }));
+  }
+  try {
+    const { data } = await Files.bulkMoveFiles(
+      {
+        file_ids: arg.fileIds,
+        new_parent_folder_id: arg.newParentFolderId
+      },
+      { requestId }
+    );
+    for (const r of data.results) {
+      if (r.ok) continue;
+      const snap = snapshots.get(r.id);
+      if (!snap || snap.parentFolderId === arg.newParentFolderId) continue;
+      dispatch(
+        detachChildFromFolder({
+          parentFolderId: arg.newParentFolderId,
+          kind: "file",
+          id: snap.id
+        })
+      );
+      dispatch(
+        attachChildToFolder({
+          parentFolderId: snap.parentFolderId,
+          kind: "file",
+          id: snap.id
+        })
+      );
+      dispatch(upsertFile(snap));
+    }
+    toastBulkPartialFailure(data, "move");
+    return data;
+  } catch (err) {
+    for (const snap of snapshots.values()) {
+      if (snap.parentFolderId === arg.newParentFolderId) continue;
+      dispatch(
+        detachChildFromFolder({
+          parentFolderId: arg.newParentFolderId,
+          kind: "file",
+          id: snap.id
+        })
+      );
+      dispatch(
+        attachChildToFolder({
+          parentFolderId: snap.parentFolderId,
+          kind: "file",
+          id: snap.id
+        })
+      );
+      dispatch(upsertFile(snap));
+    }
+    throw err;
+  } finally {
+    releaseRequest(requestId);
+  }
+});
+const bulkMoveFolders = createAsyncThunk("cloudFiles/bulkMoveFolders", async (arg, { dispatch, getState }) => {
+  if (arg.folderIds.length === 0) {
+    return { results: [], succeeded: 0, failed: 0 };
+  }
+  const state = getState();
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const id of arg.folderIds) {
+    const folder = state.cloudFiles.foldersById[id];
+    if (folder) snapshots.set(id, folder);
+  }
+  const requestId = newRequestId();
+  registerRequest({
+    requestId,
+    kind: "bulk-move-folders",
+    resourceId: null,
+    resourceType: "folder"
+  });
+  for (const [id, folder] of snapshots) {
+    if (folder.parentId === arg.newParentId) continue;
+    dispatch(
+      detachChildFromFolder({
+        parentFolderId: folder.parentId,
+        kind: "folder",
+        id
+      })
+    );
+    dispatch(
+      attachChildToFolder({
+        parentFolderId: arg.newParentId,
+        kind: "folder",
+        id
+      })
+    );
+    dispatch(upsertFolder({ ...folder, parentId: arg.newParentId }));
+  }
+  try {
+    const { data } = await Folders.bulkMoveFolders(
+      { folder_ids: arg.folderIds, new_parent_id: arg.newParentId },
+      { requestId }
+    );
+    for (const r of data.results) {
+      if (r.ok) continue;
+      const snap = snapshots.get(r.id);
+      if (!snap || snap.parentId === arg.newParentId) continue;
+      dispatch(
+        detachChildFromFolder({
+          parentFolderId: arg.newParentId,
+          kind: "folder",
+          id: snap.id
+        })
+      );
+      dispatch(
+        attachChildToFolder({
+          parentFolderId: snap.parentId,
+          kind: "folder",
+          id: snap.id
+        })
+      );
+      dispatch(upsertFolder(snap));
+    }
+    toastBulkPartialFailure(data, "move");
+    return data;
+  } catch (err) {
+    for (const snap of snapshots.values()) {
+      if (snap.parentId === arg.newParentId) continue;
+      dispatch(
+        detachChildFromFolder({
+          parentFolderId: arg.newParentId,
+          kind: "folder",
+          id: snap.id
+        })
+      );
+      dispatch(
+        attachChildToFolder({
+          parentFolderId: snap.parentId,
+          kind: "folder",
+          id: snap.id
+        })
+      );
+      dispatch(upsertFolder(snap));
+    }
+    throw err;
+  } finally {
+    releaseRequest(requestId);
+  }
+});
+export {
+  announceUploadFailures,
+  bulkDeleteFiles,
+  bulkMoveFiles,
+  bulkMoveFolders,
+  clearUploadEntry,
+  createFolder,
+  createShareLink,
+  deleteFile,
+  deleteFolder,
+  ensureCloudFileFields,
+  ensureFolderPath,
+  getFileUrl,
+  grantPermission,
+  loadFileVersions,
+  loadFolderContents,
+  loadPermissions,
+  loadShareLinks,
+  loadTrash,
+  loadUserFileTree,
+  moveFile,
+  reconcileTree,
+  renameFile,
+  restoreFile,
+  restoreFolder,
+  restoreVersion,
+  revokePermission,
+  revokeShareLink,
+  saveFileNewVersion,
+  updateFileMetadata,
+  updateFolder,
+  uploadFiles
+};
+//# sourceMappingURL=thunks.js.map