nolo-cli 0.157.0-alpha.1 → 0.157.0

package/chunk-IKOKYBYJ.js

@@ -0,0 +1,2685 @@
+import {
+  deleteDialog,
+  runtime_default,
+  toast
+} from "./chunk-XZIW3Q5B.js";
+import {
+  getCurrentSpaceId,
+  getCurrentSpaceIdRaw,
+  updateCurrentSpaceIfMatch
+} from "./chunk-ZJ7UHBJS.js";
+import {
+  formatISO
+} from "./chunk-ZRAU6T47.js";
+import {
+  require_react
+} from "./chunk-YDH3FDFQ.js";
+import {
+  UNCATEGORIZED_ID,
+  addContentAction,
+  checkSpaceMembership,
+  localSpaceAuthorityPatchStamp
+} from "./chunk-JWEXJ573.js";
+import {
+  createSpaceKey,
+  normalizeSpaceId
+} from "./chunk-UAD2WT54.js";
+import {
+  patch,
+  read,
+  readAndWait,
+  remove,
+  uploadFileAction,
+  upsertSSREntity,
+  write
+} from "./chunk-CDLP56BS.js";
+import {
+  resolveFileCategory
+} from "./chunk-3PVYUPXK.js";
+import {
+  DEVICE_LOCAL_OWNER_ID,
+  getRuntimeServerContext,
+  isDeviceLocalSpaceBody,
+  resolveReplicationServers,
+  scheduleDeleteReplication,
+  scheduleWriteReplication
+} from "./chunk-43OFVLWJ.js";
+import {
+  createAsyncThunk
+} from "./chunk-WRCZXJ4N.js";
+import {
+  getIsDesktopApp
+} from "./chunk-6Q7UTJKR.js";
+import {
+  createClientLogger
+} from "./chunk-QQ56R7KS.js";
+import {
+  selectIdentityUserId
+} from "./chunk-PXYBUFDB.js";
+import {
+  buildTombstoneRecord
+} from "./chunk-D2MDMY2M.js";
+import {
+  isSystemAdmin
+} from "./chunk-Y6ORVLSS.js";
+import {
+  asRecordOrEmpty
+} from "./chunk-KX6YBIHG.js";
+import {
+  isAbortError
+} from "./chunk-7DPNBQSV.js";
+import {
+  extractUserId
+} from "./chunk-M2EJHDJP.js";
+import {
+  SEPARATOR,
+  createKey,
+  fileKey,
+  isAgentKey,
+  isPageKey,
+  metaKey,
+  rowKey,
+  splitKey,
+  ulid
+} from "./chunk-5EMSBTQ6.js";
+import {
+  asTrimmedNonEmptyStringArray
+} from "./chunk-I42VC5KR.js";
+import {
+  asOptionalPositiveFiniteNumber
+} from "./chunk-U6VC4MU4.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// packages/render/table/tableStore.ts
+var import_react = __toESM(require_react(), 1);
+import { ulid as ulid3 } from "ulid";
+
+// packages/core/logger.ts
+import pino from "pino";
+var logger = pino({
+  level: process.env.NODE_ENV === "production" ? "info" : "debug"
+});
+
+// packages/render/table/fetchAndCacheTableRows.ts
+var TABLE_ROWS_FETCH_TIMEOUT_MS = 5e3;
+var getRowTimestamp = (row) => {
+  if (!row || typeof row !== "object") return 0;
+  return asOptionalPositiveFiniteNumber(Date.parse(row.updatedAt ?? "")) ?? asOptionalPositiveFiniteNumber(Date.parse(row.createdAt ?? "")) ?? 0;
+};
+var shouldReplaceMergedRow = (nextRow, currentRow) => {
+  const nextTs = getRowTimestamp(nextRow);
+  const currentTs = getRowTimestamp(currentRow);
+  if (nextTs !== currentTs) return nextTs > currentTs;
+  return Boolean(nextRow?.deletedAt) && !currentRow?.deletedAt;
+};
+var mergeTableRows = (...rowLists) => {
+  const merged = /* @__PURE__ */ new Map();
+  for (const rowList of rowLists) {
+    for (const row of rowList) {
+      const dbKey = row?.dbKey;
+      if (!dbKey) continue;
+      const existing = merged.get(dbKey);
+      if (!existing || shouldReplaceMergedRow(row, existing)) {
+        merged.set(dbKey, row);
+      }
+    }
+  }
+  return Array.from(merged.values());
+};
+var TABLE_SYNC_ENVELOPE = "table-sync-v1";
+var getLatestTableMeta = (snapshots) => {
+  let latestMeta = null;
+  for (const snapshot of snapshots) {
+    const tableMeta = snapshot.tableMeta;
+    if (!tableMeta || typeof tableMeta !== "object") continue;
+    if (!latestMeta || shouldReplaceMergedRow(tableMeta, latestMeta)) {
+      latestMeta = tableMeta;
+    }
+  }
+  return latestMeta;
+};
+var loadLocalTableRows = async (db, tenantId, tableId) => {
+  if (!db || typeof db.iterator !== "function") {
+    return [];
+  }
+  const rows = [];
+  const { gte, lte } = rowKey.range(tenantId, tableId);
+  try {
+    for await (const [, value] of db.iterator({ gte, lte })) {
+      if (value?.type === "table_row" /* TABLE_ROW */) {
+        rows.push(value);
+      }
+    }
+  } catch {
+    return [];
+  }
+  return rows;
+};
+var fetchTableRowsFromServer = async (server, tenantId, tableId, headers, fetchImpl = fetch) => {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(
+    () => controller.abort(),
+    TABLE_ROWS_FETCH_TIMEOUT_MS
+  );
+  try {
+    const res = await fetchImpl(`${server}/rpc/listTableRows`, {
+      method: "POST",
+      headers,
+      credentials: "include",
+      body: JSON.stringify({
+        tenantId,
+        tableId,
+        includeDeleted: true,
+        envelope: TABLE_SYNC_ENVELOPE
+      }),
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      let msg = `\u52A0\u8F7D\u8868 ${tableId} \u884C\u5931\u8D25\uFF08${res.status}\uFF09`;
+      try {
+        const err2 = await res.json();
+        if (err2 && typeof err2.message === "string") {
+          msg = err2.message;
+        }
+      } catch {
+      }
+      throw new Error(msg);
+    }
+    const data = await res.json();
+    if (Array.isArray(data)) {
+      return {
+        rows: data,
+        deletedRows: [],
+        tableMeta: null,
+        complete: false
+      };
+    }
+    if (!data || typeof data !== "object" || !Array.isArray(data.rows)) {
+      throw new Error("\u670D\u52A1\u5668\u8FD4\u56DE\u683C\u5F0F\u9519\u8BEF\uFF1A\u9884\u671F\u4E3A\u6570\u7EC4");
+    }
+    return {
+      rows: data.rows,
+      deletedRows: Array.isArray(data.deletedRows) ? data.deletedRows : [],
+      tableMeta: data.tableMeta ?? null,
+      complete: data.complete === true
+    };
+  } catch (err2) {
+    if (isAbortError(err2)) {
+      throw new Error(
+        `\u52A0\u8F7D\u8868 ${tableId} \u884C\u8D85\u65F6\uFF1A${server} \u5728 ${TABLE_ROWS_FETCH_TIMEOUT_MS / 1e3}s \u5185\u65E0\u54CD\u5E94`
+      );
+    }
+    throw err2;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+};
+var cacheMergedTableRows = async (db, mergedRows) => {
+  if (!db) return;
+  await Promise.all(
+    mergedRows.map(async (mergedRow) => {
+      if (!mergedRow?.dbKey) return;
+      try {
+        const localRow = await db.get(mergedRow.dbKey).catch(() => null);
+        if (!localRow) {
+          await db.put(mergedRow.dbKey, mergedRow);
+          return;
+        }
+        const serverTs = new Date(
+          mergedRow.updatedAt ?? mergedRow.createdAt ?? 0
+        ).getTime();
+        const localTs = new Date(
+          localRow.updatedAt ?? localRow.createdAt ?? 0
+        ).getTime();
+        const shouldOverwrite = serverTs > localTs || serverTs === localTs && Boolean(mergedRow.deletedAt) && !Boolean(localRow.deletedAt);
+        if (shouldOverwrite) {
+          await db.put(mergedRow.dbKey, mergedRow);
+        }
+      } catch {
+      }
+    })
+  );
+};
+var clearStaleLocalRows = async (db, localRows, authoritativeRows) => {
+  if (!db || typeof db.del !== "function") return;
+  const authoritativeKeys = new Set(
+    authoritativeRows.map((row) => row?.dbKey).filter((dbKey) => typeof dbKey === "string" && dbKey.length > 0)
+  );
+  await Promise.all(
+    localRows.map(async (row) => {
+      const dbKey = row?.dbKey;
+      if (typeof dbKey !== "string" || authoritativeKeys.has(dbKey)) return;
+      try {
+        await db.del(dbKey);
+      } catch {
+      }
+    })
+  );
+};
+var keepRemoteRowForPartialMerge = (row, localRowsByKey) => {
+  const dbKey = row?.dbKey;
+  if (typeof dbKey !== "string" || !dbKey) return false;
+  const localRow = localRowsByKey.get(dbKey);
+  if (!localRow) return true;
+  const remoteDeleted = Boolean(row?.deletedAt);
+  const localDeleted = Boolean(localRow?.deletedAt);
+  return remoteDeleted === localDeleted;
+};
+var fetchAndCacheTableRows = async ({
+  db,
+  tenantId,
+  tableId,
+  token,
+  remoteServers = [],
+  fetchImpl = fetch
+}) => {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (typeof token === "string" && token.trim()) {
+    headers.Authorization = `Bearer ${token.trim()}`;
+  }
+  const isWebBrowser = typeof window !== "undefined" && !getIsDesktopApp();
+  const serversToQuery = isWebBrowser && remoteServers.length > 0 ? [remoteServers[0]] : remoteServers;
+  const localRows = await loadLocalTableRows(db, tenantId, tableId);
+  const remoteResults = await Promise.allSettled(
+    serversToQuery.map(
+      (server) => fetchTableRowsFromServer(server, tenantId, tableId, headers, fetchImpl)
+    )
+  );
+  const fulfilledRemoteSnapshots = remoteResults.filter(
+    (result) => result.status === "fulfilled"
+  ).map((result) => result.value);
+  if (fulfilledRemoteSnapshots.length === 0 && localRows.length === 0) {
+    const firstFailure = remoteResults.find(
+      (result) => result.status === "rejected"
+    );
+    throw new Error(firstFailure?.reason?.message || "\u52A0\u8F7D\u8868\u884C\u5931\u8D25");
+  }
+  const allRemoteSnapshotsComplete = serversToQuery.length > 0 && remoteResults.length === serversToQuery.length && fulfilledRemoteSnapshots.length === serversToQuery.length && fulfilledRemoteSnapshots.every((snapshot) => snapshot.complete);
+  const localRowsByKey = new Map(
+    localRows.filter((row) => typeof row?.dbKey === "string" && row.dbKey.length > 0).map((row) => [row.dbKey, row])
+  );
+  const remoteRowLists = fulfilledRemoteSnapshots.map((snapshot) => {
+    const snapshotRows = [...snapshot.rows, ...snapshot.deletedRows];
+    return allRemoteSnapshotsComplete ? snapshotRows : snapshotRows.filter((row) => keepRemoteRowForPartialMerge(row, localRowsByKey));
+  });
+  const authoritativeRemoteRows = remoteRowLists.flat();
+  const tableDeleted = allRemoteSnapshotsComplete && Boolean(getLatestTableMeta(fulfilledRemoteSnapshots)?.deletedAt);
+  if (allRemoteSnapshotsComplete) {
+    await clearStaleLocalRows(db, localRows, authoritativeRemoteRows);
+  }
+  const localRowsForMerge = allRemoteSnapshotsComplete ? localRows.filter(
+    (row) => authoritativeRemoteRows.some((remoteRow) => remoteRow?.dbKey === row?.dbKey)
+  ) : localRows;
+  const mergedRows = mergeTableRows(localRowsForMerge, ...remoteRowLists);
+  await cacheMergedTableRows(db, mergedRows);
+  return tableDeleted ? [] : mergedRows.filter((row) => !row?.deletedAt);
+};
+
+// packages/render/table/tableColumnCore.ts
+var ok = (value) => ({ ok: true, value });
+var err = (error) => ({ ok: false, error });
+var hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+var buildMeta = (meta, columns, updatedAt) => ({
+  meta: { ...meta, columns, updatedAt },
+  metaChanges: { columns, updatedAt },
+  noop: false
+});
+var reorderList = (list, from, to) => {
+  const next = [...list];
+  const [moved] = next.splice(from, 1);
+  next.splice(to, 0, moved);
+  return next;
+};
+function addColumnToMeta(meta, input, deps) {
+  const { columnName } = input;
+  if (!columnName.trim()) {
+    return err("\u5B57\u6BB5\u540D\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (meta.columns.some((c) => c.name === columnName)) {
+    return err(`\u5B57\u6BB5 ${columnName} \u5DF2\u5B58\u5728`);
+  }
+  const newColumn = {
+    id: deps.id,
+    name: columnName,
+    label: columnName
+  };
+  return ok(buildMeta(meta, [...meta.columns, newColumn], deps.nowIso));
+}
+function deleteColumnFromMeta(meta, rows, input, deps) {
+  const { columnName } = input;
+  const { nowIso } = deps;
+  if (!meta.columns.some((c) => c.name === columnName)) {
+    return err(`\u5B57\u6BB5 ${columnName} \u4E0D\u5B58\u5728`);
+  }
+  const newColumns = meta.columns.filter((c) => c.name !== columnName);
+  const rowPatches = rows.filter((row) => hasOwn(row, columnName)).map((row) => ({
+    dbKey: row.dbKey,
+    changes: { [columnName]: null, updatedAt: nowIso }
+  }));
+  const newRows = rows.map((row) => {
+    if (!hasOwn(row, columnName)) {
+      return row;
+    }
+    const { [columnName]: _removed, ...rest } = row;
+    return { ...rest, updatedAt: nowIso };
+  });
+  return ok({
+    ...buildMeta(meta, newColumns, nowIso),
+    rows: newRows,
+    rowPatches
+  });
+}
+function reorderColumnInMeta(meta, input, deps) {
+  const { fromIndex, toIndex } = input;
+  const columnCount = meta.columns.length;
+  if (fromIndex < 0 || fromIndex >= columnCount || toIndex < 0 || toIndex >= columnCount) {
+    return err("\u5217\u7D22\u5F15\u8D85\u51FA\u8303\u56F4");
+  }
+  if (fromIndex === toIndex) {
+    return ok({
+      meta,
+      metaChanges: { columns: meta.columns, updatedAt: meta.updatedAt },
+      noop: true
+    });
+  }
+  return ok(
+    buildMeta(meta, reorderList(meta.columns, fromIndex, toIndex), deps.nowIso)
+  );
+}
+function renameColumnLabelInMeta(meta, input, deps) {
+  const { columnId } = input;
+  const label = input.label.trim();
+  if (!label) {
+    return err("\u5B57\u6BB5\u663E\u793A\u540D\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (!meta.columns.some((c) => c.id === columnId)) {
+    return err("\u8981\u91CD\u547D\u540D\u7684\u5B57\u6BB5\u4E0D\u5B58\u5728");
+  }
+  const newColumns = meta.columns.map(
+    (c) => c.id === columnId ? { ...c, label } : c
+  );
+  return ok(buildMeta(meta, newColumns, deps.nowIso));
+}
+function updateColumnWidthInMeta(meta, input, deps) {
+  const { columnId, width } = input;
+  if (!meta.columns.some((c) => c.id === columnId)) {
+    return err("\u8981\u8C03\u6574\u5BBD\u5EA6\u7684\u5B57\u6BB5\u4E0D\u5B58\u5728");
+  }
+  const normalizedWidth = typeof width === "number" && width > 0 ? Math.round(width) : void 0;
+  const newColumns = meta.columns.map(
+    (c) => c.id === columnId ? { ...c, width: normalizedWidth } : c
+  );
+  return ok(buildMeta(meta, newColumns, deps.nowIso));
+}
+function addColumnOptionInMeta(meta, input, deps) {
+  const { columnId } = input;
+  const option = input.option.trim();
+  if (!option) {
+    return err("\u9009\u9879\u540D\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const column = meta.columns.find((c) => c.id === columnId);
+  if (!column) {
+    return err("\u8981\u65B0\u589E\u9009\u9879\u7684\u5B57\u6BB5\u4E0D\u5B58\u5728");
+  }
+  if ((column.options ?? []).some((o) => o.trim() === option)) {
+    return ok({
+      meta,
+      metaChanges: { columns: meta.columns, updatedAt: meta.updatedAt },
+      noop: true
+    });
+  }
+  const newColumns = meta.columns.map(
+    (c) => c.id === columnId ? { ...c, options: [...c.options ?? [], option] } : c
+  );
+  return ok(buildMeta(meta, newColumns, deps.nowIso));
+}
+
+// packages/render/table/createTableAction.ts
+import { ulid as ulid2 } from "ulid";
+var DEFAULT_COLUMNS = [
+  {
+    name: "title",
+    label: "\u6807\u9898",
+    type: "text",
+    description: "\u8FD9\u4E00\u884C\u8BB0\u5F55\u7684\u4E3B\u9898\u6216\u540D\u79F0\u3002",
+    isPrimary: true,
+    required: true
+  },
+  {
+    name: "note",
+    label: "\u5907\u6CE8",
+    type: "text",
+    description: "\u5BF9\u8BE5\u6761\u76EE\u7684\u8865\u5145\u8BF4\u660E\u3002",
+    required: false
+  }
+];
+var normalizeColumns = (inputColumns) => {
+  const base = Array.isArray(inputColumns) ? inputColumns : [];
+  const normalized = base.map((c) => {
+    if (!c || typeof c.name !== "string") return null;
+    const name = c.name.trim();
+    if (!name) return null;
+    const col = {
+      id: asOptionalTrimmedString(c.id) ?? ulid2(),
+      name
+    };
+    const label = asOptionalTrimmedString(c.label);
+    if (label) col.label = label;
+    if (typeof c.type === "string") {
+      col.type = c.type;
+    }
+    const description = asOptionalTrimmedString(c.description);
+    if (description) col.description = description;
+    if (typeof c.isPrimary === "boolean") {
+      col.isPrimary = c.isPrimary;
+    }
+    if (typeof c.required === "boolean") {
+      col.required = c.required;
+    }
+    if (Array.isArray(c.options)) {
+      const opts = asTrimmedNonEmptyStringArray(c.options);
+      if (opts.length) {
+        col.options = opts;
+      }
+    }
+    return col;
+  }).filter(Boolean);
+  if (normalized.length > 0) {
+    if (!normalized.some((c) => c.isPrimary)) {
+      normalized[0].isPrimary = true;
+    }
+    return normalized;
+  }
+  return DEFAULT_COLUMNS.map((c) => ({
+    ...c,
+    id: ulid2()
+  }));
+};
+var normalizeStringArray = (value) => {
+  if (!Array.isArray(value)) return void 0;
+  const items = [...new Set(asTrimmedNonEmptyStringArray(value))];
+  return items.length ? items : void 0;
+};
+var normalizePublicIntake = (input) => {
+  if (!isRecord(input)) return void 0;
+  const allowedFields = normalizeStringArray(input.allowedFields) ?? [];
+  if (input.enabled !== true) {
+    return { enabled: false, allowedFields };
+  }
+  if (allowedFields.length === 0) {
+    throw new Error("publicIntake.allowedFields \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u5B57\u6BB5\u3002");
+  }
+  const slug = asOptionalTrimmedString(input.slug);
+  const honeypotField = asOptionalTrimmedString(input.honeypotField);
+  return {
+    enabled: true,
+    ...slug ? { slug } : {},
+    ...normalizeStringArray(input.appIds) ? { appIds: normalizeStringArray(input.appIds) } : {},
+    allowedFields,
+    ...normalizeStringArray(input.requiredFields) ? { requiredFields: normalizeStringArray(input.requiredFields) } : {},
+    ...honeypotField ? { honeypotField } : {}
+  };
+};
+var createTableAction = async ({
+  spaceId: customSpaceId,
+  title: customTitle,
+  purpose: customPurpose,
+  description: customDescription,
+  tags: customTags,
+  publicIntake,
+  categoryId,
+  columns,
+  withDefaultRows = true
+} = {}, { dispatch, getState }) => {
+  const state3 = getState();
+  const userId = selectIdentityUserId(state3);
+  if (!userId) throw new Error("User ID not found.");
+  const spaceId = customSpaceId ?? getCurrentSpaceId();
+  const tableId = ulid2();
+  const now = /* @__PURE__ */ new Date();
+  const nowIso = formatISO(now);
+  const dbKey = metaKey(userId, tableId);
+  const defaultTitle = runtime_default.t("space:newTable", {
+    defaultValue: "\u65B0\u5EFA\u8868\u683C"
+  });
+  const title = asOptionalTrimmedString(customTitle) ?? defaultTitle;
+  const purpose = asOptionalTrimmedString(customPurpose);
+  const description = asOptionalTrimmedString(customDescription);
+  const tags = Array.isArray(customTags) && customTags.length ? asTrimmedNonEmptyStringArray(customTags) : void 0;
+  const finalPublicIntake = normalizePublicIntake(publicIntake);
+  const finalColumns = normalizeColumns(columns);
+  const tableMeta = {
+    dbKey,
+    tenantId: userId,
+    tableId,
+    spaceId: spaceId ?? null,
+    displayName: title,
+    purpose,
+    description,
+    tags,
+    schemaVersion: 1,
+    columns: finalColumns,
+    views: [],
+    // 后续可以在 UI 中新增视图
+    triggers: [],
+    // 后续可以在 UI/配置中新增触发器
+    aiConfig: void 0,
+    ...finalPublicIntake ? { publicIntake: finalPublicIntake } : {},
+    createdAt: nowIso,
+    updatedAt: nowIso,
+    type: "table" /* TABLE */
+  };
+  await dispatch(
+    write({
+      data: tableMeta,
+      customKey: dbKey
+    })
+  ).unwrap();
+  if (withDefaultRows) {
+    const defaultRows = [
+      {
+        title: "\u793A\u4F8B\u4E00",
+        note: "\u4F60\u53EF\u4EE5\u5728\u8FD9\u91CC\u8BB0\u5F55\u4EFB\u4F55\u5185\u5BB9\uFF0C\u4F8B\u5982\u4EFB\u52A1\u3001\u60F3\u6CD5\u6216\u914D\u7F6E\u9879\u3002"
+      },
+      {
+        title: "\u793A\u4F8B\u4E8C",
+        note: "\u53CC\u51FB\u5355\u5143\u683C\u5F00\u59CB\u7F16\u8F91\uFF0C\u53F3\u4E0A\u89D2\u53EF\u4EE5\u6DFB\u52A0\u5B57\u6BB5\u548C\u884C\u3002"
+      }
+    ];
+    await Promise.all(
+      defaultRows.map(async (values) => {
+        const { dbKey: rowKeyStr, rowId } = rowKey.create(userId, tableId);
+        const row = {
+          dbKey: rowKeyStr,
+          tenantId: userId,
+          tableId,
+          rowId,
+          createdAt: nowIso,
+          updatedAt: nowIso,
+          type: "table_row" /* TABLE_ROW */,
+          ...values
+        };
+        await dispatch(
+          write({
+            data: row,
+            customKey: rowKeyStr
+          })
+        ).unwrap();
+      })
+    );
+  }
+  if (spaceId) {
+    await dispatch(
+      addContentToSpace({
+        spaceId,
+        contentKey: dbKey,
+        type: "table" /* TABLE */,
+        title,
+        categoryId
+      })
+    ).unwrap();
+  }
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(new Event("nolo-user-data-updated"));
+  }
+  return dbKey;
+};
+
+// packages/render/table/deleteTableAction.ts
+var parseMetaKey = (dbKey) => {
+  const parts = dbKey.split(SEPARATOR);
+  if (parts[0] !== "meta" || parts.length < 3) {
+    throw new Error(`\u975E\u6CD5\u8868 key\uFF1A${dbKey}`);
+  }
+  const tenantId = parts[1];
+  const tableId = parts.slice(2).join(SEPARATOR);
+  return { tenantId, tableId };
+};
+var collectEntriesByPrefix = async (db, prefix) => {
+  const entries = [];
+  for await (const [key, value] of db.iterator({
+    gte: prefix,
+    lte: prefix + "\uFFFF"
+  })) {
+    entries.push([key, value]);
+  }
+  return entries;
+};
+var belongsToTable = (value, tenantId, tableId) => Boolean(
+  value && typeof value === "object" && value.tenantId === tenantId && value.tableId === tableId
+);
+var indexValueReferencesRows = (value, rowDbKeys, rowIds) => {
+  if (typeof value === "string") {
+    return rowDbKeys.has(value) || rowIds.has(value);
+  }
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.dbKey === "string" && rowDbKeys.has(candidate.dbKey) || typeof candidate.rowDbKey === "string" && rowDbKeys.has(candidate.rowDbKey) || typeof candidate.rowId === "string" && rowIds.has(candidate.rowId);
+};
+var deleteTableAction = async ({ dbKey }, {
+  dispatch,
+  getState,
+  extra
+}) => {
+  const { db } = extra;
+  const state3 = getState();
+  const { currentServer, syncServers } = getRuntimeServerContext(state3);
+  const { tenantId, tableId } = parseMetaKey(dbKey);
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  const rowPrefix = createKey("row", tenantId, tableId, "");
+  const rowEntries = (await collectEntriesByPrefix(db, rowPrefix)).filter(
+    ([, value]) => belongsToTable(value, tenantId, tableId)
+  );
+  const rowDbKeys = new Set(rowEntries.map(([key]) => key));
+  const rowIds = new Set(
+    rowEntries.map(([, value]) => value.rowId).filter((rowId) => typeof rowId === "string")
+  );
+  const idxPrefix = createKey("idx", tenantId, tableId, "");
+  const idxEntries = await collectEntriesByPrefix(db, idxPrefix);
+  const idxKeys = idxEntries.filter(
+    ([, value]) => belongsToTable(value, tenantId, tableId) || indexValueReferencesRows(value, rowDbKeys, rowIds)
+  ).map(([key]) => key);
+  const viewPrefix = createKey("view", tenantId, tableId, "");
+  const viewEntries = await collectEntriesByPrefix(db, viewPrefix);
+  const viewKeys = viewEntries.filter(([, value]) => belongsToTable(value, tenantId, tableId)).map(([key]) => key);
+  const metaRecord = typeof db.get === "function" ? await db.get(dbKey).catch(() => null) : null;
+  const keysToDelete = Array.from(
+    /* @__PURE__ */ new Set([
+      ...idxKeys,
+      ...viewKeys
+    ])
+  );
+  const putOps = [
+    ...metaRecord && typeof metaRecord === "object" ? [
+      {
+        type: "put",
+        key: dbKey,
+        value: buildTombstoneRecord(metaRecord, nowIso)
+      }
+    ] : [],
+    ...rowEntries.map(([key, value]) => ({
+      type: "put",
+      key,
+      value: buildTombstoneRecord(value, nowIso)
+    }))
+  ];
+  if (keysToDelete.length > 0 || putOps.length > 0) {
+    const ops = [
+      ...putOps,
+      ...keysToDelete.map((key) => ({
+        type: "del",
+        key
+      }))
+    ];
+    await db.batch(ops);
+  }
+  scheduleDeleteReplication({
+    currentServer,
+    syncServers,
+    dbKey,
+    deleteOptions: { type: "table" },
+    state: state3
+  });
+  return dbKey;
+};
+
+// packages/render/table/tableStore.ts
+async function safeDispatch(dispatch, action) {
+  if (!dispatch) return void 0;
+  const res = await dispatch(action);
+  if (res && typeof res.unwrap === "function") {
+    return await res.unwrap();
+  }
+  return res?.payload ?? res;
+}
+var createInitialState = () => ({
+  currentTable: null,
+  expectedTableKey: null,
+  isLoading: false,
+  isInitialized: false,
+  error: null,
+  rows: [],
+  focusContext: null
+});
+var listeners = /* @__PURE__ */ new Set();
+var version = 0;
+var state = createInitialState();
+var notify = () => {
+  for (const listener of listeners) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+};
+var bump = () => {
+  version += 1;
+  notify();
+};
+var setState = (updater) => {
+  state = typeof updater === "function" ? updater(state) : updater;
+  bump();
+};
+function getTableState() {
+  return state;
+}
+function createTableCommand(name, fn) {
+  const command = (args) => {
+    return async (dispatch, getState, extra) => {
+      try {
+        const payload = await fn(args, { dispatch, getState, extra });
+        return {
+          type: `${name}/fulfilled`,
+          payload,
+          meta: { arg: args },
+          unwrap: async () => payload
+        };
+      } catch (err2) {
+        const message = err2?.message || String(err2);
+        return {
+          type: `${name}/rejected`,
+          payload: message,
+          error: { message },
+          unwrap: async () => {
+            throw err2 instanceof Error ? err2 : new Error(message);
+          }
+        };
+      }
+    };
+  };
+  command.fulfilled = {
+    type: `${name}/fulfilled`,
+    match: (action) => action?.type === `${name}/fulfilled`
+  };
+  command.rejected = {
+    type: `${name}/rejected`,
+    match: (action) => action?.type === `${name}/rejected`
+  };
+  command.pending = {
+    type: `${name}/pending`,
+    match: (action) => action?.type === `${name}/pending`
+  };
+  command.run = (args, context = {}) => fn(args, context);
+  return command;
+}
+var initTable = createTableCommand(
+  "table/initTable",
+  async (args, { dispatch } = {}) => {
+    const { tenantId, tableId } = args;
+    const dbKey = metaKey(tenantId, tableId);
+    setState((s) => ({
+      ...s,
+      isLoading: true,
+      error: null,
+      isInitialized: false,
+      currentTable: null,
+      // 从第一行起就声明「预期表」：读取期间 currentTable 为 null，
+      // 但只有本表的 loadTableRows 结果有权写入（见 isCurrentTableTarget）。
+      expectedTableKey: { tenantId, tableId },
+      rows: []
+    }));
+    try {
+      if (!dispatch) {
+        throw new Error("dispatch is required to initialize table");
+      }
+      const readAction = await dispatch(readAndWait(dbKey));
+      const isMatch = typeof readAndWait?.fulfilled?.match === "function" && readAndWait.fulfilled.match(readAction);
+      const meta = isMatch && readAction.payload ? readAction.payload : readAction?.payload || readAction;
+      if (meta && typeof meta === "object" && ("columns" in meta || "displayName" in meta || "tableId" in meta)) {
+        setState((s) => {
+          if (!isCurrentTableTarget(s, tenantId, tableId)) return s;
+          return {
+            ...s,
+            isLoading: false,
+            isInitialized: true,
+            currentTable: meta,
+            error: null
+          };
+        });
+        return meta;
+      }
+      const msg = readAction.payload?.message || `\u65E0\u6CD5\u52A0\u8F7D\u8868 ${tableId}`;
+      setState((s) => {
+        if (!isCurrentTableTarget(s, tenantId, tableId)) return s;
+        return {
+          ...s,
+          isLoading: false,
+          isInitialized: true,
+          currentTable: null,
+          error: msg,
+          rows: []
+        };
+      });
+      throw new Error(msg);
+    } catch (e) {
+      const msg = e?.message || `\u521D\u59CB\u5316\u8868 ${tableId} \u65F6\u51FA\u9519`;
+      setState((s) => {
+        if (!isCurrentTableTarget(s, tenantId, tableId)) return s;
+        return {
+          ...s,
+          isLoading: false,
+          isInitialized: true,
+          currentTable: null,
+          error: msg,
+          rows: []
+        };
+      });
+      throw e;
+    }
+  }
+);
+var sameTableTarget = (target, tenantId, tableId) => !!target && target.tenantId === tenantId && target.tableId === tableId;
+var isCurrentTableTarget = (s, tenantId, tableId) => {
+  if (s.expectedTableKey) {
+    return sameTableTarget(s.expectedTableKey, tenantId, tableId);
+  }
+  if (s.currentTable) {
+    return sameTableTarget(s.currentTable, tenantId, tableId);
+  }
+  return true;
+};
+var loadTableRows = createTableCommand(
+  "table/loadTableRows",
+  async (args, { getState, extra } = {}) => {
+    const { tenantId, tableId } = args;
+    const db = extra?.db;
+    setState((s) => {
+      if (isCurrentTableTarget(s, tenantId, tableId)) {
+        return { ...s, error: null };
+      }
+      return s;
+    });
+    try {
+      const stateObj = getState ? getState() : {};
+      const { currentToken: token, remoteServers } = getRuntimeServerContext(stateObj);
+      const rows = await fetchAndCacheTableRows({
+        db,
+        tenantId,
+        tableId,
+        token,
+        remoteServers
+      });
+      setState((s) => {
+        if (isCurrentTableTarget(s, tenantId, tableId)) {
+          return { ...s, rows };
+        }
+        return s;
+      });
+      return rows;
+    } catch (e) {
+      const msg = e?.message || "\u52A0\u8F7D\u8868\u884C\u5931\u8D25";
+      try {
+        const stateObj = getState ? getState() : {};
+        const { remoteServers } = getRuntimeServerContext(stateObj);
+        logger.warn(
+          {
+            tenantId,
+            tableId,
+            remoteServers: remoteServers?.length ?? 0,
+            err: msg
+          },
+          "loadTableRows failed"
+        );
+      } catch {
+      }
+      setState((s) => {
+        if (isCurrentTableTarget(s, tenantId, tableId)) {
+          return { ...s, error: msg, rows: [] };
+        }
+        return s;
+      });
+      throw e;
+    }
+  }
+);
+var addRow = createTableCommand(
+  "table/addRow",
+  async (args, { dispatch } = {}) => {
+    const { tenantId, tableId, values } = args;
+    setState((s) => {
+      if (s.currentTable && s.currentTable.tenantId === tenantId && s.currentTable.tableId === tableId) {
+        return { ...s, error: null };
+      }
+      return s;
+    });
+    try {
+      const { dbKey, rowId } = rowKey.create(tenantId, tableId);
+      const nowIso = formatISO(/* @__PURE__ */ new Date());
+      const row = {
+        dbKey,
+        tenantId,
+        tableId,
+        rowId,
+        createdAt: nowIso,
+        updatedAt: nowIso,
+        type: "table_row" /* TABLE_ROW */,
+        ...values
+      };
+      if (dispatch) {
+        await safeDispatch(
+          dispatch,
+          write({
+            data: row,
+            customKey: dbKey
+          })
+        );
+      }
+      setState((s) => {
+        const meta = s.currentTable;
+        if (meta && row?.tenantId === meta.tenantId && row?.tableId === meta.tableId) {
+          return { ...s, rows: [...s.rows, row] };
+        }
+        return s;
+      });
+      return row;
+    } catch (e) {
+      const msg = e?.message || "\u65B0\u589E\u8868\u884C\u5931\u8D25";
+      setState((s) => {
+        if (s.currentTable && s.currentTable.tenantId === tenantId && s.currentTable.tableId === tableId) {
+          return { ...s, error: msg };
+        }
+        return s;
+      });
+      throw e;
+    }
+  }
+);
+var deleteRow = createTableCommand(
+  "table/deleteRow",
+  async (dbKey, { dispatch, getState, extra } = {}) => {
+    try {
+      let row = state.rows.find((item) => item?.dbKey === dbKey);
+      if (!row && extra?.db && typeof extra.db.get === "function") {
+        try {
+          row = await extra.db.get(dbKey);
+        } catch {
+        }
+      }
+      if (!row && dispatch) {
+        try {
+          const readAction = await safeDispatch(dispatch, readAndWait(dbKey));
+          row = readAction?.payload || readAction;
+        } catch {
+        }
+      }
+      if (!row) {
+        throw new Error(`\u5F53\u524D\u8868\u4E2D\u627E\u4E0D\u5230\u8981\u5220\u9664\u7684\u884C\uFF1A${dbKey}`);
+      }
+      const nowIso = formatISO(/* @__PURE__ */ new Date());
+      const tombstoneRow = {
+        ...row,
+        deletedAt: nowIso,
+        updatedAt: nowIso,
+        type: "table_row" /* TABLE_ROW */
+      };
+      if (extra?.db && typeof extra.db.put === "function") {
+        await extra.db.put(dbKey, tombstoneRow);
+      }
+      if (dispatch) {
+        dispatch(upsertSSREntity(tombstoneRow));
+      }
+      const stateObj = getState ? getState() : {};
+      const { currentServer, syncServers } = getRuntimeServerContext(stateObj);
+      const servers = resolveReplicationServers(currentServer, syncServers);
+      scheduleWriteReplication(
+        servers,
+        {
+          data: tombstoneRow,
+          customKey: dbKey
+        },
+        stateObj
+      );
+      setState((s) => ({
+        ...s,
+        rows: s.rows.filter((r) => r.dbKey !== dbKey)
+      }));
+      return dbKey;
+    } catch (e) {
+      const msg = e?.message || "\u5220\u9664\u8868\u884C\u5931\u8D25";
+      setState((s) => ({ ...s, error: msg }));
+      throw e;
+    }
+  }
+);
+var createTable = createTableCommand(
+  "table/createTable",
+  async (args, context = {}) => {
+    return await createTableAction(args, context);
+  }
+);
+var deleteTable = createTableCommand(
+  "table/deleteTable",
+  async (args, context = {}) => {
+    setState((s) => ({ ...s, error: null }));
+    try {
+      const deletedKey = await deleteTableAction(args, context);
+      setState((s) => {
+        if (s.currentTable?.dbKey === deletedKey) {
+          return {
+            ...s,
+            currentTable: null,
+            rows: [],
+            isInitialized: false
+          };
+        }
+        return s;
+      });
+      return deletedKey;
+    } catch (e) {
+      const msg = e?.message || "\u5220\u9664\u8868\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+      setState((s) => ({ ...s, error: msg }));
+      throw e;
+    }
+  }
+);
+var addColumn = createTableCommand(
+  "table/addColumn",
+  async (args, { dispatch } = {}) => {
+    const { tenantId, tableId, columnName } = args;
+    const meta = state.currentTable;
+    if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
+      throw new Error("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
+    }
+    const result = addColumnToMeta(
+      meta,
+      { columnName },
+      { id: ulid3(), nowIso: formatISO(/* @__PURE__ */ new Date()) }
+    );
+    if (!result.ok) {
+      throw new Error(result.error);
+    }
+    setState((s) => ({ ...s, error: null }));
+    try {
+      if (dispatch) {
+        await safeDispatch(
+          dispatch,
+          patch({
+            dbKey: meta.dbKey,
+            changes: result.value.metaChanges
+          })
+        );
+      }
+      setState((s) => ({
+        ...s,
+        currentTable: result.value.meta,
+        isInitialized: true
+      }));
+      return result.value.meta;
+    } catch (e) {
+      const msg = e?.message || "\u6DFB\u52A0\u5B57\u6BB5\u5931\u8D25";
+      setState((s) => ({ ...s, error: msg }));
+      throw e;
+    }
+  }
+);
+var deleteColumn = createTableCommand(
+  "table/deleteColumn",
+  async (args, { dispatch } = {}) => {
+    const { tenantId, tableId, columnName } = args;
+    const meta = state.currentTable;
+    if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
+      throw new Error("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
+    }
+    const result = deleteColumnFromMeta(
+      meta,
+      state.rows,
+      { columnName },
+      { nowIso: formatISO(/* @__PURE__ */ new Date()) }
+    );
+    if (!result.ok) {
+      throw new Error(result.error);
+    }
+    const { meta: nextMeta, metaChanges, rows: newRows, rowPatches } = result.value;
+    setState((s) => ({ ...s, error: null }));
+    try {
+      if (dispatch) {
+        await Promise.all(
+          rowPatches.map((p) => safeDispatch(dispatch, patch(p)))
+        );
+        await safeDispatch(
+          dispatch,
+          patch({ dbKey: meta.dbKey, changes: metaChanges })
+        );
+      }
+      setState((s) => ({
+        ...s,
+        currentTable: nextMeta,
+        rows: newRows,
+        isInitialized: true
+      }));
+      return { meta: nextMeta, rows: newRows };
+    } catch (e) {
+      const msg = e?.message || "\u5220\u9664\u5B57\u6BB5\u5931\u8D25";
+      setState((s) => ({ ...s, error: msg }));
+      throw e;
+    }
+  }
+);
+var reorderColumn = createTableCommand(
+  "table/reorderColumn",
+  async (args, { dispatch } = {}) => {
+    const { tenantId, tableId, fromIndex, toIndex } = args;
+    const meta = state.currentTable;
+    if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
+      throw new Error("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
+    }
+    const result = reorderColumnInMeta(
+      meta,
+      { fromIndex, toIndex },
+      { nowIso: formatISO(/* @__PURE__ */ new Date()) }
+    );
+    if (!result.ok) {
+      throw new Error(result.error);
+    }
+    if (result.value.noop) {
+      return meta;
+    }
+    const { meta: nextMeta, metaChanges } = result.value;
+    setState((s) => ({ ...s, error: null }));
+    try {
+      if (dispatch) {
+        await safeDispatch(
+          dispatch,
+          patch({ dbKey: meta.dbKey, changes: metaChanges })
+        );
+      }
+      setState((s) => ({
+        ...s,
+        currentTable: nextMeta,
+        isInitialized: true
+      }));
+      return nextMeta;
+    } catch (e) {
+      const msg = e?.message || "\u8C03\u6574\u5217\u987A\u5E8F\u5931\u8D25";
+      setState((s) => ({ ...s, error: msg }));
+      throw e;
+    }
+  }
+);
+var renameColumnLabel = createTableCommand(
+  "table/renameColumnLabel",
+  async (args, { dispatch } = {}) => {
+    const { tenantId, tableId, columnId, newLabel } = args;
+    const meta = state.currentTable;
+    if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
+      throw new Error("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
+    }
+    const result = renameColumnLabelInMeta(
+      meta,
+      { columnId, label: newLabel },
+      { nowIso: formatISO(/* @__PURE__ */ new Date()) }
+    );
+    if (!result.ok) {
+      throw new Error(result.error);
+    }
+    const { meta: nextMeta, metaChanges } = result.value;
+    setState((s) => ({ ...s, error: null }));
+    try {
+      if (dispatch) {
+        await safeDispatch(
+          dispatch,
+          patch({ dbKey: meta.dbKey, changes: metaChanges })
+        );
+      }
+      setState((s) => ({
+        ...s,
+        currentTable: nextMeta,
+        isInitialized: true
+      }));
+      return nextMeta;
+    } catch (e) {
+      const msg = e?.message || "\u91CD\u547D\u540D\u5B57\u6BB5\u663E\u793A\u540D\u5931\u8D25";
+      setState((s) => ({ ...s, error: msg }));
+      throw e;
+    }
+  }
+);
+var updateColumnWidth = createTableCommand(
+  "table/updateColumnWidth",
+  async (args, { dispatch } = {}) => {
+    const { tenantId, tableId, columnId, width } = args;
+    const meta = state.currentTable;
+    if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
+      throw new Error("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
+    }
+    const result = updateColumnWidthInMeta(
+      meta,
+      { columnId, width },
+      { nowIso: formatISO(/* @__PURE__ */ new Date()) }
+    );
+    if (!result.ok) {
+      throw new Error(result.error);
+    }
+    const { meta: nextMeta, metaChanges } = result.value;
+    setState((s) => ({ ...s, error: null }));
+    try {
+      if (dispatch) {
+        await safeDispatch(
+          dispatch,
+          patch({ dbKey: meta.dbKey, changes: metaChanges })
+        );
+      }
+      setState((s) => ({
+        ...s,
+        currentTable: nextMeta,
+        isInitialized: true
+      }));
+      return nextMeta;
+    } catch (e) {
+      const msg = e?.message || "\u66F4\u65B0\u5B57\u6BB5\u5BBD\u5EA6\u5931\u8D25";
+      setState((s) => ({ ...s, error: msg }));
+      throw e;
+    }
+  }
+);
+var addColumnOption = createTableCommand(
+  "table/addColumnOption",
+  async (args, { dispatch } = {}) => {
+    const { tenantId, tableId, columnId, option } = args;
+    const meta = state.currentTable;
+    if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
+      throw new Error("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
+    }
+    const result = addColumnOptionInMeta(
+      meta,
+      { columnId, option },
+      { nowIso: formatISO(/* @__PURE__ */ new Date()) }
+    );
+    if (!result.ok) {
+      throw new Error(result.error);
+    }
+    if (result.value.noop) {
+      return meta;
+    }
+    const { meta: nextMeta, metaChanges } = result.value;
+    setState((s) => ({ ...s, error: null }));
+    try {
+      if (dispatch) {
+        await safeDispatch(
+          dispatch,
+          patch({ dbKey: meta.dbKey, changes: metaChanges })
+        );
+      }
+      setState((s) => ({
+        ...s,
+        currentTable: nextMeta,
+        isInitialized: true
+      }));
+      return nextMeta;
+    } catch (e) {
+      const msg = e?.message || "\u65B0\u589E\u9009\u9879\u5931\u8D25";
+      setState((s) => ({ ...s, error: msg }));
+      throw e;
+    }
+  }
+);
+var renameTable = createTableCommand(
+  "table/renameTable",
+  async (args, { dispatch } = {}) => {
+    const { tenantId, tableId, newName } = args;
+    const trimmedName = newName.trim();
+    if (!trimmedName) {
+      throw new Error("\u8868\u540D\u4E0D\u80FD\u4E3A\u7A7A");
+    }
+    const meta = state.currentTable;
+    if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
+      throw new Error("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
+    }
+    const nowIso = formatISO(/* @__PURE__ */ new Date());
+    setState((s) => ({ ...s, error: null }));
+    try {
+      if (dispatch) {
+        await safeDispatch(
+          dispatch,
+          patch({
+            dbKey: meta.dbKey,
+            changes: {
+              displayName: trimmedName,
+              updatedAt: nowIso
+            }
+          })
+        );
+      }
+      const nextMeta = {
+        ...meta,
+        displayName: trimmedName,
+        updatedAt: nowIso
+      };
+      setState((s) => {
+        if (!isCurrentTableTarget(s, tenantId, tableId) || !sameTableTarget(s.currentTable, tenantId, tableId)) return s;
+        return {
+          ...s,
+          currentTable: { ...s.currentTable, displayName: trimmedName, updatedAt: nowIso },
+          isInitialized: true
+        };
+      });
+      return nextMeta;
+    } catch (e) {
+      const msg = e?.message || "\u91CD\u547D\u540D\u8868\u5931\u8D25";
+      setState((s) => sameTableTarget(s.expectedTableKey ?? s.currentTable, tenantId, tableId) ? { ...s, error: msg } : s);
+      throw e;
+    }
+  }
+);
+var updateTableIcon = createTableCommand(
+  "table/updateTableIcon",
+  async (args, { dispatch } = {}) => {
+    const { tenantId, tableId, icon } = args;
+    const meta = state.currentTable;
+    if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
+      throw new Error("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
+    }
+    const nowIso = formatISO(/* @__PURE__ */ new Date());
+    setState((s) => ({ ...s, error: null }));
+    try {
+      if (dispatch) {
+        await safeDispatch(
+          dispatch,
+          patch({
+            dbKey: meta.dbKey,
+            changes: {
+              icon: icon ?? null,
+              updatedAt: nowIso
+            }
+          })
+        );
+      }
+      const nextMeta = {
+        ...meta,
+        icon: icon ?? null,
+        updatedAt: nowIso
+      };
+      setState((s) => {
+        if (!isCurrentTableTarget(s, tenantId, tableId) || !sameTableTarget(s.currentTable, tenantId, tableId)) return s;
+        return {
+          ...s,
+          currentTable: { ...s.currentTable, icon: icon ?? null, updatedAt: nowIso }
+        };
+      });
+      return nextMeta;
+    } catch (e) {
+      const msg = e?.message || "\u66F4\u65B0\u8868\u683C\u56FE\u6807\u5931\u8D25";
+      setState((s) => sameTableTarget(s.expectedTableKey ?? s.currentTable, tenantId, tableId) ? { ...s, error: msg } : s);
+      throw e;
+    }
+  }
+);
+var updateCell = createTableCommand(
+  "table/updateCell",
+  async (args, { dispatch } = {}) => {
+    const { dbKey, columnName, value } = args;
+    setState((s) => ({ ...s, error: null }));
+    try {
+      const nowIso = formatISO(/* @__PURE__ */ new Date());
+      if (dispatch) {
+        await safeDispatch(
+          dispatch,
+          patch({
+            dbKey,
+            changes: {
+              [columnName]: value,
+              updatedAt: nowIso
+            }
+          })
+        );
+      }
+      setState((s) => ({
+        ...s,
+        rows: s.rows.map((r) => {
+          if (r.dbKey === dbKey) {
+            return {
+              ...r,
+              [columnName]: value,
+              updatedAt: nowIso
+            };
+          }
+          return r;
+        })
+      }));
+      return { dbKey, columnName, value, updatedAt: nowIso };
+    } catch (e) {
+      const msg = e?.message || "\u66F4\u65B0\u5355\u5143\u683C\u5931\u8D25";
+      setState((s) => ({ ...s, error: msg }));
+      throw e;
+    }
+  }
+);
+
+// packages/create/space/content/deleteContentFromSpaceAction.ts
+var nextSpaceUpdatedAt = (value) => {
+  const previousTimestamp = typeof value === "number" ? value : typeof value === "string" ? Date.parse(value) || 0 : 0;
+  const nextTimestamp = Math.max(Date.now(), previousTimestamp + 1);
+  return typeof value === "string" ? new Date(nextTimestamp).toISOString() : nextTimestamp;
+};
+var findContentReference = (spaceData, requestedContentKey) => {
+  const contents = spaceData.contents ?? {};
+  const directMatch = contents[requestedContentKey];
+  if (directMatch) {
+    return { entryKey: requestedContentKey, contentInfo: directMatch };
+  }
+  for (const [entryKey, item] of Object.entries(contents)) {
+    if (!item) continue;
+    if (item.contentKey === requestedContentKey) {
+      return { entryKey, contentInfo: item };
+    }
+  }
+  return null;
+};
+var ENTITY_DELETE_STRATEGIES = {
+  dialog: async (key, { dispatch }) => {
+    await dispatch(deleteDialog(key)).unwrap();
+  },
+  page: async (key, { dispatch, userId, sourceServerOrigin }) => {
+    const isOwnerByKey = extractUserId(key) === userId;
+    if (isOwnerByKey || isSystemAdmin(userId)) {
+      await dispatch(remove({ dbKey: key, preferredServerOrigin: sourceServerOrigin }));
+    }
+  },
+  table: async (key, { dispatch }) => {
+    await dispatch(deleteTable({ dbKey: key })).unwrap();
+  },
+  file: async (key, { thunkAPI }) => {
+    const { deleteFileAction } = await import("./deleteFile-YM6NDPAR.js");
+    await deleteFileAction(key, thunkAPI);
+  },
+  image: async (key, { thunkAPI }) => {
+    const { deleteFileAction } = await import("./deleteFile-YM6NDPAR.js");
+    await deleteFileAction(key, thunkAPI);
+  },
+  agent: async (key, { dispatch, userId, sourceServerOrigin }) => {
+    const parts = splitKey(key);
+    const isPublic = parts[1] === "pub";
+    const isOwnerByKey = parts[1] === userId;
+    if (!isPublic) {
+      if (isOwnerByKey || isSystemAdmin(userId)) {
+        await dispatch(remove({ dbKey: key, preferredServerOrigin: sourceServerOrigin }));
+      }
+    } else {
+      const agentData = await dispatch(read({
+        dbKey: key,
+        preferredServerOrigin: sourceServerOrigin
+      })).unwrap();
+      if (agentData) {
+        const isCreator = agentData.userId === userId;
+        const isAdmin = isSystemAdmin(userId);
+        if (isCreator || isAdmin) {
+          await dispatch(remove({ dbKey: key, preferredServerOrigin: sourceServerOrigin }));
+        }
+      }
+    }
+  }
+};
+var deleteContentFromSpaceAction = async (input, thunkAPI) => {
+  const { contentKey, sourceServerOrigin } = input;
+  const spaceId = normalizeSpaceId(input.spaceId);
+  const { dispatch, getState } = thunkAPI;
+  const accountUserId = selectIdentityUserId(getState());
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceData = await dispatch(read({
+    dbKey: spaceKey,
+    preferredServerOrigin: sourceServerOrigin
+  })).unwrap();
+  if (!spaceData) throw new Error("\u7A7A\u95F4\u4E0D\u5B58\u5728");
+  checkSpaceMembership(spaceData, accountUserId);
+  const contentReference = findContentReference(spaceData, contentKey);
+  if (!contentReference) {
+    return { contentKey, spaceId, updatedSpaceData: spaceData };
+  }
+  const { entryKey, contentInfo } = contentReference;
+  const entityKey = String(contentInfo.contentKey || contentKey || entryKey);
+  const contentDeletes = {
+    [entryKey]: null
+  };
+  if (entityKey !== entryKey) {
+    contentDeletes[entityKey] = null;
+  }
+  const updatedSpaceData = await dispatch(
+    patch({
+      dbKey: spaceKey,
+      preferredServerOrigin: sourceServerOrigin,
+      changes: {
+        contents: contentDeletes,
+        updatedAt: nextSpaceUpdatedAt(spaceData.updatedAt),
+        ...localSpaceAuthorityPatchStamp(spaceData)
+      }
+    })
+  ).unwrap();
+  const userId = isDeviceLocalSpaceBody(spaceData) ? DEVICE_LOCAL_OWNER_ID : String(accountUserId ?? "");
+  let entityRemoveError = null;
+  const contentType = String(contentInfo.type || "").toLowerCase();
+  try {
+    const strategy = ENTITY_DELETE_STRATEGIES[contentType];
+    if (strategy) {
+      await strategy(entityKey, { dispatch, userId, thunkAPI, sourceServerOrigin });
+    } else if (isPageKey(entityKey)) {
+      await ENTITY_DELETE_STRATEGIES.page(entityKey, {
+        dispatch,
+        userId,
+        thunkAPI,
+        sourceServerOrigin
+      });
+    } else if (isAgentKey(entityKey)) {
+      await ENTITY_DELETE_STRATEGIES.agent(entityKey, {
+        dispatch,
+        userId,
+        thunkAPI,
+        sourceServerOrigin
+      });
+    }
+  } catch (err2) {
+    console.error(`[deleteContent] Failed to delete entity ${entityKey}:`, err2);
+    entityRemoveError = err2.message || "Unknown error";
+  }
+  return {
+    contentKey,
+    spaceId,
+    updatedSpaceData,
+    entityRemoveError
+  };
+};
+
+// packages/create/space/content/moveContentAction.ts
+var logger2 = createClientLogger("move-content");
+var moveContentAction = async (input, thunkAPI) => {
+  const {
+    contentKey,
+    sourceSpaceId,
+    targetSpaceId,
+    targetCategoryId: rawTargetCategoryId
+  } = input;
+  const { dispatch, getState } = thunkAPI;
+  const state3 = getState();
+  const userId = selectIdentityUserId(state3);
+  const now = Date.now();
+  logger2.info({ ...input, userId }, "Initiating moveContentAction");
+  if (sourceSpaceId === targetSpaceId) {
+    logger2.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.");
+    throw new Error("\u65E0\u6548\u7684\u5185\u5BB9 Key\u3002");
+  }
+  let sourceSpaceData = null;
+  let targetSpaceData = null;
+  let contentDataFromSource = null;
+  let finalSourceData = null;
+  let finalTargetData = null;
+  let overallError = void 0;
+  try {
+    const sourceSpaceKey = createSpaceKey.space(sourceSpaceId);
+    const targetSpaceKey = createSpaceKey.space(targetSpaceId);
+    logger2.info(
+      { sourceSpaceKey, targetSpaceKey },
+      "Reading source and target space data."
+    );
+    const [sourceResult, targetResult] = await Promise.allSettled([
+      dispatch(read({
+        dbKey: sourceSpaceKey
+      })).unwrap(),
+      dispatch(read({
+        dbKey: targetSpaceKey
+      })).unwrap()
+    ]);
+    if (sourceResult.status === "rejected" || !sourceResult.value) {
+      const reason = sourceResult.status === "rejected" ? sourceResult.reason : "Data is null";
+      throw new Error(
+        `\u65E0\u6CD5\u52A0\u8F7D\u6E90\u7A7A\u95F4 (${sourceSpaceId}): ${reason?.message || reason}`
+      );
+    }
+    sourceSpaceData = sourceResult.value;
+    if (targetResult.status === "rejected" || !targetResult.value) {
+      const reason = targetResult.status === "rejected" ? targetResult.reason : "Data is null";
+      throw new Error(
+        `\u65E0\u6CD5\u52A0\u8F7D\u76EE\u6807\u7A7A\u95F4 (${targetSpaceId}): ${reason?.message || reason}`
+      );
+    }
+    targetSpaceData = targetResult.value;
+    logger2.info("Checking permissions for source and target spaces.");
+    checkSpaceMembership(sourceSpaceData, userId);
+    checkSpaceMembership(targetSpaceData, userId);
+    if (!sourceSpaceData.contents || !sourceSpaceData.contents[contentKey]) {
+      logger2.error(
+        { contentKey, sourceSpaceId },
+        "Content key not found in source space contents."
+      );
+      throw new Error(
+        `\u5185\u5BB9 (${contentKey}) \u4E0D\u5728\u6E90\u7A7A\u95F4 (${sourceSpaceId}) \u4E2D\u3002`
+      );
+    }
+    contentDataFromSource = sourceSpaceData.contents[contentKey];
+    if (targetSpaceData.contents && targetSpaceData.contents[contentKey]) {
+      logger2.warn(
+        { contentKey, targetSpaceId },
+        "Content key already exists in target space. Overwriting."
+      );
+    }
+    let categoryIdForTargetStorage;
+    if (rawTargetCategoryId && rawTargetCategoryId !== "" && rawTargetCategoryId !== UNCATEGORIZED_ID) {
+      if (targetSpaceData.categories?.[rawTargetCategoryId]) {
+        categoryIdForTargetStorage = rawTargetCategoryId;
+      } else {
+        logger2.warn(
+          `Target category ${rawTargetCategoryId} not found in target space ${targetSpaceId}. Content will be uncategorized.`
+        );
+        categoryIdForTargetStorage = void 0;
+      }
+    } else {
+      categoryIdForTargetStorage = void 0;
+    }
+    const contentReferenceForTarget = {
+      ...contentDataFromSource,
+      updatedAt: now
+    };
+    delete contentReferenceForTarget.categoryId;
+    if (categoryIdForTargetStorage !== void 0) {
+      contentReferenceForTarget.categoryId = categoryIdForTargetStorage;
+    }
+    const sourcePatchChanges = {
+      contents: {
+        [contentKey]: null
+        // 从源移除引用 (null value in patch typically means delete key)
+      },
+      updatedAt: now,
+      ...localSpaceAuthorityPatchStamp(sourceSpaceData)
+    };
+    const targetPatchChanges = {
+      contents: {
+        [contentKey]: contentReferenceForTarget
+        // 向目标添加（或覆盖）引用
+      },
+      updatedAt: now,
+      ...localSpaceAuthorityPatchStamp(targetSpaceData)
+    };
+    logger2.info("Patching source and target space data.");
+    await Promise.all([
+      dispatch(
+        patch({ dbKey: sourceSpaceKey, changes: sourcePatchChanges })
+      ).unwrap(),
+      dispatch(
+        patch({ dbKey: targetSpaceKey, changes: targetPatchChanges })
+      ).unwrap()
+    ]);
+    logger2.info("Successfully patched both source and target spaces.");
+  } catch (error) {
+    logger2.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.");
+    const sourceSpaceKey = createSpaceKey.space(sourceSpaceId);
+    const targetSpaceKey = createSpaceKey.space(targetSpaceId);
+    const [finalSourceResult, finalTargetResult] = await Promise.allSettled([
+      dispatch(read({
+        dbKey: sourceSpaceKey
+      })).unwrap(),
+      dispatch(read({
+        dbKey: targetSpaceKey
+      })).unwrap()
+    ]);
+    if (finalSourceResult.status === "fulfilled") {
+      finalSourceData = finalSourceResult.value;
+    } else {
+      logger2.error(
+        { sourceSpaceId, reason: finalSourceResult.reason },
+        "Failed to re-read final source space data."
+      );
+    }
+    if (finalTargetResult.status === "fulfilled") {
+      finalTargetData = finalTargetResult.value;
+    } else {
+      logger2.error(
+        { targetSpaceId, reason: finalTargetResult.reason },
+        "Failed to re-read final target space data."
+      );
+    }
+    logger2.info(
+      {
+        hasError: !!overallError,
+        sourceReadSuccess: !!finalSourceData,
+        targetReadSuccess: !!finalTargetData
+      },
+      "Move content action finished."
+    );
+    const result = {
+      sourceSpaceId,
+      updatedSourceSpaceData: finalSourceData,
+      targetSpaceId,
+      updatedTargetSpaceData: finalTargetData,
+      error: overallError
+      // 如果过程中有错误，则传递错误信息
+    };
+    return result;
+  }
+};
+
+// packages/create/space/content/spaceContentPatch.ts
+var notifyUserDataUpdated = () => {
+  if (typeof window !== "undefined" && typeof window.dispatchEvent === "function" && typeof window.Event === "function") {
+    window.dispatchEvent(new window.Event("nolo-user-data-updated"));
+  }
+};
+var loadSpaceContentOrThrow = async (dispatch, spaceId, contentKey, sourceServerOrigin) => {
+  if (!contentKey || typeof contentKey !== "string" || contentKey.trim() === "") {
+    throw new Error("Invalid contentKey provided.");
+  }
+  const spaceKey = createSpaceKey.space(spaceId);
+  let spaceData = null;
+  try {
+    spaceData = await dispatch(
+      read({ dbKey: spaceKey, preferredServerOrigin: sourceServerOrigin })
+    ).unwrap();
+  } catch (readError) {
+    throw new Error(`\u65E0\u6CD5\u52A0\u8F7D\u7A7A\u95F4\u6570\u636E: ${spaceId}`);
+  }
+  if (!spaceData) {
+    throw new Error("Space not found");
+  }
+  const content = spaceData.contents?.[contentKey];
+  if (!content) {
+    throw new Error("Content not found in space");
+  }
+  return { spaceKey, spaceData, content };
+};
+var patchIndividualContentRecord = async (dispatch, contentKey, changes, sourceServerOrigin, failMessagePrefix) => {
+  let hasIndividualRecord = false;
+  try {
+    const existing = await dispatch(
+      read({ dbKey: contentKey, preferredServerOrigin: sourceServerOrigin })
+    ).unwrap();
+    hasIndividualRecord = Boolean(existing);
+  } catch {
+    hasIndividualRecord = false;
+  }
+  if (hasIndividualRecord) {
+    try {
+      await dispatch(
+        patch({
+          dbKey: contentKey,
+          changes,
+          preferredServerOrigin: sourceServerOrigin
+        })
+      ).unwrap();
+      notifyUserDataUpdated();
+    } catch (contentPatchError) {
+      throw new Error(
+        `${failMessagePrefix}: ${contentPatchError?.message || "\u672A\u77E5\u9519\u8BEF"}`
+      );
+    }
+  }
+};
+
+// packages/create/space/content/updateContentTitleAction.ts
+var buildContentRecordTitleChanges = (content, title, updatedAt) => {
+  const changes = { title, updatedAt };
+  if (content.type === "app") {
+    changes.name = title;
+  }
+  return changes;
+};
+var updateContentTitleAction = async (input, thunkAPI) => {
+  const { spaceId, contentKey, title, skillSummary, sourceServerOrigin } = input;
+  const { dispatch } = thunkAPI;
+  if (title === void 0 || title === null || typeof title !== "string") {
+    throw new Error("Invalid title provided.");
+  }
+  if (title.trim() === "") {
+    throw new Error("Title cannot be empty.");
+  }
+  const { spaceKey, spaceData, content } = await loadSpaceContentOrThrow(
+    dispatch,
+    spaceId,
+    contentKey,
+    sourceServerOrigin
+  );
+  const trimmedTitle = title.trim();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const changes = {
+    contents: {
+      [contentKey]: {
+        ...spaceData.contents[contentKey],
+        title: trimmedTitle,
+        updatedAt: now,
+        ...skillSummary !== void 0 ? { skillSummary } : {}
+      }
+    },
+    updatedAt: now
+  };
+  let updatedSpaceData;
+  try {
+    updatedSpaceData = await dispatch(
+      patch({
+        dbKey: spaceKey,
+        changes,
+        preferredServerOrigin: sourceServerOrigin
+      })
+    ).unwrap();
+  } catch (patchError) {
+    throw new Error(`\u66F4\u65B0\u5185\u5BB9\u6807\u9898\u5931\u8D25: ${patchError.message || "\u672A\u77E5\u9519\u8BEF"}`);
+  }
+  await patchIndividualContentRecord(
+    dispatch,
+    contentKey,
+    buildContentRecordTitleChanges(content, trimmedTitle, now),
+    sourceServerOrigin,
+    "\u6807\u9898\u5DF2\u5199\u5165\u7A7A\u95F4\uFF0C\u4F46\u540C\u6B65\u72EC\u7ACB\u8BB0\u5F55\u5931\u8D25"
+  );
+  if (contentKey.startsWith("meta-")) {
+    const parts = contentKey.split(SEPARATOR);
+    if (parts.length >= 3) {
+      const tableId = parts.slice(2).join(SEPARATOR);
+      const tenantId = parts[1];
+      try {
+        await dispatch(
+          renameTable({
+            tenantId,
+            tableId,
+            newName: trimmedTitle
+          })
+        ).unwrap();
+      } catch (tableError) {
+        console.error("Failed to sync title to TableMeta:", tableError);
+      }
+    }
+  }
+  return { spaceId, updatedSpaceData };
+};
+
+// packages/create/space/content/updateContentPinnedAction.ts
+var updateContentPinnedAction = async (input, thunkAPI) => {
+  const { spaceId, contentKey, pinned, sourceServerOrigin } = input;
+  const { dispatch } = thunkAPI;
+  if (typeof pinned !== "boolean") {
+    throw new Error("Invalid pinned value provided.");
+  }
+  if (!spaceId) {
+    if (!contentKey || typeof contentKey !== "string" || contentKey.trim() === "") {
+      throw new Error("Invalid contentKey provided.");
+    }
+    await patchIndividualContentRecord(
+      dispatch,
+      contentKey,
+      { pinned },
+      sourceServerOrigin,
+      "\u66F4\u65B0\u7F6E\u9876\u72B6\u6001\u5931\u8D25"
+    );
+    return { spaceId: null, updatedSpaceData: null };
+  }
+  const { spaceKey, spaceData } = await loadSpaceContentOrThrow(
+    dispatch,
+    spaceId,
+    contentKey,
+    sourceServerOrigin
+  );
+  const changes = {
+    contents: {
+      [contentKey]: { ...spaceData.contents[contentKey], pinned }
+    },
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  let updatedSpaceData;
+  try {
+    updatedSpaceData = await dispatch(
+      patch({ dbKey: spaceKey, changes, preferredServerOrigin: sourceServerOrigin })
+    ).unwrap();
+  } catch (patchError) {
+    throw new Error(`\u66F4\u65B0\u5185\u5BB9\u7F6E\u9876\u72B6\u6001\u5931\u8D25: ${patchError.message || "\u672A\u77E5\u9519\u8BEF"}`);
+  }
+  await patchIndividualContentRecord(
+    dispatch,
+    contentKey,
+    { pinned },
+    sourceServerOrigin,
+    "\u7F6E\u9876\u72B6\u6001\u5DF2\u5199\u5165\u7A7A\u95F4\uFF0C\u4F46\u540C\u6B65\u72EC\u7ACB\u8BB0\u5F55\u5931\u8D25"
+  );
+  return { spaceId, updatedSpaceData };
+};
+
+// packages/create/space/content/updateContentCategoryAction.ts
+var updateContentCategoryAction = async (input, thunkAPI) => {
+  const { spaceId, contentKey, categoryId: targetContainerId } = input;
+  const { dispatch, getState } = thunkAPI;
+  const state3 = getState();
+  const userId = selectIdentityUserId(state3);
+  if (!userId) {
+    throw new Error("User is not logged in.");
+  }
+  if (!contentKey || typeof contentKey !== "string" || contentKey.trim() === "") {
+    throw new Error("Invalid contentKey provided.");
+  }
+  if (typeof targetContainerId !== "string") {
+    throw new Error("Invalid target container ID provided (must be a string).");
+  }
+  const spaceKey = createSpaceKey.space(spaceId);
+  let spaceData = null;
+  try {
+    spaceData = await dispatch(read({
+      dbKey: spaceKey
+    })).unwrap();
+  } catch (readError) {
+    console.error(
+      `[updateContentCategoryAction] Failed to read space data for key ${spaceKey}:`,
+      readError
+    );
+    throw new Error(
+      `\u65E0\u6CD5\u52A0\u8F7D\u7A7A\u95F4\u6570\u636E: ${spaceId}, \u539F\u56E0: ${readError.message || "\u672A\u77E5\u9519\u8BEF"}`
+    );
+  }
+  if (!spaceData) {
+    throw new Error(`\u7A7A\u95F4\u4E0D\u5B58\u5728: ${spaceId}`);
+  }
+  try {
+    checkSpaceMembership(spaceData, userId);
+  } catch (permissionError) {
+    throw new Error(`\u6743\u9650\u4E0D\u8DB3\uFF0C\u65E0\u6CD5\u4FEE\u6539\u5185\u5BB9\u5206\u7C7B: ${permissionError.message}`);
+  }
+  const currentContent = spaceData.contents?.[contentKey];
+  if (!currentContent) {
+    console.warn(
+      `[updateContentCategoryAction] Content ${contentKey} not found in space ${spaceId}.`
+    );
+    throw new Error("Content not found");
+  }
+  if (targetContainerId !== UNCATEGORIZED_ID) {
+    if (!spaceData.categories[targetContainerId]) {
+      console.warn(
+        `[updateContentCategoryAction] Target category ${targetContainerId} not found or invalid in space ${spaceId}. Cannot move content.`
+      );
+      throw new Error("Target category not found or is invalid");
+    }
+  }
+  const now = Date.now();
+  const categoryIdValueForPatch = targetContainerId === UNCATEGORIZED_ID ? null : targetContainerId;
+  const currentCategoryId = currentContent.categoryId;
+  let needsUpdate = true;
+  if (categoryIdValueForPatch === null && currentCategoryId === void 0) {
+    needsUpdate = false;
+  } else if (categoryIdValueForPatch === currentCategoryId) {
+    needsUpdate = false;
+  }
+  let changes = null;
+  if (needsUpdate) {
+    changes = {
+      contents: {
+        // 使用动态键更新指定的 contentKey
+        [contentKey]: {
+          // --- 修改: 使用计算出的 categoryIdValueForPatch ---
+          categoryId: categoryIdValueForPatch,
+          // null 或 目标分类 ID
+          updatedAt: now
+          // 更新内容的 updatedAt
+        }
+      },
+      updatedAt: now
+      // 更新顶层的 updatedAt
+    };
+  } else {
+    console.log(
+      `[updateContentCategoryAction] No category change needed for ${contentKey}. Skipping patch.`
+    );
+    return { spaceId, updatedSpaceData: spaceData };
+  }
+  let updatedSpaceData;
+  try {
+    updatedSpaceData = await dispatch(
+      patch({ dbKey: spaceKey, changes })
+      // 使用非空断言，因为已检查
+    ).unwrap();
+  } catch (patchError) {
+    console.error(
+      `[updateContentCategoryAction] Failed to patch space data for key ${spaceKey}:`,
+      patchError
+    );
+    throw new Error(`\u66F4\u65B0\u5185\u5BB9\u5206\u7C7B\u5931\u8D25: ${patchError.message || "\u672A\u77E5\u9519\u8BEF"}`);
+  }
+  return { spaceId, updatedSpaceData };
+};
+
+// packages/create/space/content/deleteMultipleContentAction.ts
+var logger3 = 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.");
+    return { spaceId, updatedSpaceData: null };
+  }
+  const { dispatch, getState } = thunkAPI;
+  const state3 = getState();
+  const userId = selectIdentityUserId(state3);
+  logger3.info(
+    { count: contentKeys.length, spaceId, userId },
+    "Initiating deleteMultipleContentAction"
+  );
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceData = await dispatch(
+    read({
+      dbKey: spaceKey
+    })
+  ).unwrap();
+  if (!spaceData) {
+    logger3.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");
+    throw new Error("\u65E0\u6743\u4FEE\u6539\u6B64\u7A7A\u95F4");
+  }
+  const changes = {
+    contents: contentKeys.reduce(
+      (acc, key) => {
+        acc[key] = null;
+        return acc;
+      },
+      {}
+    )
+  };
+  try {
+    await dispatch(patch({ dbKey: spaceKey, changes })).unwrap();
+    logger3.info(
+      { spaceKey, count: contentKeys.length },
+      "Successfully batched patch to remove content references"
+    );
+  } catch (patchError) {
+    logger3.error(
+      { error: patchError, spaceKey },
+      "Failed to batch patch space data. Aborting."
+    );
+    throw new Error(`\u66F4\u65B0\u7A7A\u95F4\u5F15\u7528\u5931\u8D25: ${patchError.message}`);
+  }
+  const removePromises = contentKeys.map(
+    (key) => dispatch(remove(key)).unwrap()
+  );
+  const results = await Promise.allSettled(removePromises);
+  results.forEach((result, index) => {
+    if (result.status === "fulfilled") {
+      logger3.info({ contentKey: contentKeys[index] }, "Entity removed");
+    } else {
+      logger3.error(
+        { contentKey: contentKeys[index], error: result.reason },
+        "Failed to remove an entity"
+      );
+    }
+  });
+  const finalSpaceData = await dispatch(
+    read({
+      dbKey: spaceKey
+    })
+  ).unwrap();
+  logger3.info({ spaceId }, "Finished batch delete and refetched space data.");
+  return {
+    spaceId,
+    updatedSpaceData: finalSpaceData
+  };
+};
+
+// packages/create/space/content/spaceFileVersions.ts
+var normalizeFileName = (name) => typeof name === "string" ? name.trim().normalize("NFC") : "";
+var versionsOf = (entryKey, entry) => {
+  if (Array.isArray(entry.versions) && entry.versions.length > 0) {
+    return entry.versions.filter((v) => v && typeof v.fileKey === "string");
+  }
+  return [
+    {
+      fileKey: entry.contentKey || entryKey,
+      sha256: entry.sha256 || "",
+      size: typeof entry.fileSize === "number" ? entry.fileSize : 0,
+      uploadedAt: typeof entry.createdAt === "number" ? entry.createdAt : 0
+    }
+  ];
+};
+var findSameNameFileEntries = (contents, originalName) => {
+  const target = normalizeFileName(originalName);
+  if (!target || !contents) return [];
+  return Object.entries(contents).filter(([, value]) => Boolean(value)).map(([entryKey, value]) => ({ entryKey, entry: value })).filter(
+    ({ entry }) => entry.type === "file" && normalizeFileName(entry.originalName ?? entry.title) === target
+  );
+};
+var sortVersions = (versions) => [...versions].sort(
+  (a, b) => a.uploadedAt - b.uploadedAt || a.fileKey.localeCompare(b.fileKey)
+);
+var mergeVersions = (groups) => {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const { entryKey, entry } of groups) {
+    for (const v of versionsOf(entryKey, entry)) {
+      const prev = byKey.get(v.fileKey);
+      if (!prev || !prev.sha256 && v.sha256) byKey.set(v.fileKey, v);
+    }
+  }
+  return sortVersions([...byKey.values()]);
+};
+var planSpaceFileUpload = (contents, originalName, sha256) => {
+  const same = findSameNameFileEntries(contents, originalName);
+  if (same.length === 0) return { kind: "new_file" };
+  const primary = pickPrimary(same);
+  const current = primary.entry.contentKey || primary.entryKey;
+  const versions = mergeVersions(same);
+  const currentVersion = versions.find((v) => v.fileKey === current);
+  if (currentVersion?.sha256 && currentVersion.sha256 === sha256) {
+    return { kind: "unchanged", entryKey: primary.entryKey, currentKey: current };
+  }
+  const older = versions.find((v) => v.sha256 && v.sha256 === sha256);
+  if (older) {
+    return { kind: "restore_existing", entryKey: primary.entryKey, versionKey: older.fileKey };
+  }
+  return { kind: "new_version", entryKey: primary.entryKey };
+};
+var pickPrimary = (same) => [...same].sort((a, b) => {
+  const at = Math.max(...versionsOf(a.entryKey, a.entry).map((v) => v.uploadedAt));
+  const bt = Math.max(...versionsOf(b.entryKey, b.entry).map((v) => v.uploadedAt));
+  return bt - at || b.entryKey.localeCompare(a.entryKey);
+})[0];
+var buildVersionedEntryPatch = (input) => {
+  const { same, extraVersion, now } = input;
+  const versions = mergeVersions(
+    extraVersion ? [...same, { entryKey: extraVersion.fileKey, entry: { versions: [extraVersion] } }] : same
+  );
+  const currentKey = input.currentKey ?? versions[versions.length - 1].fileKey;
+  const current = versions.find((v) => v.fileKey === currentKey);
+  if (!current) throw new Error(`Version ${currentKey} not found for this file.`);
+  const template = same.length > 0 ? pickPrimary(same).entry : {};
+  const patch2 = {};
+  for (const { entryKey } of same) {
+    if (entryKey !== currentKey) patch2[entryKey] = null;
+  }
+  patch2[currentKey] = {
+    ...template,
+    contentKey: currentKey,
+    currentVersionKey: currentKey,
+    fileSize: current.size,
+    versions,
+    updatedAt: now,
+    ...input.restoredFrom ? { restoredFromVersionKey: input.restoredFrom } : {}
+  };
+  return patch2;
+};
+var sha256Hex = async (file) => {
+  const digest = await crypto.subtle.digest("SHA-256", await file.arrayBuffer());
+  return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+
+// packages/create/space/content/uploadAndAddFileToSpaceAction.ts
+var uploadQueues = /* @__PURE__ */ new Map();
+var serialize = (key, task) => {
+  const prev = uploadQueues.get(key) ?? Promise.resolve();
+  const next = prev.catch(() => void 0).then(task);
+  uploadQueues.set(key, next);
+  void next.finally(() => {
+    if (uploadQueues.get(key) === next) uploadQueues.delete(key);
+  }).catch(() => void 0);
+  return next;
+};
+var readSpaceOrNull = async (dispatch, spaceId) => {
+  try {
+    return await dispatch(read({ dbKey: createSpaceKey.space(spaceId) })).unwrap() ?? null;
+  } catch {
+    return null;
+  }
+};
+var reconcileSameNameEntries = async (thunkAPI, spaceId, originalName, options = {}) => {
+  let updated = await reconcileOnce(thunkAPI, spaceId, originalName, options);
+  for (let attempt = 0; attempt < 2 && updated; attempt += 1) {
+    const same = findSameNameFileEntries(updated.contents, originalName);
+    const keys = new Set(mergeVersions(same).map((v) => v.fileKey));
+    const missingOwn = options.extraVersion && !keys.has(options.extraVersion.fileKey);
+    if (same.length <= 1 && !missingOwn) break;
+    const fresh = await readSpaceOrNull(thunkAPI.dispatch, spaceId);
+    const freshSame = findSameNameFileEntries(fresh?.contents, originalName);
+    const freshKeys = new Set(mergeVersions(freshSame).map((v) => v.fileKey));
+    const stillMissing = options.extraVersion && !freshKeys.has(options.extraVersion.fileKey);
+    if (freshSame.length <= 1 && !stillMissing) {
+      updated = fresh;
+      break;
+    }
+    updated = await reconcileOnce(thunkAPI, spaceId, originalName, {
+      ...stillMissing ? { extraVersion: options.extraVersion } : {}
+    });
+  }
+  return updated;
+};
+var reconcileOnce = async (thunkAPI, spaceId, originalName, options = {}) => {
+  const { dispatch, getState } = thunkAPI;
+  const spaceData = await readSpaceOrNull(dispatch, spaceId);
+  if (!spaceData) return null;
+  checkSpaceMembership(spaceData, selectIdentityUserId(getState()));
+  const same = findSameNameFileEntries(spaceData.contents, originalName);
+  if (same.length === 0 && !options.extraVersion) return spaceData;
+  const contentsPatch = buildVersionedEntryPatch({ same, now: Date.now(), ...options });
+  return await dispatch(
+    patch({
+      dbKey: createSpaceKey.space(spaceId),
+      changes: {
+        contents: contentsPatch,
+        updatedAt: Date.now(),
+        ...localSpaceAuthorityPatchStamp(spaceData)
+      }
+    })
+  ).unwrap();
+};
+var uploadAndAddFileToSpaceAction = async (payload, thunkAPI) => {
+  const { spaceId, file } = payload;
+  const userId = selectIdentityUserId(thunkAPI.getState());
+  if (!userId) {
+    throw new Error("Cannot upload a file to a space without an authenticated user.");
+  }
+  return serialize(
+    `${spaceId}\0${file.name}`,
+    () => uploadOnce(payload, thunkAPI, userId)
+  );
+};
+var uploadOnce = async (payload, thunkAPI, userId) => {
+  const { spaceId, file, categoryId } = payload;
+  const { dispatch } = thunkAPI;
+  try {
+    const sha256 = await sha256Hex(file);
+    const existingSpace = await readSpaceOrNull(dispatch, spaceId);
+    const plan = existingSpace ? planSpaceFileUpload(existingSpace.contents, file.name, sha256) : { kind: "new_file" };
+    if (plan.kind === "unchanged") {
+      return {
+        spaceId,
+        updatedSpaceData: existingSpace,
+        contentKey: plan.currentKey,
+        fileId: plan.currentKey.split("-").slice(2).join("-"),
+        outcome: "unchanged"
+      };
+    }
+    if (plan.kind === "restore_existing") {
+      const updated = await reconcileSameNameEntries(thunkAPI, spaceId, file.name, {
+        currentKey: plan.versionKey,
+        restoredFrom: plan.entryKey
+      });
+      return {
+        spaceId,
+        updatedSpaceData: updated ?? existingSpace,
+        contentKey: plan.versionKey,
+        fileId: plan.versionKey.split("-").slice(2).join("-"),
+        outcome: "restored_existing"
+      };
+    }
+    const id = ulid();
+    const dbKey = fileKey.single(userId, id);
+    const contentType = "file" /* FILE */;
+    const fileCategory = resolveFileCategory({
+      mimeType: file.type,
+      fileName: file.name
+    });
+    const fileMetadata = await uploadFileAction(
+      { file, customKey: dbKey, userId },
+      thunkAPI
+    );
+    if (!fileMetadata) {
+      throw new Error("Upload failed, no metadata returned");
+    }
+    const contentKey = fileMetadata.dbKey || dbKey;
+    const title = file.name;
+    const fileSize = asOptionalFiniteNumber(file.size);
+    const version3 = {
+      fileKey: contentKey,
+      sha256,
+      size: fileSize ?? 0,
+      uploadedAt: Date.now()
+    };
+    const addAsNewFile = async () => {
+      const result2 = await addContentAction({
+        spaceId,
+        contentKey,
+        title,
+        type: contentType,
+        fileCategory,
+        mimeType: file.type || void 0,
+        fileSize,
+        originalName: file.name,
+        categoryId
+      }, thunkAPI);
+      return result2;
+    };
+    const result = plan.kind === "new_file" ? await addAsNewFile() : { spaceId, updatedSpaceData: existingSpace };
+    await dispatch(
+      patch({
+        dbKey: contentKey,
+        changes: {
+          title,
+          spaceId,
+          fileCategory,
+          mimeType: file.type || void 0,
+          fileSize,
+          originalName: file.name
+        }
+      })
+    ).unwrap();
+    const reconciled = await reconcileSameNameEntries(thunkAPI, spaceId, file.name, {
+      extraVersion: version3,
+      currentKey: contentKey
+    }).catch((error) => {
+      if (plan.kind === "new_version") throw error;
+      console.warn("[uploadAndAddFileToSpace] version reconcile failed", error);
+      return null;
+    });
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(new Event("nolo-user-data-updated"));
+    }
+    return {
+      ...result,
+      ...reconciled ? { updatedSpaceData: reconciled } : {},
+      contentKey,
+      fileId: fileMetadata.id,
+      outcome: plan.kind === "new_file" ? "new_file" : "new_version"
+    };
+  } catch (error) {
+    console.error("Upload and add file error:", error);
+    throw error;
+  }
+};
+var restoreSpaceFileVersionAction = async (input, thunkAPI) => {
+  const { spaceId, contentKey, versionKey } = input;
+  const spaceData = await readSpaceOrNull(thunkAPI.dispatch, spaceId);
+  if (!spaceData) throw new Error(`\u65E0\u6CD5\u52A0\u8F7D\u7A7A\u95F4\u6570\u636E: ${spaceId}`);
+  const entry = spaceData.contents?.[contentKey];
+  if (!entry || entry.type !== "file" /* FILE */) throw new Error("File not found in space");
+  const versions = Array.isArray(entry.versions) ? entry.versions : [];
+  if (!versions.some((v) => v.fileKey === versionKey)) {
+    throw new Error("Version not found for this file");
+  }
+  const name = entry.originalName ?? entry.title;
+  const updated = await serialize(
+    `${spaceId}\0${name}`,
+    () => reconcileSameNameEntries(thunkAPI, spaceId, name, {
+      currentKey: versionKey,
+      restoredFrom: contentKey
+    })
+  );
+  return { spaceId, updatedSpaceData: updated ?? spaceData, contentKey: versionKey };
+};
+
+// 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 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();
+}
+
+// packages/create/space/content/contentThunks.ts
+var syncCurrentSpaceIfNormalizedMatch = (spaceId, updatedSpaceData) => {
+  const normalizedSpaceId = normalizeSpaceId(spaceId);
+  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
+      };
+      if (typeof window !== "undefined") {
+        writeStoredCollapsedCategories(
+          result.spaceId,
+          collapsedCategories,
+          window.localStorage
+        );
+      }
+      expandCategoryInCollapsed(expandCategoryId, result.spaceId);
+      syncCurrentSpaceIfNormalizedMatch(
+        result.spaceId,
+        result.updatedSpaceData
+      );
+      return { ...result, expandCategoryId, collapsedCategories };
+    }
+    syncCurrentSpaceIfNormalizedMatch(result.spaceId, result.updatedSpaceData);
+    return { ...result, expandCategoryId: null };
+  }
+);
+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);
+    }
+    if (getCurrentSpaceIdRaw() === targetSpaceId && updatedTargetSpaceData) {
+      updateCurrentSpaceIfMatch(targetSpaceId, updatedTargetSpaceData);
+    }
+    return payload;
+  }
+);
+var deleteContentFromSpace = createAsyncThunk(
+  "space/deleteContentFromSpace",
+  async (arg, thunkAPI) => {
+    const payload = await deleteContentFromSpaceAction(arg, thunkAPI);
+    syncCurrentSpaceIfNormalizedMatch(
+      payload.spaceId,
+      payload.updatedSpaceData
+    );
+    return payload;
+  }
+);
+var deleteMultipleContent = createAsyncThunk(
+  "space/deleteMultipleContent",
+  async (arg, thunkAPI) => {
+    const payload = await deleteMultipleContentAction(arg, thunkAPI);
+    syncCurrentSpaceIfNormalizedMatch(
+      payload.spaceId,
+      payload.updatedSpaceData
+    );
+    return payload;
+  }
+);
+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 restoreSpaceFileVersion = createAsyncThunk(
+  "space/restoreSpaceFileVersion",
+  async (arg, thunkAPI) => {
+    const payload = await restoreSpaceFileVersionAction(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);
+      }
+      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);
+      }
+      throw error;
+    }
+  }
+);
+var updateContentPinned = createAsyncThunk(
+  "space/updateContentPinned",
+  async (arg, thunkAPI) => {
+    try {
+      const payload = await updateContentPinnedAction(arg, thunkAPI);
+      if (payload.updatedSpaceData && payload.spaceId && getCurrentSpaceIdRaw() === payload.spaceId) {
+        updateCurrentSpaceIfMatch(payload.spaceId, payload.updatedSpaceData);
+      }
+      return payload;
+    } catch (error) {
+      toast.error(
+        error?.message || "\u7F6E\u9876\u72B6\u6001\u66F4\u65B0\u5931\u8D25"
+      );
+      throw error;
+    }
+  }
+);
+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;
+  }
+);
+
+export {
+  fetchAndCacheTableRows,
+  getTableState,
+  loadTableRows,
+  addRow,
+  createTable,
+  deleteTable,
+  readStoredCollapsedCategories,
+  writeStoredCollapsedCategories,
+  DEFAULT_COLLAPSED_CATEGORIES,
+  getCollapsedCategories,
+  setCollapsedCategories,
+  toggleCategoryCollapse,
+  expandCategoryInCollapsed,
+  addContentToSpace,
+  moveContentToSpace,
+  deleteContentFromSpace,
+  deleteMultipleContent,
+  uploadAndAddFileToSpace,
+  restoreSpaceFileVersion,
+  updateContentTitle,
+  updateContentPinned,
+  updateContentCategory
+};