nolo-cli 0.149.0-alpha.1 → 0.151.0-alpha.2

package/chunk-36KZDDO5.js

@@ -1,2415 +0,0 @@
-import {
-  getCurrentSpaceId,
-  getCurrentSpaceIdRaw,
-  updateCurrentSpaceIfMatch
-} from "./chunk-ZJ7UHBJS.js";
-import {
-  deleteDialog,
-  i18nBaseConfig,
-  initReactI18next,
-  instance,
-  toast
-} from "./chunk-ACQD6YI2.js";
-import {
-  require_date_fns
-} from "./chunk-M76ECQRD.js";
-import {
-  require_react
-} from "./chunk-YDH3FDFQ.js";
-import {
-  UNCATEGORIZED_ID,
-  addContentAction,
-  checkSpaceMembership,
-  localSpaceAuthorityPatchStamp
-} from "./chunk-RSEEDUMS.js";
-import {
-  createSpaceKey,
-  normalizeSpaceId
-} from "./chunk-UAD2WT54.js";
-import {
-  isSystemAdmin
-} from "./chunk-QDSINZM3.js";
-import {
-  asRecordOrEmpty
-} from "./chunk-KX6YBIHG.js";
-import {
-  patch,
-  read,
-  readAndWait,
-  remove,
-  resolveFileCategory,
-  uploadFileAction,
-  upsertSSREntity,
-  write
-} from "./chunk-HYZIYH2H.js";
-import {
-  SEPARATOR,
-  asTrimmedNonEmptyStringArray,
-  createKey,
-  fileKey,
-  isAgentKey,
-  isPageKey,
-  metaKey,
-  rowKey,
-  splitKey,
-  ulid
-} from "./chunk-3AH7LNUB.js";
-import {
-  asOptionalFiniteNumber
-} from "./chunk-WWC7I6TA.js";
-import {
-  DEVICE_LOCAL_OWNER_ID,
-  createAsyncThunk,
-  getRuntimeServerContext,
-  isDeviceLocalSpaceBody,
-  resolveReplicationServers,
-  scheduleDeleteReplication,
-  scheduleWriteReplication
-} from "./chunk-WIWM4FE3.js";
-import {
-  createClientLogger,
-  isAbortError
-} from "./chunk-QOKAKDPE.js";
-import {
-  selectIdentityUserId
-} from "./chunk-SEJ5OS6F.js";
-import {
-  buildTombstoneRecord
-} from "./chunk-GBRG75BQ.js";
-import {
-  isRecord
-} from "./chunk-KUG52IAP.js";
-import {
-  extractUserId
-} from "./chunk-M2EJHDJP.js";
-import {
-  asTrimmedString
-} from "./chunk-3EUW3WEO.js";
-import {
-  asOptionalPositiveFiniteNumber
-} from "./chunk-U6VC4MU4.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);
-var import_date_fns2 = __toESM(require_date_fns(), 1);
-import { ulid as ulid3 } from "ulid";
-
-// 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,
-      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 (token) {
-    headers.Authorization = `Bearer ${token}`;
-  }
-  const localRows = await loadLocalTableRows(db, tenantId, tableId);
-  const remoteResults = await Promise.allSettled(
-    remoteServers.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 = remoteServers.length > 0 && remoteResults.length === remoteServers.length && fulfilledRemoteSnapshots.length === remoteServers.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
-var import_date_fns = __toESM(require_date_fns(), 1);
-import { ulid as ulid2 } from "ulid";
-
-// packages/app/i18n/client.ts
-instance.use(initReactI18next).init({
-  ...i18nBaseConfig,
-  lng: "zh-CN" /* ZH_CN */,
-  fallbackLng: {
-    ["en" /* EN */]: ["en" /* EN */],
-    ["zh-CN" /* ZH_CN */]: ["zh-CN" /* ZH_CN */, "en" /* EN */],
-    ["zh-Hant" /* ZH_HANT */]: ["zh-Hant" /* ZH_HANT */, "zh-CN" /* ZH_CN */, "en" /* EN */],
-    ["ja" /* JA */]: ["ja" /* JA */, "en" /* EN */],
-    default: ["en" /* EN */]
-  },
-  compatibilityJSON: "v3"
-});
-var client_default = instance;
-
-// packages/render/table/createTableAction.ts
-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 = (0, import_date_fns.formatISO)(now);
-  const dbKey = metaKey(userId, tableId);
-  const defaultTitle = client_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,
-  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,
-      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) => ({
-          ...s,
-          isLoading: false,
-          isInitialized: true,
-          currentTable: meta,
-          error: null
-        }));
-        return meta;
-      }
-      const msg = readAction.payload?.message || `\u65E0\u6CD5\u52A0\u8F7D\u8868 ${tableId}`;
-      setState((s) => ({
-        ...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) => ({
-        ...s,
-        isLoading: false,
-        isInitialized: true,
-        currentTable: null,
-        error: msg,
-        rows: []
-      }));
-      throw e;
-    }
-  }
-);
-var loadTableRows = createTableCommand(
-  "table/loadTableRows",
-  async (args, { getState, extra } = {}) => {
-    const { tenantId, tableId } = args;
-    const db = extra?.db;
-    setState((s) => {
-      if (s.currentTable && s.currentTable.tenantId === tenantId && s.currentTable.tableId === 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 (s.currentTable && s.currentTable.tenantId === tenantId && s.currentTable.tableId === tableId) {
-          return { ...s, rows };
-        }
-        return s;
-      });
-      return rows;
-    } catch (e) {
-      const msg = e?.message || "\u52A0\u8F7D\u8868\u884C\u5931\u8D25";
-      setState((s) => {
-        if (s.currentTable && s.currentTable.tenantId === tenantId && s.currentTable.tableId === 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 = (0, import_date_fns2.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 = (0, import_date_fns2.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: (0, import_date_fns2.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: (0, import_date_fns2.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: (0, import_date_fns2.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: (0, import_date_fns2.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: (0, import_date_fns2.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: (0, import_date_fns2.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 = (0, import_date_fns2.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) => ({
-        ...s,
-        currentTable: nextMeta,
-        isInitialized: true
-      }));
-      return nextMeta;
-    } catch (e) {
-      const msg = e?.message || "\u91CD\u547D\u540D\u8868\u5931\u8D25";
-      setState((s) => ({ ...s, error: msg }));
-      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 = (0, import_date_fns2.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) => ({
-        ...s,
-        currentTable: nextMeta
-      }));
-      return nextMeta;
-    } catch (e) {
-      const msg = e?.message || "\u66F4\u65B0\u8868\u683C\u56FE\u6807\u5931\u8D25";
-      setState((s) => ({ ...s, error: msg }));
-      throw e;
-    }
-  }
-);
-var updateCell = createTableCommand(
-  "table/updateCell",
-  async (args, { dispatch } = {}) => {
-    const { dbKey, columnName, value } = args;
-    setState((s) => ({ ...s, error: null }));
-    try {
-      const nowIso = (0, import_date_fns2.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-NX6QHCWZ.js");
-    await deleteFileAction(key, thunkAPI);
-  },
-  image: async (key, { thunkAPI }) => {
-    const { deleteFileAction } = await import("./deleteFile-NX6QHCWZ.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 logger = 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();
-  logger.info({ ...input, userId }, "Initiating moveContentAction");
-  if (sourceSpaceId === targetSpaceId) {
-    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() === "") {
-    logger.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);
-    logger.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;
-    logger.info("Checking permissions for source and target spaces.");
-    checkSpaceMembership(sourceSpaceData, userId);
-    checkSpaceMembership(targetSpaceData, userId);
-    if (!sourceSpaceData.contents || !sourceSpaceData.contents[contentKey]) {
-      logger.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]) {
-      logger.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 {
-        logger.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)
-    };
-    logger.info("Patching source and target space data.");
-    await Promise.all([
-      dispatch(
-        patch({ dbKey: sourceSpaceKey, changes: sourcePatchChanges })
-      ).unwrap(),
-      dispatch(
-        patch({ dbKey: targetSpaceKey, changes: targetPatchChanges })
-      ).unwrap()
-    ]);
-    logger.info("Successfully patched both source and target spaces.");
-  } catch (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 {
-    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([
-      dispatch(read({
-        dbKey: sourceSpaceKey
-      })).unwrap(),
-      dispatch(read({
-        dbKey: targetSpaceKey
-      })).unwrap()
-    ]);
-    if (finalSourceResult.status === "fulfilled") {
-      finalSourceData = finalSourceResult.value;
-    } else {
-      logger.error(
-        { sourceSpaceId, reason: finalSourceResult.reason },
-        "Failed to re-read final source space data."
-      );
-    }
-    if (finalTargetResult.status === "fulfilled") {
-      finalTargetData = finalTargetResult.value;
-    } else {
-      logger.error(
-        { targetSpaceId, reason: finalTargetResult.reason },
-        "Failed to re-read final target space data."
-      );
-    }
-    logger.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 logger2 = createClientLogger("delete-multiple-content");
-var deleteMultipleContentAction = async (input, thunkAPI) => {
-  const { contentKeys, spaceId } = input;
-  if (!contentKeys || contentKeys.length === 0) {
-    logger2.warn("deleteMultipleContentAction called with no contentKeys.");
-    return { spaceId, updatedSpaceData: null };
-  }
-  const { dispatch, getState } = thunkAPI;
-  const state3 = getState();
-  const userId = selectIdentityUserId(state3);
-  logger2.info(
-    { count: contentKeys.length, spaceId, userId },
-    "Initiating deleteMultipleContentAction"
-  );
-  const spaceKey = createSpaceKey.space(spaceId);
-  const spaceData = await dispatch(
-    read({
-      dbKey: spaceKey
-    })
-  ).unwrap();
-  if (!spaceData) {
-    logger2.error({ spaceKey }, "Space data not found for batch delete");
-    throw new Error("\u7A7A\u95F4\u4E0D\u5B58\u5728");
-  }
-  if (!userId || !spaceData.members.includes(userId)) {
-    logger2.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();
-    logger2.info(
-      { spaceKey, count: contentKeys.length },
-      "Successfully batched patch to remove content references"
-    );
-  } catch (patchError) {
-    logger2.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") {
-      logger2.info({ contentKey: contentKeys[index] }, "Entity removed");
-    } else {
-      logger2.error(
-        { contentKey: contentKeys[index], error: result.reason },
-        "Failed to remove an entity"
-      );
-    }
-  });
-  const finalSpaceData = await dispatch(
-    read({
-      dbKey: spaceKey
-    })
-  ).unwrap();
-  logger2.info({ spaceId }, "Finished batch delete and refetched space data.");
-  return {
-    spaceId,
-    updatedSpaceData: finalSpaceData
-  };
-};
-
-// packages/create/space/content/uploadAndAddFileToSpaceAction.ts
-var uploadAndAddFileToSpaceAction = async (payload, thunkAPI) => {
-  const { spaceId, file, categoryId } = payload;
-  const { dispatch, getState } = thunkAPI;
-  const state3 = getState();
-  const userId = selectIdentityUserId(state3);
-  if (!userId) {
-    console.warn("[uploadAndAddFileToSpace] Warning: No userId found in state. Uploading as anonymous/unknown might cause issues.");
-  }
-  try {
-    const id = ulid();
-    const dbKey = fileKey.single(userId || "unknown", 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 result = await addContentAction({
-      spaceId,
-      contentKey,
-      title,
-      type: contentType,
-      fileCategory,
-      mimeType: file.type || void 0,
-      fileSize: asOptionalFiniteNumber(file.size),
-      originalName: file.name,
-      categoryId
-    }, thunkAPI);
-    await dispatch(
-      patch({
-        dbKey: contentKey,
-        changes: {
-          title,
-          spaceId,
-          fileCategory,
-          mimeType: file.type || void 0,
-          fileSize: asOptionalFiniteNumber(file.size),
-          originalName: file.name
-        }
-      })
-    ).unwrap();
-    if (typeof window !== "undefined") {
-      window.dispatchEvent(new Event("nolo-user-data-updated"));
-    }
-    return { ...result, contentKey, fileId: fileMetadata.id };
-  } catch (error) {
-    console.error("Upload and add file error:", error);
-    throw error;
-  }
-};
-
-// 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 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,
-  client_default,
-  getTableState,
-  loadTableRows,
-  addRow,
-  createTable,
-  deleteTable,
-  readStoredCollapsedCategories,
-  writeStoredCollapsedCategories,
-  DEFAULT_COLLAPSED_CATEGORIES,
-  getCollapsedCategories,
-  setCollapsedCategories,
-  toggleCategoryCollapse,
-  expandCategoryInCollapsed,
-  addContentToSpace,
-  moveContentToSpace,
-  deleteContentFromSpace,
-  deleteMultipleContent,
-  uploadAndAddFileToSpace,
-  updateContentTitle,
-  updateContentPinned,
-  updateContentCategory
-};