nolo-cli 0.8.0 → 0.9.1

package/chunk-COMXDWNM.js

@@ -0,0 +1,807 @@
+import {
+  resolveFileCategory
+} from "./chunk-AZPCASRE.js";
+import {
+  loadFileFromIndexedDb,
+  removeAction,
+  saveFileToIndexedDb
+} from "./chunk-2EISRLRC.js";
+import {
+  fileKey,
+  getFileIdFromKey,
+  ulid
+} from "./chunk-SH2CFQOH.js";
+import {
+  readAction,
+  readRequestManager,
+  resolveAgentReadServers
+} from "./chunk-ELRRLDWI.js";
+import {
+  asyncThunkCreator,
+  buildCreateSlice,
+  compareRemoteRecordsByComparableTime,
+  createEntityAdapter,
+  getRuntimeServerContext,
+  noloDeleteRequest,
+  pickBestSettledRemoteRecord,
+  planAuthorityReadServers,
+  resolveAuthorityReplicationServers,
+  resolveRecordAuthority,
+  resolveUploadReplicationServers,
+  scheduleConfiguredPatchReplication,
+  scheduleExistingRecordReplication,
+  scheduleUploadReplication,
+  scheduleWriteReplication,
+  shouldReplaceLocalWithRemoteRecord,
+  shouldReplicateLocalRecord,
+  uploadToCurrentServer
+} from "./chunk-EYEEHCU4.js";
+import {
+  fetchFromClientDb,
+  fetchFromServer,
+  logger,
+  normalizeTimeFields
+} from "./chunk-QYXLLLGL.js";
+import {
+  isTombstoneRecord
+} from "./chunk-GBRG75BQ.js";
+import {
+  API_ENDPOINTS
+} from "./chunk-LCBAMY2M.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+
+// packages/database/actions/readAndWait.ts
+var hashTokenScope = (currentToken) => {
+  const token = currentToken || "";
+  if (!token) return "anonymous";
+  let hash = 0;
+  for (let index = 0; index < token.length; index += 1) {
+    hash = (hash << 5) - hash + token.charCodeAt(index) | 0;
+  }
+  return `token:${Math.abs(hash).toString(36)}`;
+};
+var buildReadAndWaitRequestKey = (dbKey, currentToken) => `${dbKey}\0auth:${hashTokenScope(currentToken)}`;
+var isRemoteDataNewer = (remoteData, localData) => {
+  return compareRemoteRecordsByComparableTime(remoteData, localData) > 0;
+};
+var syncLocalDataToServer = async (replicationContext, dbKey, localData) => {
+  try {
+    scheduleExistingRecordReplication({
+      currentServer: replicationContext.currentServer,
+      syncServers: replicationContext.syncServers,
+      dbKey,
+      localData,
+      state: replicationContext.state
+    });
+  } catch {
+  }
+};
+var processRemoteData = async (db, dbKey, remotePromises, localData, replicationContext) => {
+  try {
+    const settledResults = await Promise.allSettled(remotePromises);
+    const remoteResult = pickBestSettledRemoteRecord({
+      settledResults,
+      isBetterCandidate: (current, latest) => compareRemoteRecordsByComparableTime(current, latest) > 0
+    });
+    const validRemoteData = remoteResult ? remoteResult.data : null;
+    if (shouldReplaceLocalWithRemoteRecord({
+      localData,
+      remoteData: validRemoteData,
+      isRemoteNewer: isRemoteDataNewer
+    })) {
+      await db.put(dbKey, validRemoteData);
+      return validRemoteData;
+    }
+    if (localData) {
+      if (shouldReplicateLocalRecord({
+        localData,
+        remoteData: validRemoteData,
+        remoteTargetCount: remotePromises.length
+      })) {
+        void syncLocalDataToServer(replicationContext, dbKey, localData);
+      }
+      return localData;
+    }
+    throw new Error("Failed to fetch data from all sources");
+  } catch (err) {
+    if (localData) {
+      return localData;
+    }
+    throw err;
+  }
+};
+var readAndWaitAction = async (payload, thunkApi) => {
+  const dbKey = typeof payload === "string" ? payload : payload.dbKey;
+  const preferredServerOrigin = typeof payload === "string" ? void 0 : payload.preferredServerOrigin;
+  const { db } = thunkApi.extra;
+  if (!db) {
+    throw new Error(
+      "Database instance is not available in thunk extra argument."
+    );
+  }
+  const state = thunkApi.getState();
+  const {
+    currentToken,
+    remoteServers: configuredServers,
+    currentServer,
+    currentUserId,
+    syncServers,
+    userAuthorityRegistry
+  } = getRuntimeServerContext(state, preferredServerOrigin);
+  const allServers = resolveAgentReadServers({ dbKey, configuredServers });
+  const isLoggedIn = !!currentToken;
+  const executeReadAndWait = async () => {
+    const localData = await fetchFromClientDb(db, dbKey);
+    const authority = resolveRecordAuthority({
+      dbKey,
+      record: localData,
+      currentUserId,
+      currentServer,
+      userAuthorityRegistry
+    });
+    const readServers = planAuthorityReadServers({
+      allServers,
+      authorityServer: preferredServerOrigin ?? authority.authorityServer,
+      serverOrigin: authority.serverOrigin
+    });
+    const hasPreferredAuthorityServer = !!preferredServerOrigin || !!authority.authorityServer;
+    const preferredAuthorityServer = hasPreferredAuthorityServer ? readServers[0] : null;
+    if (readServers.length === 0) {
+      if (localData) {
+        return { ...localData, dbKey };
+      }
+      throw new Error(
+        `Failed to fetch data for key "${dbKey}" because network is offline and no local data is available.`
+      );
+    }
+    if (preferredAuthorityServer) {
+      try {
+        const preferredRemoteData = await fetchFromServer(
+          preferredAuthorityServer,
+          dbKey,
+          isLoggedIn ? currentToken : void 0
+        );
+        if (preferredRemoteData) {
+          await db.put(dbKey, preferredRemoteData);
+          return { ...preferredRemoteData, dbKey };
+        }
+      } catch {
+      }
+    }
+    const remainingReadServers = preferredAuthorityServer ? readServers.filter((server) => server !== preferredAuthorityServer) : readServers;
+    const remotePromises = remainingReadServers.map(
+      (server) => fetchFromServer(server, dbKey, isLoggedIn ? currentToken : void 0)
+    );
+    const chosenData = await processRemoteData(
+      db,
+      dbKey,
+      remotePromises,
+      localData,
+      { currentServer, syncServers, state }
+    );
+    return { ...chosenData, dbKey };
+  };
+  const inFlightKey = buildReadAndWaitRequestKey(dbKey, currentToken);
+  const existing = readRequestManager.getInFlight(inFlightKey);
+  if (existing) return existing;
+  let inFlightPromise;
+  inFlightPromise = executeReadAndWait().finally(() => {
+    readRequestManager.clearInFlight(inFlightKey, inFlightPromise);
+  });
+  readRequestManager.setInFlight(inFlightKey, inFlightPromise);
+  return inFlightPromise;
+};
+
+// packages/database/actions/actionToast.ts
+var registeredToast = null;
+var actionToast = {
+  success: (message) => registeredToast?.success(message),
+  error: (message) => {
+    if (registeredToast) registeredToast.error(message);
+    else console.warn(message);
+  }
+};
+
+// packages/database/actions/write.ts
+var SPACE_MEMBER_PREFIX = "space-member-";
+var getMemberUserIdFromSpaceMemberKey = (dbKey) => {
+  if (!dbKey.startsWith(SPACE_MEMBER_PREFIX)) return null;
+  const rest = dbKey.slice(SPACE_MEMBER_PREFIX.length);
+  const lastDash = rest.lastIndexOf("-");
+  if (lastDash <= 0) return null;
+  return rest.slice(0, lastDash);
+};
+var saveToClientDb = async (clientDb, dbKey, data) => {
+  if (!clientDb) {
+    logger.error({ dbKey }, "Client database is undefined in saveToClientDb");
+    throw new Error("Client database instance is required");
+  }
+  try {
+    await clientDb.put(dbKey, data);
+    logger.debug({ dbKey }, "Data saved successfully to local database.");
+  } catch (err) {
+    logger.error({ err, dbKey }, "Failed to save data to local database");
+    throw new Error(`Local database put failed for ${dbKey}: ${err.message}`);
+  }
+};
+var writeAction = async (writeConfig, thunkApi) => {
+  const { db: clientDb } = thunkApi.extra;
+  if (!clientDb) {
+    throw new Error("Client database instance is required in writeAction");
+  }
+  const state = thunkApi.getState();
+  const { currentServer, syncServers, currentUserId } = getRuntimeServerContext(state);
+  const { data, customKey } = writeConfig;
+  const userId = writeConfig.userId || currentUserId;
+  const isSpaceMemberRecord = customKey.startsWith(SPACE_MEMBER_PREFIX);
+  const recordUserId = isSpaceMemberRecord ? data.userId || getMemberUserIdFromSpaceMemberKey(customKey) || userId : userId;
+  if (!data || !customKey) {
+    const errorMsg = "Invalid arguments for writeAction: data and customKey are required.";
+    logger.error({ writeConfig }, errorMsg);
+    actionToast.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  const VALID_TYPES = [
+    "msg" /* MSG */,
+    "page" /* DOC */,
+    "dialog" /* DIALOG */,
+    "notification" /* NOTIFICATION */,
+    "token" /* TOKEN */,
+    "transaction" /* TRANSACTION */,
+    "space" /* SPACE */,
+    "setting" /* SETTING */,
+    "table" /* TABLE */,
+    "table_row" /* TABLE_ROW */,
+    "email" /* EMAIL */
+  ];
+  if (!data.type || !VALID_TYPES.includes(data.type)) {
+    logger.warn(
+      `Invalid data type "${data.type}" for writeAction with key ${customKey}. Proceeding anyway.`
+    );
+  }
+  try {
+    const willSaveData = normalizeTimeFields({
+      ...data,
+      dbKey: customKey,
+      userId: recordUserId
+    });
+    await saveToClientDb(clientDb, customKey, willSaveData);
+    const servers = resolveAuthorityReplicationServers({
+      currentServer,
+      syncServers,
+      dbKey: customKey,
+      record: willSaveData,
+      state
+    });
+    const serverWriteConfig = {
+      data: willSaveData,
+      customKey,
+      userId: recordUserId
+    };
+    if (servers.length > 0) {
+      logger.debug(
+        `[writeAction] Initiating background sync for key: ${customKey} to ${servers.length} servers.`
+      );
+      scheduleWriteReplication(servers, serverWriteConfig, state);
+    } else {
+      logger.warn(
+        { customKey },
+        "[writeAction] No available servers, data only saved locally."
+      );
+    }
+    return willSaveData;
+  } catch (error) {
+    const errorMessage = `Write action failed for ${customKey}: ${error?.message || "Unknown error"}`;
+    logger.error("[writeAction] Error:", error);
+    actionToast.error(`Failed to save data for ${customKey}.`);
+    throw new Error(errorMessage);
+  }
+};
+
+// packages/core/timestamp.ts
+function toTimestampMs(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+
+// packages/database/actions/patch.ts
+var deepMerge = (target, source) => {
+  const output = { ...target };
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      if (source[key] === null && key in output) {
+        delete output[key];
+      } else if (isRecord(source[key])) {
+        output[key] = deepMerge(output[key] || {}, source[key]);
+      } else {
+        output[key] = source[key];
+      }
+    }
+  }
+  return output;
+};
+var inferNextUpdatedAt = (currentData) => {
+  const previousUpdatedAt = currentData?.updatedAt;
+  const previousCreatedAt = currentData?.createdAt;
+  const previousMetaCreatedAt = currentData?.meta?.createdAt;
+  const previousTimestamp = Math.max(
+    toTimestampMs(previousUpdatedAt),
+    toTimestampMs(previousCreatedAt),
+    toTimestampMs(previousMetaCreatedAt)
+  );
+  const nextTimestamp = Math.max(Date.now(), previousTimestamp + 1);
+  if (typeof previousUpdatedAt === "number" || typeof previousCreatedAt === "number" || typeof previousMetaCreatedAt === "number") {
+    return nextTimestamp;
+  }
+  if (typeof previousUpdatedAt === "string" || typeof previousCreatedAt === "string") {
+    return new Date(nextTimestamp).toISOString();
+  }
+  return void 0;
+};
+var patchAction = async ({
+  dbKey,
+  changes,
+  preferredServerOrigin
+}, thunkApi) => {
+  const { db } = thunkApi.extra;
+  if (!db) {
+    const errorMsg = "Database instance is not available.";
+    actionToast.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  if (!dbKey || !changes || typeof changes !== "object") {
+    const errorMsg = "Patch action requires a valid dbKey and changes object.";
+    actionToast.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  const state = thunkApi.getState();
+  const { currentServer, syncServers: configuredSyncServers } = getRuntimeServerContext(state);
+  try {
+    const currentData = await db.get(dbKey);
+    if (!currentData) {
+      throw new Error(
+        `Cannot apply patch: Data not found locally for key: ${dbKey}.`
+      );
+    }
+    const patchChanges = Object.prototype.hasOwnProperty.call(changes, "updatedAt") ? changes : {
+      ...changes,
+      ...inferNextUpdatedAt(currentData) !== void 0 ? { updatedAt: inferNextUpdatedAt(currentData) } : {}
+    };
+    const newData = deepMerge(currentData, patchChanges);
+    const persistedData = newData && typeof newData === "object" ? { ...newData, dbKey } : { dbKey };
+    await db.put(dbKey, persistedData);
+    scheduleConfiguredPatchReplication({
+      currentServer,
+      syncServers: configuredSyncServers,
+      preferredServerOrigin,
+      dbKey,
+      changes: patchChanges,
+      state
+    });
+    return persistedData;
+  } catch (error) {
+    const errorMessage = `Failed to update data for ${dbKey}.`;
+    actionToast.error(errorMessage);
+    throw new Error(error.message || errorMessage);
+  }
+};
+
+// packages/database/actions/purge.ts
+var purgeAction = async (payload, thunkApi) => {
+  const { db: clientDb } = thunkApi.extra;
+  const dbKey = typeof payload === "string" ? payload : payload.dbKey;
+  const preferredServerOrigin = typeof payload === "string" ? void 0 : payload.preferredServerOrigin;
+  if (!clientDb) {
+    throw new Error("Client database is undefined in purgeAction");
+  }
+  const state = thunkApi.getState();
+  const { currentServer, syncServers } = getRuntimeServerContext(state);
+  const localData = await fetchFromClientDb(clientDb, dbKey);
+  if (localData && !isTombstoneRecord(localData)) {
+    throw new Error(
+      `purgeAction refused: record ${dbKey} is not tombstoned. Use removeAction instead.`
+    );
+  }
+  await clientDb.del(dbKey);
+  const servers = resolveAuthorityReplicationServers({
+    currentServer,
+    syncServers,
+    preferredServerOrigin,
+    dbKey,
+    state
+  });
+  await Promise.all(
+    servers.map(async (server) => {
+      const ok = await noloDeleteRequest(
+        server,
+        dbKey,
+        { type: "single", force: true },
+        state
+      );
+      if (!ok) {
+        console.warn("[purgeAction] server force-delete failed", { dbKey, server });
+      }
+    })
+  );
+  return { dbKey, servers };
+};
+
+// packages/database/actions/upsert.ts
+var upsertAction = async (upsertConfig, thunkApi) => {
+  const { dbKey, data } = upsertConfig;
+  if (!dbKey || !data || typeof data !== "object") {
+    const errorMsg = "upsertAction \u53C2\u6570\u65E0\u6548\uFF1AdbKey \u548C data \u5BF9\u8C61\u662F\u5FC5\u9700\u7684\u3002";
+    actionToast.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  try {
+    const existingData = await readAction({ dbKey }, thunkApi);
+    let finalResult;
+    if (existingData && Object.keys(existingData).length > 0) {
+      finalResult = await patchAction({ dbKey, changes: data }, thunkApi);
+    } else {
+      finalResult = await writeAction({ data, customKey: dbKey }, thunkApi);
+    }
+    return finalResult;
+  } catch (error) {
+    const errorMessage = `Upsert \u534F\u8C03\u64CD\u4F5C\u5931\u8D25 (dbKey: ${dbKey}): ${error.message || "\u672A\u77E5\u9519\u8BEF"}`;
+    actionToast.error("\u6570\u636E\u4FDD\u5B58\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002");
+    throw new Error(errorMessage, { cause: error });
+  }
+};
+
+// packages/database/actions/upload.ts
+var saveToClientDb2 = async (clientDb, dbKey, metadata) => {
+  if (!clientDb) {
+    logger.error({ dbKey }, "Client database is undefined in saveToClientDb");
+    throw new Error("Client database instance is required");
+  }
+  try {
+    await clientDb.put(dbKey, metadata);
+    logger.debug(
+      { dbKey },
+      "File metadata saved successfully to local database."
+    );
+  } catch (err) {
+    logger.error(
+      { err, dbKey },
+      "Failed to save file metadata to local database"
+    );
+    throw new Error(`Local database put failed for ${dbKey}: ${err.message}`);
+  }
+};
+var uploadFileAction = async (uploadConfig, thunkApi) => {
+  const { db: clientDb } = thunkApi.extra;
+  const state = thunkApi.getState();
+  const { currentServer, syncServers, currentUserId } = getRuntimeServerContext(state);
+  const { file, customKey } = uploadConfig;
+  const userId = uploadConfig.userId || currentUserId;
+  if (!file) {
+    const errorMsg = "Invalid arguments for uploadFileAction: file is required.";
+    logger.error({ uploadConfig }, errorMsg);
+    throw new Error(errorMsg);
+  }
+  try {
+    const fileId = ulid();
+    const fileExtension = file.name.split(".").pop() || "";
+    const fileName = `${fileId}${fileExtension ? "." + fileExtension : ""}`;
+    let finalDbKey = customKey;
+    if (!finalDbKey || !finalDbKey.startsWith("file-")) {
+      const actualUserId = userId || "unknown";
+      if (actualUserId === "unknown") {
+        console.warn("[uploadFileAction] User ID is unknown during upload. Key will be file-unknown.");
+      }
+      finalDbKey = fileKey.single(actualUserId, fileId);
+    }
+    const fileMetadata = normalizeTimeFields({
+      id: fileId,
+      title: file.name,
+      originalName: file.name,
+      fileName,
+      filePath: "",
+      size: file.size,
+      mimeType: file.type || "application/octet-stream",
+      type: "file" /* FILE */,
+      fileCategory: resolveFileCategory({
+        mimeType: file.type,
+        fileName: file.name
+      }),
+      dbKey: finalDbKey,
+      userId
+    });
+    await saveToClientDb2(clientDb, finalDbKey, fileMetadata);
+    try {
+      await saveFileToIndexedDb(fileId, file);
+    } catch (err) {
+      logger.warn(
+        { err, fileId },
+        "[uploadFileAction] Failed to cache file locally."
+      );
+    }
+    const tenantId = userId || "default";
+    const uploadReplicationConfig = {
+      file,
+      metadata: fileMetadata,
+      customKey: finalDbKey,
+      userId
+    };
+    const uploadServers = resolveUploadReplicationServers({
+      currentServer,
+      syncServers,
+      tenantId,
+      uploadConfig: uploadReplicationConfig,
+      state
+    });
+    const primaryUploadServer = uploadServers[0] ?? currentServer;
+    const primaryUploadSucceeded = await uploadToCurrentServer({
+      currentServer: primaryUploadServer,
+      uploadConfig: uploadReplicationConfig,
+      state
+    });
+    if (primaryUploadServer && !primaryUploadSucceeded) {
+      throw new Error(`Primary upload failed on authority server ${primaryUploadServer}`);
+    }
+    const serversToUse = scheduleUploadReplication({
+      currentServer,
+      syncServers,
+      tenantId,
+      uploadConfig: uploadReplicationConfig,
+      state,
+      excludeServers: primaryUploadServer ? [primaryUploadServer] : []
+    });
+    if (!primaryUploadServer && !serversToUse.length) {
+      logger.warn(
+        { finalDbKey, fileName, tenantId },
+        "[uploadFileAction] No replication servers available, file metadata only saved locally."
+      );
+      return fileMetadata;
+    }
+    logger.debug(
+      { primaryUploadServer, currentServer, serversToUse, tenantId },
+      `[uploadFileAction] Uploaded primary copy for ${fileName} and scheduled background sync to ${serversToUse.length} additional servers.`
+    );
+    return fileMetadata;
+  } catch (error) {
+    const errorMessage = `Upload action failed for ${customKey}: ${error?.message || "Unknown error"}`;
+    logger.error({ error }, "[uploadFileAction] Error");
+    throw new Error(errorMessage);
+  }
+};
+
+// packages/database/actions/fileContent.ts
+var resolveLocalFileId = (fileId) => {
+  if (fileId.startsWith("file-")) {
+    return getFileIdFromKey(fileId) || fileId;
+  }
+  return fileId;
+};
+var readFileContentAction = async ({
+  fileId,
+  useServerFallback = true
+}, thunkApi) => {
+  if (!fileId || typeof fileId !== "string") {
+    throw new Error("readFileContentAction requires a valid fileId string.");
+  }
+  const localId = resolveLocalFileId(fileId);
+  const localRecord = await loadFileFromIndexedDb(localId);
+  if (localRecord) {
+    return {
+      fileId: localId,
+      blob: localRecord.blob,
+      source: "local"
+    };
+  }
+  if (!useServerFallback) {
+    throw new Error(
+      `Local file not found for id "${fileId}", and server fallback is disabled.`
+    );
+  }
+  const state = thunkApi.getState();
+  const { currentServer, remoteServers: serversToTry } = getRuntimeServerContext(state);
+  if (!currentServer) {
+    throw new Error(
+      `No current server configured. Cannot fetch remote file for id "${fileId}".`
+    );
+  }
+  let lastError = "";
+  for (const server of serversToTry) {
+    const url = `${server}${API_ENDPOINTS.DATABASE}/file/content/${fileId}`;
+    console.debug("[readFileContentAction] trying server:", url);
+    try {
+      const res = await fetch(url);
+      if (!res.ok) {
+        lastError = `HTTP ${res.status} from ${server}`;
+        console.debug("[readFileContentAction] server returned:", lastError);
+        continue;
+      }
+      const blob = await res.blob();
+      if (typeof indexedDB !== "undefined") {
+        void saveFileToIndexedDb(localId, blob).catch((err) => {
+          console.warn(
+            "[readFileContentAction] Failed to cache remote file into IndexedDB:",
+            err
+          );
+        });
+      }
+      return {
+        fileId: localId,
+        blob,
+        source: "remote"
+      };
+    } catch (err) {
+      lastError = err?.message || "Network error";
+      console.debug(
+        "[readFileContentAction] fetch error from",
+        server,
+        lastError
+      );
+    }
+  }
+  throw new Error(
+    `Failed to fetch remote file content from all servers for id "${fileId}". Last error: ${lastError}`
+  );
+};
+
+// packages/database/dbSlice.ts
+var dbAdapter = createEntityAdapter({
+  selectId: (entity) => entity.dbKey
+});
+var {
+  selectById,
+  selectEntities,
+  selectAll,
+  selectIds,
+  selectTotal
+} = dbAdapter.getSelectors((state) => state.db);
+var initialState = dbAdapter.getInitialState({});
+var createSliceWithThunks = buildCreateSlice({
+  creators: { asyncThunk: asyncThunkCreator }
+});
+var dbSlice = createSliceWithThunks({
+  name: "db",
+  initialState,
+  reducers: (create) => ({
+    // Async Thunks
+    // 惰性加载 readAction：esbuild 把大型 read.ts 排到同 chunk 后部时，
+    // `var readAction` 在 create.asyncThunk(readAction) 执行时仍是 undefined，
+    // 之后所有 dispatch(read) 抛 "payloadCreator is not a function"。
+    // 动态 import 在调用期解析，避开 TDZ/求值顺序问题（同下方 share）。
+    read: create.asyncThunk(
+      async (payload, thunkApi) => {
+        const { readAction: readAction2 } = await import("./read-RIJCIVKX.js");
+        return readAction2(payload, thunkApi);
+      },
+      {
+        fulfilled: (state, action) => {
+          if (action.payload && Object.keys(action.payload).length > 0) {
+            dbAdapter.upsertOne(state, action.payload);
+          }
+        }
+      }
+    ),
+    readAndWait: create.asyncThunk(readAndWaitAction, {
+      fulfilled: (state, action) => {
+        if (action.payload && Object.keys(action.payload).length > 0) {
+          dbAdapter.upsertOne(state, action.payload);
+        }
+      }
+    }),
+    remove: create.asyncThunk(removeAction, {
+      fulfilled: (state, action) => {
+        const { dbKey } = action.payload;
+        if (dbKey) dbAdapter.removeOne(state, dbKey);
+      }
+    }),
+    purge: create.asyncThunk(purgeAction, {
+      fulfilled: (state, action) => {
+        const { dbKey } = action.payload;
+        if (dbKey) dbAdapter.removeOne(state, dbKey);
+      }
+    }),
+    write: create.asyncThunk(writeAction, {
+      fulfilled: (state, action) => {
+        if (action.payload && action.payload.dbKey && Object.keys(action.payload).length > 0) {
+          dbAdapter.upsertOne(state, action.payload);
+        }
+      }
+    }),
+    patch: create.asyncThunk(patchAction, {
+      fulfilled: (state, action) => {
+        const { payload } = action;
+        if (payload && payload.dbKey && Object.keys(payload).length > 0) {
+          dbAdapter.upsertOne(state, payload);
+        }
+      }
+    }),
+    upsert: create.asyncThunk(upsertAction, {
+      fulfilled: (state, action) => {
+        if (action.payload && action.payload.dbKey && Object.keys(action.payload).length > 0) {
+          dbAdapter.upsertOne(state, action.payload);
+        }
+      }
+    }),
+    // 文件上传（avatar / Slate / Space 等统一走这里）
+    upload: create.asyncThunk(uploadFileAction, {
+      fulfilled: (state, action) => {
+        const payload = action.payload;
+        if (payload && payload.dbKey && Object.keys(payload).length > 0) {
+          dbAdapter.upsertOne(state, payload);
+        }
+      }
+    }),
+    // 读取文件内容（优先本地 IndexedDB，无状态副作用）
+    readFileContent: create.asyncThunk(readFileContentAction, {
+      // fulfilled 时不修改 db state；由调用方通过 unwrap() 拿返回值使用
+    }),
+    // 惰性加载 shareResourceAction：静态 import 会形成
+    // dbSlice -> share/action -> settings/settingSlice -> settingPersistence
+    // -> settings/dbActionThunks -> database/dbActionThunks -> dbSlice 的循环依赖。
+    // 分包后 chunk 求值顺序一旦从环内进入 dbSlice，上面的 `readAction` 等
+    // `export const` 还处于未初始化状态，thunk 会以 undefined 作为 payloadCreator
+    // 建成，之后 dispatch(read(...)) 抛 "payloadCreator is not a function"。
+    // 这里改成动态 import，运行期才解析，彻底断开这条边。
+    share: create.asyncThunk(
+      async (config, thunkApi) => {
+        const { shareResourceAction } = await import("./action-ZJWE3Y5S.js");
+        return shareResourceAction(config, thunkApi);
+      }
+    ),
+    // SSR 预取：服务端直接注入实体到 db slice，供首屏 hydrate 使用
+    upsertSSREntity: create.reducer((state, action) => {
+      if (action.payload && action.payload.dbKey) {
+        dbAdapter.upsertOne(state, action.payload);
+      }
+    }),
+    // Undo an in-memory optimistic entity without writing a tombstone or
+    // scheduling remote deletion. Durable deletes must continue to use remove.
+    removeCachedEntity: create.reducer((state, action) => {
+      if (action.payload) dbAdapter.removeOne(state, action.payload);
+    })
+  })
+});
+var {
+  remove,
+  purge,
+  read,
+  readAndWait,
+  write,
+  patch,
+  upsert,
+  upload,
+  readFileContent,
+  share,
+  upsertSSREntity,
+  removeCachedEntity
+} = dbSlice.actions;
+var dbSlice_default = dbSlice.reducer;
+
+export {
+  readAndWaitAction,
+  toTimestampMs,
+  uploadFileAction,
+  dbAdapter,
+  selectById,
+  selectEntities,
+  selectAll,
+  selectIds,
+  selectTotal,
+  remove,
+  purge,
+  read,
+  readAndWait,
+  write,
+  patch,
+  upsert,
+  upload,
+  readFileContent,
+  share,
+  upsertSSREntity,
+  removeCachedEntity,
+  dbSlice_default
+};