nolo-cli 0.54.0 → 0.61.0-alpha.2

package/{chunk-WQHGJHAL.js → chunk-AVE2YR4F.js}

@@ -6,7 +6,7 @@ import {
 import {
   deleteDialog,
   toast
-} from "./chunk-YBFJQC2M.js";
+} from "./chunk-D5XKNNUV.js";
 import {
   require_date_fns
 } from "./chunk-M76ECQRD.js";
@@ -15,7 +15,7 @@ import {
 } from "./chunk-YDH3FDFQ.js";
 import {
   isSystemAdmin
-} from "./chunk-SVC3GGUA.js";
+} from "./chunk-VMWYBIXG.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
@@ -24,7 +24,7 @@ import {
   addContentAction,
   checkSpaceMembership,
   localSpaceAuthorityPatchStamp
-} from "./chunk-MYMBBB6Q.js";
+} from "./chunk-RVWRKFUB.js";
 import {
   createSpaceKey,
   normalizeSpaceId
@@ -38,7 +38,7 @@ import {
   uploadFileAction,
   upsertSSREntity,
   write
-} from "./chunk-7NYDJAQ7.js";
+} from "./chunk-DNNSCSA2.js";
 import {
   SEPARATOR,
   createKey,
@@ -61,19 +61,19 @@ import {
 } from "./chunk-BJIRLHJR.js";
 import {
   DEVICE_LOCAL_OWNER_ID,
-  asyncThunkCreator,
-  buildCreateSlice,
   createAsyncThunk,
   getRuntimeServerContext,
   isDeviceLocalSpaceBody,
   resolveReplicationServers,
   scheduleDeleteReplication,
-  scheduleWriteReplication,
-  selectIdentityUserId
-} from "./chunk-XOJRZUPF.js";
+  scheduleWriteReplication
+} from "./chunk-KWSQR2KK.js";
 import {
   createClientLogger
 } from "./chunk-QOKAKDPE.js";
+import {
+  selectIdentityUserId
+} from "./chunk-SEJ5OS6F.js";
 import {
   buildTombstoneRecord
 } from "./chunk-GBRG75BQ.js";
@@ -207,7 +207,8 @@ var require_html_parse_stringify = __commonJS({
   }
 });
 
-// packages/render/table/tableSlice.ts
+// packages/render/table/tableStore.ts
+var import_react9 = __toESM(require_react(), 1);
 var import_date_fns2 = __toESM(require_date_fns(), 1);
 import { ulid as ulid3 } from "ulid";
 
@@ -3148,8 +3149,8 @@ var createTableAction = async ({
   columns,
   withDefaultRows = true
 } = {}, { dispatch, getState }) => {
-  const state2 = getState();
-  const userId = selectIdentityUserId(state2);
+  const state3 = getState();
+  const userId = selectIdentityUserId(state3);
   if (!userId) throw new Error("User ID not found.");
   const spaceId = customSpaceId ?? getCurrentSpaceId();
   const tableId = ulid2();
@@ -3279,8 +3280,8 @@ var deleteTableAction = async ({ dbKey }, {
   extra
 }) => {
   const { db } = extra;
-  const state2 = getState();
-  const { currentServer, syncServers } = getRuntimeServerContext(state2);
+  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, "");
@@ -3335,726 +3336,732 @@ var deleteTableAction = async ({ dbKey }, {
     syncServers,
     dbKey,
     deleteOptions: { type: "table" },
-    state: state2
+    state: state3
   });
   return dbKey;
 };
 
-// packages/render/table/tableSlice.ts
-var initialState = {
+// 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 createSliceWithThunks = buildCreateSlice({
-  creators: { asyncThunk: asyncThunkCreator }
 });
-var tableSlice = createSliceWithThunks({
-  name: "table",
-  initialState,
-  reducers: (create) => ({
-    /* --------------------------------------
-     * 1. 创建表：createTable
-     * ------------------------------------*/
-    createTable: create.asyncThunk(
-      createTableAction
-    ),
-    /* --------------------------------------
-     * 2. 加载已有表定义：initTable
-     * ------------------------------------*/
-    initTable: create.asyncThunk(
-      async (args, { dispatch, rejectWithValue }) => {
-        const { tenantId, tableId } = args;
-        const dbKey = metaKey(tenantId, tableId);
-        try {
-          const readAction = await dispatch(readAndWait(dbKey));
-          if (readAndWait.fulfilled.match(readAction) && readAction.payload) {
-            const meta = readAction.payload;
-            return meta;
+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);
           }
-          const msg = readAction.payload?.message || `\u65E0\u6CD5\u52A0\u8F7D\u8868 ${tableId}`;
-          return rejectWithValue(msg);
-        } catch (e) {
-          return rejectWithValue(e.message || `\u521D\u59CB\u5316\u8868 ${tableId} \u65F6\u51FA\u9519`);
-        }
-      },
-      {
-        pending: (state2) => {
-          state2.isLoading = true;
-          state2.error = null;
-          state2.isInitialized = false;
-          state2.currentTable = null;
-          state2.rows = [];
-        },
-        fulfilled: (state2, action) => {
-          state2.isLoading = false;
-          state2.isInitialized = true;
-          state2.currentTable = action.payload;
-          state2.error = null;
-        },
-        rejected: (state2, action) => {
-          state2.isLoading = false;
-          state2.isInitialized = true;
-          state2.currentTable = null;
-          state2.error = action.payload || action.error.message || "\u521D\u59CB\u5316\u8868\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
-          state2.rows = [];
-        }
+        };
       }
-    ),
-    /* --------------------------------------
-     * 2.1 加载某表的所有行：loadTableRows
-     * ------------------------------------*/
-    loadTableRows: create.asyncThunk(
-      async (args, { getState, rejectWithValue, extra }) => {
-        const { tenantId, tableId } = args;
-        const { db } = extra;
-        try {
-          const state2 = getState();
-          const { currentToken: token, remoteServers } = getRuntimeServerContext(state2);
-          return await fetchAndCacheTableRows({
-            db,
-            tenantId,
-            tableId,
-            token,
-            remoteServers
-          });
-        } catch (e) {
-          return rejectWithValue(e.message || "\u52A0\u8F7D\u8868\u884C\u5931\u8D25");
-        }
-      },
-      {
-        pending: (state2) => {
-          state2.error = null;
-        },
-        fulfilled: (state2, action) => {
-          state2.rows = action.payload;
-        },
-        rejected: (state2, action) => {
-          state2.error = action.payload || action.error.message || "\u52A0\u8F7D\u8868\u884C\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
-          state2.rows = [];
-        }
+    };
+  };
+  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");
       }
-    ),
-    /* --------------------------------------
-     * 3. 新增一行：addRow
-     * ------------------------------------*/
-    addRow: create.asyncThunk(
-      async (args, { dispatch, rejectWithValue }) => {
-        const { tenantId, tableId, values } = args;
-        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
-          };
-          await dispatch(
-            write({
-              data: row,
-              customKey: dbKey
-            })
-          ).unwrap();
-          return row;
-        } catch (e) {
-          return rejectWithValue(e.message || "\u65B0\u589E\u8868\u884C\u5931\u8D25");
-        }
-      },
-      {
-        pending: (state2) => {
-          state2.error = null;
-        },
-        fulfilled: (state2, action) => {
-          const row = action.payload;
-          const meta = state2.currentTable;
-          if (meta && row?.tenantId === meta.tenantId && row?.tableId === meta.tableId) {
-            state2.rows.push(row);
-          }
-        },
-        rejected: (state2, action) => {
-          state2.error = action.payload || action.error.message || "\u65B0\u589E\u8868\u884C\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
-        }
+      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;
       }
-    ),
-    /* --------------------------------------
-     * 3.1 删除一行：deleteRow
-     * ------------------------------------*/
-    deleteRow: create.asyncThunk(
-      async (dbKey, { dispatch, getState, rejectWithValue, extra }) => {
-        try {
-          const state2 = getState();
-          const row = state2.table.rows.find((item) => item?.dbKey === dbKey);
-          if (!row) {
-            return rejectWithValue(`\u5F53\u524D\u8868\u4E2D\u627E\u4E0D\u5230\u8981\u5220\u9664\u7684\u884C\uFF1A${dbKey}`);
-          }
-          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);
-          }
-          dispatch(upsertSSREntity(tombstoneRow));
-          const { currentServer, syncServers } = getRuntimeServerContext(state2);
-          const servers = resolveReplicationServers(currentServer, syncServers);
-          scheduleWriteReplication(
-            servers,
-            {
-              data: tombstoneRow,
-              customKey: dbKey
-            },
-            state2
-          );
-          return dbKey;
-        } catch (e) {
-          return rejectWithValue(e.message || "\u5220\u9664\u8868\u884C\u5931\u8D25");
+      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 };
         }
-      },
-      {
-        pending: (state2) => {
-          state2.error = null;
-        },
-        fulfilled: (state2, action) => {
-          const dbKey = action.payload;
-          state2.rows = state2.rows.filter((row) => row.dbKey !== dbKey);
-        },
-        rejected: (state2, action) => {
-          state2.error = action.payload || action.error.message || "\u5220\u9664\u8868\u884C\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        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 };
       }
-    ),
-    /* --------------------------------------
-     * 3.2 删除整张表：deleteTable
-     * ------------------------------------*/
-    deleteTable: create.asyncThunk(
-      deleteTableAction,
-      {
-        pending: (state2) => {
-          state2.error = null;
-        },
-        fulfilled: (state2, action) => {
-          const deletedKey = action.payload;
-          if (state2.currentTable?.dbKey === deletedKey) {
-            state2.currentTable = null;
-            state2.rows = [];
-            state2.isInitialized = false;
-          }
-        },
-        rejected: (state2, action) => {
-          state2.error = action.payload || action.error.message || "\u5220\u9664\u8868\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
-        }
+      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
+          })
+        );
       }
-    ),
-    /* --------------------------------------
-     * 4. 新增字段：addColumn
-     * ------------------------------------*/
-    addColumn: create.asyncThunk(
-      async (args, { dispatch, getState, rejectWithValue }) => {
-        const { tenantId, tableId, columnName } = args;
-        const state2 = getState().table;
-        const meta = state2.currentTable;
-        if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
-          return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
+      setState((s) => {
+        const meta = s.currentTable;
+        if (meta && row?.tenantId === meta.tenantId && row?.tableId === meta.tableId) {
+          return { ...s, rows: [...s.rows, row] };
         }
-        const result = addColumnToMeta(
-          meta,
-          { columnName },
-          { id: ulid3(), nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
-        );
-        if (!result.ok) {
-          return rejectWithValue(result.error);
+        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 {
-          await dispatch(
-            patch({
-              dbKey: meta.dbKey,
-              changes: result.value.metaChanges
-            })
-          ).unwrap();
-          return result.value.meta;
-        } catch (e) {
-          return rejectWithValue(e.message || "\u6DFB\u52A0\u5B57\u6BB5\u5931\u8D25");
-        }
-      },
-      {
-        pending: (state2) => {
-          state2.error = null;
-        },
-        fulfilled: (state2, action) => {
-          state2.currentTable = action.payload;
-          state2.isInitialized = true;
-        },
-        rejected: (state2, action) => {
-          state2.error = action.payload || action.error.message || "\u4E3A\u8868\u65B0\u589E\u5B57\u6BB5\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+          row = await extra.db.get(dbKey);
+        } catch {
         }
       }
-    ),
-    /* --------------------------------------
-     * 4.1 删除字段：deleteColumn
-     * ------------------------------------*/
-    deleteColumn: create.asyncThunk(
-      async (args, { dispatch, getState, rejectWithValue }) => {
-        const { tenantId, tableId, columnName } = args;
-        const state2 = getState().table;
-        const meta = state2.currentTable;
-        if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
-          return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
-        }
-        const result = deleteColumnFromMeta(
-          meta,
-          state2.rows,
-          { columnName },
-          { nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
-        );
-        if (!result.ok) {
-          return rejectWithValue(result.error);
-        }
-        const { meta: nextMeta, metaChanges, rows: newRows, rowPatches } = result.value;
+      if (!row && dispatch) {
         try {
-          await Promise.all(
-            rowPatches.map((p) => dispatch(patch(p)).unwrap())
-          );
-          await dispatch(
-            patch({ dbKey: meta.dbKey, changes: metaChanges })
-          ).unwrap();
-          return { meta: nextMeta, rows: newRows };
-        } catch (e) {
-          return rejectWithValue(e.message || "\u5220\u9664\u5B57\u6BB5\u5931\u8D25");
+          const readAction = await safeDispatch(dispatch, readAndWait(dbKey));
+          row = readAction?.payload || readAction;
+        } catch {
         }
-      },
-      {
-        pending: (state2) => {
-          state2.error = null;
-        },
-        fulfilled: (state2, action) => {
-          state2.currentTable = action.payload.meta;
-          state2.rows = action.payload.rows;
-          state2.isInitialized = true;
+      }
+      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
         },
-        rejected: (state2, action) => {
-          state2.error = action.payload || action.error.message || "\u5220\u9664\u5B57\u6BB5\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
+        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
+          })
+        );
       }
-    ),
-    /* --------------------------------------
-     * 4.1-bis 调整字段顺序：reorderColumn
-     * ------------------------------------*/
-    reorderColumn: create.asyncThunk(
-      async (args, { dispatch, getState, rejectWithValue }) => {
-        const { tenantId, tableId, fromIndex, toIndex } = args;
-        const state2 = getState().table;
-        const meta = state2.currentTable;
-        if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
-          return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
-        }
-        const result = reorderColumnInMeta(
-          meta,
-          { fromIndex, toIndex },
-          { nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
+      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 })
         );
-        if (!result.ok) {
-          return rejectWithValue(result.error);
-        }
-        if (result.value.noop) {
-          return meta;
-        }
-        const { meta: nextMeta, metaChanges } = result.value;
-        try {
-          await dispatch(
-            patch({ dbKey: meta.dbKey, changes: metaChanges })
-          ).unwrap();
-          return nextMeta;
-        } catch (e) {
-          return rejectWithValue(e.message || "\u8C03\u6574\u5217\u987A\u5E8F\u5931\u8D25");
-        }
-      },
-      {
-        pending: (state2) => {
-          state2.error = null;
-        },
-        fulfilled: (state2, action) => {
-          state2.currentTable = action.payload;
-          state2.isInitialized = true;
-        },
-        rejected: (state2, action) => {
-          state2.error = action.payload || action.error.message || "\u8C03\u6574\u5217\u987A\u5E8F\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
-        }
       }
-    ),
-    /* --------------------------------------
-     * 4.2 重命名字段（机器名）：renameColumn
-     * 说明：这是“改字段 key 并迁移所有行数据”的重操作，
-     * 目前 UI 不直接调用，保留给将来高级设置用。
-     * ------------------------------------*/
-    renameColumn: create.asyncThunk(
-      async (args, { dispatch, getState, rejectWithValue }) => {
-        const { tenantId, tableId, oldName, newName } = args;
-        const state2 = getState().table;
-        const meta = state2.currentTable;
-        if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
-          return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
-        }
-        const result = renameColumnInMeta(
-          meta,
-          state2.rows,
-          { oldName, newName },
-          { nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
+      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 })
         );
-        if (!result.ok) {
-          return rejectWithValue(result.error);
-        }
-        const { meta: nextMeta, metaChanges, rows: newRows, rowPatches } = result.value;
-        try {
-          await Promise.all(
-            rowPatches.map((p) => dispatch(patch(p)).unwrap())
-          );
-          await dispatch(
-            patch({ dbKey: meta.dbKey, changes: metaChanges })
-          ).unwrap();
-          return { meta: nextMeta, rows: newRows };
-        } catch (e) {
-          return rejectWithValue(e.message || "\u91CD\u547D\u540D\u5B57\u6BB5\u5931\u8D25");
-        }
-      },
-      {
-        pending: (state2) => {
-          state2.error = null;
-        },
-        fulfilled: (state2, action) => {
-          state2.currentTable = action.payload.meta;
-          state2.rows = action.payload.rows;
-          state2.isInitialized = true;
-        },
-        rejected: (state2, action) => {
-          state2.error = action.payload || action.error.message || "\u91CD\u547D\u540D\u5B57\u6BB5\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
-        }
       }
-    ),
-    /* --------------------------------------
-     * 4.2-bis 重命名字段显示名：renameColumnLabel
-     * 说明：只改 columns[].label，不动 name / 行数据
-     * UI 表头双击使用这一条。
-     * ------------------------------------*/
-    renameColumnLabel: create.asyncThunk(
-      async (args, { dispatch, getState, rejectWithValue }) => {
-        const { tenantId, tableId, columnId, newLabel } = args;
-        const state2 = getState().table;
-        const meta = state2.currentTable;
-        if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
-          return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
-        }
-        const result = renameColumnLabelInMeta(
-          meta,
-          { columnId, label: newLabel },
-          { nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
+      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 renameColumn = createTableCommand(
+  "table/renameColumn",
+  async (args, { dispatch } = {}) => {
+    const { tenantId, tableId, oldName, newName } = 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 = renameColumnInMeta(
+      meta,
+      state.rows,
+      { oldName, newName },
+      { 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 })
         );
-        if (!result.ok) {
-          return rejectWithValue(result.error);
-        }
-        const { meta: nextMeta, metaChanges } = result.value;
-        try {
-          await dispatch(
-            patch({ dbKey: meta.dbKey, changes: metaChanges })
-          ).unwrap();
-          return nextMeta;
-        } catch (e) {
-          return rejectWithValue(e.message || "\u91CD\u547D\u540D\u5B57\u6BB5\u663E\u793A\u540D\u5931\u8D25");
-        }
-      },
-      {
-        pending: (state2) => {
-          state2.error = null;
-        },
-        fulfilled: (state2, action) => {
-          state2.currentTable = action.payload;
-          state2.isInitialized = true;
-        },
-        rejected: (state2, action) => {
-          state2.error = action.payload || action.error.message || "\u91CD\u547D\u540D\u5B57\u6BB5\u663E\u793A\u540D\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
-        }
       }
-    ),
-    /* --------------------------------------
-     * 4.2-ter 更新字段宽度：updateColumnWidth
-     * 说明：只改 columns[].width，用于持久化列宽
-     * ------------------------------------*/
-    updateColumnWidth: create.asyncThunk(
-      async (args, { dispatch, getState, rejectWithValue }) => {
-        const { tenantId, tableId, columnId, width } = args;
-        const state2 = getState().table;
-        const meta = state2.currentTable;
-        if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
-          return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
-        }
-        const result = updateColumnWidthInMeta(
-          meta,
-          { columnId, width },
-          { nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
+      setState((s) => ({
+        ...s,
+        currentTable: nextMeta,
+        rows: newRows,
+        isInitialized: true
+      }));
+      return { meta: nextMeta, rows: newRows };
+    } catch (e) {
+      const msg = e?.message || "\u91CD\u547D\u540D\u5B57\u6BB5\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 })
         );
-        if (!result.ok) {
-          return rejectWithValue(result.error);
-        }
-        const { meta: nextMeta, metaChanges } = result.value;
-        try {
-          await dispatch(
-            patch({ dbKey: meta.dbKey, changes: metaChanges })
-          ).unwrap();
-          return nextMeta;
-        } catch (e) {
-          return rejectWithValue(e.message || "\u66F4\u65B0\u5B57\u6BB5\u5BBD\u5EA6\u5931\u8D25");
-        }
-      },
-      {
-        pending: (state2) => {
-          state2.error = null;
-        },
-        fulfilled: (state2, action) => {
-          state2.currentTable = action.payload;
-          state2.isInitialized = true;
-        },
-        rejected: (state2, action) => {
-          state2.error = action.payload || action.error.message || "\u66F4\u65B0\u5B57\u6BB5\u5BBD\u5EA6\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
-        }
       }
-    ),
-    /* --------------------------------------
-     * 4.2-quater 新增 select 选项：addColumnOption
-     * 说明：把新选项追加到 columns[].options（select 弹层「+ 新建选项」入口），
-     * 重复选项为 no-op：跳过 patch 直接返回原 meta，fulfilled 照常刷新 currentTable。
-     * ------------------------------------*/
-    addColumnOption: create.asyncThunk(
-      async (args, { dispatch, getState, rejectWithValue }) => {
-        const { tenantId, tableId, columnId, option } = args;
-        const state2 = getState().table;
-        const meta = state2.currentTable;
-        if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
-          return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
-        }
-        const result = addColumnOptionInMeta(
-          meta,
-          { columnId, option },
-          { nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
+      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 })
         );
-        if (!result.ok) {
-          return rejectWithValue(result.error);
-        }
-        if (result.value.noop) {
-          return meta;
-        }
-        const { meta: nextMeta, metaChanges } = result.value;
-        try {
-          await dispatch(
-            patch({ dbKey: meta.dbKey, changes: metaChanges })
-          ).unwrap();
-          return nextMeta;
-        } catch (e) {
-          return rejectWithValue(e.message || "\u65B0\u589E\u9009\u9879\u5931\u8D25");
-        }
-      },
-      {
-        pending: (state2) => {
-          state2.error = null;
-        },
-        fulfilled: (state2, action) => {
-          state2.currentTable = action.payload;
-          state2.isInitialized = true;
-        },
-        rejected: (state2, action) => {
-          state2.error = action.payload || action.error.message || "\u65B0\u589E\u9009\u9879\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
-        }
       }
-    ),
-    /* --------------------------------------
-     * 4.3 重命名表：renameTable（仅修改显示名称）
-     * ------------------------------------*/
-    renameTable: create.asyncThunk(
-      async (args, { dispatch, getState, rejectWithValue }) => {
-        const { tenantId, tableId, newName } = args;
-        const trimmedName = newName.trim();
-        if (!trimmedName) {
-          return rejectWithValue("\u8868\u540D\u4E0D\u80FD\u4E3A\u7A7A");
-        }
-        const state2 = getState().table;
-        const meta = state2.currentTable;
-        if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
-          return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
-        }
-        const nowIso = (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date());
-        try {
-          await dispatch(
-            patch({
-              dbKey: meta.dbKey,
-              changes: {
-                displayName: trimmedName,
-                updatedAt: nowIso
-              }
-            })
-          ).unwrap();
-          const nextMeta = {
-            ...meta,
-            displayName: trimmedName,
-            updatedAt: nowIso
-          };
-          return nextMeta;
-        } catch (e) {
-          return rejectWithValue(e.message || "\u91CD\u547D\u540D\u8868\u5931\u8D25");
-        }
-      },
-      {
-        pending: (state2) => {
-          state2.error = null;
-        },
-        fulfilled: (state2, action) => {
-          state2.currentTable = action.payload;
-        },
-        rejected: (state2, action) => {
-          state2.error = action.payload || action.error.message || "\u91CD\u547D\u540D\u8868\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
-        }
+      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 })
+        );
       }
-    ),
-    updateTableIcon: create.asyncThunk(
-      async (args, { dispatch, getState, rejectWithValue }) => {
-        const { tenantId, tableId, icon } = args;
-        const state2 = getState().table;
-        const meta = state2.currentTable;
-        if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
-          return rejectWithValue("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
-        }
-        const nowIso = (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date());
-        try {
-          await dispatch(
-            patch({
-              dbKey: meta.dbKey,
-              changes: {
-                icon: icon ?? null,
-                updatedAt: nowIso
-              }
-            })
-          ).unwrap();
-          const nextMeta = {
-            ...meta,
-            icon: icon ?? null,
-            updatedAt: nowIso
-          };
-          return nextMeta;
-        } catch (e) {
-          return rejectWithValue(e.message || "\u66F4\u65B0\u8868\u683C\u56FE\u6807\u5931\u8D25");
-        }
-      },
-      {
-        pending: (state2) => {
-          state2.error = null;
-        },
-        fulfilled: (state2, action) => {
-          state2.currentTable = action.payload;
-        },
-        rejected: (state2, action) => {
-          state2.error = action.payload || action.error.message || "\u66F4\u65B0\u8868\u683C\u56FE\u6807\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
-        }
+      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
+            }
+          })
+        );
       }
-    ),
-    /* --------------------------------------
-     * 4.4 更新单元格：updateCell
-     * ------------------------------------*/
-    updateCell: create.asyncThunk(
-      async (args, { dispatch, rejectWithValue }) => {
-        const { dbKey, columnName, value } = args;
-        try {
-          const nowIso = (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date());
-          await dispatch(
-            patch({
-              dbKey,
-              changes: {
-                [columnName]: value,
-                updatedAt: nowIso
-              }
-            })
-          ).unwrap();
-          return { dbKey, columnName, value, updatedAt: nowIso };
-        } catch (e) {
-          return rejectWithValue(e.message || "\u66F4\u65B0\u5355\u5143\u683C\u5931\u8D25");
-        }
-      },
-      {
-        pending: (state2) => {
-          state2.error = null;
-        },
-        fulfilled: (state2, action) => {
-          const { dbKey, columnName, value, updatedAt } = action.payload;
-          const row = state2.rows.find((r) => r.dbKey === dbKey);
-          if (row) {
-            row[columnName] = value;
-            row.updatedAt = updatedAt;
-          }
-        },
-        rejected: (state2, action) => {
-          state2.error = action.payload || action.error.message || "\u66F4\u65B0\u5355\u5143\u683C\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
-        }
+      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
+            }
+          })
+        );
       }
-    ),
-    /* --------------------------------------
-     * 5. 重置当前表状态
-     * ------------------------------------*/
-    setTableFocusContext: create.reducer(
-      (state2, action) => {
-        state2.focusContext = action.payload;
+      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
+            }
+          })
+        );
       }
-    ),
-    resetTable: create.reducer((state2) => {
-      Object.assign(state2, initialState);
-    })
-  }),
-  selectors: {
-    selectCurrentTable: (s) => s.currentTable,
-    selectTableIsLoading: (s) => s.isLoading,
-    selectTableIsInitialized: (s) => s.isInitialized,
-    selectTableError: (s) => s.error,
-    selectTableColumns: (s) => s.currentTable ? s.currentTable.columns : [],
-    selectTableRows: (s) => s.rows,
-    selectTableFocusContext: (s) => s.focusContext
+      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;
+    }
   }
-});
-var {
-  createTable,
-  initTable,
-  addRow,
-  deleteRow,
-  deleteTable,
-  addColumn,
-  deleteColumn,
-  renameColumn,
-  renameColumnLabel,
-  renameTable,
-  updateTableIcon,
-  resetTable,
-  loadTableRows,
-  updateCell,
-  reorderColumn,
-  updateColumnWidth,
-  addColumnOption,
-  setTableFocusContext
-} = tableSlice.actions;
-var {
-  selectCurrentTable,
-  selectTableIsLoading,
-  selectTableIsInitialized,
-  selectTableError,
-  selectTableColumns,
-  selectTableRows,
-  selectTableFocusContext
-} = tableSlice.selectors;
-var tableSlice_default = tableSlice.reducer;
+);
 
 // packages/create/space/content/deleteContentFromSpaceAction.ts
 var nextSpaceUpdatedAt = (value) => {
@@ -4090,11 +4097,11 @@ var ENTITY_DELETE_STRATEGIES = {
     await dispatch(deleteTable({ dbKey: key })).unwrap();
   },
   file: async (key, { thunkAPI }) => {
-    const { deleteFileAction } = await import("./deleteFile-JYKRT7C3.js");
+    const { deleteFileAction } = await import("./deleteFile-FWP2PSBG.js");
     await deleteFileAction(key, thunkAPI);
   },
   image: async (key, { thunkAPI }) => {
-    const { deleteFileAction } = await import("./deleteFile-JYKRT7C3.js");
+    const { deleteFileAction } = await import("./deleteFile-FWP2PSBG.js");
     await deleteFileAction(key, thunkAPI);
   },
   agent: async (key, { dispatch, userId, sourceServerOrigin }) => {
@@ -4199,8 +4206,8 @@ var moveContentAction = async (input, thunkAPI) => {
     targetCategoryId: rawTargetCategoryId
   } = input;
   const { dispatch, getState } = thunkAPI;
-  const state2 = getState();
-  const userId = selectIdentityUserId(state2);
+  const state3 = getState();
+  const userId = selectIdentityUserId(state3);
   const now = Date.now();
   logger.info({ ...input, userId }, "Initiating moveContentAction");
   if (sourceSpaceId === targetSpaceId) {
@@ -4554,8 +4561,8 @@ var updateContentPinnedAction = async (input, thunkAPI) => {
 var updateContentCategoryAction = async (input, thunkAPI) => {
   const { spaceId, contentKey, categoryId: targetContainerId } = input;
   const { dispatch, getState } = thunkAPI;
-  const state2 = getState();
-  const userId = selectIdentityUserId(state2);
+  const state3 = getState();
+  const userId = selectIdentityUserId(state3);
   if (!userId) {
     throw new Error("User is not logged in.");
   }
@@ -4659,8 +4666,8 @@ var deleteMultipleContentAction = async (input, thunkAPI) => {
     return { spaceId, updatedSpaceData: null };
   }
   const { dispatch, getState } = thunkAPI;
-  const state2 = getState();
-  const userId = selectIdentityUserId(state2);
+  const state3 = getState();
+  const userId = selectIdentityUserId(state3);
   logger2.info(
     { count: contentKeys.length, spaceId, userId },
     "Initiating deleteMultipleContentAction"
@@ -4731,8 +4738,8 @@ var deleteMultipleContentAction = async (input, thunkAPI) => {
 var uploadAndAddFileToSpaceAction = async (payload, thunkAPI) => {
   const { spaceId, file, categoryId } = payload;
   const { dispatch, getState } = thunkAPI;
-  const state2 = getState();
-  const userId = selectIdentityUserId(state2);
+  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.");
   }
@@ -4820,7 +4827,7 @@ var writeStoredCollapsedCategories = (spaceId, collapsedCategories, storage) =>
 };
 
 // packages/create/space/spaceUiStore.ts
-var import_react9 = __toESM(require_react(), 1);
+var import_react10 = __toESM(require_react(), 1);
 var DEFAULT_COLLAPSED_CATEGORIES = {
   [UNCATEGORIZED_ID]: false
 };
@@ -4833,17 +4840,17 @@ var readStoredFavoritesCollapsed = () => {
     return false;
   }
 };
-var createInitialState = () => ({
+var createInitialState2 = () => ({
   favoritesCollapsed: readStoredFavoritesCollapsed(),
   collapsedCategories: {},
   collapsedCategoriesSpaceId: null
 });
-var state = createInitialState();
-var listeners = /* @__PURE__ */ new Set();
-var version = 0;
-var notify = () => {
-  version += 1;
-  for (const listener of listeners) {
+var state2 = createInitialState2();
+var listeners2 = /* @__PURE__ */ new Set();
+var version2 = 0;
+var notify2 = () => {
+  version2 += 1;
+  for (const listener of listeners2) {
     try {
       listener();
     } catch {
@@ -4851,44 +4858,44 @@ var notify = () => {
   }
 };
 function getCollapsedCategories() {
-  return state.collapsedCategories;
+  return state2.collapsedCategories;
 }
 function setCollapsedCategories(categories, spaceId) {
-  state = {
-    ...state,
+  state2 = {
+    ...state2,
     collapsedCategories: categories,
     collapsedCategoriesSpaceId: spaceId
   };
-  notify();
+  notify2();
 }
 function toggleCategoryCollapse(categoryId) {
-  const current = state.collapsedCategories[categoryId] ?? (DEFAULT_COLLAPSED_CATEGORIES[categoryId] ?? true);
-  state = {
-    ...state,
+  const current = state2.collapsedCategories[categoryId] ?? (DEFAULT_COLLAPSED_CATEGORIES[categoryId] ?? true);
+  state2 = {
+    ...state2,
     collapsedCategories: {
-      ...state.collapsedCategories,
+      ...state2.collapsedCategories,
       [categoryId]: !current
     }
   };
-  notify();
+  notify2();
 }
 function expandCategoryInCollapsed(categoryId, spaceId) {
   if (!categoryId || categoryId === UNCATEGORIZED_ID) return;
-  state = {
-    ...state,
+  state2 = {
+    ...state2,
     collapsedCategories: {
-      ...state.collapsedCategories,
+      ...state2.collapsedCategories,
       [categoryId]: false
     }
   };
   if (typeof window !== "undefined") {
     writeStoredCollapsedCategories(
       spaceId,
-      state.collapsedCategories,
+      state2.collapsedCategories,
       window.localStorage
     );
   }
-  notify();
+  notify2();
 }
 
 // packages/create/space/content/contentThunks.ts
@@ -5032,12 +5039,11 @@ export {
   i18nBaseConfig,
   fetchAndCacheTableRows,
   client_default,
-  createTable,
+  getTableState,
+  loadTableRows,
   addRow,
+  createTable,
   deleteTable,
-  loadTableRows,
-  selectCurrentTable,
-  selectTableRows,
   readStoredCollapsedCategories,
   writeStoredCollapsedCategories,
   DEFAULT_COLLAPSED_CATEGORIES,