nolo-cli 0.213.0 → 0.222.0-alpha.2

package/chunk-44X52WOJ.js

@@ -0,0 +1,1621 @@
+import {
+  isMediaFile,
+  resolveFileCategory
+} from "./chunk-3PVYUPXK.js";
+import {
+  loadFileFromIndexedDb,
+  removeAction,
+  saveFileToIndexedDb
+} from "./chunk-C4WTX5TU.js";
+import {
+  readAction,
+  readRequestManager,
+  resolveAgentReadServers
+} from "./chunk-WAE3GFCJ.js";
+import {
+  beginWriteAck,
+  compareRemoteRecordsByComparableTime,
+  getRuntimeServerContext,
+  pickBestSettledRemoteRecord,
+  planAuthorityReadServers,
+  resolveAuthorityReplicationServers,
+  resolveRecordAuthority,
+  resolveUploadReplicationServers,
+  scheduleConfiguredPatchReplication,
+  scheduleExistingRecordReplication,
+  scheduleUploadReplication,
+  scheduleWriteReplication,
+  shouldPreferRemoteBodyOverLocalProjection,
+  shouldReplaceLocalWithRemoteRecord,
+  shouldReplicateLocalRecord,
+  uploadToCurrentServer
+} from "./chunk-2VUZSVAS.js";
+import {
+  asyncThunkCreator,
+  buildCreateSlice,
+  createEntityAdapter,
+  noloDeleteRequest
+} from "./chunk-7Z6EW7AH.js";
+import {
+  fetchFromClientDb,
+  fetchFromServer,
+  logger,
+  normalizeTimeFields
+} from "./chunk-AGP3YSEC.js";
+import {
+  isTombstoneRecord
+} from "./chunk-BV3FLP2L.js";
+import {
+  fileKey,
+  getFileIdFromKey
+} from "./chunk-SYTHYBMI.js";
+import {
+  ulid
+} from "./chunk-OJKUU3LP.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+import {
+  API_ENDPOINTS
+} from "./chunk-LCBAMY2M.js";
+
+// packages/database/protectedRecordProtocol.ts
+var PROTECTED_RECORD_PROTOCOL_VERSION = 1;
+function assertJson(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number" && Number.isFinite(value)) return;
+  if (typeof value !== "object" || value === null || ancestors.has(value)) {
+    throw new TypeError("Invalid JSON value");
+  }
+  const array = Array.isArray(value);
+  const proto = Object.getPrototypeOf(value);
+  if (!array && proto !== Object.prototype && proto !== null) throw new TypeError("Invalid JSON object");
+  const keys = Reflect.ownKeys(value);
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  if (array && keys.length !== value.length + 1) throw new TypeError("Invalid JSON array");
+  ancestors.add(value);
+  try {
+    for (const key of keys) {
+      if (array && key === "length") continue;
+      if (typeof key !== "string") throw new TypeError("Invalid JSON key");
+      const descriptor = descriptors[key];
+      if (!descriptor.enumerable || !("value" in descriptor)) throw new TypeError("Invalid JSON property");
+      if (array && (!/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= value.length)) {
+        throw new TypeError("Invalid JSON array index");
+      }
+      assertJson(descriptor.value, ancestors);
+    }
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function assertRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Expected JSON record");
+  assertJson(value);
+}
+function envelope(value, fields) {
+  assertRecord(value);
+  if (value.protocolVersion !== PROTECTED_RECORD_PROTOCOL_VERSION) throw new TypeError("Unsupported protocolVersion");
+  if (Object.keys(value).some((key) => !fields.includes(key))) throw new TypeError("Unknown protocol field");
+  for (const key of ["mutationId", "authorityServer", "authorityEpoch"]) nonEmpty(value[key], key);
+  return value;
+}
+function nonEmpty(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) throw new TypeError(`Invalid ${field}`);
+}
+var identityFields = ["protocolVersion", "mutationId", "authorityServer", "authorityEpoch"];
+function assertProtectedMutation(input) {
+  const value = envelope(input, [...identityFields, "operation", "payload", "expectedRevision", "createOnly"]);
+  if (value.operation !== "replace" && value.operation !== "patch") throw new TypeError("Unsupported operation");
+  assertRecord(value.payload);
+  if (Object.hasOwn(value, "createOnly")) {
+    if (value.createOnly !== true || Object.hasOwn(value, "expectedRevision") || value.operation !== "replace") {
+      throw new TypeError("Invalid create-only baseline");
+    }
+  } else {
+    nonEmpty(value.expectedRevision, "expectedRevision");
+  }
+}
+function parseProtectedMutation(input) {
+  assertProtectedMutation(input);
+  return input;
+}
+function parseProtectedMutationAck(input) {
+  const value = envelope(input, [...identityFields, "revision", "record"]);
+  nonEmpty(value.revision, "revision");
+  assertRecord(value.record);
+  return value;
+}
+
+// packages/database/actions/protectedRecordSync.ts
+var PROTECTED_SYNC_PREFIX = "\0protected-record-sync:v1:";
+var ProtectedSyncError = class extends Error {
+  constructor(code, message) {
+    super(message ?? code);
+    this.code = code;
+    this.name = "ProtectedSyncError";
+  }
+};
+var protectedPageBaselineKey = (actorId, dbKey) => `\0page-read-baseline:v1:${encodeURIComponent(actorId)}:${encodeURIComponent(dbKey)}`;
+var encodeSegment = (value) => encodeURIComponent(value);
+var protectedSyncWorkingCopyKey = (actorId, dbKey) => `${PROTECTED_SYNC_PREFIX}working:${encodeSegment(actorId)}:${encodeSegment(dbKey)}`;
+var protectedSyncStateKey = (actorId, dbKey) => `${PROTECTED_SYNC_PREFIX}state:${encodeSegment(actorId)}:${encodeSegment(dbKey)}`;
+var protectedSyncLockName = (actorId, dbKey) => `protected-record-sync:${encodeSegment(actorId)}:${encodeSegment(dbKey)}`;
+var protectedSyncSendLockName = (actorId, dbKey) => `protected-record-send:${encodeSegment(actorId)}:${encodeSegment(dbKey)}`;
+var isNotFound = (error) => !!error && typeof error === "object" && error.notFound === true;
+async function readOptional(db, key) {
+  try {
+    return await db.get(key);
+  } catch (error) {
+    if (isNotFound(error)) return void 0;
+    throw error;
+  }
+}
+function protectedSyncCopy(value) {
+  if (value === void 0) return value;
+  return JSON.parse(JSON.stringify(value));
+}
+function protectedSyncJsonEqual(left, right) {
+  if (left === right) return true;
+  if (typeof left !== typeof right) return false;
+  if (left === null || right === null) return false;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+    return left.every((item, index) => protectedSyncJsonEqual(item, right[index]));
+  }
+  if (typeof left === "object") {
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    if (leftKeys.length !== rightKeys.length) return false;
+    if (leftKeys.some((key, index) => key !== rightKeys[index])) return false;
+    return leftKeys.every(
+      (key) => protectedSyncJsonEqual(left[key], right[key])
+    );
+  }
+  return false;
+}
+var requireNonEmptyString = (value, field) => {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new ProtectedSyncError("INVALID_INPUT", `${field} \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32`);
+  }
+  return value;
+};
+var requireJsonValue = (value, field) => {
+  if (value === void 0) {
+    throw new ProtectedSyncError("INVALID_INPUT", `${field} \u4E0D\u80FD\u662F undefined`);
+  }
+  try {
+    JSON.stringify(value);
+  } catch {
+    throw new ProtectedSyncError("INVALID_INPUT", `${field} \u5FC5\u987B\u662F\u53EF JSON \u5E8F\u5217\u5316\u7684\u6570\u636E`);
+  }
+  return value;
+};
+function createNavigatorLocksLock(namespace = "state") {
+  return async (scope, task) => {
+    const locks = globalThis.navigator?.locks;
+    if (!locks || typeof locks.request !== "function") {
+      throw new ProtectedSyncError(
+        "LOCK_UNAVAILABLE",
+        `navigator.locks \u4E0D\u53EF\u7528\uFF08${namespace} \u9501\uFF09\uFF1A\u6CA1\u6709\u53EF\u9760\u7684\u8DE8\u6807\u7B7E\u534F\u8C03\u5668\uFF0C\u62D2\u7EDD\u4EE5\u8FDB\u7A0B\u5185\u9501\u5192\u5145\u8DE8\u6807\u7B7E\u4E92\u65A5`
+      );
+    }
+    const name = (scope.namespace ?? namespace) === "send" ? protectedSyncSendLockName(scope.actorId, scope.dbKey) : protectedSyncLockName(scope.actorId, scope.dbKey);
+    const result = await locks.request(name, { mode: "exclusive" }, async () => task());
+    return result;
+  };
+}
+function createProtectedRecordSync(deps) {
+  const { db } = deps;
+  const stateLock = deps.lock ?? createNavigatorLocksLock("state");
+  const sendLock = deps.sendLock ?? createNavigatorLocksLock("send");
+  const withStateLock = (scope, task) => stateLock({ ...scope, namespace: "state" }, task);
+  const withSendLock = (scope, task) => sendLock({ ...scope, namespace: "send" }, task);
+  const loadState = async (actorId, dbKey) => {
+    const [workingRaw, stateRaw] = await Promise.all([
+      readOptional(db, protectedSyncWorkingCopyKey(actorId, dbKey)),
+      readOptional(db, protectedSyncStateKey(actorId, dbKey))
+    ]);
+    const working = workingRaw?.workingCopy ?? null;
+    const persisted = stateRaw ?? {};
+    const outbox = (Array.isArray(persisted.outbox) ? persisted.outbox : []).map((entry) => ({
+      ...entry,
+      // 旧版本持久化的认领标志不再解释为占用：重启后队列必须可继续。
+      inFlight: false
+    }));
+    return protectedSyncCopy({
+      actorId,
+      dbKey,
+      workingCopy: working,
+      outbox,
+      baselineRevision: persisted.baselineRevision ?? null,
+      lastAck: persisted.lastAck ?? null,
+      legacyCandidates: Array.isArray(persisted.legacyCandidates) ? persisted.legacyCandidates : [],
+      remoteCandidate: persisted.remoteCandidate ?? null,
+      blocked: persisted.blocked ?? null,
+      nextSeq: typeof persisted.nextSeq === "number" ? persisted.nextSeq : 1
+    });
+  };
+  const persist = async (state, extra, discovery) => {
+    const operations = [
+      {
+        type: "put",
+        key: protectedSyncWorkingCopyKey(state.actorId, state.dbKey),
+        value: { workingCopy: state.workingCopy }
+      },
+      {
+        type: "put",
+        key: protectedSyncStateKey(state.actorId, state.dbKey),
+        value: {
+          outbox: state.outbox,
+          baselineRevision: state.baselineRevision,
+          lastAck: state.lastAck,
+          legacyCandidates: state.legacyCandidates,
+          remoteCandidate: state.remoteCandidate,
+          blocked: state.blocked,
+          nextSeq: state.nextSeq
+        }
+      }
+    ];
+    if (extra) operations.push({ type: "put", key: extra.key, value: extra.value });
+    if (discovery) operations.push({ type: "put", key: discovery.key, value: discovery.value });
+    try {
+      await db.batch(operations);
+    } catch (error) {
+      throw new ProtectedSyncError(
+        "BATCH_FAILED",
+        `protected record sync \u843D\u76D8\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  };
+  const validateScope = (actorId, dbKey) => {
+    const actor = requireNonEmptyString(actorId, "actorId");
+    const key = requireNonEmptyString(dbKey, "dbKey");
+    if (key.startsWith("\0")) {
+      throw new ProtectedSyncError("INVALID_INPUT", "dbKey \u4E0D\u80FD\u4F7F\u7528\u5185\u90E8\u4FDD\u7559\u524D\u7F00");
+    }
+    return { actorId: actor, dbKey: key };
+  };
+  const applyAckUnlocked = async (state, mutationId, revision, record) => {
+    state.outbox = state.outbox.slice(1);
+    state.baselineRevision = revision;
+    state.lastAck = { mutationId, revision, record };
+    state.outbox = state.outbox.map((entry) => ({ ...entry, baseRevision: revision }));
+    if (state.workingCopy) {
+      state.workingCopy = state.workingCopy.mutationId === mutationId ? null : { ...state.workingCopy, baseRevision: revision };
+    }
+    await persist(state, { key: state.dbKey, value: protectedSyncCopy(record) });
+    return state;
+  };
+  const saveLocalDraft = async (input) => {
+    const scope = validateScope(input?.actorId, input?.dbKey);
+    const authorityServer = requireNonEmptyString(input.authorityServer, "authorityServer");
+    const mutationId = requireNonEmptyString(input.mutationId, "mutationId");
+    const data = requireJsonValue(input.data, "data");
+    const baseRevision = input.baseRevision ?? null;
+    const intent = {};
+    if (input.operation !== void 0) {
+      const mutation = parseProtectedMutation({
+        protocolVersion: 1,
+        operation: input.operation,
+        payload: input.payload,
+        authorityEpoch: input.authorityEpoch,
+        authorityServer,
+        mutationId,
+        expectedRevision: baseRevision
+      });
+      intent.operation = "patch";
+      intent.payload = protectedSyncCopy(mutation.payload);
+      intent.authorityEpoch = mutation.authorityEpoch;
+    } else if (input.payload !== void 0 || input.authorityEpoch !== void 0) {
+      throw new ProtectedSyncError("INVALID_INPUT", "patch intent requires explicit operation");
+    }
+    return withStateLock(scope, async () => {
+      const state = await loadState(scope.actorId, scope.dbKey);
+      const existing = state.outbox.find((entry2) => entry2.mutationId === mutationId);
+      if (existing) {
+        if (!protectedSyncJsonEqual(existing.data, data) || existing.authorityServer !== authorityServer || existing.operation !== intent.operation || existing.authorityEpoch !== intent.authorityEpoch || !protectedSyncJsonEqual(existing.payload, intent.payload)) {
+          throw new ProtectedSyncError(
+            "MUTATION_ID_CONFLICT",
+            `mutationId ${mutationId} \u5DF2\u5B58\u5728\u4E14 payload \u4E0D\u540C\uFF1A\u62D2\u7EDD\u6539\u5199\u961F\u5217\u4E2D\u7684\u4E0D\u53EF\u53D8 payload`
+          );
+        }
+        return protectedSyncCopy(state);
+      }
+      const entry = {
+        ...intent,
+        mutationId,
+        data: protectedSyncCopy(data),
+        baseRevision: baseRevision ?? state.baselineRevision,
+        authorityServer,
+        seq: state.nextSeq
+      };
+      state.outbox = [...state.outbox, entry];
+      state.nextSeq = state.nextSeq + 1;
+      state.workingCopy = {
+        ...intent,
+        mutationId,
+        data: protectedSyncCopy(data),
+        baseRevision: entry.baseRevision,
+        authorityServer,
+        seq: entry.seq
+      };
+      await persist(state);
+      return protectedSyncCopy(state);
+    });
+  };
+  const ackMutation = async (input) => {
+    const scope = validateScope(input?.actorId, input?.dbKey);
+    const mutationId = requireNonEmptyString(input.mutationId, "mutationId");
+    const revision = requireNonEmptyString(input.revision, "revision");
+    const record = requireJsonValue(input.record, "record");
+    return withStateLock(scope, async () => {
+      const state = await loadState(scope.actorId, scope.dbKey);
+      if (state.lastAck?.mutationId === mutationId) return protectedSyncCopy(state);
+      const head = state.outbox[0];
+      if (!head) {
+        throw new ProtectedSyncError("MUTATION_NOT_FOUND", `\u672A\u627E\u5230\u5F85\u786E\u8BA4\u7684 mutation\uFF1A${mutationId}`);
+      }
+      if (head.mutationId !== mutationId) {
+        const known = state.outbox.some((entry) => entry.mutationId === mutationId);
+        throw new ProtectedSyncError(
+          known ? "OUT_OF_ORDER" : "MUTATION_NOT_FOUND",
+          known ? `\u53EA\u5141\u8BB8\u786E\u8BA4\u961F\u9996\uFF1A\u5F53\u524D\u961F\u9996\u662F ${head.mutationId}\uFF0C\u4E0D\u662F ${mutationId}` : `\u672A\u627E\u5230\u5F85\u786E\u8BA4\u7684 mutation\uFF1A${mutationId}`
+        );
+      }
+      const next = await applyAckUnlocked(state, mutationId, revision, protectedSyncCopy(record));
+      return protectedSyncCopy(next);
+    });
+  };
+  const readState = async (input) => {
+    const scope = validateScope(input?.actorId, input?.dbKey);
+    return withStateLock(scope, async () => protectedSyncCopy(await loadState(scope.actorId, scope.dbKey)));
+  };
+  const acceptRemote = async (input) => {
+    const scope = validateScope(input?.actorId, input?.dbKey);
+    const record = requireJsonValue(input.record, "record");
+    const discovery = input.authority ? {
+      key: protectedPageBaselineKey(scope.actorId, scope.dbKey),
+      value: {
+        authorityServer: requireNonEmptyString(input.authority.authorityServer, "authorityServer"),
+        authorityEpoch: requireNonEmptyString(input.authority.authorityEpoch, "authorityEpoch"),
+        revision: input.revision
+      }
+    } : void 0;
+    return withStateLock(scope, async () => {
+      const state = await loadState(scope.actorId, scope.dbKey);
+      if (Array.isArray(input.legacyCandidates) && input.legacyCandidates.length > 0) {
+        const merged = [...state.legacyCandidates];
+        for (const candidate of input.legacyCandidates) {
+          const position = merged.findIndex((item) => item.candidateId === candidate.candidateId);
+          if (position === -1) merged.push(protectedSyncCopy(candidate));
+          else merged[position] = { ...merged[position], ...protectedSyncCopy(candidate) };
+        }
+        state.legacyCandidates = merged;
+      }
+      const hasPending = state.outbox.length > 0;
+      const hasWorking = state.workingCopy !== null;
+      const hasLegacy = state.legacyCandidates.length > 0;
+      if (hasPending || hasWorking || hasLegacy) {
+        state.remoteCandidate = { revision: input.revision ?? null, record: protectedSyncCopy(record) };
+        input.assertCurrentAccess?.();
+        await persist(state, void 0, discovery);
+        return {
+          applied: false,
+          reason: hasPending ? "pending-mutations" : hasWorking ? "working-copy" : "legacy-candidates",
+          state: protectedSyncCopy(state)
+        };
+      }
+      state.baselineRevision = input.revision ?? state.baselineRevision;
+      state.remoteCandidate = null;
+      state.workingCopy = null;
+      input.assertCurrentAccess?.();
+      await persist(state, { key: scope.dbKey, value: protectedSyncCopy(record) }, discovery);
+      return { applied: true, reason: null, state: protectedSyncCopy(state) };
+    });
+  };
+  const markBlocked = async (input) => {
+    const scope = validateScope(input?.actorId, input?.dbKey);
+    const reason = requireNonEmptyString(input.reason, "reason");
+    return withStateLock(scope, async () => {
+      const state = await loadState(scope.actorId, scope.dbKey);
+      state.blocked = { reason, detail: input.detail ?? null, at: Date.now() };
+      await persist(state);
+      return protectedSyncCopy(state);
+    });
+  };
+  const clearBlocked = async (input) => {
+    const scope = validateScope(input?.actorId, input?.dbKey);
+    return withStateLock(scope, async () => {
+      const state = await loadState(scope.actorId, scope.dbKey);
+      state.blocked = null;
+      await persist(state);
+      return protectedSyncCopy(state);
+    });
+  };
+  const beginInFlight = async (input) => {
+    const scope = validateScope(input?.actorId, input?.dbKey);
+    return withStateLock(scope, async () => {
+      const state = await loadState(scope.actorId, scope.dbKey);
+      if (state.blocked) {
+        throw new ProtectedSyncError("BLOCKED", `\u8BB0\u5F55\u5904\u4E8E blocked \u72B6\u6001\uFF1A${state.blocked.reason}`);
+      }
+      const head = state.outbox[0];
+      if (!head) {
+        throw new ProtectedSyncError("MUTATION_NOT_FOUND", "\u5F85\u53D1\u961F\u5217\u4E3A\u7A7A");
+      }
+      if (input.mutationId !== void 0 && input.mutationId !== head.mutationId) {
+        throw new ProtectedSyncError(
+          "OUT_OF_ORDER",
+          `\u961F\u5217\u5FC5\u987B\u6309\u5E8F\u53D1\u9001\uFF1A\u5F53\u524D\u961F\u9996\u662F ${head.mutationId}\uFF0C\u4E0D\u662F ${input.mutationId}`
+        );
+      }
+      return protectedSyncCopy(state);
+    });
+  };
+  const releaseInFlight = async (input) => {
+    const scope = validateScope(input?.actorId, input?.dbKey);
+    requireNonEmptyString(input.mutationId, "mutationId");
+    return withStateLock(scope, async () => protectedSyncCopy(await loadState(scope.actorId, scope.dbKey)));
+  };
+  const withNextMutation = async (scopeInput, send) => {
+    const scope = validateScope(scopeInput?.actorId, scopeInput?.dbKey);
+    if (typeof send !== "function") {
+      throw new ProtectedSyncError("INVALID_INPUT", "send \u5FC5\u987B\u662F\u51FD\u6570");
+    }
+    const snapshot = await withStateLock(scope, async () => {
+      const state = await loadState(scope.actorId, scope.dbKey);
+      if (state.blocked) {
+        throw new ProtectedSyncError("BLOCKED", `\u8BB0\u5F55\u5904\u4E8E blocked \u72B6\u6001\uFF1A${state.blocked.reason}`);
+      }
+      const head = state.outbox[0];
+      return { state: protectedSyncCopy(state), entry: head ? protectedSyncCopy(head) : null };
+    });
+    if (!snapshot.entry) {
+      return { mutationId: null, outcome: "none", state: snapshot.state };
+    }
+    const entry = snapshot.entry;
+    return withSendLock(scope, async () => {
+      const ready = await withStateLock(scope, async () => {
+        const state = await loadState(scope.actorId, scope.dbKey);
+        const head = state.outbox[0];
+        const same = !!head && head.mutationId === entry.mutationId && head.baseRevision === entry.baseRevision;
+        return { state, same };
+      });
+      if (!ready.same) {
+        return {
+          mutationId: null,
+          outcome: "none",
+          skipped: true,
+          state: protectedSyncCopy(ready.state)
+        };
+      }
+      const result = await send(protectedSyncCopy(entry));
+      return withStateLock(scope, async () => {
+        const state = await loadState(scope.actorId, scope.dbKey);
+        if (result?.outcome === "acked") {
+          const revision = requireNonEmptyString(result.revision, "revision");
+          const record = requireJsonValue(result.record, "record");
+          if (state.lastAck?.mutationId === entry.mutationId) {
+            return { mutationId: entry.mutationId, outcome: "acked", state: protectedSyncCopy(state) };
+          }
+          const head = state.outbox[0];
+          if (!head || head.mutationId !== entry.mutationId) {
+            return {
+              mutationId: null,
+              outcome: "none",
+              skipped: true,
+              state: protectedSyncCopy(state)
+            };
+          }
+          const next = await applyAckUnlocked(state, entry.mutationId, revision, protectedSyncCopy(record));
+          return { mutationId: entry.mutationId, outcome: "acked", state: protectedSyncCopy(next) };
+        }
+        if (result?.outcome === "pending") {
+          return {
+            mutationId: entry.mutationId,
+            outcome: "pending",
+            reason: result.reason,
+            state: protectedSyncCopy(state)
+          };
+        }
+        if (result?.outcome === "conflict" || result?.outcome === "blocked") {
+          const reason = requireNonEmptyString(result.reason, "reason");
+          const stillPending = state.outbox.some((item) => item.mutationId === entry.mutationId);
+          if (stillPending) {
+            state.blocked = { reason, detail: result.detail ?? null, at: Date.now() };
+            await persist(state);
+          }
+          return {
+            mutationId: entry.mutationId,
+            outcome: result.outcome,
+            reason,
+            state: protectedSyncCopy(state)
+          };
+        }
+        throw new ProtectedSyncError("INVALID_INPUT", "send \u5FC5\u987B\u8FD4\u56DE acked/conflict/blocked/pending");
+      });
+    });
+  };
+  return {
+    saveLocalDraft,
+    ackMutation,
+    readState,
+    acceptRemote,
+    markBlocked,
+    clearBlocked,
+    beginInFlight,
+    releaseInFlight,
+    withNextMutation
+  };
+}
+
+// packages/database/actions/protectedRecordTransport.ts
+function createProtectedRecordTransport(options) {
+  return {
+    sendNext(scope) {
+      return options.sync.withNextMutation(scope, async (entry) => {
+        const blocked = (reason) => ({ outcome: "blocked", reason });
+        if (entry.operation !== "patch") return blocked("PATCH_INTENT_REQUIRED");
+        if (!entry.authorityEpoch?.trim()) return blocked("AUTHORITY_EPOCH_REQUIRED");
+        if (!entry.baseRevision?.trim()) return blocked("BASE_REVISION_REQUIRED");
+        if (!/^page-[A-Za-z0-9_-]+$/.test(scope.dbKey)) return blocked("UNSUPPORTED_DB_KEY");
+        let mutation;
+        let origin;
+        try {
+          origin = new URL(entry.authorityServer);
+          if (!["http:", "https:"].includes(origin.protocol) || origin.username || origin.password || origin.search || origin.hash || origin.pathname !== "/") return blocked("INVALID_AUTHORITY");
+          mutation = parseProtectedMutation({
+            protocolVersion: 1,
+            operation: "patch",
+            payload: entry.payload,
+            expectedRevision: entry.baseRevision,
+            mutationId: entry.mutationId,
+            authorityServer: entry.authorityServer,
+            authorityEpoch: entry.authorityEpoch
+          });
+        } catch {
+          return blocked("INVALID_PATCH_INTENT");
+        }
+        let response;
+        try {
+          if (!await options.isAuthorityAllowed(origin.origin)) return blocked("AUTHORITY_NOT_CONFIGURED");
+          const token = await options.getToken({ actorId: scope.actorId, authorityServer: entry.authorityServer });
+          if (!token) return blocked("AUTH_REQUIRED");
+          response = await options.fetch(`${origin.origin}/api/v1/db/patch/${scope.dbKey}`, {
+            method: "PATCH",
+            redirect: "error",
+            credentials: "omit",
+            headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+            body: JSON.stringify(mutation)
+          });
+        } catch {
+          return { outcome: "pending", reason: "NETWORK_OR_CREDENTIALS_UNAVAILABLE" };
+        }
+        if (response.status === 409) return { outcome: "conflict", reason: "HTTP_409" };
+        if (response.status === 401 || response.status === 403) return blocked(`HTTP_${response.status}`);
+        if (response.status === 503) return { outcome: "pending", reason: "PROTOCOL_UNAVAILABLE" };
+        if (!response.ok) return blocked(`HTTP_${response.status}`);
+        try {
+          const ack = parseProtectedMutationAck(await response.json());
+          if (ack.mutationId !== entry.mutationId || ack.authorityServer !== entry.authorityServer || ack.authorityEpoch !== entry.authorityEpoch) return blocked("ACK_IDENTITY_MISMATCH");
+          return { outcome: "acked", revision: ack.revision, record: ack.record };
+        } catch {
+          return blocked("INVALID_ACK");
+        }
+      });
+    }
+  };
+}
+
+// packages/database/actions/protectedPageRead.ts
+var baselineKey = protectedPageBaselineKey;
+var originOf = (value) => {
+  try {
+    const url = new URL(value ?? "");
+    return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password && url.pathname === "/" && !url.search && !url.hash ? url.origin : null;
+  } catch {
+    return null;
+  }
+};
+async function getPageReadBaseline(db, actorId, dbKey) {
+  try {
+    const value = await db.get(baselineKey(actorId, dbKey));
+    if (!value) {
+      const state = await db.get(protectedSyncStateKey(actorId, dbKey));
+      if (state) throw Error("\u6587\u6863\u4FDD\u62A4\u72B6\u6001\u5B58\u5728\u4F46\u57FA\u7EBF\u7F3A\u5931\uFF0C\u5DF2\u963B\u6B62\u9000\u56DE\u65E7\u8BFB\u5199\u8DEF\u5F84");
+    }
+    return value ?? null;
+  } catch (error) {
+    if (error && typeof error === "object" && "notFound" in error && error.notFound === true) {
+      let state;
+      try {
+        state = await db.get(protectedSyncStateKey(actorId, dbKey));
+      } catch (stateError) {
+        if (!(stateError && typeof stateError === "object" && "notFound" in stateError && stateError.notFound === true)) throw stateError;
+      }
+      if (state) throw Error("\u6587\u6863\u4FDD\u62A4\u72B6\u6001\u5B58\u5728\u4F46\u57FA\u7EBF\u7F3A\u5931\uFF0C\u5DF2\u963B\u6B62\u9000\u56DE\u65E7\u8BFB\u5199\u8DEF\u5F84");
+      return null;
+    }
+    throw error;
+  }
+}
+async function readProtectedPage(options) {
+  const { db, actorId, dbKey } = options;
+  const assertAccess = (origin) => {
+    const access = options.getCurrentAccess?.() ?? options;
+    if (access.actorId !== actorId || !access.token?.trim()) {
+      throw Error("\u6587\u6863\u8BFB\u53D6\u8EAB\u4EFD\u5DF2\u53D8\u5316\u6216\u8BA4\u8BC1\u5DF2\u64A4\u9500\uFF0C\u5DF2\u505C\u6B62\u8BFB\u53D6");
+    }
+    if (origin && !access.servers.some((server) => originOf(server) === origin)) {
+      throw Error("\u6587\u6863\u5F52\u5C5E\u670D\u52A1\u5668\u4E0D\u5728\u5DF2\u914D\u7F6E\u670D\u52A1\u5668\u4E2D\u6216\u5DF2\u79FB\u9664\uFF0C\u672A\u53D1\u9001\u8BA4\u8BC1\u4FE1\u606F\uFF0C\u672A\u8F6C\u53D1\u8BA4\u8BC1\u4FE1\u606F");
+    }
+    return access.token;
+  };
+  assertAccess();
+  const sync = options.sync ?? createProtectedRecordSync({ db });
+  const saved = await getPageReadBaseline(db, actorId, dbKey);
+  assertAccess(saved?.authorityServer);
+  if (saved) {
+    const state = await sync.readState({ actorId, dbKey });
+    if (state.workingCopy) {
+      if (options.getCurrentAccess && !state.blocked && !state.legacyCandidates.length) {
+        const transport = createProtectedRecordTransport({
+          sync,
+          fetch: options.fetch,
+          isAuthorityAllowed: (origin) => {
+            const access = options.getCurrentAccess();
+            return access.actorId === actorId && access.servers.some((server) => originOf(server) === origin);
+          },
+          getToken: async () => {
+            const access = options.getCurrentAccess();
+            return access.actorId === actorId ? access.token ?? null : null;
+          }
+        });
+        for (let count = 0; count < state.outbox.length; count++) {
+          if ((await transport.sendNext({ actorId, dbKey })).outcome !== "acked") break;
+        }
+        const latest = await sync.readState({ actorId, dbKey });
+        assertAccess(saved.authorityServer);
+        return latest.workingCopy?.data ?? latest.lastAck?.record ?? state.workingCopy.data;
+      }
+      assertAccess(saved.authorityServer);
+      return state.workingCopy.data;
+    }
+  }
+  const servers = saved ? [saved.authorityServer] : options.servers;
+  for (const server of servers) {
+    const origin = originOf(server);
+    if (!origin) continue;
+    const token = assertAccess(origin);
+    let response;
+    try {
+      response = await options.fetch(`${origin}/api/v1/db/read/${encodeURIComponent(dbKey)}`, {
+        headers: { Authorization: `Bearer ${token}` },
+        redirect: "error",
+        credentials: "omit",
+        signal: AbortSignal.timeout(5e3)
+      });
+    } catch {
+      assertAccess(origin);
+      continue;
+    }
+    assertAccess(origin);
+    if (!response.ok) continue;
+    const authorityServer = originOf(response.headers.get("X-Nolo-Authority-Server"));
+    const authorityEpoch = response.headers.get("X-Nolo-Authority-Epoch");
+    if (!authorityServer || !authorityEpoch?.trim()) continue;
+    const authorityToken = assertAccess(authorityServer);
+    if (authorityServer !== origin) {
+      response = await options.fetch(`${authorityServer}/api/v1/db/read/${encodeURIComponent(dbKey)}`, {
+        headers: { Authorization: `Bearer ${authorityToken}` },
+        redirect: "error",
+        credentials: "omit",
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!response.ok || response.headers.get("X-Nolo-Authority-Server") !== authorityServer || response.headers.get("X-Nolo-Authority-Epoch") !== authorityEpoch) throw Error("\u6587\u6863\u5F52\u5C5E\u6821\u9A8C\u5931\u8D25\uFF0C\u672A\u91C7\u7528\u526F\u672C");
+    }
+    if (saved && (saved.authorityServer !== authorityServer || saved.authorityEpoch !== authorityEpoch)) {
+      throw Error("\u6587\u6863\u5F52\u5C5E\u5DF2\u5207\u6362\uFF0C\u4FDD\u7559\u672C\u5730\u5185\u5BB9\uFF0C\u9700\u91CD\u65B0\u786E\u8BA4\u5F52\u5C5E");
+    }
+    const etag = response.headers.get("ETag");
+    if (!etag || !/^"[^"\r\n]+"$/.test(etag)) throw Error("\u6587\u6863\u670D\u52A1\u5668\u672A\u8FD4\u56DE\u6709\u6548\u7248\u672C\u57FA\u7EBF");
+    const record = await response.json();
+    if (!record || record.type !== "page") throw Error("\u6587\u6863\u5F52\u5C5E\u670D\u52A1\u5668\u8FD4\u56DE\u4E86\u65E0\u6548\u8BB0\u5F55");
+    const local = await db.get(dbKey).catch((error) => {
+      if (error && typeof error === "object" && "notFound" in error && error.notFound === true) return void 0;
+      throw error;
+    });
+    const localIsProjection = shouldPreferRemoteBodyOverLocalProjection(local, record);
+    const candidates = !saved && local && !localIsProjection && JSON.stringify(local) !== JSON.stringify(record) ? [{ candidateId: "legacy-local", source: "local", record: local, revision: null, observedAt: null }] : void 0;
+    assertAccess(authorityServer);
+    const result = await sync.acceptRemote({
+      actorId,
+      dbKey,
+      record,
+      revision: etag.slice(1, -1),
+      authority: { authorityServer, authorityEpoch },
+      legacyCandidates: candidates,
+      assertCurrentAccess: () => {
+        assertAccess(authorityServer);
+      }
+    });
+    assertAccess(authorityServer);
+    return result.state.workingCopy?.data ?? (!result.applied && local ? local : record);
+  }
+  if (saved) {
+    const local = await db.get(dbKey);
+    assertAccess(saved.authorityServer);
+    if (local) return local;
+    throw Error("\u6587\u6863\u6743\u5A01\u670D\u52A1\u5668\u4E0D\u53EF\u7528\uFF0C\u4E14\u6CA1\u6709\u672C\u5730\u7F13\u5B58");
+  }
+  assertAccess();
+  return void 0;
+}
+
+// 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 () => {
+    if (dbKey.startsWith("page-") && currentUserId && currentToken && typeof db.batch === "function") {
+      const protectedData = await readProtectedPage({
+        db,
+        actorId: currentUserId,
+        dbKey,
+        servers: preferredServerOrigin ? [preferredServerOrigin, ...allServers] : allServers,
+        token: currentToken,
+        fetch,
+        getCurrentAccess: () => {
+          const context = getRuntimeServerContext(thunkApi.getState());
+          return { actorId: context.currentUserId, token: context.currentToken, servers: context.remoteServers };
+        }
+      });
+      if (protectedData !== void 0) return { ...protectedData, dbKey };
+    }
+    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 */,
+    "agent" /* AGENT */,
+    "agent-automation" /* AGENT_AUTOMATION */
+  ];
+  if (!data.type || !VALID_TYPES.includes(data.type)) {
+    logger.warn(
+      `Invalid data type "${data.type}" for writeAction with key ${customKey}. Proceeding anyway.`
+    );
+  }
+  let writeAck = null;
+  try {
+    const willSaveData = normalizeTimeFields({
+      ...data,
+      dbKey: customKey,
+      userId: recordUserId
+    });
+    writeAck = beginWriteAck(customKey);
+    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.`
+      );
+      const replication = scheduleWriteReplication(
+        servers,
+        serverWriteConfig,
+        state
+      );
+      writeAck.settleWithReplication(replication);
+    } else {
+      writeAck.markNotReplicated();
+      logger.warn(
+        { customKey },
+        "[writeAction] No available servers, data only saved locally."
+      );
+    }
+    return willSaveData;
+  } catch (error) {
+    writeAck?.markAborted();
+    const errorMessage = `Write action failed for ${customKey}: ${error?.message || "Unknown error"}`;
+    logger.error({ error }, "[writeAction] Error");
+    actionToast.error(`Failed to save data for ${customKey}.`);
+    throw new Error(errorMessage);
+  }
+};
+
+// packages/database/actions/protectedPagePatch.ts
+async function patchProtectedPage(options) {
+  const baseline = await getPageReadBaseline(options.db, options.actorId, options.dbKey);
+  if (!baseline) return void 0;
+  const sync = options.sync ?? createProtectedRecordSync({ db: options.db });
+  const scope = { actorId: options.actorId, dbKey: options.dbKey };
+  const state = await sync.readState(scope);
+  if (state.legacyCandidates.length) throw Error("\u672C\u5730\u65E7\u526F\u672C\u5C1A\u672A\u786E\u8BA4\uFF0C\u672A\u8986\u76D6\u4E91\u7AEF\uFF1B\u8BF7\u5148\u5904\u7406\u7248\u672C\u5DEE\u5F02");
+  const current = state.workingCopy?.data ?? await options.db.get(options.dbKey) ?? options.data;
+  const data = options.buildData ? options.buildData(current) : options.data;
+  const draft = await sync.saveLocalDraft({
+    ...scope,
+    ...baseline,
+    baseRevision: state.baselineRevision ?? baseline.revision,
+    mutationId: crypto.randomUUID(),
+    data,
+    operation: "patch",
+    payload: options.changes
+  });
+  if (draft.blocked) throw Error("\u8349\u7A3F\u5DF2\u4FDD\u5B58\u5728\u672C\u5730\uFF0C\u4F46\u540C\u6B65\u53D7\u963B\uFF1B\u4E91\u7AEF\u5C1A\u672A\u786E\u8BA4");
+  const transport = createProtectedRecordTransport({
+    sync,
+    fetch: options.fetch,
+    isAuthorityAllowed: options.isAuthorityAllowed,
+    getToken: async () => options.token()
+  });
+  let result;
+  for (let count = 0; count < draft.outbox.length; count++) {
+    result = await transport.sendNext(scope);
+    if (result.outcome !== "acked") break;
+  }
+  if (result?.outcome === "conflict" || result?.outcome === "blocked") {
+    throw Error("\u8349\u7A3F\u5DF2\u4FDD\u5B58\u5728\u672C\u5730\uFF0C\u4F46\u5B58\u5728\u7248\u672C\u51B2\u7A81\u6216\u6388\u6743\u95EE\u9898\uFF1B\u672A\u8986\u76D6\u4E91\u7AEF");
+  }
+  const latest = await sync.readState(scope);
+  if (options.requireServerConfirmation && latest.outbox.length) {
+    throw Error("\u8349\u7A3F\u5DF2\u4FDD\u5B58\u5728\u672C\u5730\uFF0C\u7B49\u5F85\u670D\u52A1\u5668\u786E\u8BA4\uFF1B\u8BF7\u8054\u7F51\u540E\u91CD\u8BD5\u4FDD\u5B58");
+  }
+  return latest.workingCopy?.data ?? latest.lastAck?.record ?? options.data;
+}
+
+// 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,
+  requireServerConfirmation
+}, 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, currentToken, currentUserId } = getRuntimeServerContext(state);
+  try {
+    let currentData = await db.get(dbKey);
+    if (!currentData) {
+      const hydrateServer = preferredServerOrigin ?? currentServer;
+      const remoteData = hydrateServer ? await fetchFromServer(hydrateServer, dbKey, currentToken) : null;
+      if (!remoteData) {
+        throw new Error(
+          `Cannot apply patch: Data not found locally or on server for key: ${dbKey}.`
+        );
+      }
+      const latestLocal = await db.get(dbKey);
+      currentData = latestLocal ?? remoteData;
+    }
+    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 };
+    if (dbKey.startsWith("page-") && currentUserId && typeof db.batch === "function") {
+      const protectedData = await patchProtectedPage({
+        db,
+        actorId: currentUserId,
+        dbKey,
+        data: persistedData,
+        changes: patchChanges,
+        requireServerConfirmation,
+        buildData: (latest) => ({ ...deepMerge(latest, patchChanges), dbKey }),
+        isAuthorityAllowed: (origin) => {
+          const context = getRuntimeServerContext(thunkApi.getState());
+          return context.currentUserId === currentUserId && context.remoteServers.some((server) => {
+            try {
+              return new URL(server).origin === origin;
+            } catch {
+              return false;
+            }
+          });
+        },
+        token: async () => {
+          const context = getRuntimeServerContext(thunkApi.getState());
+          return context.currentUserId === currentUserId ? context.currentToken ?? null : null;
+        },
+        fetch
+      });
+      if (protectedData !== void 0) return protectedData;
+    }
+    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, onProgress, signal } = 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);
+    const cacheLocally = async () => {
+      try {
+        await saveFileToIndexedDb(fileId, file);
+      } catch (err) {
+        logger.warn(
+          { err, fileId },
+          "[uploadFileAction] Failed to cache file locally."
+        );
+      }
+    };
+    const localCachePromise = isMediaFile(file) ? cacheLocally() : null;
+    if (!localCachePromise) {
+      await cacheLocally();
+    }
+    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,
+      ...onProgress ? { onProgress } : {},
+      ...signal ? { signal } : {}
+    });
+    if (localCachePromise) {
+      await localCachePromise;
+    }
+    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-MRQHJMJ2.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-CK64LS6S.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,
+  readFileContentAction,
+  dbAdapter,
+  selectById,
+  selectEntities,
+  selectAll,
+  selectIds,
+  selectTotal,
+  remove,
+  purge,
+  read,
+  readAndWait,
+  write,
+  patch,
+  upsert,
+  upload,
+  readFileContent,
+  share,
+  upsertSSREntity,
+  removeCachedEntity,
+  dbSlice_default
+};