@ai-matrx/media 0.8.0 → 0.9.0

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

@@ -0,0 +1,836 @@
+import { createSlice } from "@reduxjs/toolkit";
+import {
+  addField,
+  assignField,
+  createFieldFlags,
+  hasField,
+  removeField
+} from "@ai-matrx/agents/field-flags";
+import { DEFAULT_VISIBLE_COLUMNS } from "../types.js";
+function emptyFileRecord(id) {
+  return {
+    id,
+    ownerId: "",
+    filePath: "",
+    fileName: "",
+    mimeType: null,
+    fileSize: null,
+    checksum: null,
+    visibility: "personal",
+    currentVersion: 1,
+    parentFolderId: null,
+    metadata: {},
+    createdAt: "",
+    updatedAt: "",
+    deletedAt: null,
+    publicUrl: null,
+    url: null,
+    cdnUrl: null,
+    downloadUrl: null,
+    thumbnailUrl: null,
+    source: { kind: "real" },
+    _dirty: false,
+    _dirtyFields: createFieldFlags(),
+    _fieldHistory: {},
+    _loadedFields: createFieldFlags(),
+    _loading: false,
+    _error: null,
+    _pendingRequestIds: []
+  };
+}
+function emptyFolderRecord(id) {
+  return {
+    id,
+    ownerId: "",
+    folderPath: "",
+    folderName: "",
+    parentId: null,
+    visibility: "personal",
+    metadata: {},
+    createdAt: "",
+    updatedAt: "",
+    deletedAt: null,
+    source: { kind: "real" },
+    _dirty: false,
+    _dirtyFields: createFieldFlags(),
+    _fieldHistory: {},
+    _loadedFields: createFieldFlags(),
+    _loading: false,
+    _error: null,
+    _pendingRequestIds: []
+  };
+}
+function mergeFileIntoRecord(record, partial) {
+  Object.keys(partial).forEach((key) => {
+    const value = partial[key];
+    if (value !== void 0) {
+      assignField(record, key, value);
+      addField(record._loadedFields, key);
+    }
+  });
+}
+function mergeFolderIntoRecord(record, partial) {
+  Object.keys(partial).forEach((key) => {
+    const value = partial[key];
+    if (value !== void 0) {
+      assignField(record, key, value);
+      addField(record._loadedFields, key);
+    }
+  });
+}
+function applyFileFieldEdit(record, field, value) {
+  if (!hasField(record._dirtyFields, field)) {
+    if (field === "fileName" || field === "filePath" || field === "visibility" || field === "parentFolderId" || field === "metadata" || field === "deletedAt") {
+      record._fieldHistory[field] = record[field];
+    }
+  }
+  assignField(record, field, value);
+  addField(record._dirtyFields, field);
+  record._dirty = true;
+}
+function applyFolderFieldEdit(record, field, value) {
+  if (!hasField(record._dirtyFields, field)) {
+    if (field === "folderName" || field === "folderPath" || field === "parentId" || field === "visibility" || field === "metadata") {
+      record._fieldHistory[field] = record[field];
+    }
+  }
+  assignField(record, field, value);
+  addField(record._dirtyFields, field);
+  record._dirty = true;
+}
+function markFileClean(record) {
+  record._dirty = false;
+  record._dirtyFields = createFieldFlags();
+  record._fieldHistory = {};
+  record._error = null;
+}
+function markFolderClean(record) {
+  record._dirty = false;
+  record._dirtyFields = createFieldFlags();
+  record._fieldHistory = {};
+  record._error = null;
+}
+const initialState = {
+  filesById: {},
+  foldersById: {},
+  versionsByFileId: {},
+  permissionsByResourceId: {},
+  shareLinksByResourceId: {},
+  tree: {
+    rootFolderIds: [],
+    rootFileIds: [],
+    childrenByFolderId: {},
+    fullyLoadedFolderIds: {},
+    status: "idle",
+    error: null,
+    lastReconciledAt: null
+  },
+  selection: {
+    selectedIds: [],
+    anchorId: null
+  },
+  ui: {
+    viewMode: "list",
+    // Files lists always open most-recently-updated first. Folders still
+    // group above files (see `compareNodes`); within each group the newest
+    // edit floats to the top.
+    sortBy: "updated_at",
+    sortDir: "desc",
+    kindFilter: "all",
+    detailsLevel: "compact",
+    columnFilters: {
+      name: "",
+      type: [],
+      extension: "",
+      mime: "",
+      path: "",
+      owner: [],
+      modified: "any",
+      created: "any",
+      size: "any",
+      access: "any",
+      rag: []
+    },
+    visibleColumns: { ...DEFAULT_VISIBLE_COLUMNS },
+    searchQuery: "",
+    chipFilter: null,
+    activeFileId: null,
+    activeFolderId: null,
+    focusedId: null
+  },
+  uploads: {},
+  ragStatus: {
+    byFileId: {},
+    isFetching: false,
+    lastFetchedAt: null
+  },
+  realtime: {
+    status: "detached",
+    userId: null,
+    lastEventAt: null,
+    error: null
+  }
+};
+const slice = createSlice({
+  name: "cloudFiles",
+  initialState,
+  reducers: {
+    // ---- Files: upsert / merge ---------------------------------------------
+    upsertFiles(state, action) {
+      for (const partial of action.payload) {
+        if (!partial.id) continue;
+        const existing = state.filesById[partial.id] ?? emptyFileRecord(partial.id);
+        mergeFileIntoRecord(existing, partial);
+        state.filesById[partial.id] = existing;
+      }
+    },
+    upsertFile(state, action) {
+      const partial = action.payload;
+      if (!partial.id) return;
+      const existing = state.filesById[partial.id] ?? emptyFileRecord(partial.id);
+      mergeFileIntoRecord(existing, partial);
+      state.filesById[partial.id] = existing;
+    },
+    // ---- Files: field edits (optimistic) -----------------------------------
+    setFileField(state, action) {
+      const { id, field, value } = action.payload;
+      const record = state.filesById[id];
+      if (!record) return;
+      applyFileFieldEdit(record, field, value);
+    },
+    resetFileField(state, action) {
+      const { id, field } = action.payload;
+      const record = state.filesById[id];
+      if (!record) return;
+      const snapKey = field;
+      const snapshotValue = record._fieldHistory[snapKey];
+      if (snapKey in record._fieldHistory && snapshotValue !== void 0) {
+        assignField(record, snapKey, snapshotValue);
+        delete record._fieldHistory[snapKey];
+        removeField(record._dirtyFields, field);
+      }
+      if (Object.keys(record._dirtyFields).length === 0) {
+        record._dirty = false;
+      }
+    },
+    markFileSaved(state, action) {
+      const record = state.filesById[action.payload.id];
+      if (!record) return;
+      markFileClean(record);
+    },
+    rollbackFileOptimisticUpdate(state, action) {
+      const { id, snapshot } = action.payload;
+      const record = state.filesById[id];
+      if (!record) return;
+      Object.assign(record, snapshot);
+      record._dirty = false;
+      record._dirtyFields = createFieldFlags();
+      record._fieldHistory = {};
+    },
+    // ---- Files: remove / pending requests ----------------------------------
+    removeFile(state, action) {
+      const { id } = action.payload;
+      delete state.filesById[id];
+      delete state.versionsByFileId[id];
+      for (const parentId of Object.keys(state.tree.childrenByFolderId)) {
+        const bucket = state.tree.childrenByFolderId[parentId];
+        const idx = bucket.fileIds.indexOf(id);
+        if (idx >= 0) bucket.fileIds.splice(idx, 1);
+      }
+      const rootIdx = state.tree.rootFileIds.indexOf(id);
+      if (rootIdx >= 0) state.tree.rootFileIds.splice(rootIdx, 1);
+    },
+    addFilePendingRequest(state, action) {
+      const { id, requestId } = action.payload;
+      const record = state.filesById[id];
+      if (!record) return;
+      if (!record._pendingRequestIds.includes(requestId)) {
+        record._pendingRequestIds.push(requestId);
+      }
+    },
+    removeFilePendingRequest(state, action) {
+      const { id, requestId } = action.payload;
+      const record = state.filesById[id];
+      if (!record) return;
+      const idx = record._pendingRequestIds.indexOf(requestId);
+      if (idx >= 0) record._pendingRequestIds.splice(idx, 1);
+    },
+    setFileLoading(state, action) {
+      const record = state.filesById[action.payload.id];
+      if (!record) return;
+      record._loading = action.payload.loading;
+    },
+    setFileError(state, action) {
+      const record = state.filesById[action.payload.id];
+      if (!record) return;
+      record._error = action.payload.error;
+    },
+    // ---- Folders: mirror of file reducers ----------------------------------
+    upsertFolders(state, action) {
+      for (const partial of action.payload) {
+        if (!partial.id) continue;
+        const existing = state.foldersById[partial.id] ?? emptyFolderRecord(partial.id);
+        mergeFolderIntoRecord(existing, partial);
+        state.foldersById[partial.id] = existing;
+      }
+    },
+    upsertFolder(state, action) {
+      const partial = action.payload;
+      if (!partial.id) return;
+      const existing = state.foldersById[partial.id] ?? emptyFolderRecord(partial.id);
+      mergeFolderIntoRecord(existing, partial);
+      state.foldersById[partial.id] = existing;
+    },
+    setFolderField(state, action) {
+      const { id, field, value } = action.payload;
+      const record = state.foldersById[id];
+      if (!record) return;
+      applyFolderFieldEdit(record, field, value);
+    },
+    markFolderSaved(state, action) {
+      const record = state.foldersById[action.payload.id];
+      if (!record) return;
+      markFolderClean(record);
+    },
+    rollbackFolderOptimisticUpdate(state, action) {
+      const { id, snapshot } = action.payload;
+      const record = state.foldersById[id];
+      if (!record) return;
+      Object.assign(record, snapshot);
+      record._dirty = false;
+      record._dirtyFields = createFieldFlags();
+      record._fieldHistory = {};
+    },
+    removeFolder(state, action) {
+      const { id } = action.payload;
+      delete state.foldersById[id];
+      delete state.tree.childrenByFolderId[id];
+      for (const parentId of Object.keys(state.tree.childrenByFolderId)) {
+        const bucket = state.tree.childrenByFolderId[parentId];
+        const idx = bucket.folderIds.indexOf(id);
+        if (idx >= 0) bucket.folderIds.splice(idx, 1);
+      }
+      const rootIdx = state.tree.rootFolderIds.indexOf(id);
+      if (rootIdx >= 0) state.tree.rootFolderIds.splice(rootIdx, 1);
+    },
+    // ---- Versions ----------------------------------------------------------
+    upsertVersionsForFile(state, action) {
+      state.versionsByFileId[action.payload.fileId] = action.payload.versions;
+    },
+    // ---- Permissions -------------------------------------------------------
+    upsertPermissionsForResource(state, action) {
+      state.permissionsByResourceId[action.payload.resourceId] = action.payload.permissions;
+    },
+    removePermissionForResource(state, action) {
+      const { resourceId, granteeId, granteeType } = action.payload;
+      const list = state.permissionsByResourceId[resourceId];
+      if (!list) return;
+      state.permissionsByResourceId[resourceId] = list.filter(
+        (p) => !(p.granteeId === granteeId && (granteeType ? p.granteeType === granteeType : true))
+      );
+    },
+    // ---- Share links -------------------------------------------------------
+    upsertShareLinksForResource(state, action) {
+      state.shareLinksByResourceId[action.payload.resourceId] = action.payload.shareLinks;
+    },
+    removeShareLink(state, action) {
+      const { linkId } = action.payload;
+      for (const resourceId of Object.keys(state.shareLinksByResourceId)) {
+        state.shareLinksByResourceId[resourceId] = state.shareLinksByResourceId[resourceId].filter((l) => l.id !== linkId);
+      }
+    },
+    // ---- Tree --------------------------------------------------------------
+    setTreeStatus(state, action) {
+      state.tree.status = action.payload.status;
+      state.tree.error = action.payload.error ?? null;
+    },
+    replaceTree(state, action) {
+      const incomingIds = new Set(action.payload.rootFolderIds);
+      const virtualRoots = state.tree.rootFolderIds.filter((id) => {
+        if (incomingIds.has(id)) return false;
+        return state.foldersById[id]?.source.kind === "virtual";
+      });
+      state.tree.rootFolderIds = [
+        ...virtualRoots,
+        ...action.payload.rootFolderIds
+      ];
+      state.tree.rootFileIds = action.payload.rootFileIds;
+      const preservedChildren = {};
+      for (const [folderId, children] of Object.entries(
+        state.tree.childrenByFolderId
+      )) {
+        if (state.foldersById[folderId]?.source.kind === "virtual") {
+          preservedChildren[folderId] = children;
+        }
+      }
+      state.tree.childrenByFolderId = {
+        ...preservedChildren,
+        ...action.payload.childrenByFolderId
+      };
+      state.tree.fullyLoadedFolderIds = action.payload.fullyLoadedFolderIds ?? {};
+      state.tree.status = "loaded";
+      state.tree.error = null;
+      state.tree.lastReconciledAt = Date.now();
+    },
+    markFolderFullyLoaded(state, action) {
+      state.tree.fullyLoadedFolderIds[action.payload.folderId] = true;
+    },
+    /**
+     * Mount a virtual adapter as a synthetic root folder. Called once per
+     * registered `VirtualSourceAdapter` from `attachVirtualRoots()` (a thunk
+     * fired during `/files` bootstrap). The synthetic folder has id
+     * `vfs:<adapterId>:__root__` and `source.kind: "virtual"` so the existing
+     * tree renderer and selectors treat it like any other folder.
+     */
+    attachVirtualRoot(state, action) {
+      const { adapterId, rootId, label } = action.payload;
+      if (state.foldersById[rootId]) return;
+      state.foldersById[rootId] = {
+        id: rootId,
+        ownerId: "",
+        folderPath: `/${label}`,
+        folderName: label,
+        parentId: null,
+        visibility: "personal",
+        metadata: {},
+        createdAt: "",
+        updatedAt: "",
+        deletedAt: null,
+        source: { kind: "virtual", adapterId, virtualId: "__root__" },
+        _dirty: false,
+        _dirtyFields: {},
+        _fieldHistory: {},
+        _loadedFields: {},
+        _loading: false,
+        _error: null,
+        _pendingRequestIds: []
+      };
+      if (!state.tree.rootFolderIds.includes(rootId)) {
+        state.tree.rootFolderIds.unshift(rootId);
+      }
+    },
+    attachChildToFolder(state, action) {
+      const { parentFolderId, kind, id } = action.payload;
+      if (!parentFolderId) {
+        if (kind === "file") {
+          if (!state.tree.rootFileIds.includes(id)) {
+            state.tree.rootFileIds.push(id);
+          }
+        } else {
+          if (!state.tree.rootFolderIds.includes(id)) {
+            state.tree.rootFolderIds.push(id);
+          }
+        }
+        return;
+      }
+      const bucket = state.tree.childrenByFolderId[parentFolderId] ??= {
+        folderIds: [],
+        fileIds: []
+      };
+      const list = kind === "file" ? bucket.fileIds : bucket.folderIds;
+      if (!list.includes(id)) list.push(id);
+    },
+    detachChildFromFolder(state, action) {
+      const { parentFolderId, kind, id } = action.payload;
+      if (!parentFolderId) {
+        const list2 = kind === "file" ? state.tree.rootFileIds : state.tree.rootFolderIds;
+        const idx2 = list2.indexOf(id);
+        if (idx2 >= 0) list2.splice(idx2, 1);
+        return;
+      }
+      const bucket = state.tree.childrenByFolderId[parentFolderId];
+      if (!bucket) return;
+      const list = kind === "file" ? bucket.fileIds : bucket.folderIds;
+      const idx = list.indexOf(id);
+      if (idx >= 0) list.splice(idx, 1);
+    },
+    // ---- Selection + UI ---------------------------------------------------
+    setSelection(state, action) {
+      state.selection = action.payload;
+    },
+    clearSelection(state) {
+      state.selection = { selectedIds: [], anchorId: null };
+    },
+    toggleSelection(state, action) {
+      const { id } = action.payload;
+      const idx = state.selection.selectedIds.indexOf(id);
+      if (idx >= 0) {
+        state.selection.selectedIds.splice(idx, 1);
+        if (state.selection.anchorId === id) state.selection.anchorId = null;
+      } else {
+        state.selection.selectedIds.push(id);
+        state.selection.anchorId = id;
+      }
+    },
+    setViewMode(state, action) {
+      state.ui.viewMode = action.payload;
+    },
+    setSort(state, action) {
+      state.ui.sortBy = action.payload.sortBy;
+      state.ui.sortDir = action.payload.sortDir;
+    },
+    setKindFilter(state, action) {
+      state.ui.kindFilter = action.payload;
+    },
+    setDetailsLevel(state, action) {
+      state.ui.detailsLevel = action.payload;
+    },
+    setColumnFilter(state, action) {
+      const next = action.payload;
+      switch (next.column) {
+        case "name":
+          state.ui.columnFilters.name = next.value;
+          break;
+        case "type":
+          state.ui.columnFilters.type = next.value;
+          break;
+        case "extension":
+          state.ui.columnFilters.extension = next.value;
+          break;
+        case "mime":
+          state.ui.columnFilters.mime = next.value;
+          break;
+        case "path":
+          state.ui.columnFilters.path = next.value;
+          break;
+        case "owner":
+          state.ui.columnFilters.owner = next.value;
+          break;
+        case "modified":
+          state.ui.columnFilters.modified = next.value;
+          break;
+        case "created":
+          state.ui.columnFilters.created = next.value;
+          break;
+        case "size":
+          state.ui.columnFilters.size = next.value;
+          break;
+        case "access":
+          state.ui.columnFilters.access = next.value;
+          break;
+        case "rag":
+          state.ui.columnFilters.rag = next.value;
+          break;
+      }
+    },
+    clearColumnFilters(state) {
+      state.ui.columnFilters = {
+        name: "",
+        type: [],
+        extension: "",
+        mime: "",
+        path: "",
+        owner: [],
+        modified: "any",
+        created: "any",
+        size: "any",
+        access: "any",
+        rag: []
+      };
+    },
+    setColumnVisibility(state, action) {
+      const { column, visible } = action.payload;
+      if (column === "name") {
+        state.ui.visibleColumns.name = true;
+        return;
+      }
+      state.ui.visibleColumns[column] = visible;
+    },
+    resetColumnVisibility(state) {
+      state.ui.visibleColumns = { ...DEFAULT_VISIBLE_COLUMNS };
+    },
+    setActiveFileId(state, action) {
+      state.ui.activeFileId = action.payload;
+    },
+    setActiveFolderId(state, action) {
+      state.ui.activeFolderId = action.payload;
+    },
+    /** Tree-wide search box value. Empty string clears the search. */
+    setSearchQuery(state, action) {
+      state.ui.searchQuery = action.payload;
+    },
+    /** Active sticky chip (Recents / Starred). Pass null to clear. */
+    setChipFilter(state, action) {
+      state.ui.chipFilter = action.payload;
+    },
+    /**
+     * Apply many UI fields in one transaction. Used by the URL-sync layer
+     * to hydrate Redux from a `?...` query string on first paint without
+     * dispatching N separate actions (which would each spawn a re-render).
+     *
+     * Only fields present in the payload are written. Pass `columnFilters`
+     * with the FULL shape — partial column-filter merges are intentionally
+     * not supported here; the URL serializer always emits the full shape.
+     */
+    setUiBatch(state, action) {
+      const next = action.payload;
+      if (next.viewMode !== void 0) state.ui.viewMode = next.viewMode;
+      if (next.sortBy !== void 0) state.ui.sortBy = next.sortBy;
+      if (next.sortDir !== void 0) state.ui.sortDir = next.sortDir;
+      if (next.kindFilter !== void 0) state.ui.kindFilter = next.kindFilter;
+      if (next.detailsLevel !== void 0) {
+        state.ui.detailsLevel = next.detailsLevel;
+      }
+      if (next.searchQuery !== void 0) {
+        state.ui.searchQuery = next.searchQuery;
+      }
+      if (next.chipFilter !== void 0) state.ui.chipFilter = next.chipFilter;
+      if (next.activeFileId !== void 0) {
+        state.ui.activeFileId = next.activeFileId;
+      }
+      if (next.activeFolderId !== void 0) {
+        state.ui.activeFolderId = next.activeFolderId;
+      }
+      if (next.columnFilters !== void 0) {
+        const cf = next.columnFilters;
+        if (cf.name !== void 0) state.ui.columnFilters.name = cf.name;
+        if (cf.type !== void 0) state.ui.columnFilters.type = cf.type;
+        if (cf.extension !== void 0) {
+          state.ui.columnFilters.extension = cf.extension;
+        }
+        if (cf.mime !== void 0) state.ui.columnFilters.mime = cf.mime;
+        if (cf.path !== void 0) state.ui.columnFilters.path = cf.path;
+        if (cf.owner !== void 0) state.ui.columnFilters.owner = cf.owner;
+        if (cf.modified !== void 0) {
+          state.ui.columnFilters.modified = cf.modified;
+        }
+        if (cf.created !== void 0) {
+          state.ui.columnFilters.created = cf.created;
+        }
+        if (cf.size !== void 0) state.ui.columnFilters.size = cf.size;
+        if (cf.access !== void 0) state.ui.columnFilters.access = cf.access;
+        if (cf.rag !== void 0) state.ui.columnFilters.rag = cf.rag;
+      }
+      if (next.visibleColumns !== void 0) {
+        state.ui.visibleColumns = {
+          ...DEFAULT_VISIBLE_COLUMNS,
+          ...next.visibleColumns,
+          // `name` is the row anchor — never hideable. Keep this invariant
+          // even when callers (or a malicious URL) try to flip it.
+          name: true
+        };
+      }
+    },
+    /**
+     * Move "focus" (Google-Drive-style single-item highlight) to the given id.
+     * Pass null to clear. Automatically set after folder/file creation so the
+     * newly-created item is highlighted and scrolled into view.
+     */
+    setFocusedId(state, action) {
+      state.ui.focusedId = action.payload;
+    },
+    // ---- Uploads -----------------------------------------------------------
+    trackUploadStart(state, action) {
+      const { requestId, fileName, fileSize, parentFolderId, folderPath } = action.payload;
+      state.uploads[requestId] = {
+        requestId,
+        fileName,
+        fileSize,
+        parentFolderId,
+        folderPath: folderPath ?? null,
+        status: "uploading",
+        bytesUploaded: 0,
+        startedAt: Date.now(),
+        completedAt: null,
+        error: null,
+        retries: 0,
+        fileId: null
+      };
+    },
+    updateUploadProgress(state, action) {
+      const entry = state.uploads[action.payload.requestId];
+      if (!entry) return;
+      entry.bytesUploaded = action.payload.bytesUploaded;
+    },
+    updateUploadStatus(state, action) {
+      const entry = state.uploads[action.payload.requestId];
+      if (!entry) return;
+      entry.status = action.payload.status;
+      if (action.payload.fileId !== void 0)
+        entry.fileId = action.payload.fileId;
+      if (action.payload.error !== void 0)
+        entry.error = action.payload.error;
+      if (action.payload.status === "success" || action.payload.status === "error" || action.payload.status === "cancelled") {
+        entry.completedAt = Date.now();
+      }
+    },
+    clearUpload(state, action) {
+      delete state.uploads[action.payload.requestId];
+    },
+    clearCompletedUploads(state) {
+      for (const id of Object.keys(state.uploads)) {
+        const entry = state.uploads[id];
+        if (entry.status === "success" || entry.status === "cancelled") {
+          delete state.uploads[id];
+        }
+      }
+    },
+    // ---- Realtime lifecycle -----------------------------------------------
+    setRealtimeStatus(state, action) {
+      state.realtime.status = action.payload.status;
+      if (action.payload.userId !== void 0) {
+        state.realtime.userId = action.payload.userId;
+      }
+      state.realtime.error = action.payload.error ?? null;
+      if (action.payload.status === "subscribed") {
+        state.realtime.lastEventAt = Date.now();
+      }
+    },
+    touchRealtime(state) {
+      state.realtime.lastEventAt = Date.now();
+    },
+    // ---- Knowledge status (per-file) ---------------------------------------------
+    setRagStatusForFile(state, action) {
+      const { fileId, status } = action.payload;
+      state.ragStatus.byFileId[fileId] = status;
+    },
+    setRagStatusBatch(state, action) {
+      Object.assign(state.ragStatus.byFileId, action.payload.entries);
+      state.ragStatus.lastFetchedAt = Date.now();
+    },
+    setRagStatusFetching(state, action) {
+      state.ragStatus.isFetching = action.payload;
+    },
+    clearRagStatuses(state) {
+      state.ragStatus.byFileId = {};
+      state.ragStatus.lastFetchedAt = null;
+    },
+    resetCloudFilesState() {
+      return initialState;
+    }
+  }
+});
+const {
+  // files
+  upsertFile,
+  upsertFiles,
+  setFileField,
+  resetFileField,
+  markFileSaved,
+  rollbackFileOptimisticUpdate,
+  removeFile,
+  addFilePendingRequest,
+  removeFilePendingRequest,
+  setFileLoading,
+  setFileError,
+  // folders
+  upsertFolder,
+  upsertFolders,
+  setFolderField,
+  markFolderSaved,
+  rollbackFolderOptimisticUpdate,
+  removeFolder,
+  // versions / permissions / shares
+  upsertVersionsForFile,
+  upsertPermissionsForResource,
+  removePermissionForResource,
+  upsertShareLinksForResource,
+  removeShareLink,
+  // tree
+  setTreeStatus,
+  replaceTree,
+  markFolderFullyLoaded,
+  attachVirtualRoot,
+  attachChildToFolder,
+  detachChildFromFolder,
+  // selection + ui
+  setSelection,
+  clearSelection,
+  toggleSelection,
+  setViewMode,
+  setSort,
+  setKindFilter,
+  setDetailsLevel,
+  setColumnFilter,
+  clearColumnFilters,
+  setColumnVisibility,
+  resetColumnVisibility,
+  setActiveFileId,
+  setActiveFolderId,
+  setSearchQuery,
+  setChipFilter,
+  setUiBatch,
+  setFocusedId,
+  // uploads
+  trackUploadStart,
+  updateUploadProgress,
+  updateUploadStatus,
+  clearUpload,
+  clearCompletedUploads,
+  // rag status
+  setRagStatusForFile,
+  setRagStatusBatch,
+  setRagStatusFetching,
+  clearRagStatuses,
+  // realtime
+  setRealtimeStatus,
+  touchRealtime,
+  // working copies
+  resetCloudFilesState
+} = slice.actions;
+const cloudFilesReducer = slice.reducer;
+var slice_default = slice.reducer;
+export {
+  addFilePendingRequest,
+  attachChildToFolder,
+  attachVirtualRoot,
+  clearColumnFilters,
+  clearCompletedUploads,
+  clearRagStatuses,
+  clearSelection,
+  clearUpload,
+  cloudFilesReducer,
+  slice_default as default,
+  detachChildFromFolder,
+  emptyFileRecord,
+  emptyFolderRecord,
+  markFileSaved,
+  markFolderFullyLoaded,
+  markFolderSaved,
+  removeFile,
+  removeFilePendingRequest,
+  removeFolder,
+  removePermissionForResource,
+  removeShareLink,
+  replaceTree,
+  resetCloudFilesState,
+  resetColumnVisibility,
+  resetFileField,
+  rollbackFileOptimisticUpdate,
+  rollbackFolderOptimisticUpdate,
+  setActiveFileId,
+  setActiveFolderId,
+  setChipFilter,
+  setColumnFilter,
+  setColumnVisibility,
+  setDetailsLevel,
+  setFileError,
+  setFileField,
+  setFileLoading,
+  setFocusedId,
+  setFolderField,
+  setKindFilter,
+  setRagStatusBatch,
+  setRagStatusFetching,
+  setRagStatusForFile,
+  setRealtimeStatus,
+  setSearchQuery,
+  setSelection,
+  setSort,
+  setTreeStatus,
+  setUiBatch,
+  setViewMode,
+  toggleSelection,
+  touchRealtime,
+  trackUploadStart,
+  updateUploadProgress,
+  updateUploadStatus,
+  upsertFile,
+  upsertFiles,
+  upsertFolder,
+  upsertFolders,
+  upsertPermissionsForResource,
+  upsertShareLinksForResource,
+  upsertVersionsForFile
+};
+//# sourceMappingURL=slice.js.map