nolo-cli 0.108.0-alpha.2 → 0.108.1

package/{chunk-ABQYVJBJ.js → chunk-AIZE5TDM.js}

@@ -1,16 +1,16 @@
 import {
   getRuntimeServerContext,
   scheduleDeleteReplication
-} from "./chunk-UKWGR5SS.js";
+} from "./chunk-4YRTZIVN.js";
 import {
   fetchFromClientDb
-} from "./chunk-QOKAKDPE.js";
+} from "./chunk-6Q7UTJKR.js";
 import {
   selectIdentityToken
 } from "./chunk-SEJ5OS6F.js";
 import {
   buildTombstoneRecord
-} from "./chunk-GBRG75BQ.js";
+} from "./chunk-D2MDMY2M.js";
 
 // packages/database/fileStorage.ts
 var DB_NAME = "nolo-file-storage";

package/{chunk-LJ5VW2UJ.js → chunk-ALKCVCA5.js}

@@ -1,13 +1,13 @@
 import {
   generatePkcePair,
   startCallbackServer
-} from "./chunk-Z5625XML.js";
-import {
-  toErrorMessage
-} from "./chunk-HNMXYYJR.js";
+} from "./chunk-OYBAT7RT.js";
 import {
   asOptionalFiniteNumber
 } from "./chunk-WWC7I6TA.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
 
 // packages/cli/oauth/flows/cloudflare.ts
 var CLOUDFLARE_OAUTH_AUTH_ENDPOINT = "https://dash.cloudflare.com/oauth2/auth";

package/{chunk-5UTFL4QJ.js → chunk-APO5TOXO.js}

@@ -3,7 +3,7 @@ import {
   isCoreDrainingBody,
   normalizeNonNegativeMs,
   parseRetryAfterHeaderMs
-} from "./chunk-3L2WKC3W.js";
+} from "./chunk-XPWGOTBQ.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";

package/{chunk-E4MARS3Q.js → chunk-AU7AXHUL.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-KHCLMKZZ.js";
 import {
   buildSkillDiscoveryLayer
-} from "./chunk-DVINR3PL.js";
+} from "./chunk-VEA7H5FG.js";
 
 // packages/agent-runtime/skillDiscovery.ts
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";

package/{chunk-DOTZ5GTO.js → chunk-AWYWIWTU.js}

@@ -5,29 +5,21 @@ import {
 } from "./chunk-ZJ7UHBJS.js";
 import {
   deleteDialog,
-  i18nBaseConfig,
-  initReactI18next,
-  instance,
+  runtime_default,
   toast
-} from "./chunk-YWIEQS6H.js";
+} from "./chunk-2DRYS3G3.js";
 import {
-  require_date_fns
-} from "./chunk-M76ECQRD.js";
+  formatISO
+} from "./chunk-ZRAU6T47.js";
 import {
   require_react
 } from "./chunk-YDH3FDFQ.js";
-import {
-  isSystemAdmin
-} from "./chunk-QDSINZM3.js";
-import {
-  asRecordOrEmpty
-} from "./chunk-KX6YBIHG.js";
 import {
   UNCATEGORIZED_ID,
   addContentAction,
   checkSpaceMembership,
   localSpaceAuthorityPatchStamp
-} from "./chunk-AHAHBQMU.js";
+} from "./chunk-2OMUAIKR.js";
 import {
   createSpaceKey,
   normalizeSpaceId
@@ -37,57 +29,71 @@ import {
   read,
   readAndWait,
   remove,
-  resolveFileCategory,
   uploadFileAction,
   upsertSSREntity,
   write
-} from "./chunk-VRTTFDBM.js";
-import {
-  SEPARATOR,
-  asTrimmedNonEmptyStringArray,
-  createKey,
-  fileKey,
-  isAgentKey,
-  isPageKey,
-  metaKey,
-  rowKey,
-  splitKey,
-  ulid
-} from "./chunk-VMFTFOWF.js";
-import {
-  asOptionalFiniteNumber
-} from "./chunk-WWC7I6TA.js";
+} from "./chunk-RNNWTMKT.js";
 import {
-  extractUserId
-} from "./chunk-M2EJHDJP.js";
+  resolveFileCategory
+} from "./chunk-3PVYUPXK.js";
 import {
   DEVICE_LOCAL_OWNER_ID,
-  createAsyncThunk,
   getRuntimeServerContext,
   isDeviceLocalSpaceBody,
   resolveReplicationServers,
   scheduleDeleteReplication,
   scheduleWriteReplication
-} from "./chunk-UKWGR5SS.js";
+} from "./chunk-4YRTZIVN.js";
 import {
-  createClientLogger,
-  isAbortError
-} from "./chunk-QOKAKDPE.js";
+  createAsyncThunk
+} from "./chunk-IJERIUXS.js";
+import {
+  createClientLogger
+} from "./chunk-QQ56R7KS.js";
 import {
   selectIdentityUserId
 } from "./chunk-SEJ5OS6F.js";
 import {
   buildTombstoneRecord
-} from "./chunk-GBRG75BQ.js";
+} from "./chunk-D2MDMY2M.js";
+import {
+  isSystemAdmin
+} from "./chunk-OKARGYFT.js";
+import {
+  asRecordOrEmpty
+} from "./chunk-KX6YBIHG.js";
+import {
+  isAbortError
+} from "./chunk-7DPNBQSV.js";
+import {
+  extractUserId
+} from "./chunk-M2EJHDJP.js";
+import {
+  SEPARATOR,
+  createKey,
+  fileKey,
+  isAgentKey,
+  isPageKey,
+  metaKey,
+  rowKey,
+  splitKey,
+  ulid
+} from "./chunk-RLRYVSCD.js";
+import {
+  asTrimmedNonEmptyStringArray
+} from "./chunk-I42VC5KR.js";
+import {
+  asOptionalPositiveFiniteNumber
+} from "./chunk-U6VC4MU4.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
-import {
-  asOptionalPositiveFiniteNumber
-} from "./chunk-U6VC4MU4.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
@@ -97,7 +103,6 @@ import {
 
 // packages/render/table/tableStore.ts
 var import_react = __toESM(require_react(), 1);
-var import_date_fns2 = __toESM(require_date_fns(), 1);
 import { ulid as ulid3 } from "ulid";
 
 // packages/render/table/fetchAndCacheTableRows.ts
@@ -434,25 +439,7 @@ function addColumnOptionInMeta(meta, input, deps) {
 }
 
 // packages/render/table/createTableAction.ts
-var import_date_fns = __toESM(require_date_fns(), 1);
 import { ulid as ulid2 } from "ulid";
-
-// packages/app/i18n/client.ts
-instance.use(initReactI18next).init({
-  ...i18nBaseConfig,
-  lng: "zh-CN" /* ZH_CN */,
-  fallbackLng: {
-    ["en" /* EN */]: ["en" /* EN */],
-    ["zh-CN" /* ZH_CN */]: ["zh-CN" /* ZH_CN */, "en" /* EN */],
-    ["zh-Hant" /* ZH_HANT */]: ["zh-Hant" /* ZH_HANT */, "zh-CN" /* ZH_CN */, "en" /* EN */],
-    ["ja" /* JA */]: ["ja" /* JA */, "en" /* EN */],
-    default: ["en" /* EN */]
-  },
-  compatibilityJSON: "v3"
-});
-var client_default = instance;
-
-// packages/render/table/createTableAction.ts
 var DEFAULT_COLUMNS = [
   {
     name: "title",
@@ -554,9 +541,9 @@ var createTableAction = async ({
   const spaceId = customSpaceId ?? getCurrentSpaceId();
   const tableId = ulid2();
   const now = /* @__PURE__ */ new Date();
-  const nowIso = (0, import_date_fns.formatISO)(now);
+  const nowIso = formatISO(now);
   const dbKey = metaKey(userId, tableId);
-  const defaultTitle = client_default.t("space:newTable", {
+  const defaultTitle = runtime_default.t("space:newTable", {
     defaultValue: "\u65B0\u5EFA\u8868\u683C"
   });
   const title = asOptionalTrimmedString(customTitle) ?? defaultTitle;
@@ -924,7 +911,7 @@ var addRow = createTableCommand(
     });
     try {
       const { dbKey, rowId } = rowKey.create(tenantId, tableId);
-      const nowIso = (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date());
+      const nowIso = formatISO(/* @__PURE__ */ new Date());
       const row = {
         dbKey,
         tenantId,
@@ -985,7 +972,7 @@ var deleteRow = createTableCommand(
       if (!row) {
         throw new Error(`\u5F53\u524D\u8868\u4E2D\u627E\u4E0D\u5230\u8981\u5220\u9664\u7684\u884C\uFF1A${dbKey}`);
       }
-      const nowIso = (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date());
+      const nowIso = formatISO(/* @__PURE__ */ new Date());
       const tombstoneRow = {
         ...row,
         deletedAt: nowIso,
@@ -1063,7 +1050,7 @@ var addColumn = createTableCommand(
     const result = addColumnToMeta(
       meta,
       { columnName },
-      { id: ulid3(), nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
+      { id: ulid3(), nowIso: formatISO(/* @__PURE__ */ new Date()) }
     );
     if (!result.ok) {
       throw new Error(result.error);
@@ -1104,7 +1091,7 @@ var deleteColumn = createTableCommand(
       meta,
       state.rows,
       { columnName },
-      { nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
+      { nowIso: formatISO(/* @__PURE__ */ new Date()) }
     );
     if (!result.ok) {
       throw new Error(result.error);
@@ -1146,7 +1133,7 @@ var reorderColumn = createTableCommand(
     const result = reorderColumnInMeta(
       meta,
       { fromIndex, toIndex },
-      { nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
+      { nowIso: formatISO(/* @__PURE__ */ new Date()) }
     );
     if (!result.ok) {
       throw new Error(result.error);
@@ -1187,7 +1174,7 @@ var renameColumnLabel = createTableCommand(
     const result = renameColumnLabelInMeta(
       meta,
       { columnId, label: newLabel },
-      { nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
+      { nowIso: formatISO(/* @__PURE__ */ new Date()) }
     );
     if (!result.ok) {
       throw new Error(result.error);
@@ -1225,7 +1212,7 @@ var updateColumnWidth = createTableCommand(
     const result = updateColumnWidthInMeta(
       meta,
       { columnId, width },
-      { nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
+      { nowIso: formatISO(/* @__PURE__ */ new Date()) }
     );
     if (!result.ok) {
       throw new Error(result.error);
@@ -1263,7 +1250,7 @@ var addColumnOption = createTableCommand(
     const result = addColumnOptionInMeta(
       meta,
       { columnId, option },
-      { nowIso: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date()) }
+      { nowIso: formatISO(/* @__PURE__ */ new Date()) }
     );
     if (!result.ok) {
       throw new Error(result.error);
@@ -1305,7 +1292,7 @@ var renameTable = createTableCommand(
     if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
       throw new Error("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
     }
-    const nowIso = (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date());
+    const nowIso = formatISO(/* @__PURE__ */ new Date());
     setState((s) => ({ ...s, error: null }));
     try {
       if (dispatch) {
@@ -1346,7 +1333,7 @@ var updateTableIcon = createTableCommand(
     if (!meta || meta.tenantId !== tenantId || meta.tableId !== tableId) {
       throw new Error("\u5F53\u524D\u6CA1\u6709\u52A0\u8F7D\u5BF9\u5E94\u7684\u8868\u5B9A\u4E49");
     }
-    const nowIso = (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date());
+    const nowIso = formatISO(/* @__PURE__ */ new Date());
     setState((s) => ({ ...s, error: null }));
     try {
       if (dispatch) {
@@ -1384,7 +1371,7 @@ var updateCell = createTableCommand(
     const { dbKey, columnName, value } = args;
     setState((s) => ({ ...s, error: null }));
     try {
-      const nowIso = (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date());
+      const nowIso = formatISO(/* @__PURE__ */ new Date());
       if (dispatch) {
         await safeDispatch(
           dispatch,
@@ -1453,11 +1440,11 @@ var ENTITY_DELETE_STRATEGIES = {
     await dispatch(deleteTable({ dbKey: key })).unwrap();
   },
   file: async (key, { thunkAPI }) => {
-    const { deleteFileAction } = await import("./deleteFile-YG6QMJLU.js");
+    const { deleteFileAction } = await import("./deleteFile-6JWDDRVP.js");
     await deleteFileAction(key, thunkAPI);
   },
   image: async (key, { thunkAPI }) => {
-    const { deleteFileAction } = await import("./deleteFile-YG6QMJLU.js");
+    const { deleteFileAction } = await import("./deleteFile-6JWDDRVP.js");
     await deleteFileAction(key, thunkAPI);
   },
   agent: async (key, { dispatch, userId, sourceServerOrigin }) => {
@@ -2090,18 +2077,191 @@ var deleteMultipleContentAction = async (input, thunkAPI) => {
   };
 };
 
+// packages/create/space/content/spaceFileVersions.ts
+var normalizeFileName = (name) => typeof name === "string" ? name.trim().normalize("NFC") : "";
+var versionsOf = (entryKey, entry) => {
+  if (Array.isArray(entry.versions) && entry.versions.length > 0) {
+    return entry.versions.filter((v) => v && typeof v.fileKey === "string");
+  }
+  return [
+    {
+      fileKey: entry.contentKey || entryKey,
+      sha256: entry.sha256 || "",
+      size: typeof entry.fileSize === "number" ? entry.fileSize : 0,
+      uploadedAt: typeof entry.createdAt === "number" ? entry.createdAt : 0
+    }
+  ];
+};
+var findSameNameFileEntries = (contents, originalName) => {
+  const target = normalizeFileName(originalName);
+  if (!target || !contents) return [];
+  return Object.entries(contents).filter(([, value]) => Boolean(value)).map(([entryKey, value]) => ({ entryKey, entry: value })).filter(
+    ({ entry }) => entry.type === "file" && normalizeFileName(entry.originalName ?? entry.title) === target
+  );
+};
+var sortVersions = (versions) => [...versions].sort(
+  (a, b) => a.uploadedAt - b.uploadedAt || a.fileKey.localeCompare(b.fileKey)
+);
+var mergeVersions = (groups) => {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const { entryKey, entry } of groups) {
+    for (const v of versionsOf(entryKey, entry)) {
+      const prev = byKey.get(v.fileKey);
+      if (!prev || !prev.sha256 && v.sha256) byKey.set(v.fileKey, v);
+    }
+  }
+  return sortVersions([...byKey.values()]);
+};
+var planSpaceFileUpload = (contents, originalName, sha256) => {
+  const same = findSameNameFileEntries(contents, originalName);
+  if (same.length === 0) return { kind: "new_file" };
+  const primary = pickPrimary(same);
+  const current = primary.entry.contentKey || primary.entryKey;
+  const versions = mergeVersions(same);
+  const currentVersion = versions.find((v) => v.fileKey === current);
+  if (currentVersion?.sha256 && currentVersion.sha256 === sha256) {
+    return { kind: "unchanged", entryKey: primary.entryKey, currentKey: current };
+  }
+  const older = versions.find((v) => v.sha256 && v.sha256 === sha256);
+  if (older) {
+    return { kind: "restore_existing", entryKey: primary.entryKey, versionKey: older.fileKey };
+  }
+  return { kind: "new_version", entryKey: primary.entryKey };
+};
+var pickPrimary = (same) => [...same].sort((a, b) => {
+  const at = Math.max(...versionsOf(a.entryKey, a.entry).map((v) => v.uploadedAt));
+  const bt = Math.max(...versionsOf(b.entryKey, b.entry).map((v) => v.uploadedAt));
+  return bt - at || b.entryKey.localeCompare(a.entryKey);
+})[0];
+var buildVersionedEntryPatch = (input) => {
+  const { same, extraVersion, now } = input;
+  const versions = mergeVersions(
+    extraVersion ? [...same, { entryKey: extraVersion.fileKey, entry: { versions: [extraVersion] } }] : same
+  );
+  const currentKey = input.currentKey ?? versions[versions.length - 1].fileKey;
+  const current = versions.find((v) => v.fileKey === currentKey);
+  if (!current) throw new Error(`Version ${currentKey} not found for this file.`);
+  const template = same.length > 0 ? pickPrimary(same).entry : {};
+  const patch2 = {};
+  for (const { entryKey } of same) {
+    if (entryKey !== currentKey) patch2[entryKey] = null;
+  }
+  patch2[currentKey] = {
+    ...template,
+    contentKey: currentKey,
+    currentVersionKey: currentKey,
+    fileSize: current.size,
+    versions,
+    updatedAt: now,
+    ...input.restoredFrom ? { restoredFromVersionKey: input.restoredFrom } : {}
+  };
+  return patch2;
+};
+var sha256Hex = async (file) => {
+  const digest = await crypto.subtle.digest("SHA-256", await file.arrayBuffer());
+  return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+
 // packages/create/space/content/uploadAndAddFileToSpaceAction.ts
-var uploadAndAddFileToSpaceAction = async (payload, thunkAPI) => {
-  const { spaceId, file, categoryId } = payload;
+var uploadQueues = /* @__PURE__ */ new Map();
+var serialize = (key, task) => {
+  const prev = uploadQueues.get(key) ?? Promise.resolve();
+  const next = prev.catch(() => void 0).then(task);
+  uploadQueues.set(key, next);
+  void next.finally(() => {
+    if (uploadQueues.get(key) === next) uploadQueues.delete(key);
+  }).catch(() => void 0);
+  return next;
+};
+var readSpaceOrNull = async (dispatch, spaceId) => {
+  try {
+    return await dispatch(read({ dbKey: createSpaceKey.space(spaceId) })).unwrap() ?? null;
+  } catch {
+    return null;
+  }
+};
+var reconcileSameNameEntries = async (thunkAPI, spaceId, originalName, options = {}) => {
+  let updated = await reconcileOnce(thunkAPI, spaceId, originalName, options);
+  for (let attempt = 0; attempt < 2 && updated; attempt += 1) {
+    const same = findSameNameFileEntries(updated.contents, originalName);
+    const keys = new Set(mergeVersions(same).map((v) => v.fileKey));
+    const missingOwn = options.extraVersion && !keys.has(options.extraVersion.fileKey);
+    if (same.length <= 1 && !missingOwn) break;
+    const fresh = await readSpaceOrNull(thunkAPI.dispatch, spaceId);
+    const freshSame = findSameNameFileEntries(fresh?.contents, originalName);
+    const freshKeys = new Set(mergeVersions(freshSame).map((v) => v.fileKey));
+    const stillMissing = options.extraVersion && !freshKeys.has(options.extraVersion.fileKey);
+    if (freshSame.length <= 1 && !stillMissing) {
+      updated = fresh;
+      break;
+    }
+    updated = await reconcileOnce(thunkAPI, spaceId, originalName, {
+      ...stillMissing ? { extraVersion: options.extraVersion } : {}
+    });
+  }
+  return updated;
+};
+var reconcileOnce = async (thunkAPI, spaceId, originalName, options = {}) => {
   const { dispatch, getState } = thunkAPI;
-  const state3 = getState();
-  const userId = selectIdentityUserId(state3);
+  const spaceData = await readSpaceOrNull(dispatch, spaceId);
+  if (!spaceData) return null;
+  checkSpaceMembership(spaceData, selectIdentityUserId(getState()));
+  const same = findSameNameFileEntries(spaceData.contents, originalName);
+  if (same.length === 0 && !options.extraVersion) return spaceData;
+  const contentsPatch = buildVersionedEntryPatch({ same, now: Date.now(), ...options });
+  return await dispatch(
+    patch({
+      dbKey: createSpaceKey.space(spaceId),
+      changes: {
+        contents: contentsPatch,
+        updatedAt: Date.now(),
+        ...localSpaceAuthorityPatchStamp(spaceData)
+      }
+    })
+  ).unwrap();
+};
+var uploadAndAddFileToSpaceAction = async (payload, thunkAPI) => {
+  const { spaceId, file } = payload;
+  const userId = selectIdentityUserId(thunkAPI.getState());
   if (!userId) {
-    console.warn("[uploadAndAddFileToSpace] Warning: No userId found in state. Uploading as anonymous/unknown might cause issues.");
+    throw new Error("Cannot upload a file to a space without an authenticated user.");
   }
+  return serialize(
+    `${spaceId}\0${file.name}`,
+    () => uploadOnce(payload, thunkAPI, userId)
+  );
+};
+var uploadOnce = async (payload, thunkAPI, userId) => {
+  const { spaceId, file, categoryId } = payload;
+  const { dispatch } = thunkAPI;
   try {
+    const sha256 = await sha256Hex(file);
+    const existingSpace = await readSpaceOrNull(dispatch, spaceId);
+    const plan = existingSpace ? planSpaceFileUpload(existingSpace.contents, file.name, sha256) : { kind: "new_file" };
+    if (plan.kind === "unchanged") {
+      return {
+        spaceId,
+        updatedSpaceData: existingSpace,
+        contentKey: plan.currentKey,
+        fileId: plan.currentKey.split("-").slice(2).join("-"),
+        outcome: "unchanged"
+      };
+    }
+    if (plan.kind === "restore_existing") {
+      const updated = await reconcileSameNameEntries(thunkAPI, spaceId, file.name, {
+        currentKey: plan.versionKey,
+        restoredFrom: plan.entryKey
+      });
+      return {
+        spaceId,
+        updatedSpaceData: updated ?? existingSpace,
+        contentKey: plan.versionKey,
+        fileId: plan.versionKey.split("-").slice(2).join("-"),
+        outcome: "restored_existing"
+      };
+    }
     const id = ulid();
-    const dbKey = fileKey.single(userId || "unknown", id);
+    const dbKey = fileKey.single(userId, id);
     const contentType = "file" /* FILE */;
     const fileCategory = resolveFileCategory({
       mimeType: file.type,
@@ -2116,17 +2276,28 @@ var uploadAndAddFileToSpaceAction = async (payload, thunkAPI) => {
     }
     const contentKey = fileMetadata.dbKey || dbKey;
     const title = file.name;
-    const result = await addContentAction({
-      spaceId,
-      contentKey,
-      title,
-      type: contentType,
-      fileCategory,
-      mimeType: file.type || void 0,
-      fileSize: asOptionalFiniteNumber(file.size),
-      originalName: file.name,
-      categoryId
-    }, thunkAPI);
+    const fileSize = asOptionalFiniteNumber(file.size);
+    const version3 = {
+      fileKey: contentKey,
+      sha256,
+      size: fileSize ?? 0,
+      uploadedAt: Date.now()
+    };
+    const addAsNewFile = async () => {
+      const result2 = await addContentAction({
+        spaceId,
+        contentKey,
+        title,
+        type: contentType,
+        fileCategory,
+        mimeType: file.type || void 0,
+        fileSize,
+        originalName: file.name,
+        categoryId
+      }, thunkAPI);
+      return result2;
+    };
+    const result = plan.kind === "new_file" ? await addAsNewFile() : { spaceId, updatedSpaceData: existingSpace };
     await dispatch(
       patch({
         dbKey: contentKey,
@@ -2135,20 +2306,54 @@ var uploadAndAddFileToSpaceAction = async (payload, thunkAPI) => {
           spaceId,
           fileCategory,
           mimeType: file.type || void 0,
-          fileSize: asOptionalFiniteNumber(file.size),
+          fileSize,
           originalName: file.name
         }
       })
     ).unwrap();
+    const reconciled = await reconcileSameNameEntries(thunkAPI, spaceId, file.name, {
+      extraVersion: version3,
+      currentKey: contentKey
+    }).catch((error) => {
+      if (plan.kind === "new_version") throw error;
+      console.warn("[uploadAndAddFileToSpace] version reconcile failed", error);
+      return null;
+    });
     if (typeof window !== "undefined") {
       window.dispatchEvent(new Event("nolo-user-data-updated"));
     }
-    return { ...result, contentKey, fileId: fileMetadata.id };
+    return {
+      ...result,
+      ...reconciled ? { updatedSpaceData: reconciled } : {},
+      contentKey,
+      fileId: fileMetadata.id,
+      outcome: plan.kind === "new_file" ? "new_file" : "new_version"
+    };
   } catch (error) {
     console.error("Upload and add file error:", error);
     throw error;
   }
 };
+var restoreSpaceFileVersionAction = async (input, thunkAPI) => {
+  const { spaceId, contentKey, versionKey } = input;
+  const spaceData = await readSpaceOrNull(thunkAPI.dispatch, spaceId);
+  if (!spaceData) throw new Error(`\u65E0\u6CD5\u52A0\u8F7D\u7A7A\u95F4\u6570\u636E: ${spaceId}`);
+  const entry = spaceData.contents?.[contentKey];
+  if (!entry || entry.type !== "file" /* FILE */) throw new Error("File not found in space");
+  const versions = Array.isArray(entry.versions) ? entry.versions : [];
+  if (!versions.some((v) => v.fileKey === versionKey)) {
+    throw new Error("Version not found for this file");
+  }
+  const name = entry.originalName ?? entry.title;
+  const updated = await serialize(
+    `${spaceId}\0${name}`,
+    () => reconcileSameNameEntries(thunkAPI, spaceId, name, {
+      currentKey: versionKey,
+      restoredFrom: contentKey
+    })
+  );
+  return { spaceId, updatedSpaceData: updated ?? spaceData, contentKey: versionKey };
+};
 
 // packages/create/space/spaceCollapsedState.ts
 var SPACE_COLLAPSE_STORAGE_PREFIX = "space-collapsed-categories:";
@@ -2343,6 +2548,16 @@ var uploadAndAddFileToSpace = createAsyncThunk(
     return payload;
   }
 );
+var restoreSpaceFileVersion = createAsyncThunk(
+  "space/restoreSpaceFileVersion",
+  async (arg, thunkAPI) => {
+    const payload = await restoreSpaceFileVersionAction(arg, thunkAPI);
+    if (getCurrentSpaceIdRaw() === payload.spaceId) {
+      updateCurrentSpaceIfMatch(payload.spaceId, payload.updatedSpaceData);
+    }
+    return payload;
+  }
+);
 var updateContentTitle = createAsyncThunk(
   "space/updateContentTitle",
   async (arg, thunkAPI) => {
@@ -2391,7 +2606,6 @@ var updateContentCategory = createAsyncThunk(
 
 export {
   fetchAndCacheTableRows,
-  client_default,
   getTableState,
   loadTableRows,
   addRow,
@@ -2409,6 +2623,7 @@ export {
   deleteContentFromSpace,
   deleteMultipleContent,
   uploadAndAddFileToSpace,
+  restoreSpaceFileVersion,
   updateContentTitle,
   updateContentPinned,
   updateContentCategory