nolo-cli 0.8.0-alpha.2 → 0.8.0-alpha.20

package/chunk-K777STIO.js

@@ -0,0 +1,478 @@
+import {
+  getRuntimeServerContext,
+  partitionReadServers,
+  pickBestSettledRemoteRecord,
+  planAuthorityReadServers,
+  resolveRecordAuthority,
+  scheduleExistingRecordReplication,
+  shouldReplaceLocalWithRemoteRecord,
+  shouldReplicateLocalRecord
+} from "./chunk-XBROXIGL.js";
+import {
+  fetchFromClientDb,
+  fetchFromServer,
+  isAbortError,
+  isReadTimeoutError,
+  logger
+} from "./chunk-WI4XWASA.js";
+import {
+  shouldReplaceWithNextRecord
+} from "./chunk-GBRG75BQ.js";
+import {
+  NOLO_CLUSTER_SERVERS,
+  normalizeKnownServerOrigin
+} from "./chunk-LCBAMY2M.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+
+// packages/core/builtinAgents.ts
+var BUILTIN_NOLO_AGENT_KEY = "agent-pub-01NOLOAPPBLD000000019KCKT0";
+var BUILTIN_APP_BUILDER_AGENT_KEY = "agent-pub-01APPBUILDER00000001YAII3I";
+var BUILTIN_ECOMMERCE_AGENT_KEY = "agent-pub-01ECOMMERCEAG00000001PYQ2J";
+var BUILTIN_AGENT_CREATOR_AGENT_KEY = "agent-pub-01NOLOAGENTCRT000000000001";
+var BUILTIN_FEEDBACK_AGENT_KEY = "agent-pub-01NOLOFEEDBACKA000000000R2";
+var BUILTIN_CHROME_OPERATOR_AGENT_KEY = "agent-pub-01CHROMEOPR000000000001";
+var PUBLIC_DEEPSEEK_V4_FLASH_AGENT_ID = "01DSV4FLASHPB00000000JFPFD";
+var PUBLIC_DEEPSEEK_V4_FLASH_AGENT_KEY = `agent-pub-${PUBLIC_DEEPSEEK_V4_FLASH_AGENT_ID}`;
+var PUBLIC_DEEPSEEK_V4_PRO_AGENT_ID = "01DSV4PROPUB00000001A9OLZN";
+var PUBLIC_DEEPSEEK_V4_PRO_AGENT_KEY = `agent-pub-${PUBLIC_DEEPSEEK_V4_PRO_AGENT_ID}`;
+var PUBLIC_KIMI_K27_CODING_AGENT_ID = "01KIMIK27CODEOL000000001";
+var PUBLIC_KIMI_K27_CODING_AGENT_KEY = `agent-pub-${PUBLIC_KIMI_K27_CODING_AGENT_ID}`;
+var PUBLIC_GLM_52_AGENT_ID = "01GLM52CHAT00000000001U721";
+var PUBLIC_GLM_52_AGENT_KEY = `agent-pub-${PUBLIC_GLM_52_AGENT_ID}`;
+var PUBLIC_KIMI_K26_IMAGE_AGENT_ID = "01KIMIK26OLLAMA0000000001";
+var PUBLIC_KIMI_K26_IMAGE_AGENT_KEY = `agent-pub-${PUBLIC_KIMI_K26_IMAGE_AGENT_ID}`;
+var BUILTIN_PLATFORM_AGENT_KEYS = [
+  BUILTIN_NOLO_AGENT_KEY,
+  BUILTIN_APP_BUILDER_AGENT_KEY,
+  BUILTIN_ECOMMERCE_AGENT_KEY,
+  BUILTIN_AGENT_CREATOR_AGENT_KEY,
+  BUILTIN_FEEDBACK_AGENT_KEY,
+  BUILTIN_CHROME_OPERATOR_AGENT_KEY
+];
+var BUILTIN_PLATFORM_AGENT_KEY_SET = new Set(BUILTIN_PLATFORM_AGENT_KEYS);
+
+// packages/database/actions/agentReadResolution.ts
+var BUILTIN_PLATFORM_AGENT_KEYS2 = [
+  ...BUILTIN_PLATFORM_AGENT_KEYS
+];
+var BUILTIN_PLATFORM_AGENT_KEY_SET2 = new Set(
+  BUILTIN_PLATFORM_AGENT_KEYS2
+);
+var normalizeServer = (server) => normalizeKnownServerOrigin(server) ?? normalizeServerOrigin(server);
+var isBuiltinPlatformAgentKey = (dbKey) => typeof dbKey === "string" && BUILTIN_PLATFORM_AGENT_KEY_SET2.has(dbKey);
+var resolveAgentReadServers = ({
+  dbKey,
+  configuredServers
+}) => {
+  const normalized = configuredServers.map(normalizeServer);
+  if (!isBuiltinPlatformAgentKey(dbKey)) {
+    return Array.from(new Set(normalized));
+  }
+  return Array.from(/* @__PURE__ */ new Set([...normalized, ...NOLO_CLUSTER_SERVERS]));
+};
+
+// packages/database/actions/readRequestManager.ts
+var DEFAULT_MISS_COOLDOWN_MS = 2e3;
+var DEFAULT_LOCAL_HIT_REVALIDATE_COOLDOWN_MS = 1500;
+var DEFAULT_MISS_CACHE_MAX_SIZE = 1e3;
+var ReadRequestManager = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  inFlightReads = /* @__PURE__ */ new Map();
+  recentMisses = /* @__PURE__ */ new Map();
+  recentLocalHitRevalidations = /* @__PURE__ */ new Map();
+  get missCooldownMs() {
+    return this.options.missCooldownMs ?? DEFAULT_MISS_COOLDOWN_MS;
+  }
+  get missCacheMaxSize() {
+    return this.options.missCacheMaxSize ?? DEFAULT_MISS_CACHE_MAX_SIZE;
+  }
+  get localHitRevalidateCooldownMs() {
+    return this.options.localHitRevalidateCooldownMs ?? DEFAULT_LOCAL_HIT_REVALIDATE_COOLDOWN_MS;
+  }
+  getInFlight(dbKey) {
+    return this.inFlightReads.get(dbKey);
+  }
+  setInFlight(dbKey, promise) {
+    this.inFlightReads.set(dbKey, promise);
+  }
+  clearInFlight(dbKey, promise) {
+    if (this.inFlightReads.get(dbKey) === promise) {
+      this.inFlightReads.delete(dbKey);
+    }
+  }
+  clearMiss(dbKey) {
+    this.recentMisses.delete(dbKey);
+  }
+  getRetryInMs(dbKey, now) {
+    const missUntil = this.recentMisses.get(dbKey);
+    if (typeof missUntil !== "number") return null;
+    if (missUntil <= now) {
+      this.recentMisses.delete(dbKey);
+      return null;
+    }
+    return missUntil - now;
+  }
+  markMiss(dbKey, now, cooldownMs = this.missCooldownMs) {
+    this.recentMisses.set(dbKey, now + cooldownMs);
+    this.cleanupMisses(now);
+  }
+  getLocalHitRevalidateInMs(dbKey, now) {
+    const nextAllowedAt = this.recentLocalHitRevalidations.get(dbKey);
+    if (typeof nextAllowedAt !== "number") return null;
+    if (nextAllowedAt <= now) {
+      this.recentLocalHitRevalidations.delete(dbKey);
+      return null;
+    }
+    return nextAllowedAt - now;
+  }
+  markLocalHitRevalidated(dbKey, now, cooldownMs = this.localHitRevalidateCooldownMs) {
+    this.recentLocalHitRevalidations.set(dbKey, now + cooldownMs);
+    this.cleanupLocalHitRevalidations(now);
+  }
+  cleanupExpiringMap(map, now) {
+    for (const [key, expiresAt] of Array.from(map.entries())) {
+      if (expiresAt <= now) {
+        map.delete(key);
+      }
+    }
+    if (map.size <= this.missCacheMaxSize) return;
+    const overflow = map.size - this.missCacheMaxSize;
+    const keys = Array.from(map.keys());
+    for (let i = 0; i < overflow; i += 1) {
+      const key = keys[i];
+      if (key) map.delete(key);
+    }
+  }
+  cleanupMisses(now) {
+    this.cleanupExpiringMap(this.recentMisses, now);
+  }
+  cleanupLocalHitRevalidations(now) {
+    this.cleanupExpiringMap(this.recentLocalHitRevalidations, now);
+  }
+  // test helper
+  getMissCacheSize() {
+    return this.recentMisses.size;
+  }
+  // test helper
+  getLocalHitRevalidationCacheSize() {
+    return this.recentLocalHitRevalidations.size;
+  }
+};
+var readRequestManager = new ReadRequestManager();
+
+// packages/database/actions/read.ts
+var updateClientDbIfNewer = async (clientDb, dbKey, remoteData, localData) => {
+  if (!clientDb) return;
+  try {
+    if (isRemoteDataNewer(remoteData, localData)) {
+      await clientDb.put(
+        dbKey,
+        normalizeReadRecord(dbKey, remoteData, { forCache: true })
+      );
+    }
+  } catch (err) {
+    throw err;
+  }
+};
+var normalizeReadRecord = (dbKey, data, options = {}) => {
+  if (!data || typeof data !== "object") return data;
+  const baseRecord = options.forCache ? data : { ...data, dbKey };
+  return baseRecord;
+};
+var isRemoteDataNewer = (remoteData, localData) => {
+  if (!remoteData || typeof remoteData !== "object") return false;
+  if (!localData || typeof localData !== "object") return true;
+  return shouldReplaceWithNextRecord(remoteData, localData);
+};
+var syncLocalDataToServer = async (replicationContext, dbKey, localData) => {
+  try {
+    scheduleExistingRecordReplication({
+      currentServer: replicationContext.currentServer,
+      syncServers: replicationContext.syncServers,
+      dbKey,
+      localData,
+      state: replicationContext.state
+    });
+  } catch (err) {
+  }
+};
+var saveRemoteDataToClientDb = async (clientDb, dbKey, remoteData, serverOrigin) => {
+  if (!clientDb) return;
+  try {
+    const normalizedRemoteData = normalizeReadRecord(dbKey, remoteData, {
+      forCache: true
+    });
+    await clientDb.put(
+      dbKey,
+      serverOrigin ? {
+        ...normalizedRemoteData,
+        serverOrigin
+      } : normalizedRemoteData
+    );
+  } catch (err) {
+  }
+};
+var processRemoteDataInBackground = async (clientDb, dbKey, remotePromises, remoteServers, localData, replicationContext) => {
+  if (!clientDb) return;
+  try {
+    const settledResults = await Promise.allSettled(remotePromises);
+    const remoteResult = pickBestSettledRemoteRecord({
+      settledResults,
+      isBetterCandidate: (current, latest) => shouldReplaceWithNextRecord(current, latest)
+    });
+    const validRemoteData = remoteResult ? remoteResult.data : null;
+    const serverOrigin = remoteResult && remoteServers[remoteResult.index] ? remoteServers[remoteResult.index] : void 0;
+    if (shouldReplaceLocalWithRemoteRecord({
+      localData,
+      remoteData: validRemoteData,
+      isRemoteNewer: isRemoteDataNewer
+    })) {
+      await updateClientDbIfNewer(
+        clientDb,
+        dbKey,
+        serverOrigin ? { ...validRemoteData, serverOrigin } : validRemoteData,
+        localData
+      );
+    }
+    if (shouldReplicateLocalRecord({
+      localData,
+      remoteData: validRemoteData,
+      remoteTargetCount: remotePromises.length
+    })) {
+      await syncLocalDataToServer(replicationContext, dbKey, localData);
+    }
+  } catch (err) {
+  }
+};
+var readAction = async (payload, thunkApi) => {
+  const dbKey = payload.dbKey;
+  const signal = payload.signal;
+  const preferredServerOrigin = payload.preferredServerOrigin;
+  if (!dbKey || typeof dbKey !== "string") {
+    throw new Error("readAction requires a non-empty dbKey.");
+  }
+  if (signal?.aborted) {
+    throw new DOMException("Aborted", "AbortError");
+  }
+  const { db: clientDb } = thunkApi.extra;
+  if (!clientDb) {
+    throw new Error("Client database is not available.");
+  }
+  const executeRead = async () => {
+    const isDialogKey = dbKey.startsWith("dialog-") && !dbKey.includes("-msg-");
+    const readStartedAt = isDialogKey ? Date.now() : 0;
+    const state = thunkApi.getState();
+    const {
+      currentToken,
+      remoteServers: configuredServers,
+      currentServer,
+      currentUserId,
+      syncServers,
+      userAuthorityRegistry
+    } = getRuntimeServerContext(state, preferredServerOrigin);
+    const allServers = resolveAgentReadServers({ dbKey, configuredServers });
+    const isLoggedIn = !!currentToken;
+    const now = Date.now();
+    const localData = await fetchFromClientDb(clientDb, dbKey);
+    if (isDialogKey) {
+      console.info("[readAction-perf] dialog local-read", {
+        dbKey,
+        localHit: !!localData,
+        localReadMs: Date.now() - readStartedAt,
+        serverCount: allServers.length
+      });
+    }
+    const authority = resolveRecordAuthority({
+      dbKey,
+      record: localData,
+      currentUserId,
+      currentServer,
+      userAuthorityRegistry
+    });
+    const authorityPlannedServers = planAuthorityReadServers({
+      allServers,
+      authorityServer: preferredServerOrigin ?? authority.authorityServer,
+      serverOrigin: authority.serverOrigin
+    });
+    const { preferredServer, fallbackServers, orderedServersForLocalHit } = partitionReadServers({
+      allServers: authorityPlannedServers,
+      preferredServerOrigin: preferredServerOrigin ?? authority.authorityServer
+    });
+    readRequestManager.cleanupMisses(now);
+    readRequestManager.cleanupLocalHitRevalidations(now);
+    if (localData) {
+      readRequestManager.clearMiss(dbKey);
+    } else {
+      const retryInMs = readRequestManager.getRetryInMs(dbKey, now);
+      if (typeof retryInMs === "number" && retryInMs > 0) {
+        logger.debug(
+          { dbKey, retryInMs },
+          "[readAction] Suppressing repeated miss read"
+        );
+        throw new Error(
+          `Read temporarily suppressed for missing key "${dbKey}".`
+        );
+      }
+    }
+    if (authorityPlannedServers.length === 0) {
+      if (localData) {
+        if (isDialogKey) {
+          console.info("[readAction-perf] dialog offline-local-hit", {
+            dbKey,
+            totalMs: Date.now() - readStartedAt
+          });
+        }
+        return normalizeReadRecord(dbKey, localData);
+      }
+      readRequestManager.markMiss(dbKey, now);
+      throw new Error(
+        `Failed to fetch data for key "${dbKey}" because network is offline and no local data is available.`
+      );
+    }
+    if (localData) {
+      const retryInMs = signal?.aborted ? void 0 : readRequestManager.getLocalHitRevalidateInMs(dbKey, now);
+      if (!signal?.aborted) {
+        if (retryInMs === null) {
+          readRequestManager.markLocalHitRevalidated(dbKey, now);
+          const remotePromises2 = orderedServersForLocalHit.map(
+            (server) => fetchFromServer(
+              server,
+              dbKey,
+              isLoggedIn ? currentToken : void 0,
+              signal
+            )
+          );
+          void processRemoteDataInBackground(
+            clientDb,
+            dbKey,
+            remotePromises2,
+            orderedServersForLocalHit,
+            localData,
+            { currentServer, syncServers, state }
+          );
+        } else {
+          logger.debug(
+            { dbKey, retryInMs },
+            "[readAction] Skipping frequent local-hit revalidation"
+          );
+        }
+      }
+      if (isDialogKey) {
+        console.info("[readAction-perf] dialog local-hit-return", {
+          dbKey,
+          totalMs: Date.now() - readStartedAt,
+          revalidating: retryInMs === null
+        });
+      }
+      return normalizeReadRecord(dbKey, localData);
+    }
+    if (preferredServer) {
+      try {
+        const preferredRemoteData = await fetchFromServer(
+          preferredServer,
+          dbKey,
+          isLoggedIn ? currentToken : void 0,
+          signal
+        );
+        if (preferredRemoteData) {
+          await saveRemoteDataToClientDb(
+            clientDb,
+            dbKey,
+            preferredRemoteData,
+            preferredServer
+          );
+          readRequestManager.clearMiss(dbKey);
+          if (isDialogKey) {
+            console.info("[readAction-perf] dialog preferred-remote-hit", {
+              dbKey,
+              totalMs: Date.now() - readStartedAt,
+              server: preferredServer
+            });
+          }
+          return normalizeReadRecord(dbKey, {
+            ...preferredRemoteData,
+            serverOrigin: preferredServer
+          });
+        }
+      } catch (error) {
+        if (signal?.aborted || isAbortError(error)) {
+          throw error;
+        }
+        if (isReadTimeoutError(error)) {
+          logger.warn(
+            { dbKey, preferredServer, error: String(error.message) },
+            "[readAction] Preferred server timed out; falling back to remaining servers"
+          );
+        } else {
+          logger.warn(
+            { dbKey, preferredServer, error: String(error) },
+            "[readAction] Preferred server read failed; falling back to remaining servers"
+          );
+        }
+      }
+    }
+    const remotePromises = fallbackServers.map(
+      (server) => fetchFromServer(
+        server,
+        dbKey,
+        isLoggedIn ? currentToken : void 0,
+        signal
+      )
+    );
+    const settledResults = await Promise.allSettled(remotePromises);
+    if (signal?.aborted) {
+      throw new DOMException("Aborted", "AbortError");
+    }
+    const remoteResult = pickBestSettledRemoteRecord({
+      settledResults,
+      isBetterCandidate: (current, latest) => shouldReplaceWithNextRecord(current, latest)
+    });
+    if (remoteResult) {
+      const { data: validRemoteData } = remoteResult;
+      const serverOrigin = fallbackServers[remoteResult.index];
+      if (!signal?.aborted) {
+        await saveRemoteDataToClientDb(
+          clientDb,
+          dbKey,
+          validRemoteData,
+          serverOrigin
+        );
+      }
+      readRequestManager.clearMiss(dbKey);
+      const remoteData = serverOrigin ? { ...validRemoteData, dbKey, serverOrigin } : { ...validRemoteData, dbKey };
+      return normalizeReadRecord(dbKey, remoteData);
+    }
+    readRequestManager.markMiss(dbKey, Date.now());
+    throw new Error(
+      `Failed to fetch data for key "${dbKey}" from all sources.`
+    );
+  };
+  const canDedup = !signal;
+  if (canDedup) {
+    const existing = readRequestManager.getInFlight(dbKey);
+    if (existing) return existing;
+    let inFlightPromise;
+    inFlightPromise = executeRead().finally(() => {
+      readRequestManager.clearInFlight(dbKey, inFlightPromise);
+    });
+    readRequestManager.setInFlight(dbKey, inFlightPromise);
+    return inFlightPromise;
+  }
+  return executeRead();
+};
+
+export {
+  BUILTIN_NOLO_AGENT_KEY,
+  PUBLIC_DEEPSEEK_V4_FLASH_AGENT_KEY,
+  PUBLIC_DEEPSEEK_V4_PRO_AGENT_KEY,
+  PUBLIC_KIMI_K27_CODING_AGENT_KEY,
+  PUBLIC_GLM_52_AGENT_KEY,
+  PUBLIC_KIMI_K26_IMAGE_AGENT_KEY,
+  readRequestManager,
+  resolveAgentReadServers,
+  readAction
+};

package/chunk-KKY4B2Q2.js

@@ -0,0 +1,21 @@
+// packages/agent-runtime/staleReplayGuard.ts
+var wrapHistoricalSummaryWithReplayGuard = (summary) => {
+  const trimmed = summary.trim();
+  if (!trimmed) return "";
+  return [
+    "\u3010\u5386\u53F2\u53C2\u8003\uFF0C\u975E\u6D3B\u6307\u4EE4\u3011\u4EE5\u4E0B\u4E3A\u51BB\u7ED3\u6458\u8981\uFF0C\u5176\u4E2D\u7684\u4EFB\u52A1/skill/ARGUMENTS \u9ED8\u8BA4\u5DF2\u8FC7\u671F\uFF0C\u4E0D\u5F97\u91CD\u65B0\u6267\u884C\u3002",
+    trimmed
+  ].join("\n");
+};
+
+// packages/agent-runtime/memoryUseGuidance.ts
+var MEMORY_USE_GUIDANCE = `--- \u8BB0\u5FC6\u4F7F\u7528\u65B9\u5F0F ---
+- \u8BB0\u5FC6\u662F\u4E2A\u6027\u5316\u589E\u5F3A\u5C42\uFF1B\u5F53\u524D\u8F93\u5165/\u5BF9\u8BDD/\u7CFB\u7EDF\u89C4\u5219/Agent prompt/skill/\u7528\u6237\u5168\u5C40\u504F\u597D\u90FD\u4F18\u5148\u4E8E\u5B83\u3002\u5F53\u524D\u8F93\u5165\u7ED9\u51FA\u65B0\u8BED\u8A00\u3001\u6280\u672F\u6808\u3001\u6570\u503C\u3001\u7EA6\u675F\u6216\u660E\u786E\u8986\u76D6\u65E7\u504F\u597D\u65F6\uFF0C\u91C7\u7528\u5F53\u524D\u8F93\u5165\uFF0C\u4E0D\u8981\u628A\u65E7\u8BB0\u5FC6\u5F53\u66F4\u9AD8\u771F\u503C\u3002
+- \u8BB0\u5FC6\u542B\u7528\u6237\u8EAB\u4EFD/\u79F0\u547C/\u5173\u7CFB/\u957F\u671F\u504F\u597D/\u9879\u76EE\u80CC\u666F\u65F6\uFF0C\u76F8\u5173\u5904\u81EA\u7136\u4F53\u73B0\uFF08\u5F00\u573A\u79F0\u547C\u3001\u4E0A\u4E0B\u6587\u786E\u8BA4\u3001\u56DE\u7B54\u7ED3\u6784\u3001\u53D6\u820D\u6807\u51C6\uFF09\uFF0C\u4E0D\u8981\u6BCF\u53E5\u673A\u68B0\u79F0\u547C\u7528\u6237\u3002
+- \u201C\u4E0A\u6B21/\u7EE7\u7EED/\u8FD9\u4E2A\u9879\u76EE\u201D\u7B49\u6307\u4EE3\u4F18\u5148\u6309\u5F53\u524D dialog/space/project/agent/sourceDialog \u7B49 KV \u8DEF\u5F84\u548C\u65F6\u95F4\u7EBF\u5B9A\u4F4D\uFF0C\u4E0D\u8981\u53EA\u6309\u8BED\u4E49\u76F8\u4F3C\u5EA6\u635E\u4E00\u6761\u3002
+- \u63A8\u65AD\u578B\u8BB0\u5FC6\u53EA\u7528\u4E8E\u628A\u63E1\u8BED\u6C14\u3001\u72B6\u6001\u548C\u672A\u5B8C\u6210\u4E8B\u9879\uFF0C\u4E0D\u8981\u8BF4\u6210\u201C\u4F60\u660E\u786E\u544A\u8BC9\u8FC7\u6211\u201D\u6216\u5F53\u6210\u7528\u6237\u5DF2\u6388\u6743\u4FDD\u5B58\u7684\u4E8B\u5B9E\u3002\u51B2\u7A81\u6216\u573A\u666F\u4E0D\u660E\u65F6\u8BF4\u660E\u4F9D\u636E\u6216\u7B80\u77ED\u786E\u8BA4\uFF0C\u4E0D\u8981\u786C\u5957\u3002`;
+
+export {
+  wrapHistoricalSummaryWithReplayGuard,
+  MEMORY_USE_GUIDANCE
+};

package/chunk-KQHGZWSV.js

@@ -0,0 +1,63 @@
+import {
+  getRecordTimestamp,
+  isTombstoneRecord,
+  shouldReplaceWithNextRecord
+} from "./chunk-GBRG75BQ.js";
+
+// packages/database/userDataMerge.ts
+var getUserDataItemTimestamp = (dataItem) => getRecordTimestamp(dataItem);
+var getItemKey = (item) => {
+  const candidates = [
+    typeof item.contentKey === "string" ? item.contentKey : void 0,
+    typeof item.dbKey === "string" ? item.dbKey : void 0,
+    typeof item.appKey === "string" ? item.appKey : void 0,
+    typeof item.appId === "string" ? item.appId : void 0,
+    item.id
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim().length > 0) {
+      return candidate;
+    }
+  }
+  return null;
+};
+var mergeAndDedupUserData = (localData, remoteResults, options = {}) => {
+  const uniqueMap = /* @__PURE__ */ new Map();
+  const mergeRecordMetadata = (currentItem, nextItem) => {
+    if (typeof currentItem.serverOrigin !== "string" && typeof nextItem.serverOrigin === "string" && nextItem.serverOrigin.trim().length > 0) {
+      return {
+        ...currentItem,
+        serverOrigin: nextItem.serverOrigin
+      };
+    }
+    return currentItem;
+  };
+  const addToMap = (item) => {
+    const itemKey = getItemKey(item);
+    if (!itemKey) return;
+    const existing = uniqueMap.get(itemKey);
+    if (!existing) {
+      uniqueMap.set(itemKey, item);
+      return;
+    }
+    if (shouldReplaceWithNextRecord(item, existing)) {
+      uniqueMap.set(itemKey, item);
+      return;
+    }
+    uniqueMap.set(itemKey, mergeRecordMetadata(existing, item));
+  };
+  localData.forEach(addToMap);
+  remoteResults.forEach((result) => {
+    const items = result?.data?.data;
+    if (Array.isArray(items)) {
+      items.forEach(addToMap);
+    }
+  });
+  const merged = Array.from(uniqueMap.values());
+  return options.includeDeleted ? merged : merged.filter((item) => !isTombstoneRecord(item));
+};
+
+export {
+  getUserDataItemTimestamp,
+  mergeAndDedupUserData
+};

package/chunk-KUG52IAP.js

@@ -0,0 +1,8 @@
+// packages/core/isRecord.ts
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export {
+  isRecord
+};

package/chunk-KX6YBIHG.js

@@ -0,0 +1,8 @@
+// packages/core/recordOrEmpty.ts
+function asRecordOrEmpty(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+export {
+  asRecordOrEmpty
+};

package/chunk-LCBAMY2M.js

@@ -0,0 +1,60 @@
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+
+// packages/database/config.ts
+var API_VERSION = "/api/v1";
+var SERVERS = {
+  MAIN: "https://nolo.chat",
+  US: "https://us.nolo.chat"
+};
+var NOLO_CLUSTER_SERVERS = Object.values(SERVERS);
+var LEGACY_SERVER_ORIGIN_MAP = {
+  "https://nolotus.com": SERVERS.MAIN,
+  "https://www.nolotus.com": SERVERS.MAIN,
+  "https://us.nolotus.com": SERVERS.US,
+  "https://www.us.nolotus.com": SERVERS.US
+};
+var normalizeKnownServerOrigin = (server) => {
+  if (typeof server !== "string" || server.trim().length === 0) return null;
+  const trimmed = server.trim();
+  let origin;
+  try {
+    origin = new URL(trimmed).origin;
+  } catch {
+    origin = normalizeServerOrigin(trimmed);
+  }
+  return LEGACY_SERVER_ORIGIN_MAP[origin.toLowerCase()] ?? origin;
+};
+var LOCAL_DEV_SERVER_ORIGIN_PATTERN = /^https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|nolotus\.local)(?::\d+)?$/i;
+var isLocalDevServerOrigin = (server) => {
+  if (typeof server !== "string" || server.trim().length === 0) return false;
+  const normalized = normalizeKnownServerOrigin(server) ?? normalizeServerOrigin(server);
+  return LOCAL_DEV_SERVER_ORIGIN_PATTERN.test(normalized);
+};
+var isNoloClusterServerOrigin = (server) => {
+  if (typeof server !== "string" || server.trim().length === 0) return false;
+  const normalized = normalizeKnownServerOrigin(server) ?? normalizeServerOrigin(server);
+  return /^https?:\/\/(?:us\.)?nolo\.chat$/i.test(normalized);
+};
+var API_ENDPOINTS = {
+  DATABASE: `${API_VERSION}/db`,
+  SHARE: `${API_VERSION}/share`,
+  USERS: `${API_VERSION}/users`,
+  WEATHER: `${API_VERSION}/weather`,
+  HI: `${API_VERSION}/hi`,
+  CHAT: `${API_VERSION}/chat`,
+  EXECUTE_SQL: `${API_VERSION}/sqlite/execute_sql`,
+  // --- 新增端点 ---
+  TRANSACTIONS: `${API_VERSION}/transactions`
+};
+
+export {
+  API_VERSION,
+  SERVERS,
+  NOLO_CLUSTER_SERVERS,
+  normalizeKnownServerOrigin,
+  isLocalDevServerOrigin,
+  isNoloClusterServerOrigin,
+  API_ENDPOINTS
+};

package/chunk-LM6IYQ3F.js

@@ -0,0 +1,16 @@
+// packages/database-engine/dbPath.ts
+import { homedir } from "node:os";
+import path from "node:path";
+function resolveServerDbPath(options = {}) {
+  const env = options.env ?? process.env;
+  return env.NOLO_SERVER_DB_PATH?.trim() || path.join(options.cwd ?? process.cwd(), "data", "leveldb");
+}
+function resolveNoloHome(options = {}) {
+  const env = options.env ?? process.env;
+  return env.NOLO_HOME?.trim() || path.join(options.homeDir ?? homedir(), ".nolo");
+}
+
+export {
+  resolveServerDbPath,
+  resolveNoloHome
+};