nolo-cli 0.49.1 → 0.50.0

package/{chunk-6SMMK7MD.js → chunk-GKB4AZKV.js}

@@ -1,25 +1,21 @@
+import {
+  getCurrentSpaceId,
+  getCurrentSpaceIdRaw,
+  updateCurrentSpaceIfMatch
+} from "./chunk-ZJ7UHBJS.js";
 import {
   deleteDialog,
   toast
-} from "./chunk-EURF2SV6.js";
-import {
-  deleteServerSyncedCredential
-} from "./chunk-WX5E6HZS.js";
+} from "./chunk-UMCMW5R3.js";
 import {
   require_date_fns
 } from "./chunk-M76ECQRD.js";
 import {
   require_react
-} from "./chunk-MRWGHF56.js";
-import {
-  createFileCredentialBroker
-} from "./chunk-NQ4N4IGO.js";
-import {
-  toErrorMessage
-} from "./chunk-HNMXYYJR.js";
+} from "./chunk-YDH3FDFQ.js";
 import {
   isSystemAdmin
-} from "./chunk-X7S7OFUX.js";
+} from "./chunk-CEVCRRHU.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
@@ -27,52 +23,39 @@ import {
   UNCATEGORIZED_ID,
   addContentAction,
   checkSpaceMembership,
+  localSpaceAuthorityPatchStamp
+} from "./chunk-J7KDNHUO.js";
+import {
   createSpaceKey,
-  localSpaceAuthorityPatchStamp,
   normalizeSpaceId
-} from "./chunk-4RXXP6WD.js";
+} from "./chunk-UAD2WT54.js";
 import {
   patch,
   read,
   readAndWait,
   remove,
   resolveFileCategory,
-  selectById,
-  selectEntities,
-  toTimestampMs,
   uploadFileAction,
   upsertSSREntity,
   write
-} from "./chunk-76UA7376.js";
+} from "./chunk-273FJUYI.js";
 import {
-  DB_PREFIX,
   SEPARATOR,
-  TYPE_STORAGE_PREFIXES,
   createKey,
   fileKey,
   isAgentKey,
-  isAppKey,
-  isDialogKey,
-  isFileKey,
   isPageKey,
-  isTableMetaKey,
-  isTaskKey,
   metaKey,
   rowKey,
   splitKey,
-  toTrimmedString,
   ulid
 } from "./chunk-SVEUG45B.js";
 import {
   asOptionalFiniteNumber
 } from "./chunk-WWC7I6TA.js";
 import {
-  asNonEmptyStringArray,
   asTrimmedNonEmptyStringArray
 } from "./chunk-I42VC5KR.js";
-import {
-  readAction
-} from "./chunk-2JYSSXLY.js";
 import {
   extractUserId
 } from "./chunk-BJIRLHJR.js";
@@ -80,31 +63,20 @@ import {
   DEVICE_LOCAL_OWNER_ID,
   asyncThunkCreator,
   buildCreateSlice,
+  createAsyncThunk,
   getRuntimeServerContext,
-  isDeviceLocalOwnerId,
   isDeviceLocalSpaceBody,
-  isDeviceLocalSpaceMembership,
-  resolveEffectiveSpaceActorId,
-  resolveRecordOwnerUserId,
   resolveReplicationServers,
   scheduleDeleteReplication,
   scheduleWriteReplication,
-  selectIdentityUserId,
-  selectRuntimeSnapshot
-} from "./chunk-HHBXCRJS.js";
+  selectIdentityUserId
+} from "./chunk-XOJRZUPF.js";
 import {
-  createClientLogger,
-  fetchFromServer,
-  getAllServers,
-  logger
-} from "./chunk-L3JWI7WX.js";
+  createClientLogger
+} from "./chunk-QOKAKDPE.js";
 import {
-  buildTombstoneRecord,
-  isTombstoneRecord
+  buildTombstoneRecord
 } from "./chunk-GBRG75BQ.js";
-import {
-  isRecord
-} from "./chunk-KUG52IAP.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
@@ -112,8 +84,8 @@ import {
   asOptionalPositiveFiniteNumber
 } from "./chunk-U6VC4MU4.js";
 import {
-  API_ENDPOINTS
-} from "./chunk-LCBAMY2M.js";
+  isRecord
+} from "./chunk-KUG52IAP.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
@@ -235,550 +207,9 @@ var require_html_parse_stringify = __commonJS({
   }
 });
 
-// packages/create/space/category/categoryActions.ts
-import { ulid as ulid2 } from "ulid";
-
-// packages/create/space/spaceCurrentStore.ts
-var import_react = __toESM(require_react(), 1);
-var VIEW_MODE_STORAGE_KEY = "nolo-space-view-mode";
-var readStoredViewMode = () => {
-  try {
-    if (typeof window === "undefined") return "all";
-    return window.localStorage.getItem(VIEW_MODE_STORAGE_KEY) === "categories" ? "categories" : "all";
-  } catch {
-    return "all";
-  }
-};
-var writeStoredViewMode = (mode) => {
-  try {
-    if (typeof window === "undefined") return;
-    window.localStorage.setItem(VIEW_MODE_STORAGE_KEY, mode);
-  } catch {
-  }
-};
-var createInitialState = () => ({
-  currentSpaceId: null,
-  currentSpace: null,
-  viewMode: readStoredViewMode()
-});
-var state = createInitialState();
-var listeners = /* @__PURE__ */ new Set();
-var version = 0;
-var notify = () => {
-  version += 1;
-  for (const listener of listeners) {
-    try {
-      listener();
-    } catch {
-    }
-  }
-};
-function getCurrentSpaceId() {
-  return state.viewMode === "all" ? null : state.currentSpaceId;
-}
-function getCurrentSpaceIdRaw() {
-  return state.currentSpaceId;
-}
-function getCurrentSpaceRaw() {
-  return state.currentSpace;
-}
-function getViewMode() {
-  return state.viewMode;
-}
-function setViewMode(mode) {
-  if (state.viewMode === mode) return;
-  state = { ...state, viewMode: mode };
-  writeStoredViewMode(mode);
-  notify();
-}
-function setCurrentSpace(space) {
-  state = { ...state, currentSpace: space };
-  notify();
-}
-function setCurrentSpaceBoth(spaceId, space) {
-  state = { ...state, currentSpaceId: spaceId, currentSpace: space };
-  notify();
-}
-function updateCurrentSpaceIfMatch(spaceId, space) {
-  const currentId = state.currentSpaceId;
-  if (currentId && normalizeSpaceId(currentId) === normalizeSpaceId(spaceId)) {
-    state = { ...state, currentSpace: space };
-    notify();
-  }
-}
-function resetSpaceCurrentState() {
-  state = { currentSpaceId: null, currentSpace: null, viewMode: "all" };
-  writeStoredViewMode("all");
-  notify();
-}
-function appendDialogContentEntry(dialogKey, title, timestamp) {
-  if (!state.currentSpace) return;
-  state = {
-    ...state,
-    currentSpace: {
-      ...state.currentSpace,
-      contents: {
-        ...state.currentSpace.contents ?? {},
-        [dialogKey]: {
-          title,
-          type: "dialog",
-          contentKey: dialogKey,
-          pinned: false,
-          createdAt: timestamp,
-          updatedAt: timestamp
-        }
-      },
-      updatedAt: timestamp
-    }
-  };
-  notify();
-}
-
-// packages/create/space/spaceCollapsedState.ts
-var SPACE_COLLAPSE_STORAGE_PREFIX = "space-collapsed-categories:";
-var normalizeCollapsedCategories = (value) => {
-  const entries = Object.entries(asRecordOrEmpty(value)).filter(
-    ([key, collapsed]) => typeof key === "string" && typeof collapsed === "boolean"
-  );
-  return Object.fromEntries(entries);
-};
-var storageKeyForSpace = (spaceId) => `${SPACE_COLLAPSE_STORAGE_PREFIX}${spaceId}`;
-var readStoredCollapsedCategories = (spaceId, storage) => {
-  if (!spaceId || !storage) return {};
-  try {
-    const raw = storage.getItem(storageKeyForSpace(spaceId));
-    if (!raw) return { [UNCATEGORIZED_ID]: false };
-    return normalizeCollapsedCategories(JSON.parse(raw));
-  } catch (error) {
-    console.warn("[Space] \u8BFB\u53D6\u5206\u7C7B\u6298\u53E0\u72B6\u6001\u5931\u8D25:", error);
-    return {};
-  }
-};
-var writeStoredCollapsedCategories = (spaceId, collapsedCategories, storage) => {
-  if (!spaceId || !storage) return;
-  try {
-    storage.setItem(
-      storageKeyForSpace(spaceId),
-      JSON.stringify(normalizeCollapsedCategories(collapsedCategories))
-    );
-  } catch (error) {
-    console.warn("[Space] \u4FDD\u5B58\u5206\u7C7B\u6298\u53E0\u72B6\u6001\u5931\u8D25:", error);
-  }
-};
-
-// packages/create/space/spaceUiStore.ts
-var import_react2 = __toESM(require_react(), 1);
-var DEFAULT_COLLAPSED_CATEGORIES = {
-  [UNCATEGORIZED_ID]: false
-};
-var FAVORITES_COLLAPSED_STORAGE_KEY = "nolo-sidebar-favorites-collapsed";
-var readStoredFavoritesCollapsed = () => {
-  try {
-    if (typeof window === "undefined") return false;
-    return window.localStorage.getItem(FAVORITES_COLLAPSED_STORAGE_KEY) === "1";
-  } catch {
-    return false;
-  }
-};
-var writeStoredFavoritesCollapsed = (collapsed) => {
-  try {
-    if (typeof window === "undefined") return;
-    window.localStorage.setItem(
-      FAVORITES_COLLAPSED_STORAGE_KEY,
-      collapsed ? "1" : "0"
-    );
-  } catch {
-  }
-};
-var createInitialState2 = () => ({
-  favoritesCollapsed: readStoredFavoritesCollapsed(),
-  collapsedCategories: {},
-  collapsedCategoriesSpaceId: null
-});
-var state2 = createInitialState2();
-var listeners2 = /* @__PURE__ */ new Set();
-var version2 = 0;
-var notify2 = () => {
-  version2 += 1;
-  for (const listener of listeners2) {
-    try {
-      listener();
-    } catch {
-    }
-  }
-};
-function getCollapsedCategories() {
-  return state2.collapsedCategories;
-}
-function setCollapsedCategories(categories, spaceId) {
-  state2 = {
-    ...state2,
-    collapsedCategories: categories,
-    collapsedCategoriesSpaceId: spaceId
-  };
-  notify2();
-}
-function toggleCategoryCollapse(categoryId) {
-  const current = state2.collapsedCategories[categoryId] ?? (DEFAULT_COLLAPSED_CATEGORIES[categoryId] ?? true);
-  state2 = {
-    ...state2,
-    collapsedCategories: {
-      ...state2.collapsedCategories,
-      [categoryId]: !current
-    }
-  };
-  notify2();
-}
-function expandCategoryInCollapsed(categoryId, spaceId) {
-  if (!categoryId || categoryId === UNCATEGORIZED_ID) return;
-  state2 = {
-    ...state2,
-    collapsedCategories: {
-      ...state2.collapsedCategories,
-      [categoryId]: false
-    }
-  };
-  if (typeof window !== "undefined") {
-    writeStoredCollapsedCategories(
-      spaceId,
-      state2.collapsedCategories,
-      window.localStorage
-    );
-  }
-  notify2();
-}
-function resetSpaceUiState() {
-  state2 = {
-    favoritesCollapsed: false,
-    collapsedCategories: {},
-    collapsedCategoriesSpaceId: null
-  };
-  writeStoredFavoritesCollapsed(false);
-  notify2();
-}
-
-// packages/create/space/category/categoryActions.ts
-var createCategoryActions = (create) => ({
-  // --- Regular Reducers ---
-  /**
-   * (新增) 从持久化存储中水合分类的折叠状态
-   */
-  hydrateCollapsedCategories: create.reducer(
-    (state6, action) => {
-      setCollapsedCategories(
-        normalizeCollapsedCategories(action.payload),
-        getCurrentSpaceIdRaw()
-      );
-    }
-  ),
-  // --- Async Thunks ---
-  /**
-   * 批量切换所有分类的折叠状态，并持久化到本地
-   */
-  setAllCategoriesCollapsed: create.asyncThunk(
-    async (input, thunkAPI) => {
-      const { getState } = thunkAPI;
-      const rootState = getState();
-      const spaceId = input.spaceId || getCurrentSpaceId();
-      if (!spaceId) throw new Error("\u65E0\u6CD5\u5207\u6362\u6298\u53E0\u72B6\u6001\uFF1A\u6CA1\u6709\u6D3B\u52A8\u7684\u7A7A\u95F4\u3002");
-      const currentSpace = getCurrentSpaceRaw();
-      const categoryIds = currentSpace?.categories ? Object.keys(currentSpace.categories) : [];
-      categoryIds.push(UNCATEGORIZED_ID);
-      const collapsedCategories = {};
-      categoryIds.forEach((id) => {
-        collapsedCategories[id] = input.collapsed;
-      });
-      if (typeof window !== "undefined") {
-        writeStoredCollapsedCategories(
-          spaceId,
-          collapsedCategories,
-          window.localStorage
-        );
-      }
-      setCollapsedCategories(collapsedCategories, spaceId);
-      return collapsedCategories;
-    },
-    {
-      rejected: (state6, action) => {
-        console.error("\u6279\u91CF\u5207\u6362\u5206\u7C7B\u6298\u53E0\u72B6\u6001\u5931\u8D25:", action.error.message);
-      }
-    }
-  ),
-  /**
-   * 切换单个分类的折叠状态，并持久化存储。
-   * 直接使用当前激活的 spaceId，无需外部传入。
-   */
-  toggleCategoryCollapse: create.asyncThunk(
-    async (input, thunkAPI) => {
-      const { getState } = thunkAPI;
-      const { categoryId } = input;
-      const rootState = getState();
-      const spaceId = getCurrentSpaceId();
-      if (!spaceId) throw new Error("\u65E0\u6CD5\u5207\u6362\u6298\u53E0\u72B6\u6001\uFF1A\u6CA1\u6709\u6D3B\u52A8\u7684\u7A7A\u95F4\u3002");
-      if (!categoryId) throw new Error("\u65E0\u6548\u7684\u5206\u7C7BID\u3002");
-      const defaultCollapsed = DEFAULT_COLLAPSED_CATEGORIES[categoryId] ?? true;
-      const currentCollapsedCategories = getCollapsedCategories();
-      const isCurrentlyCollapsed = currentCollapsedCategories[categoryId] ?? defaultCollapsed;
-      const newCollapsedState = !isCurrentlyCollapsed;
-      const collapsedCategories = {
-        ...currentCollapsedCategories,
-        [categoryId]: newCollapsedState
-      };
-      if (typeof window !== "undefined") {
-        writeStoredCollapsedCategories(
-          spaceId,
-          collapsedCategories,
-          window.localStorage
-        );
-      }
-      toggleCategoryCollapse(categoryId);
-      return collapsedCategories;
-    },
-    {
-      rejected: (state6, action) => {
-        console.error("\u5207\u6362\u5206\u7C7B\u6298\u53E0\u72B6\u6001\u5931\u8D25:", action.error.message);
-      }
-    }
-  ),
-  /**
-   * 添加新分类
-   */
-  addCategory: create.asyncThunk(
-    async (input, thunkAPI) => {
-      const { spaceId: inputSpaceId, name, categoryId, order } = input;
-      const { dispatch, getState } = thunkAPI;
-      const rootState = getState();
-      const spaceId = inputSpaceId || getCurrentSpaceId();
-      if (!spaceId) {
-        throw new Error("\u65E0\u6CD5\u6DFB\u52A0\u5206\u7C7B\uFF1A\u672A\u9009\u62E9\u5F53\u524D\u7A7A\u95F4\u4E14\u672A\u63D0\u4F9B\u7A7A\u95F4 ID\u3002");
-      }
-      const currentUserId = selectIdentityUserId(rootState);
-      if (!currentUserId) throw new Error("User is not logged in.");
-      if (!name.trim()) {
-        throw new Error("\u65E0\u6548\u7684\u5206\u7C7B\u540D\u79F0\u3002");
-      }
-      const spaceKey = createSpaceKey.space(spaceId);
-      const spaceData = await dispatch(read({
-        dbKey: spaceKey
-      })).unwrap();
-      checkSpaceMembership(spaceData, currentUserId);
-      const newCategoryId = categoryId || ulid2();
-      if (spaceData.categories?.[newCategoryId]) {
-        throw new Error(`\u5206\u7C7B ID "${newCategoryId}" \u5DF2\u5B58\u5728\u3002`);
-      }
-      const existingValidCategories = spaceData.categories ? Object.values(spaceData.categories).filter(Boolean) : [];
-      const finalOrder = typeof order === "number" ? order : existingValidCategories.length;
-      const nowISO = (/* @__PURE__ */ new Date()).toISOString();
-      const newCategory = {
-        name: name.trim(),
-        order: finalOrder,
-        updatedAt: nowISO
-      };
-      const updatedSpaceData = await dispatch(
-        patch({
-          dbKey: spaceKey,
-          changes: {
-            categories: { [newCategoryId]: newCategory },
-            updatedAt: nowISO
-          }
-        })
-      ).unwrap();
-      const currentCollapsedCategories = getCollapsedCategories();
-      const collapsedCategories = {
-        ...currentCollapsedCategories,
-        [newCategoryId]: false
-      };
-      if (typeof window !== "undefined") {
-        writeStoredCollapsedCategories(
-          spaceId,
-          collapsedCategories,
-          window.localStorage
-        );
-      }
-      expandCategoryInCollapsed(newCategoryId, spaceId);
-      return { spaceId, updatedSpaceData, newCategoryId, collapsedCategories };
-    },
-    {
-      fulfilled: (state6, action) => {
-        if (getCurrentSpaceIdRaw() === action.payload.spaceId) {
-          updateCurrentSpaceIfMatch(action.payload.spaceId, action.payload.updatedSpaceData);
-        }
-      }
-    }
-  ),
-  /**
-    * 删除单个分类
-    */
-  deleteCategory: create.asyncThunk(
-    async (input, thunkAPI) => {
-      const { categoryId, spaceId } = input;
-      const { dispatch, getState } = thunkAPI;
-      const rootState = getState();
-      const currentUserId = selectIdentityUserId(rootState);
-      if (!currentUserId) throw new Error("User is not logged in.");
-      if (!categoryId.trim()) throw new Error("\u65E0\u6548\u7684 categoryId\u3002");
-      const spaceKey = createSpaceKey.space(spaceId);
-      const spaceData = await dispatch(read({
-        dbKey: spaceKey
-      })).unwrap();
-      checkSpaceMembership(spaceData, currentUserId);
-      if (!spaceData?.categories?.[categoryId]) {
-        throw new Error("\u6307\u5B9A\u7684\u5206\u7C7B\u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u5220\u9664\u3002");
-      }
-      const nowISO = (/* @__PURE__ */ new Date()).toISOString();
-      const changes = {
-        categories: { [categoryId]: null },
-        updatedAt: nowISO
-      };
-      if (spaceData.contents) {
-        const contentsPatch = {};
-        let contentsChanged = false;
-        for (const key in spaceData.contents) {
-          if (spaceData.contents[key]?.categoryId === categoryId) {
-            contentsPatch[key] = {
-              categoryId: null,
-              updatedAt: nowISO
-            };
-            contentsChanged = true;
-          }
-        }
-        if (contentsChanged) changes.contents = contentsPatch;
-      }
-      const updatedSpaceData = await dispatch(
-        patch({ dbKey: spaceKey, changes })
-      ).unwrap();
-      const collapsedCategories = { ...getCollapsedCategories() };
-      delete collapsedCategories[categoryId];
-      setCollapsedCategories(collapsedCategories, spaceId);
-      if (typeof window !== "undefined") {
-        writeStoredCollapsedCategories(
-          spaceId,
-          collapsedCategories,
-          window.localStorage
-        );
-      }
-      return { spaceId, updatedSpaceData, collapsedCategories };
-    },
-    {
-      fulfilled: (state6, action) => {
-        if (getCurrentSpaceIdRaw() === action.payload.spaceId) {
-          updateCurrentSpaceIfMatch(action.payload.spaceId, action.payload.updatedSpaceData);
-        }
-      }
-    }
-  ),
-  /**
-   * 修改分类名称
-   */
-  updateCategoryName: create.asyncThunk(
-    async (input, thunkAPI) => {
-      const { spaceId, categoryId, name } = input;
-      const { dispatch, getState } = thunkAPI;
-      const currentUserId = selectIdentityUserId(getState());
-      if (!currentUserId) throw new Error("User is not logged in.");
-      if (!categoryId.trim()) throw new Error("\u65E0\u6548\u7684 categoryId\u3002");
-      const trimmedName = name.trim();
-      if (!trimmedName) throw new Error("\u5206\u7C7B\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A\u6216\u4EC5\u5305\u542B\u7A7A\u683C\u3002");
-      const spaceKey = createSpaceKey.space(spaceId);
-      const spaceData = await dispatch(read({
-        dbKey: spaceKey
-      })).unwrap();
-      checkSpaceMembership(spaceData, currentUserId);
-      const existingCategory = spaceData.categories?.[categoryId];
-      if (!existingCategory) {
-        throw new Error("\u6307\u5B9A\u7684\u5206\u7C7B\u4E0D\u5B58\u5728\u3002");
-      }
-      const nowISO = (/* @__PURE__ */ new Date()).toISOString();
-      const changes = {
-        categories: {
-          [categoryId]: {
-            ...existingCategory,
-            name: trimmedName,
-            updatedAt: nowISO
-          }
-        },
-        updatedAt: nowISO
-      };
-      const updatedSpaceData = await dispatch(
-        patch({ dbKey: spaceKey, changes })
-      ).unwrap();
-      return { spaceId, updatedSpaceData };
-    },
-    {
-      fulfilled: (state6, action) => {
-        if (getCurrentSpaceIdRaw() === action.payload.spaceId) {
-          updateCurrentSpaceIfMatch(action.payload.spaceId, action.payload.updatedSpaceData);
-        }
-      }
-    }
-  ),
-  /**
-   * 重新排序分类
-   */
-  reorderCategories: create.asyncThunk(
-    async (input, thunkAPI) => {
-      const { spaceId, sortedCategoryIds } = input;
-      const { dispatch, getState } = thunkAPI;
-      const stateRoot = getState();
-      const currentUserId = selectIdentityUserId(stateRoot);
-      if (!currentUserId) {
-        throw new Error("User is not logged in.");
-      }
-      if (!Array.isArray(sortedCategoryIds)) {
-        throw new Error(
-          "Invalid sortedCategoryIds provided: must be an array."
-        );
-      }
-      const spaceKey = createSpaceKey.space(spaceId);
-      const spaceData = await dispatch(read({
-        dbKey: spaceKey
-      })).unwrap();
-      checkSpaceMembership(spaceData, currentUserId);
-      if (!spaceData.categories || Object.keys(spaceData.categories).length === 0) {
-        return { spaceId, updatedSpaceData: spaceData };
-      }
-      const nowISO = (/* @__PURE__ */ new Date()).toISOString();
-      const currentCategories = spaceData.categories;
-      const updatedCategoriesChanges = {};
-      let hasValidChanges = false;
-      sortedCategoryIds.forEach((catId, index) => {
-        const existingCategory = currentCategories[catId];
-        if (existingCategory) {
-          updatedCategoriesChanges[catId] = {
-            ...existingCategory,
-            order: index,
-            updatedAt: nowISO
-          };
-          if (existingCategory.order !== index) {
-            hasValidChanges = true;
-          }
-        }
-      });
-      if (!hasValidChanges) {
-        return { spaceId, updatedSpaceData: spaceData };
-      }
-      const changes = {
-        categories: updatedCategoriesChanges,
-        updatedAt: nowISO
-      };
-      const updatedSpaceData = await dispatch(
-        patch({ dbKey: spaceKey, changes })
-      ).unwrap();
-      return { spaceId, updatedSpaceData };
-    },
-    {
-      fulfilled: (state6, action) => {
-        if (getCurrentSpaceIdRaw() === action.payload.spaceId) {
-          updateCurrentSpaceIfMatch(action.payload.spaceId, action.payload.updatedSpaceData);
-        }
-      }
-    }
-  )
-});
-
 // packages/render/table/tableSlice.ts
 var import_date_fns2 = __toESM(require_date_fns(), 1);
-import { ulid as ulid4 } from "ulid";
+import { ulid as ulid3 } from "ulid";
 
 // packages/render/table/fetchAndCacheTableRows.ts
 var getRowTimestamp = (row) => {
@@ -1133,7 +564,7 @@ function addColumnOptionInMeta(meta, input, deps) {
 
 // packages/render/table/createTableAction.ts
 var import_date_fns = __toESM(require_date_fns(), 1);
-import { ulid as ulid3 } from "ulid";
+import { ulid as ulid2 } from "ulid";
 
 // node_modules/i18next/dist/esm/i18next.js
 var isString = (obj) => typeof obj === "string";
@@ -3509,10 +2940,10 @@ var loadNamespaces = instance.loadNamespaces;
 var loadLanguages = instance.loadLanguages;
 
 // node_modules/react-i18next/dist/es/Trans.js
-var import_react5 = __toESM(require_react(), 1);
+var import_react3 = __toESM(require_react(), 1);
 
 // node_modules/react-i18next/dist/es/TransWithoutContext.js
-var import_react3 = __toESM(require_react(), 1);
+var import_react = __toESM(require_react(), 1);
 var import_html_parse_stringify = __toESM(require_html_parse_stringify(), 1);
 
 // node_modules/react-i18next/dist/es/unescape.js
@@ -3568,7 +2999,7 @@ var setI18n = (instance2) => {
 };
 
 // node_modules/react-i18next/dist/es/context.js
-var import_react4 = __toESM(require_react(), 1);
+var import_react2 = __toESM(require_react(), 1);
 
 // node_modules/react-i18next/dist/es/initReactI18next.js
 var initReactI18next = {
@@ -3580,22 +3011,22 @@ var initReactI18next = {
 };
 
 // node_modules/react-i18next/dist/es/context.js
-var I18nContext = (0, import_react4.createContext)();
+var I18nContext = (0, import_react2.createContext)();
 
 // node_modules/react-i18next/dist/es/useTranslation.js
-var import_react6 = __toESM(require_react(), 1);
+var import_react4 = __toESM(require_react(), 1);
 
 // node_modules/react-i18next/dist/es/withTranslation.js
-var import_react7 = __toESM(require_react(), 1);
+var import_react5 = __toESM(require_react(), 1);
 
 // node_modules/react-i18next/dist/es/I18nextProvider.js
-var import_react8 = __toESM(require_react(), 1);
+var import_react6 = __toESM(require_react(), 1);
 
 // node_modules/react-i18next/dist/es/withSSR.js
-var import_react10 = __toESM(require_react(), 1);
+var import_react8 = __toESM(require_react(), 1);
 
 // node_modules/react-i18next/dist/es/useSSR.js
-var import_react9 = __toESM(require_react(), 1);
+var import_react7 = __toESM(require_react(), 1);
 
 // packages/app/i18n/i18n.base.ts
 var i18nBaseConfig = {
@@ -3646,7 +3077,7 @@ var normalizeColumns = (inputColumns) => {
     const name = c.name.trim();
     if (!name) return null;
     const col = {
-      id: asOptionalTrimmedString(c.id) ?? ulid3(),
+      id: asOptionalTrimmedString(c.id) ?? ulid2(),
       name
     };
     const label = asOptionalTrimmedString(c.label);
@@ -3678,7 +3109,7 @@ var normalizeColumns = (inputColumns) => {
   }
   return DEFAULT_COLUMNS.map((c) => ({
     ...c,
-    id: ulid3()
+    id: ulid2()
   }));
 };
 var normalizeStringArray = (value) => {
@@ -3717,11 +3148,11 @@ var createTableAction = async ({
   columns,
   withDefaultRows = true
 } = {}, { dispatch, getState }) => {
-  const state6 = getState();
-  const userId = selectIdentityUserId(state6);
+  const state2 = getState();
+  const userId = selectIdentityUserId(state2);
   if (!userId) throw new Error("User ID not found.");
   const spaceId = customSpaceId ?? getCurrentSpaceId();
-  const tableId = ulid3();
+  const tableId = ulid2();
   const now = /* @__PURE__ */ new Date();
   const nowIso = (0, import_date_fns.formatISO)(now);
   const dbKey = metaKey(userId, tableId);
@@ -3848,8 +3279,8 @@ var deleteTableAction = async ({ dbKey }, {
   extra
 }) => {
   const { db } = extra;
-  const state6 = getState();
-  const { currentServer, syncServers } = getRuntimeServerContext(state6);
+  const state2 = getState();
+  const { currentServer, syncServers } = getRuntimeServerContext(state2);
   const { tenantId, tableId } = parseMetaKey(dbKey);
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   const rowPrefix = createKey("row", tenantId, tableId, "");
@@ -3904,7 +3335,7 @@ var deleteTableAction = async ({ dbKey }, {
     syncServers,
     dbKey,
     deleteOptions: { type: "table" },
-    state: state6
+    state: state2
   });
   return dbKey;
 };
@@ -3939,37 +3370,37 @@ var tableSlice = createSliceWithThunks({
         const { tenantId, tableId } = args;
         const dbKey = metaKey(tenantId, tableId);
         try {
-          const readAction2 = await dispatch(readAndWait(dbKey));
-          if (readAndWait.fulfilled.match(readAction2) && readAction2.payload) {
-            const meta = readAction2.payload;
+          const readAction = await dispatch(readAndWait(dbKey));
+          if (readAndWait.fulfilled.match(readAction) && readAction.payload) {
+            const meta = readAction.payload;
             return meta;
           }
-          const msg = readAction2.payload?.message || `\u65E0\u6CD5\u52A0\u8F7D\u8868 ${tableId}`;
+          const msg = readAction.payload?.message || `\u65E0\u6CD5\u52A0\u8F7D\u8868 ${tableId}`;
           return rejectWithValue(msg);
         } catch (e) {
           return rejectWithValue(e.message || `\u521D\u59CB\u5316\u8868 ${tableId} \u65F6\u51FA\u9519`);
         }
       },
       {
-        pending: (state6) => {
-          state6.isLoading = true;
-          state6.error = null;
-          state6.isInitialized = false;
-          state6.currentTable = null;
-          state6.rows = [];
+        pending: (state2) => {
+          state2.isLoading = true;
+          state2.error = null;
+          state2.isInitialized = false;
+          state2.currentTable = null;
+          state2.rows = [];
         },
-        fulfilled: (state6, action) => {
-          state6.isLoading = false;
-          state6.isInitialized = true;
-          state6.currentTable = action.payload;
-          state6.error = null;
+        fulfilled: (state2, action) => {
+          state2.isLoading = false;
+          state2.isInitialized = true;
+          state2.currentTable = action.payload;
+          state2.error = null;
         },
-        rejected: (state6, action) => {
-          state6.isLoading = false;
-          state6.isInitialized = true;
-          state6.currentTable = null;
-          state6.error = action.payload || action.error.message || "\u521D\u59CB\u5316\u8868\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
-          state6.rows = [];
+        rejected: (state2, action) => {
+          state2.isLoading = false;
+          state2.isInitialized = true;
+          state2.currentTable = null;
+          state2.error = action.payload || action.error.message || "\u521D\u59CB\u5316\u8868\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+          state2.rows = [];
         }
       }
     ),
@@ -3981,8 +3412,8 @@ var tableSlice = createSliceWithThunks({
         const { tenantId, tableId } = args;
         const { db } = extra;
         try {
-          const state6 = getState();
-          const { currentToken: token, remoteServers } = getRuntimeServerContext(state6);
+          const state2 = getState();
+          const { currentToken: token, remoteServers } = getRuntimeServerContext(state2);
           return await fetchAndCacheTableRows({
             db,
             tenantId,
@@ -3995,15 +3426,15 @@ var tableSlice = createSliceWithThunks({
         }
       },
       {
-        pending: (state6) => {
-          state6.error = null;
+        pending: (state2) => {
+          state2.error = null;
         },
-        fulfilled: (state6, action) => {
-          state6.rows = action.payload;
+        fulfilled: (state2, action) => {
+          state2.rows = action.payload;
         },
-        rejected: (state6, action) => {
-          state6.error = action.payload || action.error.message || "\u52A0\u8F7D\u8868\u884C\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
-          state6.rows = [];
+        rejected: (state2, action) => {
+          state2.error = action.payload || action.error.message || "\u52A0\u8F7D\u8868\u884C\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+          state2.rows = [];
         }
       }
     ),
@@ -4038,18 +3469,18 @@ var tableSlice = createSliceWithThunks({
         }
       },
       {
-        pending: (state6) => {
-          state6.error = null;
+        pending: (state2) => {
+          state2.error = null;
         },
-        fulfilled: (state6, action) => {
+        fulfilled: (state2, action) => {
           const row = action.payload;
-          const meta = state6.currentTable;
+          const meta = state2.currentTable;
           if (meta && row?.tenantId === meta.tenantId && row?.tableId === meta.tableId) {
-            state6.rows.push(row);
+            state2.rows.push(row);
           }
         },
-        rejected: (state6, action) => {
-          state6.error = action.payload || action.error.message || "\u65B0\u589E\u8868\u884C\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        rejected: (state2, action) => {
+          state2.error = action.payload || action.error.message || "\u65B0\u589E\u8868\u884C\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
         }
       }
     ),
@@ -4059,8 +3490,8 @@ var tableSlice = createSliceWithThunks({
     deleteRow: create.asyncThunk(
       async (dbKey, { dispatch, getState, rejectWithValue, extra }) => {
         try {
-          const state6 = getState();
-          const row = state6.table.rows.find((item) => item?.dbKey === dbKey);
+          const state2 = getState();
+          const row = state2.table.rows.find((item) => item?.dbKey === dbKey);
           if (!row) {
             return rejectWithValue(`\u5F53\u524D\u8868\u4E2D\u627E\u4E0D\u5230\u8981\u5220\u9664\u7684\u884C\uFF1A${dbKey}`);
           }
@@ -4075,7 +3506,7 @@ var tableSlice = createSliceWithThunks({
             await extra.db.put(dbKey, tombstoneRow);
           }
           dispatch(upsertSSREntity(tombstoneRow));
-          const { currentServer, syncServers } = getRuntimeServerContext(state6);
+          const { currentServer, syncServers } = getRuntimeServerContext(state2);
           const servers = resolveReplicationServers(currentServer, syncServers);
           scheduleWriteReplication(
             servers,
@@ -4083,7 +3514,7 @@ var tableSlice = createSliceWithThunks({
               data: tombstoneRow,
               customKey: dbKey
             },
-            state6
+            state2
           );
           return dbKey;
         } catch (e) {
@@ -4091,15 +3522,15 @@ var tableSlice = createSliceWithThunks({
         }
       },
       {
-        pending: (state6) => {
-          state6.error = null;
+        pending: (state2) => {
+          state2.error = null;
         },
-        fulfilled: (state6, action) => {
+        fulfilled: (state2, action) => {
           const dbKey = action.payload;
-          state6.rows = state6.rows.filter((row) => row.dbKey !== dbKey);
+          state2.rows = state2.rows.filter((row) => row.dbKey !== dbKey);
         },
-        rejected: (state6, action) => {
-          state6.error = action.payload || action.error.message || "\u5220\u9664\u8868\u884C\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        rejected: (state2, action) => {
+          state2.error = action.payload || action.error.message || "\u5220\u9664\u8868\u884C\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
         }
       }
     ),
@@ -4109,19 +3540,19 @@ var tableSlice = createSliceWithThunks({
     deleteTable: create.asyncThunk(
       deleteTableAction,
       {
-        pending: (state6) => {
-          state6.error = null;
+        pending: (state2) => {
+          state2.error = null;
         },
-        fulfilled: (state6, action) => {
+        fulfilled: (state2, action) => {
           const deletedKey = action.payload;
-          if (state6.currentTable?.dbKey === deletedKey) {
-            state6.currentTable = null;
-            state6.rows = [];
-            state6.isInitialized = false;
+          if (state2.currentTable?.dbKey === deletedKey) {
+            state2.currentTable = null;
+            state2.rows = [];
+            state2.isInitialized = false;
           }
         },
-        rejected: (state6, action) => {
-          state6.error = action.payload || action.error.message || "\u5220\u9664\u8868\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        rejected: (state2, action) => {
+          state2.error = action.payload || action.error.message || "\u5220\u9664\u8868\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
         }
       }
     ),
@@ -4131,15 +3562,15 @@ var tableSlice = createSliceWithThunks({
     addColumn: create.asyncThunk(
       async (args, { dispatch, getState, rejectWithValue }) => {
         const { tenantId, tableId, columnName } = args;
-        const state6 = getState().table;
-        const meta = state6.currentTable;
+        const state2 = getState().table;
+        const meta = state2.currentTable;
         if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
           return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
         }
         const result = addColumnToMeta(
           meta,
           { columnName },
-          { id: ulid4(), nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
+          { id: ulid3(), nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
         );
         if (!result.ok) {
           return rejectWithValue(result.error);
@@ -4157,15 +3588,15 @@ var tableSlice = createSliceWithThunks({
         }
       },
       {
-        pending: (state6) => {
-          state6.error = null;
+        pending: (state2) => {
+          state2.error = null;
         },
-        fulfilled: (state6, action) => {
-          state6.currentTable = action.payload;
-          state6.isInitialized = true;
+        fulfilled: (state2, action) => {
+          state2.currentTable = action.payload;
+          state2.isInitialized = true;
         },
-        rejected: (state6, action) => {
-          state6.error = action.payload || action.error.message || "\u4E3A\u8868\u65B0\u589E\u5B57\u6BB5\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        rejected: (state2, action) => {
+          state2.error = action.payload || action.error.message || "\u4E3A\u8868\u65B0\u589E\u5B57\u6BB5\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
         }
       }
     ),
@@ -4175,14 +3606,14 @@ var tableSlice = createSliceWithThunks({
     deleteColumn: create.asyncThunk(
       async (args, { dispatch, getState, rejectWithValue }) => {
         const { tenantId, tableId, columnName } = args;
-        const state6 = getState().table;
-        const meta = state6.currentTable;
+        const state2 = getState().table;
+        const meta = state2.currentTable;
         if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
           return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
         }
         const result = deleteColumnFromMeta(
           meta,
-          state6.rows,
+          state2.rows,
           { columnName },
           { nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
         );
@@ -4203,16 +3634,16 @@ var tableSlice = createSliceWithThunks({
         }
       },
       {
-        pending: (state6) => {
-          state6.error = null;
+        pending: (state2) => {
+          state2.error = null;
         },
-        fulfilled: (state6, action) => {
-          state6.currentTable = action.payload.meta;
-          state6.rows = action.payload.rows;
-          state6.isInitialized = true;
+        fulfilled: (state2, action) => {
+          state2.currentTable = action.payload.meta;
+          state2.rows = action.payload.rows;
+          state2.isInitialized = true;
         },
-        rejected: (state6, action) => {
-          state6.error = action.payload || action.error.message || "\u5220\u9664\u5B57\u6BB5\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        rejected: (state2, action) => {
+          state2.error = action.payload || action.error.message || "\u5220\u9664\u5B57\u6BB5\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
         }
       }
     ),
@@ -4222,8 +3653,8 @@ var tableSlice = createSliceWithThunks({
     reorderColumn: create.asyncThunk(
       async (args, { dispatch, getState, rejectWithValue }) => {
         const { tenantId, tableId, fromIndex, toIndex } = args;
-        const state6 = getState().table;
-        const meta = state6.currentTable;
+        const state2 = getState().table;
+        const meta = state2.currentTable;
         if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
           return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
         }
@@ -4249,15 +3680,15 @@ var tableSlice = createSliceWithThunks({
         }
       },
       {
-        pending: (state6) => {
-          state6.error = null;
+        pending: (state2) => {
+          state2.error = null;
         },
-        fulfilled: (state6, action) => {
-          state6.currentTable = action.payload;
-          state6.isInitialized = true;
+        fulfilled: (state2, action) => {
+          state2.currentTable = action.payload;
+          state2.isInitialized = true;
         },
-        rejected: (state6, action) => {
-          state6.error = action.payload || action.error.message || "\u8C03\u6574\u5217\u987A\u5E8F\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        rejected: (state2, action) => {
+          state2.error = action.payload || action.error.message || "\u8C03\u6574\u5217\u987A\u5E8F\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
         }
       }
     ),
@@ -4269,14 +3700,14 @@ var tableSlice = createSliceWithThunks({
     renameColumn: create.asyncThunk(
       async (args, { dispatch, getState, rejectWithValue }) => {
         const { tenantId, tableId, oldName, newName } = args;
-        const state6 = getState().table;
-        const meta = state6.currentTable;
+        const state2 = getState().table;
+        const meta = state2.currentTable;
         if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
           return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
         }
         const result = renameColumnInMeta(
           meta,
-          state6.rows,
+          state2.rows,
           { oldName, newName },
           { nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
         );
@@ -4297,16 +3728,16 @@ var tableSlice = createSliceWithThunks({
         }
       },
       {
-        pending: (state6) => {
-          state6.error = null;
+        pending: (state2) => {
+          state2.error = null;
         },
-        fulfilled: (state6, action) => {
-          state6.currentTable = action.payload.meta;
-          state6.rows = action.payload.rows;
-          state6.isInitialized = true;
+        fulfilled: (state2, action) => {
+          state2.currentTable = action.payload.meta;
+          state2.rows = action.payload.rows;
+          state2.isInitialized = true;
         },
-        rejected: (state6, action) => {
-          state6.error = action.payload || action.error.message || "\u91CD\u547D\u540D\u5B57\u6BB5\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        rejected: (state2, action) => {
+          state2.error = action.payload || action.error.message || "\u91CD\u547D\u540D\u5B57\u6BB5\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
         }
       }
     ),
@@ -4318,8 +3749,8 @@ var tableSlice = createSliceWithThunks({
     renameColumnLabel: create.asyncThunk(
       async (args, { dispatch, getState, rejectWithValue }) => {
         const { tenantId, tableId, columnId, newLabel } = args;
-        const state6 = getState().table;
-        const meta = state6.currentTable;
+        const state2 = getState().table;
+        const meta = state2.currentTable;
         if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
           return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
         }
@@ -4342,15 +3773,15 @@ var tableSlice = createSliceWithThunks({
         }
       },
       {
-        pending: (state6) => {
-          state6.error = null;
+        pending: (state2) => {
+          state2.error = null;
         },
-        fulfilled: (state6, action) => {
-          state6.currentTable = action.payload;
-          state6.isInitialized = true;
+        fulfilled: (state2, action) => {
+          state2.currentTable = action.payload;
+          state2.isInitialized = true;
         },
-        rejected: (state6, action) => {
-          state6.error = action.payload || action.error.message || "\u91CD\u547D\u540D\u5B57\u6BB5\u663E\u793A\u540D\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        rejected: (state2, action) => {
+          state2.error = action.payload || action.error.message || "\u91CD\u547D\u540D\u5B57\u6BB5\u663E\u793A\u540D\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
         }
       }
     ),
@@ -4361,8 +3792,8 @@ var tableSlice = createSliceWithThunks({
     updateColumnWidth: create.asyncThunk(
       async (args, { dispatch, getState, rejectWithValue }) => {
         const { tenantId, tableId, columnId, width } = args;
-        const state6 = getState().table;
-        const meta = state6.currentTable;
+        const state2 = getState().table;
+        const meta = state2.currentTable;
         if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
           return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
         }
@@ -4385,15 +3816,15 @@ var tableSlice = createSliceWithThunks({
         }
       },
       {
-        pending: (state6) => {
-          state6.error = null;
+        pending: (state2) => {
+          state2.error = null;
         },
-        fulfilled: (state6, action) => {
-          state6.currentTable = action.payload;
-          state6.isInitialized = true;
+        fulfilled: (state2, action) => {
+          state2.currentTable = action.payload;
+          state2.isInitialized = true;
         },
-        rejected: (state6, action) => {
-          state6.error = action.payload || action.error.message || "\u66F4\u65B0\u5B57\u6BB5\u5BBD\u5EA6\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        rejected: (state2, action) => {
+          state2.error = action.payload || action.error.message || "\u66F4\u65B0\u5B57\u6BB5\u5BBD\u5EA6\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
         }
       }
     ),
@@ -4405,8 +3836,8 @@ var tableSlice = createSliceWithThunks({
     addColumnOption: create.asyncThunk(
       async (args, { dispatch, getState, rejectWithValue }) => {
         const { tenantId, tableId, columnId, option } = args;
-        const state6 = getState().table;
-        const meta = state6.currentTable;
+        const state2 = getState().table;
+        const meta = state2.currentTable;
         if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
           return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
         }
@@ -4432,15 +3863,15 @@ var tableSlice = createSliceWithThunks({
         }
       },
       {
-        pending: (state6) => {
-          state6.error = null;
+        pending: (state2) => {
+          state2.error = null;
         },
-        fulfilled: (state6, action) => {
-          state6.currentTable = action.payload;
-          state6.isInitialized = true;
+        fulfilled: (state2, action) => {
+          state2.currentTable = action.payload;
+          state2.isInitialized = true;
         },
-        rejected: (state6, action) => {
-          state6.error = action.payload || action.error.message || "\u65B0\u589E\u9009\u9879\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        rejected: (state2, action) => {
+          state2.error = action.payload || action.error.message || "\u65B0\u589E\u9009\u9879\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
         }
       }
     ),
@@ -4454,8 +3885,8 @@ var tableSlice = createSliceWithThunks({
         if (!trimmedName) {
           return rejectWithValue("\u8868\u540D\u4E0D\u80FD\u4E3A\u7A7A");
         }
-        const state6 = getState().table;
-        const meta = state6.currentTable;
+        const state2 = getState().table;
+        const meta = state2.currentTable;
         if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
           return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
         }
@@ -4481,22 +3912,22 @@ var tableSlice = createSliceWithThunks({
         }
       },
       {
-        pending: (state6) => {
-          state6.error = null;
+        pending: (state2) => {
+          state2.error = null;
         },
-        fulfilled: (state6, action) => {
-          state6.currentTable = action.payload;
+        fulfilled: (state2, action) => {
+          state2.currentTable = action.payload;
         },
-        rejected: (state6, action) => {
-          state6.error = action.payload || action.error.message || "\u91CD\u547D\u540D\u8868\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        rejected: (state2, action) => {
+          state2.error = action.payload || action.error.message || "\u91CD\u547D\u540D\u8868\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
         }
       }
     ),
     updateTableIcon: create.asyncThunk(
       async (args, { dispatch, getState, rejectWithValue }) => {
         const { tenantId, tableId, icon } = args;
-        const state6 = getState().table;
-        const meta = state6.currentTable;
+        const state2 = getState().table;
+        const meta = state2.currentTable;
         if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
           return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
         }
@@ -4522,14 +3953,14 @@ var tableSlice = createSliceWithThunks({
         }
       },
       {
-        pending: (state6) => {
-          state6.error = null;
+        pending: (state2) => {
+          state2.error = null;
         },
-        fulfilled: (state6, action) => {
-          state6.currentTable = action.payload;
+        fulfilled: (state2, action) => {
+          state2.currentTable = action.payload;
         },
-        rejected: (state6, action) => {
-          state6.error = action.payload || action.error.message || "\u66F4\u65B0\u8868\u683C\u56FE\u6807\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        rejected: (state2, action) => {
+          state2.error = action.payload || action.error.message || "\u66F4\u65B0\u8868\u683C\u56FE\u6807\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
         }
       }
     ),
@@ -4556,19 +3987,19 @@ var tableSlice = createSliceWithThunks({
         }
       },
       {
-        pending: (state6) => {
-          state6.error = null;
+        pending: (state2) => {
+          state2.error = null;
         },
-        fulfilled: (state6, action) => {
+        fulfilled: (state2, action) => {
           const { dbKey, columnName, value, updatedAt } = action.payload;
-          const row = state6.rows.find((r) => r.dbKey === dbKey);
+          const row = state2.rows.find((r) => r.dbKey === dbKey);
           if (row) {
             row[columnName] = value;
             row.updatedAt = updatedAt;
           }
         },
-        rejected: (state6, action) => {
-          state6.error = action.payload || action.error.message || "\u66F4\u65B0\u5355\u5143\u683C\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        rejected: (state2, action) => {
+          state2.error = action.payload || action.error.message || "\u66F4\u65B0\u5355\u5143\u683C\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
         }
       }
     ),
@@ -4576,12 +4007,12 @@ var tableSlice = createSliceWithThunks({
      * 5. 重置当前表状态
      * ------------------------------------*/
     setTableFocusContext: create.reducer(
-      (state6, action) => {
-        state6.focusContext = action.payload;
+      (state2, action) => {
+        state2.focusContext = action.payload;
       }
     ),
-    resetTable: create.reducer((state6) => {
-      Object.assign(state6, initialState);
+    resetTable: create.reducer((state2) => {
+      Object.assign(state2, initialState);
     })
   }),
   selectors: {
@@ -4659,11 +4090,11 @@ var ENTITY_DELETE_STRATEGIES = {
     await dispatch(deleteTable({ dbKey: key })).unwrap();
   },
   file: async (key, { thunkAPI }) => {
-    const { deleteFileAction } = await import("./deleteFile-NPZ64DFN.js");
+    const { deleteFileAction } = await import("./deleteFile-JYKRT7C3.js");
     await deleteFileAction(key, thunkAPI);
   },
   image: async (key, { thunkAPI }) => {
-    const { deleteFileAction } = await import("./deleteFile-NPZ64DFN.js");
+    const { deleteFileAction } = await import("./deleteFile-JYKRT7C3.js");
     await deleteFileAction(key, thunkAPI);
   },
   agent: async (key, { dispatch, userId, sourceServerOrigin }) => {
@@ -4759,7 +4190,7 @@ var deleteContentFromSpaceAction = async (input, thunkAPI) => {
 };
 
 // packages/create/space/content/moveContentAction.ts
-var logger2 = createClientLogger("move-content");
+var logger = createClientLogger("move-content");
 var moveContentAction = async (input, thunkAPI) => {
   const {
     contentKey,
@@ -4768,18 +4199,18 @@ var moveContentAction = async (input, thunkAPI) => {
     targetCategoryId: rawTargetCategoryId
   } = input;
   const { dispatch, getState } = thunkAPI;
-  const state6 = getState();
-  const userId = selectIdentityUserId(state6);
+  const state2 = getState();
+  const userId = selectIdentityUserId(state2);
   const now = Date.now();
-  logger2.info({ ...input, userId }, "Initiating moveContentAction");
+  logger.info({ ...input, userId }, "Initiating moveContentAction");
   if (sourceSpaceId === targetSpaceId) {
-    logger2.error("Source and target space IDs are the same.");
+    logger.error("Source and target space IDs are the same.");
     throw new Error(
       "\u6E90\u7A7A\u95F4\u548C\u76EE\u6807\u7A7A\u95F4\u4E0D\u80FD\u76F8\u540C\u3002\u5982\u9700\u4FEE\u6539\u5206\u7C7B\uFF0C\u8BF7\u4F7F\u7528\u66F4\u65B0\u5206\u7C7B\u64CD\u4F5C\u3002"
     );
   }
   if (!contentKey || typeof contentKey !== "string" || contentKey.trim() === "") {
-    logger2.error("Invalid contentKey provided.");
+    logger.error("Invalid contentKey provided.");
     throw new Error("\u65E0\u6548\u7684\u5185\u5BB9 Key\u3002");
   }
   let sourceSpaceData = null;
@@ -4791,7 +4222,7 @@ var moveContentAction = async (input, thunkAPI) => {
   try {
     const sourceSpaceKey = createSpaceKey.space(sourceSpaceId);
     const targetSpaceKey = createSpaceKey.space(targetSpaceId);
-    logger2.info(
+    logger.info(
       { sourceSpaceKey, targetSpaceKey },
       "Reading source and target space data."
     );
@@ -4817,11 +4248,11 @@ var moveContentAction = async (input, thunkAPI) => {
       );
     }
     targetSpaceData = targetResult.value;
-    logger2.info("Checking permissions for source and target spaces.");
+    logger.info("Checking permissions for source and target spaces.");
     checkSpaceMembership(sourceSpaceData, userId);
     checkSpaceMembership(targetSpaceData, userId);
     if (!sourceSpaceData.contents || !sourceSpaceData.contents[contentKey]) {
-      logger2.error(
+      logger.error(
         { contentKey, sourceSpaceId },
         "Content key not found in source space contents."
       );
@@ -4831,7 +4262,7 @@ var moveContentAction = async (input, thunkAPI) => {
     }
     contentDataFromSource = sourceSpaceData.contents[contentKey];
     if (targetSpaceData.contents && targetSpaceData.contents[contentKey]) {
-      logger2.warn(
+      logger.warn(
         { contentKey, targetSpaceId },
         "Content key already exists in target space. Overwriting."
       );
@@ -4841,7 +4272,7 @@ var moveContentAction = async (input, thunkAPI) => {
       if (targetSpaceData.categories?.[rawTargetCategoryId]) {
         categoryIdForTargetStorage = rawTargetCategoryId;
       } else {
-        logger2.warn(
+        logger.warn(
           `Target category ${rawTargetCategoryId} not found in target space ${targetSpaceId}. Content will be uncategorized.`
         );
         categoryIdForTargetStorage = void 0;
@@ -4873,7 +4304,7 @@ var moveContentAction = async (input, thunkAPI) => {
       updatedAt: now,
       ...localSpaceAuthorityPatchStamp(targetSpaceData)
     };
-    logger2.info("Patching source and target space data.");
+    logger.info("Patching source and target space data.");
     await Promise.all([
       dispatch(
         patch({ dbKey: sourceSpaceKey, changes: sourcePatchChanges })
@@ -4882,15 +4313,15 @@ var moveContentAction = async (input, thunkAPI) => {
         patch({ dbKey: targetSpaceKey, changes: targetPatchChanges })
       ).unwrap()
     ]);
-    logger2.info("Successfully patched both source and target spaces.");
+    logger.info("Successfully patched both source and target spaces.");
   } catch (error) {
-    logger2.error(
+    logger.error(
       { error: error.message, stack: error.stack },
       "Error during move content action execution."
     );
     overallError = error.message || "\u79FB\u52A8\u5185\u5BB9\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
   } finally {
-    logger2.info("Attempting to re-read final space data.");
+    logger.info("Attempting to re-read final space data.");
     const sourceSpaceKey = createSpaceKey.space(sourceSpaceId);
     const targetSpaceKey = createSpaceKey.space(targetSpaceId);
     const [finalSourceResult, finalTargetResult] = await Promise.allSettled([
@@ -4904,7 +4335,7 @@ var moveContentAction = async (input, thunkAPI) => {
     if (finalSourceResult.status === "fulfilled") {
       finalSourceData = finalSourceResult.value;
     } else {
-      logger2.error(
+      logger.error(
         { sourceSpaceId, reason: finalSourceResult.reason },
         "Failed to re-read final source space data."
       );
@@ -4912,12 +4343,12 @@ var moveContentAction = async (input, thunkAPI) => {
     if (finalTargetResult.status === "fulfilled") {
       finalTargetData = finalTargetResult.value;
     } else {
-      logger2.error(
+      logger.error(
         { targetSpaceId, reason: finalTargetResult.reason },
         "Failed to re-read final target space data."
       );
     }
-    logger2.info(
+    logger.info(
       {
         hasError: !!overallError,
         sourceReadSuccess: !!finalSourceData,
@@ -5123,8 +4554,8 @@ var updateContentPinnedAction = async (input, thunkAPI) => {
 var updateContentCategoryAction = async (input, thunkAPI) => {
   const { spaceId, contentKey, categoryId: targetContainerId } = input;
   const { dispatch, getState } = thunkAPI;
-  const state6 = getState();
-  const userId = selectIdentityUserId(state6);
+  const state2 = getState();
+  const userId = selectIdentityUserId(state2);
   if (!userId) {
     throw new Error("User is not logged in.");
   }
@@ -5220,17 +4651,17 @@ var updateContentCategoryAction = async (input, thunkAPI) => {
 };
 
 // packages/create/space/content/deleteMultipleContentAction.ts
-var logger3 = createClientLogger("delete-multiple-content");
+var logger2 = createClientLogger("delete-multiple-content");
 var deleteMultipleContentAction = async (input, thunkAPI) => {
   const { contentKeys, spaceId } = input;
   if (!contentKeys || contentKeys.length === 0) {
-    logger3.warn("deleteMultipleContentAction called with no contentKeys.");
+    logger2.warn("deleteMultipleContentAction called with no contentKeys.");
     return { spaceId, updatedSpaceData: null };
   }
   const { dispatch, getState } = thunkAPI;
-  const state6 = getState();
-  const userId = selectIdentityUserId(state6);
-  logger3.info(
+  const state2 = getState();
+  const userId = selectIdentityUserId(state2);
+  logger2.info(
     { count: contentKeys.length, spaceId, userId },
     "Initiating deleteMultipleContentAction"
   );
@@ -5241,11 +4672,11 @@ var deleteMultipleContentAction = async (input, thunkAPI) => {
     })
   ).unwrap();
   if (!spaceData) {
-    logger3.error({ spaceKey }, "Space data not found for batch delete");
+    logger2.error({ spaceKey }, "Space data not found for batch delete");
     throw new Error("\u7A7A\u95F4\u4E0D\u5B58\u5728");
   }
   if (!userId || !spaceData.members.includes(userId)) {
-    logger3.warn({ userId, spaceId }, "Unauthorized attempt for batch delete");
+    logger2.warn({ userId, spaceId }, "Unauthorized attempt for batch delete");
     throw new Error("\u65E0\u6743\u4FEE\u6539\u6B64\u7A7A\u95F4");
   }
   const changes = {
@@ -5259,12 +4690,12 @@ var deleteMultipleContentAction = async (input, thunkAPI) => {
   };
   try {
     await dispatch(patch({ dbKey: spaceKey, changes })).unwrap();
-    logger3.info(
+    logger2.info(
       { spaceKey, count: contentKeys.length },
       "Successfully batched patch to remove content references"
     );
   } catch (patchError) {
-    logger3.error(
+    logger2.error(
       { error: patchError, spaceKey },
       "Failed to batch patch space data. Aborting."
     );
@@ -5276,9 +4707,9 @@ var deleteMultipleContentAction = async (input, thunkAPI) => {
   const results = await Promise.allSettled(removePromises);
   results.forEach((result, index) => {
     if (result.status === "fulfilled") {
-      logger3.info({ contentKey: contentKeys[index] }, "Entity removed");
+      logger2.info({ contentKey: contentKeys[index] }, "Entity removed");
     } else {
-      logger3.error(
+      logger2.error(
         { contentKey: contentKeys[index], error: result.reason },
         "Failed to remove an entity"
       );
@@ -5289,7 +4720,7 @@ var deleteMultipleContentAction = async (input, thunkAPI) => {
       dbKey: spaceKey
     })
   ).unwrap();
-  logger3.info({ spaceId }, "Finished batch delete and refetched space data.");
+  logger2.info({ spaceId }, "Finished batch delete and refetched space data.");
   return {
     spaceId,
     updatedSpaceData: finalSpaceData
@@ -5300,8 +4731,8 @@ var deleteMultipleContentAction = async (input, thunkAPI) => {
 var uploadAndAddFileToSpaceAction = async (payload, thunkAPI) => {
   const { spaceId, file, categoryId } = payload;
   const { dispatch, getState } = thunkAPI;
-  const state6 = getState();
-  const userId = selectIdentityUserId(state6);
+  const state2 = getState();
+  const userId = selectIdentityUserId(state2);
   if (!userId) {
     console.warn("[uploadAndAddFileToSpace] Warning: No userId found in state. Uploading as anonymous/unknown might cause issues.");
   }
@@ -5356,2242 +4787,270 @@ var uploadAndAddFileToSpaceAction = async (payload, thunkAPI) => {
   }
 };
 
-// packages/create/space/content/contentThunks.ts
-var createContentThunks = (create) => ({
-  /**
-   * Add content into a space. When the content lands in a real category,
-   * force-expand that category (Redux + localStorage) so "create page"
-   * never leaves the new item trapped inside a default-collapsed section.
-   */
-  addContentToSpace: create.asyncThunk(
-    async (input, thunkAPI) => {
-      const result = await addContentAction(input, thunkAPI);
-      const rawCategoryId = asTrimmedString(input.categoryId);
-      const expandCategoryId = rawCategoryId && rawCategoryId !== UNCATEGORIZED_ID ? rawCategoryId : null;
-      if (expandCategoryId) {
-        const collapsedCategories = {
-          ...getCollapsedCategories(),
-          [expandCategoryId]: false
-        };
-        if (typeof window !== "undefined") {
-          writeStoredCollapsedCategories(
-            result.spaceId,
-            collapsedCategories,
-            window.localStorage
-          );
-        }
-        expandCategoryInCollapsed(expandCategoryId, result.spaceId);
-        return { ...result, expandCategoryId, collapsedCategories };
-      }
-      return { ...result, expandCategoryId: null };
-    },
-    {
-      fulfilled: (state6, action) => {
-        const { spaceId, updatedSpaceData } = action.payload;
-        const normalizedSpaceId = normalizeSpaceId(spaceId);
-        const rawSpaceId = getCurrentSpaceIdRaw();
-        const normalizedCurrentSpaceId = rawSpaceId ? normalizeSpaceId(rawSpaceId) : null;
-        if (normalizedCurrentSpaceId === normalizedSpaceId && updatedSpaceData) {
-          updateCurrentSpaceIfMatch(action.payload.spaceId, updatedSpaceData);
-        }
-      }
-    }
-  ),
-  moveContentToSpace: create.asyncThunk(moveContentAction, {
-    fulfilled: (_state, action) => {
-      const {
-        sourceSpaceId,
-        updatedSourceSpaceData,
-        targetSpaceId,
-        updatedTargetSpaceData
-      } = action.payload;
-      if (getCurrentSpaceIdRaw() === sourceSpaceId && updatedSourceSpaceData) {
-        updateCurrentSpaceIfMatch(sourceSpaceId, updatedSourceSpaceData);
-      }
-      if (getCurrentSpaceIdRaw() === targetSpaceId && updatedTargetSpaceData) {
-        updateCurrentSpaceIfMatch(targetSpaceId, updatedTargetSpaceData);
-      }
-    }
-  }),
-  deleteContentFromSpace: create.asyncThunk(deleteContentFromSpaceAction, {
-    fulfilled: (_state, action) => {
-      const { spaceId, updatedSpaceData } = action.payload;
-      const normalizedSpaceId = normalizeSpaceId(spaceId);
-      const rawSpaceId = getCurrentSpaceIdRaw();
-      const normalizedCurrentSpaceId = rawSpaceId ? normalizeSpaceId(rawSpaceId) : null;
-      if (normalizedCurrentSpaceId === normalizedSpaceId && updatedSpaceData) {
-        updateCurrentSpaceIfMatch(action.payload.spaceId, updatedSpaceData);
-      }
-    }
-  }),
-  // --- 新增: 批量删除内容的 Thunk ---
-  deleteMultipleContent: create.asyncThunk(deleteMultipleContentAction, {
-    fulfilled: (_state, action) => {
-      const normalizedSpaceId = normalizeSpaceId(action.payload.spaceId);
-      const rawSpaceId = getCurrentSpaceIdRaw();
-      const normalizedCurrentSpaceId = rawSpaceId ? normalizeSpaceId(rawSpaceId) : null;
-      if (normalizedCurrentSpaceId === normalizedSpaceId && action.payload.updatedSpaceData) {
-        updateCurrentSpaceIfMatch(action.payload.spaceId, action.payload.updatedSpaceData);
-      }
-    }
-  }),
-  uploadAndAddFileToSpace: create.asyncThunk(uploadAndAddFileToSpaceAction, {
-    fulfilled: (state6, action) => {
-      if (getCurrentSpaceIdRaw() === action.payload.spaceId) {
-        updateCurrentSpaceIfMatch(action.payload.spaceId, action.payload.updatedSpaceData);
-      }
-    }
-  }),
-  // --- 结束新增 ---
-  updateContentTitle: create.asyncThunk(updateContentTitleAction, {
-    fulfilled: (state6, action) => {
-      if (getCurrentSpaceIdRaw() === action.payload.spaceId) {
-        updateCurrentSpaceIfMatch(action.payload.spaceId, action.payload.updatedSpaceData);
-      }
-    },
-    rejected: (_state, action) => {
-      const message = action.error.message || "\u6807\u9898\u4FDD\u5B58\u5931\u8D25";
-      if (message.includes("\u65E0\u6CD5\u52A0\u8F7D\u7A7A\u95F4\u6570\u636E")) return;
-      toast.error(message);
-    }
-  }),
-  updateContentPinned: create.asyncThunk(updateContentPinnedAction, {
-    fulfilled: (state6, action) => {
-      if (action.payload.updatedSpaceData && getCurrentSpaceIdRaw() === action.payload.spaceId) {
-        updateCurrentSpaceIfMatch(action.payload.spaceId, action.payload.updatedSpaceData);
-      }
-    },
-    rejected: (_state, action) => {
-      toast.error(action.error.message || "\u7F6E\u9876\u72B6\u6001\u66F4\u65B0\u5931\u8D25");
-    }
-  }),
-  updateContentCategory: create.asyncThunk(updateContentCategoryAction, {
-    fulfilled: (state6, action) => {
-      if (getCurrentSpaceIdRaw() === action.payload.spaceId) {
-        updateCurrentSpaceIfMatch(action.payload.spaceId, action.payload.updatedSpaceData);
-      }
-    }
-  })
-});
-
-// packages/create/space/spaceAccess.ts
-var resolveSpaceRemoteServers = (state6) => {
-  const currentServer = typeof state6?.settings?.currentServer === "string" ? state6.settings.currentServer : void 0;
-  const syncServers = Array.isArray(state6?.settings?.syncServers) ? state6.settings.syncServers : void 0;
-  return getAllServers(currentServer, syncServers);
-};
-var selectSpaceRemoteAuth = (state6) => ({
-  token: state6?.auth?.currentToken ?? null,
-  userId: state6?.auth?.currentUser?.userId ?? null,
-  servers: resolveSpaceRemoteServers(state6)
-});
-var spaceListsUser = (spaceData, userId) => {
-  if (!spaceData || isTombstoneRecord(spaceData)) return false;
-  if (spaceData.ownerId === userId) return true;
-  return Array.isArray(spaceData.members) && spaceData.members.includes(userId);
+// packages/create/space/spaceCollapsedState.ts
+var SPACE_COLLAPSE_STORAGE_PREFIX = "space-collapsed-categories:";
+var normalizeCollapsedCategories = (value) => {
+  const entries = Object.entries(asRecordOrEmpty(value)).filter(
+    ([key, collapsed]) => typeof key === "string" && typeof collapsed === "boolean"
+  );
+  return Object.fromEntries(entries);
 };
-var membershipBelongsToUser = (membership, userId) => !membership.userId || membership.userId === userId;
-var membershipFetchCache = /* @__PURE__ */ new Map();
-var MEMBERSHIP_FETCH_CACHE_TTL_MS = 3e4;
-async function fetchMembershipsFromServer(server, token, userId, timeoutMs) {
-  if (!token) return { ok: false, memberships: [] };
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+var storageKeyForSpace = (spaceId) => `${SPACE_COLLAPSE_STORAGE_PREFIX}${spaceId}`;
+var readStoredCollapsedCategories = (spaceId, storage) => {
+  if (!spaceId || !storage) return {};
   try {
-    const response = await fetch(`${server}/rpc/getUserSpaceMemberships`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ userId }),
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-    if (!response.ok) {
-      console.error(
-        `Failed to fetch memberships from ${server}: ${response.statusText}`
-      );
-      return { ok: false, memberships: [] };
-    }
-    const data = await response.json();
-    return {
-      ok: true,
-      server,
-      memberships: Array.isArray(data) ? data : []
-    };
+    const raw = storage.getItem(storageKeyForSpace(spaceId));
+    if (!raw) return { [UNCATEGORIZED_ID]: false };
+    return normalizeCollapsedCategories(JSON.parse(raw));
   } catch (error) {
-    clearTimeout(timeoutId);
-    console.error(`Error fetching memberships from ${server}:`, error);
-    return { ok: false, memberships: [] };
+    console.warn("[Space] \u8BFB\u53D6\u5206\u7C7B\u6298\u53E0\u72B6\u6001\u5931\u8D25:", error);
+    return {};
   }
-}
-var fetchRemoteUserSpaceMemberships = (server, token, userId, timeoutMs = 5e3) => {
-  const cacheKey = `${server}|${userId}`;
-  const cached = membershipFetchCache.get(cacheKey);
-  if (cached) return cached;
-  const promise = fetchMembershipsFromServer(server, token, userId, timeoutMs);
-  membershipFetchCache.set(cacheKey, promise);
-  promise.catch(() => {
-  }).finally(() => {
-    setTimeout(() => {
-      if (membershipFetchCache.get(cacheKey) === promise) {
-        membershipFetchCache.delete(cacheKey);
-      }
-    }, MEMBERSHIP_FETCH_CACHE_TTL_MS);
-  });
-  return promise;
 };
-var fetchRemoteSpace = async (server, token, spaceId) => {
+var writeStoredCollapsedCategories = (spaceId, collapsedCategories, storage) => {
+  if (!spaceId || !storage) return;
   try {
-    const space = await fetchFromServer(
-      server,
-      createSpaceKey.space(normalizeSpaceId(spaceId)),
-      token ?? void 0
+    storage.setItem(
+      storageKeyForSpace(spaceId),
+      JSON.stringify(normalizeCollapsedCategories(collapsedCategories))
     );
-    return space && typeof space === "object" ? space : null;
-  } catch {
-    return null;
+  } catch (error) {
+    console.warn("[Space] \u4FDD\u5B58\u5206\u7C7B\u6298\u53E0\u72B6\u6001\u5931\u8D25:", error);
   }
 };
-var hasActiveRemoteMembership = async (server, token, userId, spaceId) => {
-  const result = await fetchRemoteUserSpaceMemberships(server, token, userId);
-  if (!result.ok) return false;
-  const normalizedSpaceId = normalizeSpaceId(spaceId);
-  return result.memberships.some((membership) => {
-    const membershipSpaceId = typeof membership?.spaceId === "string" ? normalizeSpaceId(membership.spaceId) : "";
-    return membershipSpaceId === normalizedSpaceId && membershipBelongsToUser(membership, userId) && !isTombstoneRecord(membership);
-  });
+
+// packages/create/space/spaceUiStore.ts
+var import_react9 = __toESM(require_react(), 1);
+var DEFAULT_COLLAPSED_CATEGORIES = {
+  [UNCATEGORIZED_ID]: false
 };
-var fetchAuthoritativeRemoteSpace = async ({
-  servers,
-  token,
-  userId,
-  spaceId
-}) => {
-  const normalizedSpaceId = normalizeSpaceId(spaceId);
-  for (const server of servers) {
-    const space = await fetchRemoteSpace(server, token, normalizedSpaceId);
-    if (!space) continue;
-    if (!spaceListsUser(space, userId)) {
-      throw new Error(`Current user is not a member of space: ${normalizedSpaceId}`);
-    }
-    if (space.ownerId !== userId) {
-      const hasMembership = await hasActiveRemoteMembership(
-        server,
-        token,
-        userId,
-        normalizedSpaceId
-      );
-      if (!hasMembership) {
-        throw new Error(
-          `Current user has no active membership for space: ${normalizedSpaceId}`
-        );
-      }
+var FAVORITES_COLLAPSED_STORAGE_KEY = "nolo-sidebar-favorites-collapsed";
+var readStoredFavoritesCollapsed = () => {
+  try {
+    if (typeof window === "undefined") return false;
+    return window.localStorage.getItem(FAVORITES_COLLAPSED_STORAGE_KEY) === "1";
+  } catch {
+    return false;
+  }
+};
+var createInitialState = () => ({
+  favoritesCollapsed: readStoredFavoritesCollapsed(),
+  collapsedCategories: {},
+  collapsedCategoriesSpaceId: null
+});
+var state = createInitialState();
+var listeners = /* @__PURE__ */ new Set();
+var version = 0;
+var notify = () => {
+  version += 1;
+  for (const listener of listeners) {
+    try {
+      listener();
+    } catch {
     }
-    return space;
   }
-  return null;
 };
-
-// packages/create/space/member/isSpaceMembershipRemoteUnavailableError.ts
-var SPACE_MEMBERSHIP_REMOTE_UNAVAILABLE = "space_membership_remote_unavailable";
-var isSpaceMembershipRemoteUnavailableError = (error) => {
-  if (typeof error === "string") {
-    return error.includes(SPACE_MEMBERSHIP_REMOTE_UNAVAILABLE);
-  }
-  if (error instanceof Error) {
-    return error.message.includes(SPACE_MEMBERSHIP_REMOTE_UNAVAILABLE);
-  }
-  if (error && typeof error === "object" && "message" in error && typeof error.message === "string") {
-    return error.message.includes(
-      SPACE_MEMBERSHIP_REMOTE_UNAVAILABLE
+function getCollapsedCategories() {
+  return state.collapsedCategories;
+}
+function setCollapsedCategories(categories, spaceId) {
+  state = {
+    ...state,
+    collapsedCategories: categories,
+    collapsedCategoriesSpaceId: spaceId
+  };
+  notify();
+}
+function toggleCategoryCollapse(categoryId) {
+  const current = state.collapsedCategories[categoryId] ?? (DEFAULT_COLLAPSED_CATEGORIES[categoryId] ?? true);
+  state = {
+    ...state,
+    collapsedCategories: {
+      ...state.collapsedCategories,
+      [categoryId]: !current
+    }
+  };
+  notify();
+}
+function expandCategoryInCollapsed(categoryId, spaceId) {
+  if (!categoryId || categoryId === UNCATEGORIZED_ID) return;
+  state = {
+    ...state,
+    collapsedCategories: {
+      ...state.collapsedCategories,
+      [categoryId]: false
+    }
+  };
+  if (typeof window !== "undefined") {
+    writeStoredCollapsedCategories(
+      spaceId,
+      state.collapsedCategories,
+      window.localStorage
     );
   }
-  return false;
-};
+  notify();
+}
 
-// packages/create/space/member/fetchUserSpaceMembershipsAction.ts
-var CONTENT_SPACE_RECOVERY_TYPES = [
-  "app" /* APP */,
-  "page" /* DOC */,
-  "dialog" /* DIALOG */,
-  "image" /* IMAGE */,
-  "file" /* FILE */,
-  "table" /* TABLE */,
-  "agent" /* AGENT */
-];
-var readLocalSpaceData = async (db, spaceId) => {
+// packages/create/space/content/contentThunks.ts
+var syncCurrentSpaceIfNormalizedMatch = (spaceId, updatedSpaceData) => {
   const normalizedSpaceId = normalizeSpaceId(spaceId);
-  const spaceKey = createSpaceKey.space(normalizedSpaceId);
-  try {
-    return await db.get(spaceKey) ?? null;
-  } catch {
-    return null;
-  }
-};
-var membershipCheckUserId = (membership, activeUserId) => isDeviceLocalSpaceMembership(membership) ? DEVICE_LOCAL_OWNER_ID : activeUserId;
-var buildLocalMembershipPreview = async (userId, db, memberships) => {
-  const preview = await Promise.all(
-    memberships.map(async (membership) => {
-      if (isTombstoneRecord(membership)) return null;
-      const checkUserId = membershipCheckUserId(membership, userId);
-      if (!membershipBelongsToUser(membership, checkUserId)) return null;
-      const normalizedSpaceId = normalizeSpaceId(membership.spaceId);
-      const localSpaceData = await readLocalSpaceData(db, normalizedSpaceId);
-      if (!localSpaceData || isTombstoneRecord(localSpaceData)) return null;
-      if (!spaceListsUser(localSpaceData, checkUserId)) return null;
-      return {
-        ...membership,
-        spaceId: normalizedSpaceId
+  const rawSpaceId = getCurrentSpaceIdRaw();
+  const normalizedCurrentSpaceId = rawSpaceId ? normalizeSpaceId(rawSpaceId) : null;
+  if (normalizedCurrentSpaceId === normalizedSpaceId && updatedSpaceData) {
+    updateCurrentSpaceIfMatch(spaceId, updatedSpaceData);
+  }
+};
+var addContentToSpace = createAsyncThunk(
+  "space/addContentToSpace",
+  async (input, thunkAPI) => {
+    const result = await addContentAction(input, thunkAPI);
+    const rawCategoryId = asTrimmedString(input.categoryId);
+    const expandCategoryId = rawCategoryId && rawCategoryId !== UNCATEGORIZED_ID ? rawCategoryId : null;
+    if (expandCategoryId) {
+      const collapsedCategories = {
+        ...getCollapsedCategories(),
+        [expandCategoryId]: false
       };
-    })
-  );
-  return preview.filter(
-    (membership) => !!membership
-  );
-};
-var fetchLocalForUser = async (userId, db) => {
-  try {
-    const memberships = [];
-    const prefix = `space-member-${userId}`;
-    let iterator = db.iterator({
-      gte: prefix,
-      lte: prefix + "\xFF"
-    });
-    if (iterator && typeof iterator.then === "function") {
-      iterator = await iterator;
-    }
-    for await (const [_, memberData] of iterator) {
-      if (memberData && typeof memberData === "object" && memberData.spaceId && !isTombstoneRecord(memberData)) {
-        memberships.push(memberData);
+      if (typeof window !== "undefined") {
+        writeStoredCollapsedCategories(
+          result.spaceId,
+          collapsedCategories,
+          window.localStorage
+        );
       }
+      expandCategoryInCollapsed(expandCategoryId, result.spaceId);
+      syncCurrentSpaceIfNormalizedMatch(
+        result.spaceId,
+        result.updatedSpaceData
+      );
+      return { ...result, expandCategoryId, collapsedCategories };
     }
-    return memberships;
-  } catch (error) {
-    console.error("Error fetching local memberships:", error);
-    return [];
+    syncCurrentSpaceIfNormalizedMatch(result.spaceId, result.updatedSpaceData);
+    return { ...result, expandCategoryId: null };
   }
-};
-var fetchLocalUnion = async (userId, db) => {
-  const deviceLocalRows = await fetchLocalForUser(DEVICE_LOCAL_OWNER_ID, db);
-  const taggedLocal = deviceLocalRows.map(
-    (membership) => ({
-      ...membership,
-      spaceId: normalizeSpaceId(membership.spaceId),
-      deviceLocal: true,
-      userId: membership.userId || DEVICE_LOCAL_OWNER_ID
-    })
-  );
-  if (isDeviceLocalOwnerId(userId)) {
-    return taggedLocal;
-  }
-  const accountRows = await fetchLocalForUser(userId, db);
-  const taggedAccount = accountRows.map(
-    (membership) => ({
-      ...membership,
-      spaceId: normalizeSpaceId(membership.spaceId),
-      deviceLocal: false
-    })
-  );
-  return [...taggedLocal, ...taggedAccount];
-};
-var fetchRemoteContentSpaceIds = async (server, userId, token) => {
-  try {
-    const queryParams = new URLSearchParams({ limit: "200" });
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    const authToken = asTrimmedString(token);
-    if (authToken) {
-      headers.Authorization = `Bearer ${authToken}`;
+);
+var moveContentToSpace = createAsyncThunk(
+  "space/moveContentToSpace",
+  async (arg, thunkAPI) => {
+    const payload = await moveContentAction(arg, thunkAPI);
+    const {
+      sourceSpaceId,
+      updatedSourceSpaceData,
+      targetSpaceId,
+      updatedTargetSpaceData
+    } = payload;
+    if (getCurrentSpaceIdRaw() === sourceSpaceId && updatedSourceSpaceData) {
+      updateCurrentSpaceIfMatch(sourceSpaceId, updatedSourceSpaceData);
     }
-    const response = await fetch(
-      `${server}${API_ENDPOINTS.DATABASE}/query/${encodeURIComponent(userId)}?${queryParams}`,
-      {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          type: [...CONTENT_SPACE_RECOVERY_TYPES],
-          includeDeleted: true,
-          summary: true
-        })
-      }
-    );
-    if (!response.ok) return [];
-    const data = await response.json();
-    const records = Array.isArray(data?.data?.data) ? data.data.data : [];
-    return records.filter((record) => !isTombstoneRecord(record)).map(
-      (record) => typeof record?.spaceId === "string" ? normalizeSpaceId(record.spaceId) : ""
-    ).filter((spaceId) => spaceId.length > 0);
-  } catch {
-    return [];
+    if (getCurrentSpaceIdRaw() === targetSpaceId && updatedTargetSpaceData) {
+      updateCurrentSpaceIfMatch(targetSpaceId, updatedTargetSpaceData);
+    }
+    return payload;
   }
-};
-var recoverMembershipsFromContentSpaces = async ({
-  servers,
-  token,
-  userId,
-  knownSpaceIds
-}) => {
-  const candidateSpaceIds = /* @__PURE__ */ new Set();
-  await Promise.all(
-    servers.map(async (server) => {
-      const spaceIds = await fetchRemoteContentSpaceIds(server, userId, token);
-      spaceIds.forEach((spaceId) => {
-        if (!knownSpaceIds.has(spaceId)) {
-          candidateSpaceIds.add(spaceId);
-        }
-      });
-    })
-  );
-  const results = await Promise.all(
-    [...candidateSpaceIds].map(async (spaceId) => {
-      try {
-        for (const server of servers) {
-          const remoteSpace = await fetchRemoteSpace(server, token, spaceId);
-          if (!spaceListsUser(remoteSpace, userId)) continue;
-          return {
-            userId,
-            spaceId,
-            spaceName: typeof remoteSpace?.name === "string" && remoteSpace.name.trim() ? remoteSpace.name : spaceId,
-            role: remoteSpace?.ownerId === userId ? "owner" /* OWNER */ : "member" /* MEMBER */,
-            joinedAt: remoteSpace?.updatedAt ?? remoteSpace?.createdAt ?? Date.now(),
-            sourceServer: server
-          };
-        }
-      } catch {
-      }
-      return null;
-    })
-  );
-  const recovered = results.filter(
-    (m) => m !== null
-  );
-  return recovered;
-};
-var fetchUserSpaceMembershipsAction = async (userId, thunkAPI) => {
-  const state6 = thunkAPI.getState();
-  const db = thunkAPI.extra.db;
-  const { token, servers } = selectSpaceRemoteAuth(state6);
-  const isLocalActor = isDeviceLocalOwnerId(userId);
-  const localMembershipsPromise = fetchLocalUnion(userId, db);
-  const remoteResultsPromise = isLocalActor ? Promise.resolve([]) : Promise.all(
-    servers.map(
-      (server) => fetchRemoteUserSpaceMemberships(server, token, userId)
-    )
-  );
-  const localMemberships = await localMembershipsPromise;
-  if (state6.space?.memberSpaces === null && localMemberships.length > 0) {
-    const localPreview = await buildLocalMembershipPreview(
-      userId,
-      db,
-      localMemberships
+);
+var deleteContentFromSpace = createAsyncThunk(
+  "space/deleteContentFromSpace",
+  async (arg, thunkAPI) => {
+    const payload = await deleteContentFromSpaceAction(arg, thunkAPI);
+    syncCurrentSpaceIfNormalizedMatch(
+      payload.spaceId,
+      payload.updatedSpaceData
     );
-    if (localPreview.length > 0) {
-      thunkAPI.dispatch?.({
-        type: "space/hydrateMemberSpacesFromLocal",
-        payload: localPreview
-      });
-    }
+    return payload;
   }
-  const remoteResults = await remoteResultsPromise;
-  const successfulRemoteResults = remoteResults.filter((result) => result.ok);
-  const successfulRemoteMemberships = successfulRemoteResults.flatMap(
-    (result) => result.memberships.map((membership) => ({
-      ...membership,
-      sourceServer: result.server
-    }))
-  );
-  const hasSuccessfulRemoteFetch = successfulRemoteResults.length > 0;
-  const hasRemoteAuthority = !isLocalActor && !!token && servers.length > 0;
-  if (hasRemoteAuthority && !hasSuccessfulRemoteFetch) {
-    throw new Error(
-      `${SPACE_MEMBERSHIP_REMOTE_UNAVAILABLE}: unable to refresh memberships from ${servers.join(", ")}`
+);
+var deleteMultipleContent = createAsyncThunk(
+  "space/deleteMultipleContent",
+  async (arg, thunkAPI) => {
+    const payload = await deleteMultipleContentAction(arg, thunkAPI);
+    syncCurrentSpaceIfNormalizedMatch(
+      payload.spaceId,
+      payload.updatedSpaceData
     );
+    return payload;
   }
-  const remoteSpaceIds = new Set(
-    successfulRemoteMemberships.map(
-      (membership) => normalizeSpaceId(membership.spaceId)
-    )
-  );
-  const filteredLocalMemberships = hasSuccessfulRemoteFetch ? (await Promise.all(
-    localMemberships.map(async (membership) => {
-      const normalizedSpaceId = normalizeSpaceId(membership.spaceId);
-      if (membership.deviceLocal || isDeviceLocalSpaceMembership(membership)) {
-        return {
-          ...membership,
-          spaceId: normalizedSpaceId,
-          deviceLocal: true
-        };
+);
+var uploadAndAddFileToSpace = createAsyncThunk(
+  "space/uploadAndAddFileToSpace",
+  async (arg, thunkAPI) => {
+    const payload = await uploadAndAddFileToSpaceAction(arg, thunkAPI);
+    if (getCurrentSpaceIdRaw() === payload.spaceId) {
+      updateCurrentSpaceIfMatch(payload.spaceId, payload.updatedSpaceData);
+    }
+    return payload;
+  }
+);
+var updateContentTitle = createAsyncThunk(
+  "space/updateContentTitle",
+  async (arg, thunkAPI) => {
+    try {
+      const payload = await updateContentTitleAction(arg, thunkAPI);
+      if (getCurrentSpaceIdRaw() === payload.spaceId) {
+        updateCurrentSpaceIfMatch(payload.spaceId, payload.updatedSpaceData);
       }
-      if (remoteSpaceIds.has(normalizedSpaceId)) {
-        return {
-          ...membership,
-          spaceId: normalizedSpaceId
-        };
+      return payload;
+    } catch (error) {
+      const message = error?.message || "\u6807\u9898\u4FDD\u5B58\u5931\u8D25";
+      if (!message.includes("\u65E0\u6CD5\u52A0\u8F7D\u7A7A\u95F4\u6570\u636E")) {
+        toast.error(message);
       }
-      console.warn(
-        `[SpaceMembership] Membership missing from remote index, verifying space record: user=${userId}, spaceId=${normalizedSpaceId}`
+      throw error;
+    }
+  }
+);
+var updateContentPinned = createAsyncThunk(
+  "space/updateContentPinned",
+  async (arg, thunkAPI) => {
+    try {
+      const payload = await updateContentPinnedAction(arg, thunkAPI);
+      if (payload.updatedSpaceData && getCurrentSpaceIdRaw() === payload.spaceId) {
+        updateCurrentSpaceIfMatch(payload.spaceId, payload.updatedSpaceData);
+      }
+      return payload;
+    } catch (error) {
+      toast.error(
+        error?.message || "\u7F6E\u9876\u72B6\u6001\u66F4\u65B0\u5931\u8D25"
       );
-      return {
-        ...membership,
-        spaceId: normalizedSpaceId,
-        requiresRemoteSpaceVerification: true
-      };
-    })
-  )).filter((membership) => !!membership) : localMemberships.map((membership) => ({
-    ...membership,
-    spaceId: normalizeSpaceId(membership.spaceId)
-  }));
-  const verifyActiveSpaceMembership = async (membership) => {
-    if (isTombstoneRecord(membership)) return null;
-    const checkUserId = membershipCheckUserId(membership, userId);
-    if (!membershipBelongsToUser(membership, checkUserId)) return null;
-    const normalizedSpaceId = normalizeSpaceId(membership.spaceId);
-    const localSpaceData = await readLocalSpaceData(db, normalizedSpaceId);
-    const isDeviceLocal = membership.deviceLocal || isDeviceLocalSpaceMembership(membership);
-    if (isDeviceLocal) {
-      if (!localSpaceData || isTombstoneRecord(localSpaceData)) return null;
-      if (!spaceListsUser(localSpaceData, checkUserId)) {
-        return null;
-      }
-      const {
-        sourceServer: _s,
-        requiresRemoteSpaceVerification: _r,
-        deviceLocal: _d,
-        ...visible
-      } = membership;
-      return {
-        ...visible,
-        spaceId: normalizedSpaceId,
-        userId: DEVICE_LOCAL_OWNER_ID
-      };
+      throw error;
     }
-    if (membership.sourceServer || membership.requiresRemoteSpaceVerification) {
-      if (localSpaceData && isTombstoneRecord(localSpaceData)) return null;
-      if (membership.sourceServer && !membership.requiresRemoteSpaceVerification) {
-        const { sourceServer: _ss, ...verifiedMembership } = membership;
-        return {
-          ...verifiedMembership,
-          spaceId: normalizedSpaceId
-        };
-      }
-      try {
-        const remoteSpaceServers = Array.from(
-          new Set(
-            [membership.sourceServer, ...servers].filter(
-              (server) => typeof server === "string" && server.length > 0
-            )
-          )
-        );
-        let remoteSpace = null;
-        for (const server of remoteSpaceServers) {
-          remoteSpace = await fetchRemoteSpace(
-            server,
-            token,
-            normalizedSpaceId
-          );
-          if (remoteSpace) break;
-        }
-        if (!spaceListsUser(remoteSpace, userId)) return null;
-        const {
-          requiresRemoteSpaceVerification,
-          deviceLocal: _dl,
-          ...verifiedMembership
-        } = membership;
-        return {
-          ...verifiedMembership,
-          spaceId: normalizedSpaceId
-        };
-      } catch {
-        return null;
-      }
-    }
-    if (localSpaceData) {
-      return !spaceListsUser(localSpaceData, userId) ? null : {
-        ...membership,
-        spaceId: normalizedSpaceId
-      };
-    }
-    if (!membership.sourceServer && servers.length === 0) {
-      return {
-        ...membership,
-        spaceId: normalizedSpaceId
-      };
-    }
-    try {
-      const remoteSpace = await readAction(
-        {
-          dbKey: createSpaceKey.space(normalizedSpaceId),
-          preferredServerOrigin: membership.sourceServer
-        },
-        thunkAPI
-      );
-      if (!spaceListsUser(remoteSpace, userId)) return null;
-      return {
-        ...membership,
-        spaceId: normalizedSpaceId
-      };
-    } catch {
-      return null;
-    }
-  };
-  const activeMemberships = (await Promise.all(
-    [...filteredLocalMemberships, ...successfulRemoteMemberships].map(
-      verifyActiveSpaceMembership
-    )
-  )).filter((membership) => !!membership);
-  const knownSpaceIds = new Set(
-    [
-      ...filteredLocalMemberships,
-      ...successfulRemoteMemberships,
-      ...activeMemberships
-    ].map((membership) => normalizeSpaceId(membership.spaceId))
-  );
-  if (hasRemoteAuthority && hasSuccessfulRemoteFetch && !isLocalActor) {
-    void recoverMembershipsFromContentSpaces({
-      servers,
-      token,
-      userId,
-      knownSpaceIds
-    }).then((rawRecovered) => {
-      const activeUserId = thunkAPI.getState()?.auth?.currentUser?.userId ?? null;
-      if (activeUserId !== userId) return;
-      if (rawRecovered.length === 0) return;
-      const cleaned = rawRecovered.map((membership) => {
-        const {
-          sourceServer: _ss,
-          requiresRemoteSpaceVerification: _rv,
-          deviceLocal: _dl,
-          ...visible
-        } = membership;
-        return { ...visible, spaceId: normalizeSpaceId(membership.spaceId) };
-      });
-      thunkAPI.dispatch?.({
-        type: "space/appendRecoveredMemberships",
-        payload: cleaned
-      });
-    }).catch(() => {
-    });
-  }
-  const membershipMap = /* @__PURE__ */ new Map();
-  const preferAccountOnCollision = (existing, next) => {
-    if (!existing) return next;
-    const existingLocal = isDeviceLocalSpaceMembership(existing);
-    const nextLocal = isDeviceLocalSpaceMembership(next);
-    if (existingLocal && !nextLocal) return next;
-    if (!existingLocal && nextLocal) return existing;
-    return next;
-  };
-  [...activeMemberships].forEach((membership) => {
-    const normalizedSpaceId = normalizeSpaceId(membership.spaceId);
-    const {
-      sourceServer: _sourceServer,
-      requiresRemoteSpaceVerification: _req,
-      deviceLocal: _deviceLocal,
-      ...visibleMembership
-    } = membership;
-    const cleaned = {
-      ...visibleMembership,
-      spaceId: normalizedSpaceId
-    };
-    const existing = membershipMap.get(normalizedSpaceId);
-    membershipMap.set(
-      normalizedSpaceId,
-      preferAccountOnCollision(existing, cleaned)
-    );
-  });
-  const finalMemberships = Array.from(membershipMap.values()).sort(
-    (a, b) => (b.joinedAt || 0) - (a.joinedAt || 0)
-  );
-  return finalMemberships;
-};
-
-// packages/database/thunkApiTypes.ts
-var dbThunkState = (thunkApi) => thunkApi.getState();
-var dbThunkExtra = (thunkApi) => thunkApi.extra;
-
-// packages/create/space/member/addMemberAction.ts
-var addMemberAction = async (input, thunkAPI) => {
-  const { spaceId, memberId, role = "member" /* MEMBER */ } = input;
-  const { dispatch } = thunkAPI;
-  const state6 = dbThunkState(thunkAPI);
-  const currentUserId = selectIdentityUserId(state6);
-  const { db } = dbThunkExtra(thunkAPI);
-  const resolvedMemberId = db ? await resolveMemberId(db, memberId) : memberId.trim();
-  const spaceKey = createSpaceKey.space(spaceId);
-  const spaceData = await dispatch(read({
-    dbKey: spaceKey
-  })).unwrap();
-  if (!spaceData) {
-    throw new Error("Space not found");
-  }
-  if (!currentUserId) {
-    throw new Error("User is not logged in.");
-  }
-  if (!spaceData.members.includes(currentUserId)) {
-    throw new Error("\u5F53\u524D\u7528\u6237\u4E0D\u662F\u7A7A\u95F4\u6210\u5458\uFF0C\u65E0\u6CD5\u6DFB\u52A0\u6210\u5458");
-  }
-  if (spaceData.members.includes(resolvedMemberId)) {
-    throw new Error("\u6210\u5458\u5DF2\u5B58\u5728");
-  }
-  const updatedSpaceData = {
-    ...spaceData,
-    members: [...spaceData.members, resolvedMemberId],
-    updatedAt: Date.now()
-  };
-  await dispatch(
-    write({ data: updatedSpaceData, customKey: spaceKey })
-  ).unwrap();
-  const now = Date.now();
-  const spaceMemberData = {
-    userId: resolvedMemberId,
-    role,
-    // 使用传入的 role，默认为 MEMBER
-    joinedAt: now,
-    updatedAt: now,
-    // 可选字段，初始化时设置为当前时间
-    spaceId,
-    spaceName: spaceData.name,
-    ownerId: spaceData.ownerId,
-    visibility: spaceData.visibility,
-    type: "space" /* SPACE */
-    // 添加 type 字段
-  };
-  const spaceMemberKey = createSpaceKey.member(resolvedMemberId, spaceId);
-  await dispatch(
-    write({
-      data: spaceMemberData,
-      customKey: spaceMemberKey
-    })
-  ).unwrap();
-  return { spaceId, updatedSpaceData };
-};
-async function resolveMemberId(db, identifier) {
-  const trimmed = identifier.trim();
-  let foundUserId = null;
-  let matchCount = 0;
-  try {
-    for await (const [key, value] of db.iterator({
-      gte: `${DB_PREFIX.USER}`,
-      lte: `${DB_PREFIX.USER}\uFFFF`
-    })) {
-      if (value.username === trimmed) {
-        foundUserId = key.slice(DB_PREFIX.USER.length);
-        matchCount++;
-      }
-    }
-  } catch (err2) {
-    logger.warn({ err: err2, identifier: trimmed }, "Failed to scan users by username");
-  }
-  if (matchCount > 1) {
-    throw new Error(
-      `\u627E\u5230\u591A\u4E2A\u7528\u6237\u540D\u4E3A ${trimmed} \u7684\u7528\u6237\uFF0C\u8BF7\u4F7F\u7528\u7528\u6237 ID \u9080\u8BF7`
-    );
-  }
-  if (matchCount === 1 && foundUserId) {
-    return foundUserId;
-  }
-  return trimmed;
-}
-
-// packages/create/space/member/removeMemberAction.ts
-var removeMemberAction = async (input, thunkAPI) => {
-  const { spaceId, memberId } = input;
-  const { dispatch, getState } = thunkAPI;
-  const state6 = getState();
-  const currentUserId = selectIdentityUserId(state6);
-  const spaceKey = createSpaceKey.space(spaceId);
-  const spaceData = await dispatch(read({
-    dbKey: spaceKey
-  })).unwrap();
-  if (!spaceData) {
-    throw new Error("Space not found");
-  }
-  if (spaceData.ownerId !== currentUserId) {
-    throw new Error("\u53EA\u6709\u7A7A\u95F4\u6240\u6709\u8005\u624D\u80FD\u5220\u9664\u6210\u5458");
-  }
-  if (!spaceData.members.includes(memberId)) {
-    throw new Error("\u5F85\u5220\u9664\u7684\u6210\u5458\u4E0D\u5B58\u5728");
-  }
-  const updatedSpaceData = {
-    ...spaceData,
-    members: spaceData.members.filter((id) => id !== memberId),
-    updatedAt: Date.now()
-  };
-  const memberKey = createSpaceKey.member(memberId, spaceId);
-  await Promise.all([
-    dispatch(write({ data: updatedSpaceData, customKey: spaceKey })).unwrap(),
-    dispatch(remove(memberKey)).unwrap()
-    // 使用 remove 替代 del
-  ]);
-  return { spaceId, updatedSpaceData };
-};
-
-// packages/create/space/spaceMembershipStore.ts
-var import_react11 = __toESM(require_react(), 1);
-var createInitialState3 = () => ({
-  memberSpaces: null,
-  loading: false,
-  membershipStatus: "idle",
-  initialized: false
-});
-var state3 = createInitialState3();
-var listeners3 = /* @__PURE__ */ new Set();
-var version3 = 0;
-var notify3 = () => {
-  version3 += 1;
-  for (const listener of listeners3) {
-    try {
-      listener();
-    } catch {
-    }
-  }
-};
-var getMembershipUpdatedAt = (space) => {
-  if (!space) return 0;
-  return toTimestampMs(
-    space.spaceUpdatedAt ?? space.memberUpdatedAt ?? space.updatedAt ?? space.createdAt ?? space.joinedAt
-  );
-};
-function dedupeMemberSpacesById(memberSpaces) {
-  const membershipMap = /* @__PURE__ */ new Map();
-  memberSpaces.forEach((space) => {
-    const prev = membershipMap.get(space.spaceId);
-    if (!prev || getMembershipUpdatedAt(space) >= getMembershipUpdatedAt(prev)) {
-      membershipMap.set(space.spaceId, space);
-    }
-  });
-  return Array.from(membershipMap.values());
-}
-function getAllMemberSpaces() {
-  const memberSpaces = dedupeMemberSpacesById(state3.memberSpaces || []);
-  return [...memberSpaces].sort((a, b) => {
-    return getMembershipUpdatedAt(b) - getMembershipUpdatedAt(a);
-  });
-}
-function setMemberSpaces(spaces) {
-  state3 = {
-    ...state3,
-    memberSpaces: spaces,
-    loading: false,
-    error: void 0,
-    membershipStatus: "fresh",
-    initialized: true
-  };
-  notify3();
-}
-function setMembershipLoading() {
-  state3 = { ...state3, loading: true, membershipStatus: "loading" };
-  notify3();
-}
-function setMembershipRejected(errorMessage, isRemoteUnavailable) {
-  const membershipStatus = isRemoteUnavailable ? "offline" : state3.membershipStatus === "loading" ? "idle" : state3.membershipStatus;
-  state3 = {
-    ...state3,
-    loading: false,
-    error: errorMessage,
-    membershipStatus
-  };
-  notify3();
-}
-function hydrateMemberSpacesFromLocal(spaces) {
-  if (state3.memberSpaces !== null || spaces.length === 0) return;
-  state3 = {
-    ...state3,
-    memberSpaces: dedupeMemberSpacesById(spaces),
-    loading: false
-  };
-  notify3();
-}
-function appendRecoveredMemberships(recovered) {
-  if (!recovered || recovered.length === 0) return;
-  if (state3.memberSpaces === null) {
-    state3 = {
-      ...state3,
-      memberSpaces: dedupeMemberSpacesById(recovered)
-    };
-    notify3();
-    return;
-  }
-  state3 = {
-    ...state3,
-    memberSpaces: dedupeMemberSpacesById([
-      ...state3.memberSpaces,
-      ...recovered
-    ]).sort((a, b) => toTimestampMs(b.joinedAt) - toTimestampMs(a.joinedAt))
-  };
-  notify3();
-}
-function setSpaceInitialized() {
-  state3 = { ...state3, initialized: true };
-  notify3();
-}
-function setMembershipLoaded() {
-  state3 = { ...state3, loading: false, error: void 0 };
-  notify3();
-}
-function addMemberSpace(space) {
-  const existing = state3.memberSpaces || [];
-  state3 = {
-    ...state3,
-    memberSpaces: dedupeMemberSpacesById([...existing, space])
-  };
-  notify3();
-}
-function removeMemberSpace(spaceId) {
-  if (!state3.memberSpaces) return;
-  const normalized = normalizeSpaceId(spaceId);
-  state3 = {
-    ...state3,
-    memberSpaces: state3.memberSpaces.filter(
-      (s) => normalizeSpaceId(s.spaceId) !== normalized
-    )
-  };
-  notify3();
-}
-function updateMemberSpaceName(spaceId, name) {
-  if (!state3.memberSpaces || !name) return;
-  state3 = {
-    ...state3,
-    memberSpaces: state3.memberSpaces.map(
-      (space) => space.spaceId === spaceId ? { ...space, spaceName: name } : space
-    )
-  };
-  notify3();
-}
-function resetSpaceMembershipState() {
-  state3 = createInitialState3();
-  notify3();
-}
-
-// packages/create/space/member/memberThunks.ts
-var createMemberThunks = (create) => ({
-  fetchUserSpaceMemberships: create.asyncThunk(
-    fetchUserSpaceMembershipsAction,
-    {
-      pending: (state6) => {
-        setMembershipLoading();
-      },
-      fulfilled: (state6, action) => {
-        setMemberSpaces(action.payload);
-      },
-      rejected: (state6, action) => {
-        setMembershipRejected(
-          action.error.message,
-          isSpaceMembershipRemoteUnavailableError(action.error)
-        );
-      }
-    }
-  ),
-  addMember: create.asyncThunk(addMemberAction, {
-    fulfilled: (state6, action) => {
-      if (getCurrentSpaceIdRaw() === action.payload.spaceId) {
-        updateCurrentSpaceIfMatch(action.payload.spaceId, action.payload.updatedSpaceData);
-      }
-    }
-  }),
-  removeMember: create.asyncThunk(removeMemberAction, {
-    fulfilled: (state6, action) => {
-      if (getCurrentSpaceIdRaw() === action.payload.spaceId) {
-        updateCurrentSpaceIfMatch(action.payload.spaceId, action.payload.updatedSpaceData);
-      }
-    }
-  })
-});
-
-// packages/database/queryPrefixes.ts
-function getUserDataPrefixes(type, userId) {
-  const normalizedType = toTrimmedString(type);
-  const normalizedUserId = toTrimmedString(userId);
-  if (!normalizedType || !normalizedUserId) return [];
-  const aliases = TYPE_STORAGE_PREFIXES[normalizedType] ?? [normalizedType];
-  const seen = /* @__PURE__ */ new Set();
-  const prefixes = [];
-  for (const raw of aliases) {
-    const alias = toTrimmedString(raw);
-    if (!alias) continue;
-    const prefix = `${alias}-${normalizedUserId}-`;
-    if (seen.has(prefix)) continue;
-    seen.add(prefix);
-    prefixes.push(prefix);
-  }
-  return prefixes;
-}
-
-// packages/database/client/fetchUserData.ts
-var attachQueriedKey = (key, value) => {
-  if (!value || typeof value !== "object") return value;
-  if (typeof value.dbKey === "string" && value.dbKey.trim().length > 0) {
-    return value;
-  }
-  return {
-    ...value,
-    dbKey: key
-  };
-};
-var normalizeTypeList = (types) => {
-  const raw = Array.isArray(types) ? types : [types];
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const t2 of raw) {
-    const n = toTrimmedString(t2);
-    if (!n || seen.has(n)) continue;
-    seen.add(n);
-    out.push(n);
-  }
-  return out;
-};
-async function fetchUserData(db, types, userId, options = {}) {
-  const results = {};
-  const typeArray = normalizeTypeList(types);
-  const includeDeleted = options.includeDeleted === true;
-  try {
-    for (const type of typeArray) {
-      const byKey = /* @__PURE__ */ new Map();
-      const prefixes = getUserDataPrefixes(type, userId);
-      for (const prefix of prefixes) {
-        if (!prefix) continue;
-        let iterator = db.iterator({
-          gte: prefix,
-          lte: `${prefix}\uFFFF`
-        });
-        if (iterator && typeof iterator.then === "function") {
-          iterator = await iterator;
-        }
-        for await (const [key, value] of iterator) {
-          const keyStr = String(key);
-          if (byKey.has(keyStr)) continue;
-          const hydrated = attachQueriedKey(keyStr, value);
-          if (!hydrated) continue;
-          if (!includeDeleted && hydrated.deletedAt) continue;
-          byKey.set(keyStr, hydrated);
-        }
-      }
-      results[type] = [...byKey.values()];
-    }
-    if (Array.isArray(types)) {
-      return results;
-    }
-    const single = toTrimmedString(types);
-    return results[single] ?? [];
-  } catch (error) {
-    console.error("Query error:", error);
-    throw error;
-  }
-}
-
-// packages/create/space/addSpaceAction.ts
-import { ulid as ulid5 } from "ulid";
-async function getUserDataOnce({
-  types,
-  userId,
-  limit,
-  isLoggedIn = false,
-  currentUserId,
-  db
-}) {
-  try {
-    const typeArray = Array.isArray(types) ? types : [types];
-    const effectiveUserId = userId === "local" && isLoggedIn && currentUserId ? currentUserId : userId;
-    const localResults = await fetchUserData(db, typeArray, effectiveUserId);
-    const localData = Object.values(localResults).flat();
-    return { data: localData };
-  } catch (err2) {
-    const error = err2 instanceof Error ? err2 : new Error("Unknown error occurred");
-    return { data: [], error };
-  }
-}
-var targetTypes = ["dialog" /* DIALOG */, "page" /* DOC */];
-var getCurrentPathForLog = () => typeof window !== "undefined" && typeof window.location?.pathname === "string" ? window.location.pathname : void 0;
-var addSpaceAction = async (input, thunkAPI) => {
-  const {
-    name,
-    description = "",
-    boundFolder
-  } = input;
-  const visibility = input.visibility ?? "private" /* PRIVATE */;
-  const { dispatch, getState, extra } = thunkAPI;
-  const state6 = getState();
-  const accountUserId = selectIdentityUserId(state6);
-  const userId = resolveEffectiveSpaceActorId(accountUserId);
-  const spaceId = ulid5();
-  const now = Date.now();
-  const nowISO = new Date(now).toISOString();
-  const spaceData = {
-    id: spaceId,
-    name,
-    description,
-    boundFolder,
-    ownerId: userId,
-    userId,
-    visibility,
-    members: [userId],
-    categories: {},
-    contents: {},
-    createdAt: now,
-    updatedAt: now,
-    type: "space" /* SPACE */
-  };
-  const spaces = getAllMemberSpaces();
-  const hasSpaceForActor = spaces.some(
-    (membership) => {
-      if (isDeviceLocalOwnerId(userId)) {
-        return isDeviceLocalSpaceMembership(membership);
-      }
-      if (isDeviceLocalSpaceMembership(membership)) return false;
-      return membership.userId === userId || membership.ownerId === userId;
-    }
-  );
-  console.info("[space/create] addSpaceAction", {
-    userId,
-    name,
-    visibility,
-    boundFolder,
-    memberSpaceCount: spaces.length,
-    hasSpaceForActor,
-    currentPath: getCurrentPathForLog()
-  });
-  if (!hasSpaceForActor) {
-    const { data: oldItems = [] } = await getUserDataOnce({
-      types: targetTypes,
-      userId,
-      limit: 100,
-      db: extra.db
-    });
-    const hasOldSideData = oldItems.length > 0;
-    if (hasOldSideData) {
-      const contents = {};
-      const updatePromises = [];
-      for (const item of oldItems) {
-        if (!item.id || !item.type) continue;
-        const recordOwner = resolveRecordOwnerUserId(item);
-        if (recordOwner !== userId) continue;
-        const stableContentKey = typeof item.dbKey === "string" && item.dbKey.trim() ? item.dbKey : item.id;
-        contents[stableContentKey] = {
-          title: item.title || "",
-          type: item.type,
-          contentKey: stableContentKey,
-          categoryId: "",
-          pinned: false,
-          createdAt: item.createdAt ?? now,
-          updatedAt: item.updatedAt ?? now,
-          order: item.order
-        };
-        if (item.dbKey) {
-          updatePromises.push(
-            dispatch(
-              patch({
-                dbKey: item.dbKey,
-                changes: { spaceId, updatedAt: now }
-              })
-            )
-          );
-        }
-      }
-      spaceData.contents = contents;
-      await Promise.all(updatePromises);
-    }
-  }
-  const spaceKey = createSpaceKey.space(spaceId);
-  await dispatch(
-    write({ data: spaceData, customKey: spaceKey, userId })
-  ).unwrap();
-  const spaceMemberKey = createSpaceKey.member(userId, spaceId);
-  const spaceMemberData = {
-    dbKey: spaceMemberKey,
-    type: "space" /* SPACE */,
-    userId,
-    role: "owner" /* OWNER */,
-    joinedAt: now,
-    spaceId,
-    spaceName: name,
-    ownerId: userId,
-    visibility,
-    createdAt: nowISO,
-    updatedAt: nowISO
-  };
-  await dispatch(
-    write({ data: spaceMemberData, customKey: spaceMemberKey, userId })
-  ).unwrap();
-  return spaceMemberData;
-};
-
-// packages/app/favorite/favoriteStore.ts
-var import_react14 = __toESM(require_react());
-
-// packages/app/sessionSnapshot.ts
-var import_react12 = __toESM(require_react());
-
-// packages/app/hooks/useHasMounted.ts
-var import_react13 = __toESM(require_react());
-
-// packages/app/favorite/favoriteStore.ts
-var createInitialState4 = () => ({
-  agentIds: [],
-  contentIds: [],
-  favoritedAtById: {},
-  initialized: false,
-  loading: false,
-  error: null
-});
-var state4 = createInitialState4();
-var listeners4 = /* @__PURE__ */ new Set();
-var version4 = 0;
-var notify4 = () => {
-  version4 += 1;
-  for (const listener of listeners4) {
-    try {
-      listener();
-    } catch {
-    }
-  }
-};
-function removeFavoriteLocally(payload) {
-  const { targetType, id } = payload;
-  if (targetType === "agent") {
-    state4 = {
-      ...state4,
-      agentIds: state4.agentIds.filter((item) => item !== id),
-      favoritedAtById: { ...state4.favoritedAtById }
-    };
-    delete state4.favoritedAtById[id];
-    notify4();
-    return;
-  }
-  if (targetType === "doc" || targetType === "page" || targetType === "content") {
-    state4 = {
-      ...state4,
-      contentIds: state4.contentIds.filter((item) => item !== id),
-      favoritedAtById: { ...state4.favoritedAtById }
-    };
-    delete state4.favoritedAtById[id];
-    notify4();
-  }
-}
-
-// packages/app/favorite/deletedFavoriteProjection.ts
-var resolveDeletedFavoriteProjectionRemoval = (contentKey) => {
-  if (!contentKey) return null;
-  if (isAgentKey(contentKey)) {
-    return { targetType: "agent", id: contentKey };
-  }
-  if (isPageKey(contentKey) || isTableMetaKey(contentKey) || isFileKey(contentKey)) {
-    return { targetType: "content", id: contentKey };
-  }
-  return null;
-};
-
-// packages/agent-runtime/deleteAgentLocalCredential.ts
-var AGENT_LOCAL_CREDENTIAL_DELETE_FAILED_MESSAGE = "Agent was deleted, but local API key cleanup failed. You may remove the leftover credential manually if needed.";
-var createAgentLocalCredentialBroker = createFileCredentialBroker;
-function isPublicAgentProjectionKey(dbKey) {
-  const key = asTrimmedString(dbKey);
-  return key.startsWith("agent-pub-");
-}
-function extractAgentLocalCredentialRef(record) {
-  if (!record || typeof record !== "object") return null;
-  const value = record.credentialRef;
-  return asOptionalTrimmedString(value) ?? null;
-}
-async function deleteAgentLocalCredentialRef(credentialRef, options) {
-  const ref = asTrimmedString(credentialRef);
-  if (!ref) {
-    return { deleted: false, skipped: true };
-  }
-  try {
-    const factory = options?.brokerFactory ?? createAgentLocalCredentialBroker;
-    const broker = factory();
-    await broker.delete(ref);
-    return { deleted: true };
-  } catch {
-    return {
-      deleted: false,
-      warning: AGENT_LOCAL_CREDENTIAL_DELETE_FAILED_MESSAGE
-    };
-  }
-}
-
-// packages/app/hooks/deleteDbKey.ts
-var performDirectDelete = async (dispatch, getState, contentKey, preferredServerOrigin, includeAttachments) => {
-  if (isDialogKey(contentKey)) {
-    await dispatch(
-      deleteDialog({ dialogKey: contentKey, includeAttachments })
-    ).unwrap();
-    return;
-  }
-  if (isTableMetaKey(contentKey)) {
-    await dispatch(deleteTable({ dbKey: contentKey })).unwrap();
-    return;
-  }
-  if (isAgentKey(contentKey)) {
-    let credentialRef = null;
-    let credentialSynced = false;
-    if (!isPublicAgentProjectionKey(contentKey)) {
-      try {
-        let record = selectById(getState(), contentKey);
-        if (!record) {
-          try {
-            record = await dispatch(
-              read({
-                dbKey: contentKey,
-                preferredServerOrigin
-              })
-            ).unwrap();
-          } catch {
-            record = null;
-          }
-        }
-        credentialRef = extractAgentLocalCredentialRef(record);
-        if (record && typeof record === "object" && "credentialSynced" in record) {
-          credentialSynced = record.credentialSynced === true;
-        }
-      } catch {
-        credentialRef = null;
-      }
-    }
-    await dispatch(
-      remove({
-        dbKey: contentKey,
-        preferredServerOrigin
-      })
-    ).unwrap();
-    if (credentialRef) {
-      const cleanup = await deleteAgentLocalCredentialRef(credentialRef);
-      if (!cleanup.deleted && "warning" in cleanup) {
-        console.warn(
-          "[deleteDbKey] local API credential cleanup failed after agent delete:",
-          cleanup.warning
-        );
-      }
-    }
-    if (credentialRef && credentialSynced) {
-      try {
-        const { currentServer, currentToken } = selectRuntimeSnapshot(
-          getState()
-        );
-        if (currentServer && currentToken) {
-          await deleteServerSyncedCredential(
-            { currentServer, authToken: currentToken },
-            credentialRef
-          );
-        }
-      } catch {
-      }
-    }
-    return;
-  }
-  if (isAppKey(contentKey) || isPageKey(contentKey) || isFileKey(contentKey) || isTaskKey(contentKey)) {
-    await dispatch(
-      remove({
-        dbKey: contentKey,
-        preferredServerOrigin
-      })
-    ).unwrap();
-  }
-};
-var resolveDeleteInput = (input) => {
-  if (typeof input === "string" && input.trim()) {
-    return { contentKey: input };
-  }
-  if (input && typeof input === "object") {
-    const candidates = [input.contentKey, input.dbKey, input.key];
-    const preferredServerOrigin = asNonEmptyStringArray([
-      input.preferredServerOrigin,
-      input.serverOrigin
-    ])[0];
-    const inputSpaceId = typeof input.spaceId === "string" && input.spaceId.trim().length > 0 ? input.spaceId : null;
-    const includeAttachments = input.includeAttachments === true;
-    for (const candidate of candidates) {
-      if (typeof candidate === "string" && candidate.trim()) {
-        return {
-          contentKey: candidate,
-          preferredServerOrigin,
-          inputSpaceId,
-          includeAttachments
-        };
-      }
-    }
-  }
-  throw new Error("Invalid delete key");
-};
-var extractDeleteErrorMessage = (error, seen = /* @__PURE__ */ new Set(), depth = 0) => {
-  if (depth > 8) {
-    return null;
-  }
-  if (error instanceof Error && error.message.trim()) {
-    return error.message;
-  }
-  if (typeof error === "string" && error.trim()) {
-    return error;
-  }
-  if (!error || typeof error !== "object") {
-    return null;
-  }
-  if (seen.has(error)) {
-    return null;
-  }
-  seen.add(error);
-  const record = error;
-  const directKeys = ["message", "error", "detail", "title"];
-  for (const key of directKeys) {
-    const value = record[key];
-    if (typeof value === "string" && value.trim()) {
-      return value;
-    }
-  }
-  const nestedKeys = ["payload", "data", "cause"];
-  for (const key of nestedKeys) {
-    const message = extractDeleteErrorMessage(record[key], seen, depth + 1);
-    if (message) {
-      return message;
-    }
-  }
-  if (Array.isArray(record.errors)) {
-    const messages = record.errors.map((item) => extractDeleteErrorMessage(item, seen, depth + 1)).filter((item) => Boolean(item));
-    if (messages.length > 0) {
-      return messages.join("\n");
-    }
-  }
-  try {
-    const serialized = JSON.stringify(error);
-    if (serialized && serialized !== "{}") {
-      return serialized;
-    }
-  } catch {
-    return null;
-  }
-  return null;
-};
-var getDeleteErrorMessage = (error, fallback = "Delete failed") => {
-  return extractDeleteErrorMessage(error) ?? fallback;
-};
-var normalizeDeleteError = (error) => {
-  if (error instanceof Error && error.message.trim()) {
-    return error;
-  }
-  return new Error(getDeleteErrorMessage(error));
-};
-var deleteDbKey = (input, spaceId) => async (dispatch, getState) => {
-  try {
-    const {
-      contentKey,
-      preferredServerOrigin,
-      inputSpaceId,
-      includeAttachments
-    } = resolveDeleteInput(input);
-    const effectiveSpaceId = typeof spaceId === "string" && spaceId.trim().length > 0 ? spaceId : inputSpaceId ?? null;
-    await performDirectDelete(
-      dispatch,
-      getState,
-      contentKey,
-      preferredServerOrigin,
-      includeAttachments
-    );
-    const spaceIds = isAppKey(contentKey) ? /* @__PURE__ */ new Set([
-      effectiveSpaceId,
-      ...getAllMemberSpaces().map((space) => space.spaceId)
-    ]) : /* @__PURE__ */ new Set([effectiveSpaceId]);
-    await Promise.all(
-      [...spaceIds].filter((spaceId2) => Boolean(spaceId2)).map(
-        (spaceId2) => dispatch(
-          deleteContentFromSpace({
-            contentKey,
-            spaceId: spaceId2,
-            ...preferredServerOrigin ? { sourceServerOrigin: preferredServerOrigin } : {}
-          })
-        ).unwrap().catch((err2) => {
-          console.warn("[deleteDbKey] space cleanup failed (entity already tombstoned):", err2);
-        })
-      )
-    );
-    const favoriteProjectionRemoval = resolveDeletedFavoriteProjectionRemoval(contentKey);
-    if (favoriteProjectionRemoval) {
-      removeFavoriteLocally(favoriteProjectionRemoval);
-    }
-    if (typeof window !== "undefined") {
-      window.dispatchEvent(
-        new CustomEvent("nolo-user-data-updated", {
-          detail: { deletedDbKey: contentKey }
-        })
-      );
-    }
-    return true;
-  } catch (error) {
-    throw normalizeDeleteError(error);
   }
-};
-
-// packages/create/space/deleteSpaceAction.ts
-var getCurrentUserId = (state6) => asOptionalTrimmedString(selectIdentityUserId(state6)) ?? null;
-var fetchSpaceData = async (spaceId, dispatch) => {
-  const spaceKey = createSpaceKey.space(spaceId);
-  try {
-    return await dispatch(read({
-      dbKey: spaceKey
-    })).unwrap();
-  } catch (error) {
-    console.warn(`Failed to read space ${spaceId}:`, error);
-    return void 0;
-  }
-};
-var checkOwnerPermission = (spaceData, accountUserId) => {
-  if (!spaceData) return;
-  if (isDeviceLocalSpaceBody(spaceData)) return;
-  if (!accountUserId) {
-    throw new Error("User is not logged in.");
-  }
-  if (spaceData.ownerId !== accountUserId) {
-    throw new Error("Only owner can delete space");
-  }
-};
-var deleteSpaceData = async (spaceId, dispatch) => {
-  const spaceKey = createSpaceKey.space(spaceId);
-  try {
-    await dispatch(remove(spaceKey)).unwrap();
-  } catch (error) {
-    console.warn(`Failed to delete space ${spaceId}:`, error);
-  }
-};
-var tombstoneLocalAuthorityRecord = async (dbKey, existing, dispatch) => {
-  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-  const base = existing && typeof existing === "object" ? { ...existing } : { dbKey };
-  const tombstone = buildTombstoneRecord(
-    {
-      ...base,
-      dbKey,
-      userId: DEVICE_LOCAL_OWNER_ID
-    },
-    nowIso
-  );
-  await dispatch(
-    write({
-      data: tombstone,
-      customKey: dbKey,
-      userId: DEVICE_LOCAL_OWNER_ID
-    })
-  ).unwrap();
-};
-var deleteLocalSpaceAuthority = async (spaceId, spaceData, dispatch) => {
-  const spaceKey = createSpaceKey.space(spaceId);
-  try {
-    await tombstoneLocalAuthorityRecord(
-      spaceKey,
-      spaceData && typeof spaceData === "object" ? spaceData : { dbKey: spaceKey },
-      dispatch
-    );
-  } catch (error) {
-    console.warn(`Failed to tombstone local space ${spaceId}:`, error);
-    throw error;
-  }
-  const memberIds = /* @__PURE__ */ new Set([
-    DEVICE_LOCAL_OWNER_ID,
-    ...asTrimmedNonEmptyStringArray(spaceData?.members)
-  ]);
-  for (const memberId of memberIds) {
-    const memberKey = createSpaceKey.member(memberId, spaceId);
-    let existingMember = null;
-    try {
-      existingMember = await dispatch(read({ dbKey: memberKey })).unwrap();
-    } catch {
-      existingMember = null;
-    }
-    try {
-      await tombstoneLocalAuthorityRecord(
-        memberKey,
-        existingMember ?? {
-          dbKey: memberKey,
-          type: "space" /* SPACE */,
-          userId: memberId,
-          spaceId: normalizeSpaceId(spaceId)
-        },
-        dispatch
-      );
-    } catch (err2) {
-      console.warn(
-        `Failed to tombstone local membership ${memberId} for space ${spaceId}:`,
-        err2
-      );
-    }
-  }
-};
-var deleteAllMembers = async (spaceData, spaceId, dispatch) => {
-  if (spaceData?.members) {
-    for (const memberId of spaceData.members) {
-      const memberKey = createSpaceKey.member(memberId, spaceId);
-      await dispatch(remove(memberKey)).unwrap().catch(
-        (err2) => console.warn(
-          `Failed to delete member ${memberId} for space ${spaceId}:`,
-          err2
-        )
-      );
-    }
-  }
-};
-var deleteCurrentUserMember = async (userId, spaceId, dispatch) => {
-  const currentUserMemberKey = createSpaceKey.member(userId, spaceId);
-  await dispatch(remove(currentUserMemberKey)).unwrap().catch(
-    (err2) => console.warn(
-      `Failed to delete member key for user ${userId} in space ${spaceId}:`,
-      err2
-    )
-  );
-};
-var resolveDeleteArgs = (input) => {
-  if (typeof input === "string") {
-    return { spaceId: input, strategy: "delete-space-only" };
-  }
-  return {
-    spaceId: input.spaceId,
-    strategy: input.strategy ?? "delete-space-only"
-  };
-};
-var isOwnedByUser = (entityKey, entity, userId) => {
-  if (!entityKey || !userId) return false;
-  const keyParts = splitKey(entityKey);
-  const keyedOwner = keyParts[1];
-  if ((isDialogKey(entityKey) || isPageKey(entityKey) || isFileKey(entityKey) || isTableMetaKey(entityKey)) && keyedOwner === userId) {
-    return true;
-  }
-  if ((isAgentKey(entityKey) || isAppKey(entityKey)) && entity?.userId === userId) {
-    return true;
-  }
-  if (entity?.tenantId === userId || entity?.userId === userId || entity?.ownerId === userId) {
-    return true;
-  }
-  return false;
-};
-var nextUpdatedAt = (entity) => {
-  const source = entity?.updatedAt ?? entity?.updated_at ?? entity?.createdAt ?? entity?.created ?? Date.now();
-  const timestamp = typeof source === "number" ? source : Date.parse(String(source)) || Date.now();
-  return new Date(Math.max(Date.now(), timestamp + 1)).toISOString();
-};
-var listSpaceEntities = async (spaceData, dispatch) => {
-  const results = [];
-  const contents = Object.values(spaceData?.contents ?? {}).filter(Boolean);
-  for (const item of contents) {
-    const entityKey = typeof item.contentKey === "string" ? item.contentKey : "";
-    if (!entityKey) continue;
-    let entity = null;
-    try {
-      entity = await dispatch(read({ dbKey: entityKey })).unwrap();
-    } catch {
-      entity = null;
-    }
-    results.push({ entityKey, entity });
-  }
-  return results;
-};
-var clearEntitySpaceIds = async (entities, dispatch) => {
-  await Promise.all(
-    entities.filter(({ entity }) => entity && typeof entity === "object").map(
-      ({ entityKey, entity }) => dispatch(
-        patch({
-          dbKey: entityKey,
-          changes: {
-            spaceId: null,
-            updatedAt: nextUpdatedAt(entity)
-          }
-        })
-      ).unwrap()
-    )
-  );
-};
-var deleteOwnedEntities = async (ownedEntities, dispatch) => {
-  for (const { entityKey } of ownedEntities) {
-    await dispatch(deleteDbKey(entityKey));
-  }
-};
-var deleteSpaceAction = async (input, thunkAPI) => {
-  const { dispatch, getState } = thunkAPI;
-  const { spaceId, strategy } = resolveDeleteArgs(input);
-  const accountUserId = getCurrentUserId(getState());
-  const spaceData = await fetchSpaceData(spaceId, dispatch);
-  const isLocalSpace = isDeviceLocalSpaceBody(spaceData);
-  if (!isLocalSpace) {
-    if (!accountUserId) {
-      throw new Error("User is not logged in.");
-    }
-    checkOwnerPermission(spaceData, accountUserId);
-  }
-  const ownershipUserId = isLocalSpace ? DEVICE_LOCAL_OWNER_ID : accountUserId;
-  if (spaceData && strategy !== "delete-space-only") {
-    const allEntities = await listSpaceEntities(spaceData, dispatch);
-    const ownedEntities = allEntities.filter(
-      ({ entityKey, entity }) => isOwnedByUser(entityKey, entity, ownershipUserId)
-    );
-    const unownedEntities = allEntities.filter(
-      ({ entityKey, entity }) => !isOwnedByUser(entityKey, entity, ownershipUserId)
-    );
-    if (strategy === "move-owned-to-all") {
-      await clearEntitySpaceIds(allEntities, dispatch);
-    } else if (strategy === "delete-owned-content") {
-      await deleteOwnedEntities(ownedEntities, dispatch);
-      await clearEntitySpaceIds(unownedEntities, dispatch);
-    }
-  }
-  if (isLocalSpace) {
-    await deleteLocalSpaceAuthority(spaceId, spaceData, dispatch);
-  } else {
-    await deleteSpaceData(spaceId, dispatch);
-    await deleteAllMembers(spaceData, spaceId, dispatch);
-    await deleteCurrentUserMember(accountUserId, spaceId, dispatch);
-  }
-  return { spaceId, strategy };
-};
-
-// packages/create/space/fetchSpaceAction.ts
-var fetchSpaceAction = async (input, thunkAPI) => {
-  const rawSpaceId = typeof input === "string" ? input : input?.spaceId;
-  const fresh = typeof input === "object" && input !== null ? !!input.fresh : false;
-  const { dispatch } = thunkAPI;
-  if (!rawSpaceId) {
-    throw new Error("spaceId is required");
-  }
-  const spaceId = normalizeSpaceId(rawSpaceId);
-  const spaceKey = createSpaceKey.space(spaceId);
-  const readSpace = async (dbKey) => {
-    try {
-      const { read: read2, readAndWait: readAndWait2 } = await import("./dbSlice-FWF5F4L7.js");
-      if (fresh) {
-        return await dispatch(readAndWait2(dbKey)).unwrap();
-      }
-      return await dispatch(
-        read2({
-          dbKey
-        })
-      ).unwrap();
-    } catch {
-      return null;
-    }
-  };
-  const readLocalSpaceBody = async () => {
-    let spaceData2 = await readSpace(spaceKey);
-    if (!spaceData2 && rawSpaceId !== spaceKey) {
-      spaceData2 = await readSpace(rawSpaceId);
-    }
-    if (!spaceData2 || isTombstoneRecord(spaceData2)) {
-      return null;
-    }
-    return spaceData2;
-  };
-  if (fresh) {
-    const localBody = await readLocalSpaceBody();
-    if (localBody && isDeviceLocalSpaceBody(localBody)) {
-      return { spaceId, spaceData: localBody };
-    }
-    const { token, userId, servers } = selectSpaceRemoteAuth(thunkAPI.getState());
-    if (token && userId && servers.length > 0) {
-      const remoteSpace = await fetchAuthoritativeRemoteSpace({
-        servers,
-        token,
-        userId,
-        spaceId
-      });
-      if (remoteSpace) return { spaceId, spaceData: remoteSpace };
-      throw new Error(`Space not found: ${spaceId}`);
-    }
-    if (localBody) {
-      return { spaceId, spaceData: localBody };
-    }
-    throw new Error(`Space not found: ${spaceId}`);
-  }
-  const spaceData = await readLocalSpaceBody();
-  if (!spaceData) {
-    throw new Error(`Space not found: ${spaceId}`);
-  }
-  return { spaceId, spaceData };
-};
-
-// packages/create/space/updateSpaceAction.ts
-var updateSpaceAction = async (input, thunkAPI) => {
-  const { spaceId, name, description, visibility, boundFolder } = input;
-  const { dispatch, getState } = thunkAPI;
-  const state6 = getState();
-  const userId = selectIdentityUserId(state6);
-  const spaceKey = createSpaceKey.space(spaceId);
-  let spaceData = null;
-  try {
-    spaceData = await dispatch(read({
-      dbKey: spaceKey
-    })).unwrap();
-  } catch (readError) {
-    throw new Error(
-      `\u65E0\u6CD5\u52A0\u8F7D\u7A7A\u95F4\u6570\u636E: ${spaceId}, \u539F\u56E0: ${toErrorMessage(readError)}`
-    );
-  }
-  if (!spaceData) {
-    throw new Error(`\u7A7A\u95F4\u4E0D\u5B58\u5728: ${spaceId}`);
-  }
-  if (!userId) {
-    throw new Error("\u7528\u6237\u672A\u767B\u5F55\uFF0C\u65E0\u6CD5\u66F4\u65B0\u7A7A\u95F4\u8BBE\u7F6E\u3002");
-  }
-  if (!spaceData.members || !spaceData.members.includes(userId)) {
-    throw new Error("\u5F53\u524D\u7528\u6237\u4E0D\u662F\u7A7A\u95F4\u6210\u5458\uFF0C\u65E0\u6CD5\u66F4\u65B0\u7A7A\u95F4\u8BBE\u7F6E\u3002");
-  }
-  const changes = {};
-  let hasChanges = false;
-  if (name !== void 0 && name !== spaceData.name) {
-    changes.name = name.trim();
-    hasChanges = true;
-  }
-  if (description !== void 0 && description !== spaceData.description) {
-    changes.description = description;
-    hasChanges = true;
-  }
-  if (visibility !== void 0 && visibility !== spaceData.visibility) {
-    changes.visibility = visibility;
-    hasChanges = true;
-  }
-  if (boundFolder !== void 0 && (boundFolder || void 0) !== (spaceData.boundFolder || void 0)) {
-    changes.boundFolder = boundFolder || void 0;
-    hasChanges = true;
-  }
-  if (!hasChanges) {
-    return { updatedSpace: spaceData, spaceId };
-  }
-  const now = Date.now();
-  changes.updatedAt = now;
-  let updatedSpaceData;
-  try {
-    updatedSpaceData = await dispatch(
-      patch({
-        dbKey: spaceKey,
-        changes
-      })
-    ).unwrap();
-  } catch (patchError) {
-    throw new Error(`\u66F4\u65B0\u7A7A\u95F4\u8BBE\u7F6E\u5931\u8D25: ${toErrorMessage(patchError)}`);
-  }
-  if (changes.name !== void 0) {
-    const memberKey = createSpaceKey.member(userId, spaceId);
-    try {
-      const memberData = await dispatch(
-        read({
-          dbKey: memberKey
-        })
-      ).unwrap();
-      if (memberData) {
-        const memberChanges = {
-          spaceName: changes.name,
-          updatedAt: now
-          // 为 member 数据也设置 updatedAt
-        };
-        await dispatch(
-          patch({
-            dbKey: memberKey,
-            changes: memberChanges
-          })
-        ).unwrap();
-      }
-    } catch (memberError) {
-      console.error(
-        `Failed to update member data ${memberKey} for space name change:`,
-        memberError
-      );
-    }
-  }
-  return {
-    updatedSpace: updatedSpaceData,
-    spaceId
-  };
-};
-
-// packages/create/space/fetchSpaceSidebarStateAction.ts
-var fetchSpaceSidebarStateAction = async (spaceId, thunkAPI) => {
-  const { dispatch, getState } = thunkAPI;
-  const normalizedSpaceId = normalizeSpaceId(spaceId);
-  return {
-    collapsedCategories: typeof window === "undefined" ? {} : readStoredCollapsedCategories(
-      normalizedSpaceId,
-      window.localStorage
-    )
-  };
-};
-
-// packages/create/space/changeSpaceAction.ts
-var getSpaceUpdatedAt = (space) => {
-  if (!space) return 0;
-  return toTimestampMs(space.updatedAt);
-};
-var changeSpaceAction = async (spaceId, thunkAPI) => {
-  const normalizedSpaceId = normalizeSpaceId(spaceId);
-  const sidebarPromise = fetchSpaceSidebarStateAction(
-    normalizedSpaceId,
-    thunkAPI
-  ).catch(() => ({ collapsedCategories: {} }));
-  let spaceData = null;
-  let usedLocal = false;
-  try {
-    const local = await fetchSpaceAction(
-      { spaceId: normalizedSpaceId, fresh: false },
-      thunkAPI
-    );
-    if (local?.spaceData) {
-      spaceData = local.spaceData;
-      usedLocal = true;
-    }
-  } catch {
-  }
-  if (!spaceData) {
-    const fresh = await fetchSpaceAction(
-      { spaceId: normalizedSpaceId, fresh: true },
-      thunkAPI
-    );
-    if (!fresh?.spaceData) {
-      throw new Error("\u7A7A\u95F4\u4E0D\u5B58\u5728\u6216\u52A0\u8F7D\u5931\u8D25");
-    }
-    spaceData = fresh.spaceData;
-  } else if (usedLocal) {
-    void fetchSpaceAction({ spaceId: normalizedSpaceId, fresh: true }, thunkAPI).then((result) => {
-      if (!result?.spaceData) return;
-      const state6 = thunkAPI.getState()?.space;
-      if (!state6) return;
-      if (normalizeSpaceId(state6.currentSpaceId || "") !== normalizedSpaceId) {
-        return;
-      }
-      if (getSpaceUpdatedAt(result.spaceData) < getSpaceUpdatedAt(state6.currentSpace)) {
-        return;
-      }
-      thunkAPI.dispatch({
-        type: "space/fetchSpace/fulfilled",
-        payload: {
-          spaceId: normalizedSpaceId,
-          spaceData: result.spaceData
-        },
-        meta: {
-          arg: { spaceId: normalizedSpaceId, fresh: true },
-          requestId: `changeSpace-revalidate-${normalizedSpaceId}`,
-          requestStatus: "fulfilled"
-        }
-      });
-    }).catch(() => {
-    });
-  }
-  const sidebarState = await sidebarPromise;
-  return {
-    spaceId: normalizedSpaceId,
-    spaceData,
-    sidebarState
-  };
-};
-
-// packages/create/space/spaceThunks.ts
-var createSpaceThunks = (create) => ({
-  fetchSpaceSidebarState: create.asyncThunk(fetchSpaceSidebarStateAction, {
-    fulfilled: (state6, action) => {
-      setCollapsedCategories(action.payload.collapsedCategories, getCurrentSpaceIdRaw());
-    },
-    rejected: (state6, action) => {
-      console.error("\u83B7\u53D6\u7A7A\u95F4\u4FA7\u8FB9\u680F\u72B6\u6001\u5931\u8D25:", action.error.message);
-      setCollapsedCategories({}, getCurrentSpaceIdRaw());
-    }
-  }),
-  changeSpace: create.asyncThunk(changeSpaceAction, {
-    pending: (state6, action) => {
-      const newSpaceId = normalizeSpaceId(action.meta.arg);
-      if (getCurrentSpaceIdRaw() !== newSpaceId) {
-        setMembershipLoading();
-        setCurrentSpace(null);
-      }
-    },
-    fulfilled: (state6, action) => {
-      setCurrentSpaceBoth(action.payload.spaceId, action.payload.spaceData);
-      setMembershipLoaded();
-      setCollapsedCategories(
-        action.payload.sidebarState?.collapsedCategories || {},
-        action.payload.spaceId
-      );
-    },
-    rejected: (state6, action) => {
-      setMembershipRejected(action.error.message || "\u5207\u6362\u7A7A\u95F4\u5931\u8D25", false);
-      setCurrentSpaceBoth(null, null);
-      setCollapsedCategories({}, null);
-    }
-  }),
-  addSpace: create.asyncThunk(addSpaceAction, {
-    pending: (state6) => {
-      setMembershipLoading();
-    },
-    fulfilled: (state6, action) => {
-      addMemberSpace(action.payload);
-    },
-    rejected: (state6, action) => {
-      setMembershipRejected(action.error.message, false);
-    }
-  }),
-  deleteSpace: create.asyncThunk(deleteSpaceAction, {
-    fulfilled: (state6, action) => {
-      const normalizedSpaceId = normalizeSpaceId(action.payload.spaceId);
-      const currentSpaceId = getCurrentSpaceIdRaw();
-      const normalizedCurrentSpaceId = currentSpaceId ? normalizeSpaceId(currentSpaceId) : null;
-      removeMemberSpace(normalizedSpaceId);
-      if (normalizedCurrentSpaceId === normalizedSpaceId) {
-        setCurrentSpaceBoth(null, null);
-        setCollapsedCategories({}, null);
-        setViewMode("all");
-      }
-    }
-  }),
-  updateSpace: create.asyncThunk(updateSpaceAction, {
-    fulfilled: (state6, action) => {
-      const { updatedSpace, spaceId } = action.payload;
-      updateCurrentSpaceIfMatch(spaceId, updatedSpace);
-      if (updatedSpace.name) {
-        updateMemberSpaceName(updatedSpace.id, updatedSpace.name);
-      }
-    }
-  }),
-  fetchSpace: create.asyncThunk(fetchSpaceAction, {
-    fulfilled: (state6, action) => {
-      const { spaceId, spaceData } = action.payload;
-      const currentSpaceId = getCurrentSpaceIdRaw();
-      if (!currentSpaceId || currentSpaceId === spaceId) {
-        setCurrentSpaceBoth(spaceId, spaceData);
-        setSpaceInitialized();
-      }
-    }
-  })
-});
-
-// packages/create/space/spaceDialogStore.ts
-var import_react15 = __toESM(require_react(), 1);
-var createInitialState5 = () => ({
-  dialogStatuses: {},
-  dialogEventTimestamps: {},
-  dialogTitles: {},
-  unreadDialogIds: {}
-});
-var state5 = createInitialState5();
-var listeners5 = /* @__PURE__ */ new Set();
-var version5 = 0;
-var notify5 = () => {
-  version5 += 1;
-  for (const listener of listeners5) {
-    try {
-      listener();
-    } catch {
+);
+var updateContentCategory = createAsyncThunk(
+  "space/updateContentCategory",
+  async (arg, thunkAPI) => {
+    const payload = await updateContentCategoryAction(arg, thunkAPI);
+    if (getCurrentSpaceIdRaw() === payload.spaceId) {
+      updateCurrentSpaceIfMatch(payload.spaceId, payload.updatedSpaceData);
     }
+    return payload;
   }
-};
-var nextDialogEventTimestamp = (prev, now = Date.now()) => Math.max(now, toTimestampMs(prev) + 1);
-function applySpaceEventDialog(ev, now = Date.now()) {
-  if (ev.type === "dialog.created" && ev.dialogKey && ev.dialogId && ev.title) {
-    const ts = nextDialogEventTimestamp(state5.dialogEventTimestamps[ev.dialogId], now);
-    state5 = {
-      ...state5,
-      dialogStatuses: { ...state5.dialogStatuses, [ev.dialogId]: "running" },
-      dialogEventTimestamps: { ...state5.dialogEventTimestamps, [ev.dialogId]: ts },
-      dialogTitles: { ...state5.dialogTitles, [ev.dialogId]: ev.title },
-      unreadDialogIds: { ...state5.unreadDialogIds, [ev.dialogId]: false }
-    };
-    if (state5.unreadDialogIds[ev.dialogId] !== void 0) {
-      const next = { ...state5.unreadDialogIds };
-      delete next[ev.dialogId];
-      state5 = { ...state5, unreadDialogIds: next };
-    }
-  }
-  if (ev.type === "dialog.done" && ev.dialogId) {
-    const ts = nextDialogEventTimestamp(state5.dialogEventTimestamps[ev.dialogId], now);
-    state5 = {
-      ...state5,
-      dialogStatuses: { ...state5.dialogStatuses, [ev.dialogId]: "done" },
-      dialogEventTimestamps: { ...state5.dialogEventTimestamps, [ev.dialogId]: ts },
-      unreadDialogIds: { ...state5.unreadDialogIds, [ev.dialogId]: true }
-    };
-  }
-  if (ev.type === "dialog.failed" && ev.dialogId) {
-    const ts = nextDialogEventTimestamp(state5.dialogEventTimestamps[ev.dialogId], now);
-    state5 = {
-      ...state5,
-      dialogStatuses: { ...state5.dialogStatuses, [ev.dialogId]: "failed" },
-      dialogEventTimestamps: { ...state5.dialogEventTimestamps, [ev.dialogId]: ts },
-      unreadDialogIds: { ...state5.unreadDialogIds, [ev.dialogId]: true }
-    };
-  }
-  notify5();
-}
-function clearDialogUnread(dialogId) {
-  if (state5.unreadDialogIds[dialogId] === void 0) return;
-  const next = { ...state5.unreadDialogIds };
-  delete next[dialogId];
-  state5 = { ...state5, unreadDialogIds: next };
-  notify5();
-}
-function resetSpaceDialogState() {
-  state5 = createInitialState5();
-  notify5();
-}
-
-// packages/create/space/spaceCurrentSelectors.ts
-var getSpaceUpdatedAt2 = (space) => space ? Number(space.updatedAt) || 0 : 0;
-function getCurrentSpace(entities) {
-  const spaceId = getCurrentSpaceId();
-  if (!spaceId) return null;
-  const stored = getCurrentSpaceRaw();
-  const entity = entities[createSpaceKey.space(spaceId)];
-  if (!stored) return entity ?? null;
-  if (!entity) return stored;
-  return getSpaceUpdatedAt2(entity) > getSpaceUpdatedAt2(stored) ? entity : stored;
-}
-
-// packages/create/space/spaceSlice.ts
-var createSliceWithThunks2 = buildCreateSlice({
-  creators: { asyncThunk: asyncThunkCreator }
-});
-var initialState2 = {};
-var spaceSlice = createSliceWithThunks2({
-  name: "space",
-  initialState: initialState2,
-  reducers: (create) => ({
-    ...createSpaceThunks(create),
-    ...createCategoryActions(create),
-    ...createContentThunks(create),
-    ...createMemberThunks(create),
-    resetSpace: create.reducer((_state) => {
-      resetSpaceUiState();
-      resetSpaceDialogState();
-      resetSpaceMembershipState();
-      resetSpaceCurrentState();
-    }),
-    setViewMode: create.reducer((_state, action) => {
-      setViewMode(action.payload);
-    }),
-    hydrateMemberSpacesFromLocal: create.reducer((_state, action) => {
-      hydrateMemberSpacesFromLocal(action.payload);
-    }),
-    appendRecoveredMemberships: create.reducer((_state, action) => {
-      appendRecoveredMemberships(action.payload);
-    }),
-    markDialogRead: create.asyncThunk(
-      async (payload, thunkAPI) => {
-        if (payload.dialogKey) {
-          const { patch: patch2 } = await import("./dbSlice-FWF5F4L7.js");
-          try {
-            await thunkAPI.dispatch(
-              patch2({ dbKey: payload.dialogKey, changes: { unreadAt: null } })
-            ).unwrap();
-          } catch (error) {
-            console.warn("[space/markDialogRead] failed to clear unreadAt", payload.dialogKey, error);
-          }
-        }
-        return { dialogId: payload.dialogId };
-      },
-      {
-        pending: (_state, action) => clearDialogUnread(action.meta.arg.dialogId),
-        fulfilled: (_state, action) => clearDialogUnread(action.payload.dialogId)
-      }
-    ),
-    applySpaceEvent: create.reducer((_state, action) => {
-      const now = Date.now();
-      const ev = action.payload;
-      if (ev.type === "dialog.created" && ev.dialogKey && ev.dialogId && ev.title) {
-        appendDialogContentEntry(ev.dialogKey, ev.title, Math.max(now, 1));
-      }
-      applySpaceEventDialog(ev, now);
-    })
-  })
-});
-var {
-  toggleCategoryCollapse: toggleCategoryCollapse2,
-  setAllCategoriesCollapsed,
-  changeSpace,
-  addSpace,
-  deleteSpace,
-  updateSpace,
-  fetchSpace,
-  addCategory,
-  deleteCategory,
-  updateCategoryName,
-  reorderCategories,
-  addContentToSpace,
-  moveContentToSpace,
-  deleteContentFromSpace,
-  deleteMultipleContent,
-  updateContentTitle,
-  updateContentPinned,
-  updateContentCategory,
-  uploadAndAddFileToSpace,
-  fetchUserSpaceMemberships,
-  addMember,
-  removeMember,
-  fetchSpaceSidebarState,
-  applySpaceEvent,
-  markDialogRead,
-  resetSpace,
-  setViewMode: setViewMode2,
-  toggleFavoritesCollapse,
-  hydrateMemberSpacesFromLocal: hydrateMemberSpacesFromLocal2,
-  appendRecoveredMemberships: appendRecoveredMemberships2
-} = spaceSlice.actions;
-var selectCurrentSpaceId = (_state) => getCurrentSpaceId();
-var selectCurrentSpace = (state6) => getCurrentSpace(selectEntities(state6));
-var selectSpaceById = (state6, spaceId) => {
-  if (!spaceId) return null;
-  return selectEntities(state6)[createSpaceKey.space(spaceId)] || null;
-};
-var selectViewMode = (_state) => getViewMode();
-var selectDialogStatusFromEntity = (dialogKey) => (state6) => selectEntities(state6)[dialogKey]?.status;
-var selectIsDialogUnreadFromEntity = (dialogKey) => (state6) => {
-  const entity = selectEntities(state6)[dialogKey];
-  return typeof entity?.unreadAt === "number" && entity.unreadAt > 0;
-};
-var spaceSlice_default = spaceSlice.reducer;
+);
 
 export {
   instance,
   initReactI18next,
   i18nBaseConfig,
-  getCurrentSpaceId,
-  getCurrentSpaceIdRaw,
-  getViewMode,
   fetchAndCacheTableRows,
   client_default,
   createTable,
   addRow,
+  deleteTable,
   loadTableRows,
   selectCurrentTable,
   selectTableRows,
-  dedupeMemberSpacesById,
-  getAllMemberSpaces,
-  fetchUserData,
-  deleteDbKey,
-  toggleCategoryCollapse2 as toggleCategoryCollapse,
-  setAllCategoriesCollapsed,
-  changeSpace,
-  addSpace,
-  deleteSpace,
-  updateSpace,
-  fetchSpace,
-  addCategory,
-  deleteCategory,
-  updateCategoryName,
-  reorderCategories,
+  readStoredCollapsedCategories,
+  writeStoredCollapsedCategories,
+  DEFAULT_COLLAPSED_CATEGORIES,
+  getCollapsedCategories,
+  setCollapsedCategories,
+  toggleCategoryCollapse,
+  expandCategoryInCollapsed,
   addContentToSpace,
   moveContentToSpace,
   deleteContentFromSpace,
   deleteMultipleContent,
+  uploadAndAddFileToSpace,
   updateContentTitle,
   updateContentPinned,
-  updateContentCategory,
-  uploadAndAddFileToSpace,
-  fetchUserSpaceMemberships,
-  addMember,
-  removeMember,
-  fetchSpaceSidebarState,
-  applySpaceEvent,
-  markDialogRead,
-  resetSpace,
-  setViewMode2 as setViewMode,
-  toggleFavoritesCollapse,
-  hydrateMemberSpacesFromLocal2 as hydrateMemberSpacesFromLocal,
-  appendRecoveredMemberships2 as appendRecoveredMemberships,
-  selectCurrentSpaceId,
-  selectCurrentSpace,
-  selectSpaceById,
-  selectViewMode,
-  selectDialogStatusFromEntity,
-  selectIsDialogUnreadFromEntity,
-  spaceSlice_default
+  updateContentCategory
 };