nolo-cli 0.212.0-alpha.1 → 0.222.0-alpha.2

package/{chunk-NJR3WKVP.js → chunk-YWWDC3O7.js}

@@ -2,28 +2,35 @@ import {
   deleteDialog,
   runtime_default,
   toast
-} from "./chunk-VZKUKCA6.js";
+} from "./chunk-MZLE5HQ3.js";
 import {
+  getAllMemberSpaces,
   getCurrentSpaceId,
   getCurrentSpaceIdRaw,
   updateCurrentSpaceIfMatch
-} from "./chunk-5XBUWM6I.js";
+} from "./chunk-MBG66ZBH.js";
+import {
+  require_formatISO
+} from "./chunk-UVLYNWIE.js";
+import {
+  require_react
+} from "./chunk-5FUN7EG4.js";
 import {
   UNCATEGORIZED_ID,
   addContentAction,
+  canManageSpaceContent,
   checkSpaceMembership,
-  localSpaceAuthorityPatchStamp
-} from "./chunk-VPAZOH2D.js";
+  loadSpaceContentOrThrow,
+  localSpaceAuthorityPatchStamp,
+  notifyUserDataUpdated,
+  patchIndividualContentRecord,
+  readContentRecordForSpaceSync,
+  syncContentRecordSpaceId
+} from "./chunk-JA3ICVJY.js";
 import {
   createSpaceKey,
   normalizeSpaceId
 } from "./chunk-UAD2WT54.js";
-import {
-  require_formatISO
-} from "./chunk-WPORQFYN.js";
-import {
-  require_react
-} from "./chunk-YDH3FDFQ.js";
 import {
   patch,
   read,
@@ -32,7 +39,7 @@ import {
   uploadFileAction,
   upsertSSREntity,
   write
-} from "./chunk-BFM34N54.js";
+} from "./chunk-44X52WOJ.js";
 import {
   resolveFileCategory
 } from "./chunk-3PVYUPXK.js";
@@ -43,10 +50,10 @@ import {
   resolveReplicationServers,
   scheduleDeleteReplication,
   scheduleWriteReplication
-} from "./chunk-PYRUW7XN.js";
+} from "./chunk-2VUZSVAS.js";
 import {
   createAsyncThunk
-} from "./chunk-P5L7CXOC.js";
+} from "./chunk-7Z6EW7AH.js";
 import {
   getIsDesktopApp
 } from "./chunk-AGP3YSEC.js";
@@ -58,22 +65,19 @@ import {
 } from "./chunk-PXYBUFDB.js";
 import {
   buildTombstoneRecord
-} from "./chunk-D2MDMY2M.js";
-import {
-  isSystemAdmin
-} from "./chunk-Y6ORVLSS.js";
+} from "./chunk-BV3FLP2L.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
 import {
   isAbortError
 } from "./chunk-7DPNBQSV.js";
+import {
+  isSystemAdmin
+} from "./chunk-7ET2U67U.js";
 import {
   extractUserId
 } from "./chunk-M2EJHDJP.js";
-import {
-  isRecord
-} from "./chunk-KUG52IAP.js";
 import {
   SEPARATOR,
   createKey,
@@ -83,28 +87,31 @@ import {
   metaKey,
   rowKey,
   splitKey
-} from "./chunk-JY5NGFFH.js";
+} from "./chunk-SYTHYBMI.js";
 import {
   ulid
-} from "./chunk-XJWWBO34.js";
+} from "./chunk-OJKUU3LP.js";
 import {
   asTrimmedNonEmptyStringArray
 } from "./chunk-I42VC5KR.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
 import {
   asOptionalPositiveFiniteNumber
 } from "./chunk-U6VC4MU4.js";
 import {
   asOptionalFiniteNumber
 } from "./chunk-WWC7I6TA.js";
-import {
-  asTrimmedString
-} from "./chunk-3EUW3WEO.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
 import {
   __toESM
-} from "./chunk-4VNS5WPM.js";
+} from "./chunk-U67V476Y.js";
 
 // packages/render/table/tableStore.ts
 var import_react = __toESM(require_react(), 1);
@@ -1506,11 +1513,11 @@ var ENTITY_DELETE_STRATEGIES = {
     await dispatch(deleteTable({ dbKey: key })).unwrap();
   },
   file: async (key, { thunkAPI }) => {
-    const { deleteFileAction } = await import("./deleteFile-7VQGLK2V.js");
+    const { deleteFileAction } = await import("./deleteFile-Q3YDB4ML.js");
     await deleteFileAction(key, thunkAPI);
   },
   image: async (key, { thunkAPI }) => {
-    const { deleteFileAction } = await import("./deleteFile-7VQGLK2V.js");
+    const { deleteFileAction } = await import("./deleteFile-Q3YDB4ML.js");
     await deleteFileAction(key, thunkAPI);
   },
   agent: async (key, { dispatch, userId, sourceServerOrigin }) => {
@@ -1605,8 +1612,110 @@ var deleteContentFromSpaceAction = async (input, thunkAPI) => {
   };
 };
 
+// packages/create/space/content/unlinkSpaceContentAction.ts
+var logger2 = createClientLogger("unlink-space-content");
+var resolveMembershipRole = (spaceId) => {
+  const normalized = normalizeSpaceId(spaceId);
+  const membership = getAllMemberSpaces().find(
+    (space) => normalizeSpaceId(space.spaceId) === normalized
+  );
+  return membership ? { role: membership.role } : null;
+};
+var unlinkSpaceContentAction = async (input, thunkAPI) => {
+  const { spaceId, contentKey, sourceServerOrigin } = input;
+  const { dispatch, getState } = thunkAPI;
+  const userId = selectIdentityUserId(getState()) ?? null;
+  if (!contentKey || typeof contentKey !== "string" || !contentKey.trim()) {
+    throw new Error("\u65E0\u6548\u7684\u5185\u5BB9 Key\u3002");
+  }
+  if (!spaceId || typeof spaceId !== "string" || !spaceId.trim()) {
+    throw new Error("\u65E0\u6548\u7684\u7A7A\u95F4 ID\u3002");
+  }
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceData = await dispatch(
+    read({ dbKey: spaceKey, preferredServerOrigin: sourceServerOrigin })
+  ).unwrap();
+  if (!spaceData) {
+    throw new Error(`\u65E0\u6CD5\u52A0\u8F7D\u7A7A\u95F4\u6570\u636E: ${spaceId}`);
+  }
+  checkSpaceMembership(spaceData, userId);
+  if (!canManageSpaceContent(spaceData, userId, resolveMembershipRole(spaceId))) {
+    throw new Error("\u5F53\u524D\u89D2\u8272\u4E0D\u80FD\u4ECE\u7A7A\u95F4\u79FB\u9664\u5185\u5BB9");
+  }
+  const result = {
+    spaceId,
+    contentKey,
+    updatedSpaceData: spaceData,
+    removed: false,
+    entitySpaceSync: "no-record"
+  };
+  if (spaceData.contents?.[contentKey]) {
+    let updatedSpaceData;
+    try {
+      updatedSpaceData = await dispatch(
+        patch({
+          dbKey: spaceKey,
+          changes: {
+            contents: { [contentKey]: null },
+            updatedAt: Date.now(),
+            ...localSpaceAuthorityPatchStamp(spaceData)
+          }
+        })
+      ).unwrap();
+    } catch (patchError) {
+      throw new Error(
+        `\u4ECE\u7A7A\u95F4\u79FB\u9664\u5F15\u7528\u5931\u8D25: ${patchError?.message || "\u672A\u77E5\u9519\u8BEF"}`
+      );
+    }
+    result.removed = true;
+    result.updatedSpaceData = updatedSpaceData;
+  }
+  const entityRead = await readContentRecordForSpaceSync(dispatch, contentKey);
+  if (entityRead.status === "unreadable") {
+    result.entitySpaceSync = "unreadable";
+    result.error = "\u5F15\u7528\u5DF2\u4ECE\u7A7A\u95F4\u79FB\u9664\uFF0C\u4F46\u65E0\u6CD5\u8BFB\u53D6\u5185\u5BB9\u8BB0\u5F55\uFF0C\u5F52\u5C5E\u7A7A\u95F4\u672A\u5BF9\u9F50\uFF08\u53EF\u91CD\u8BD5\uFF09";
+    notifyUserDataUpdated();
+    return result;
+  }
+  if (entityRead.status === "missing") {
+    result.entitySpaceSync = "no-record";
+    notifyUserDataUpdated();
+    return result;
+  }
+  const record = entityRead.record;
+  const ownerRaw = typeof record.userId === "string" ? record.userId : typeof record.ownerId === "string" ? record.ownerId : "";
+  const owner = ownerRaw.trim();
+  const ownsRecord = Boolean(owner) && (owner === userId || owner === "local");
+  if (!ownsRecord) {
+    result.entitySpaceSync = "skipped-not-owner";
+    notifyUserDataUpdated();
+    return result;
+  }
+  const currentSpaceId = typeof record.spaceId === "string" ? normalizeSpaceId(record.spaceId) : null;
+  if (currentSpaceId !== normalizeSpaceId(spaceId)) {
+    result.entitySpaceSync = "skipped-mismatch";
+    notifyUserDataUpdated();
+    return result;
+  }
+  try {
+    await dispatch(
+      patch({ dbKey: contentKey, changes: { spaceId: null } })
+    ).unwrap();
+    result.entitySpaceSync = "cleared";
+  } catch (entityPatchError) {
+    result.entitySpaceSync = "failed";
+    result.error = `\u5F15\u7528\u5DF2\u79FB\u9664\uFF0C\u4F46\u6E05\u7A7A\u5185\u5BB9\u5F52\u5C5E\u7A7A\u95F4\u5931\u8D25\uFF08\u53EF\u91CD\u8BD5\uFF09: ${entityPatchError?.message || "\u672A\u77E5\u9519\u8BEF"}`;
+    logger2.error(
+      { contentKey, spaceId, reason: entityPatchError?.message },
+      "Failed to clear content spaceId after unlink"
+    );
+  }
+  notifyUserDataUpdated();
+  return result;
+};
+
 // packages/create/space/content/moveContentAction.ts
-var logger2 = createClientLogger("move-content");
+var logger3 = createClientLogger("move-content");
 var moveContentAction = async (input, thunkAPI) => {
   const {
     contentKey,
@@ -1618,15 +1727,15 @@ var moveContentAction = async (input, thunkAPI) => {
   const state3 = getState();
   const userId = selectIdentityUserId(state3);
   const now = Date.now();
-  logger2.info({ ...input, userId }, "Initiating moveContentAction");
+  logger3.info({ ...input, userId }, "Initiating moveContentAction");
   if (sourceSpaceId === targetSpaceId) {
-    logger2.error("Source and target space IDs are the same.");
+    logger3.error("Source and target space IDs are the same.");
     throw new Error(
       "\u6E90\u7A7A\u95F4\u548C\u76EE\u6807\u7A7A\u95F4\u4E0D\u80FD\u76F8\u540C\u3002\u5982\u9700\u4FEE\u6539\u5206\u7C7B\uFF0C\u8BF7\u4F7F\u7528\u66F4\u65B0\u5206\u7C7B\u64CD\u4F5C\u3002"
     );
   }
   if (!contentKey || typeof contentKey !== "string" || contentKey.trim() === "") {
-    logger2.error("Invalid contentKey provided.");
+    logger3.error("Invalid contentKey provided.");
     throw new Error("\u65E0\u6548\u7684\u5185\u5BB9 Key\u3002");
   }
   let sourceSpaceData = null;
@@ -1634,11 +1743,15 @@ var moveContentAction = async (input, thunkAPI) => {
   let contentDataFromSource = null;
   let finalSourceData = null;
   let finalTargetData = null;
+  let contentSpaceSync = void 0;
+  let targetWritten = false;
+  let sourcePruned = false;
+  let resumedFromTarget = false;
   let overallError = void 0;
   try {
     const sourceSpaceKey = createSpaceKey.space(sourceSpaceId);
     const targetSpaceKey = createSpaceKey.space(targetSpaceId);
-    logger2.info(
+    logger3.info(
       { sourceSpaceKey, targetSpaceKey },
       "Reading source and target space data."
     );
@@ -1664,80 +1777,119 @@ var moveContentAction = async (input, thunkAPI) => {
       );
     }
     targetSpaceData = targetResult.value;
-    logger2.info("Checking permissions for source and target spaces.");
+    logger3.info("Checking permissions for source and target spaces.");
     checkSpaceMembership(sourceSpaceData, userId);
     checkSpaceMembership(targetSpaceData, userId);
-    if (!sourceSpaceData.contents || !sourceSpaceData.contents[contentKey]) {
-      logger2.error(
-        { contentKey, sourceSpaceId },
-        "Content key not found in source space contents."
-      );
+    const sourceSpaceKeyForWrite = createSpaceKey.space(sourceSpaceId);
+    const targetSpaceKeyForWrite = createSpaceKey.space(targetSpaceId);
+    const sourceHasLink = Boolean(sourceSpaceData.contents?.[contentKey]);
+    const targetHasLink = Boolean(targetSpaceData.contents?.[contentKey]);
+    if (!sourceHasLink && !targetHasLink) {
       throw new Error(
-        `\u5185\u5BB9 (${contentKey}) \u4E0D\u5728\u6E90\u7A7A\u95F4 (${sourceSpaceId}) \u4E2D\u3002`
+        `\u5185\u5BB9 (${contentKey}) \u65E2\u4E0D\u5728\u6E90\u7A7A\u95F4 (${sourceSpaceId}) \u4E5F\u4E0D\u5728\u76EE\u6807\u7A7A\u95F4 (${targetSpaceId}) \u4E2D\u3002`
       );
     }
-    contentDataFromSource = sourceSpaceData.contents[contentKey];
-    if (targetSpaceData.contents && targetSpaceData.contents[contentKey]) {
-      logger2.warn(
-        { contentKey, targetSpaceId },
-        "Content key already exists in target space. Overwriting."
+    contentDataFromSource = sourceSpaceData.contents?.[contentKey] ?? null;
+    resumedFromTarget = !sourceHasLink && targetHasLink;
+    if (resumedFromTarget) {
+      logger3.info(
+        { contentKey, sourceSpaceId, targetSpaceId },
+        "Source link already pruned and target link exists; resuming convergence (no overwrite)."
       );
     }
     let categoryIdForTargetStorage;
-    if (rawTargetCategoryId && rawTargetCategoryId !== "" && rawTargetCategoryId !== UNCATEGORIZED_ID) {
-      if (targetSpaceData.categories?.[rawTargetCategoryId]) {
-        categoryIdForTargetStorage = rawTargetCategoryId;
-      } else {
-        logger2.warn(
-          `Target category ${rawTargetCategoryId} not found in target space ${targetSpaceId}. Content will be uncategorized.`
+    if (!targetHasLink) {
+      if (rawTargetCategoryId && rawTargetCategoryId !== "" && rawTargetCategoryId !== UNCATEGORIZED_ID) {
+        if (targetSpaceData.categories?.[rawTargetCategoryId]) {
+          categoryIdForTargetStorage = rawTargetCategoryId;
+        } else {
+          logger3.warn(
+            `Target category ${rawTargetCategoryId} not found in target space ${targetSpaceId}. Content will be uncategorized.`
+          );
+          categoryIdForTargetStorage = void 0;
+        }
+      }
+    }
+    if (!targetHasLink) {
+      if (!contentDataFromSource) {
+        throw new Error(`\u5185\u5BB9 (${contentKey}) \u5728\u6E90\u7A7A\u95F4\u4E2D\u6CA1\u6709\u53EF\u8FC1\u79FB\u7684\u5F15\u7528\u6570\u636E\u3002`);
+      }
+      const contentReferenceForTarget = {
+        ...contentDataFromSource,
+        updatedAt: now
+      };
+      delete contentReferenceForTarget.categoryId;
+      if (categoryIdForTargetStorage !== void 0) {
+        contentReferenceForTarget.categoryId = categoryIdForTargetStorage;
+      }
+      try {
+        await dispatch(
+          patch({
+            dbKey: targetSpaceKeyForWrite,
+            changes: {
+              contents: { [contentKey]: contentReferenceForTarget },
+              updatedAt: now,
+              ...localSpaceAuthorityPatchStamp(targetSpaceData)
+            }
+          })
+        ).unwrap();
+      } catch (targetPatchError) {
+        throw new Error(
+          `\u76EE\u6807\u7A7A\u95F4\u5199\u5165\u5931\u8D25\uFF0C\u6E90\u7A7A\u95F4\u5F15\u7528\u5DF2\u4FDD\u7559\uFF08\u53EF\u91CD\u8BD5\uFF09: ${targetPatchError?.message || "\u672A\u77E5\u9519\u8BEF"}`
         );
-        categoryIdForTargetStorage = void 0;
       }
-    } else {
-      categoryIdForTargetStorage = void 0;
+      targetWritten = true;
+      logger3.info("Target reference written (target-first).");
     }
-    const contentReferenceForTarget = {
-      ...contentDataFromSource,
-      updatedAt: now
-    };
-    delete contentReferenceForTarget.categoryId;
-    if (categoryIdForTargetStorage !== void 0) {
-      contentReferenceForTarget.categoryId = categoryIdForTargetStorage;
+    try {
+      contentSpaceSync = await syncContentRecordSpaceId(
+        dispatch,
+        contentKey,
+        targetSpaceId,
+        "\u5185\u5BB9\u5DF2\u8FC1\u79FB\u5230\u76EE\u6807\u7A7A\u95F4\uFF0C\u4F46\u540C\u6B65\u5185\u5BB9\u8BB0\u5F55\u7684\u5F52\u5C5E\u7A7A\u95F4\u5931\u8D25",
+        {
+          actorUserId: userId,
+          targetSpaceIsDeviceLocal: isDeviceLocalSpaceBody(sourceSpaceData) || isDeviceLocalSpaceBody(targetSpaceData)
+        }
+      );
+    } catch (entitySyncError) {
+      throw new Error(
+        `${entitySyncError?.message || "\u540C\u6B65\u5185\u5BB9\u8BB0\u5F55\u5931\u8D25"}\uFF08\u76EE\u6807\u7A7A\u95F4\u5DF2\u5199\u5165\uFF0C\u6E90\u7A7A\u95F4\u5F15\u7528\u5DF2\u4FDD\u7559\uFF0C\u53EF\u91CD\u8BD5\uFF09`
+      );
     }
-    const sourcePatchChanges = {
-      contents: {
-        [contentKey]: null
-        // 从源移除引用 (null value in patch typically means delete key)
-      },
-      updatedAt: now,
-      ...localSpaceAuthorityPatchStamp(sourceSpaceData)
-    };
-    const targetPatchChanges = {
-      contents: {
-        [contentKey]: contentReferenceForTarget
-        // 向目标添加（或覆盖）引用
-      },
-      updatedAt: now,
-      ...localSpaceAuthorityPatchStamp(targetSpaceData)
-    };
-    logger2.info("Patching source and target space data.");
-    await Promise.all([
-      dispatch(
-        patch({ dbKey: sourceSpaceKey, changes: sourcePatchChanges })
-      ).unwrap(),
-      dispatch(
-        patch({ dbKey: targetSpaceKey, changes: targetPatchChanges })
-      ).unwrap()
-    ]);
-    logger2.info("Successfully patched both source and target spaces.");
+    if (contentSpaceSync === "unreadable") {
+      throw new Error(
+        "\u65E0\u6CD5\u8BFB\u53D6\u5185\u5BB9\u8BB0\u5F55\u786E\u8BA4\u5F52\u5C5E\u7A7A\u95F4\u540C\u6B65\uFF08\u76EE\u6807\u7A7A\u95F4\u5DF2\u5199\u5165\uFF0C\u6E90\u7A7A\u95F4\u5F15\u7528\u5DF2\u4FDD\u7559\uFF0C\u53EF\u91CD\u8BD5\uFF09"
+      );
+    }
+    if (sourceHasLink) {
+      try {
+        await dispatch(
+          patch({
+            dbKey: sourceSpaceKeyForWrite,
+            changes: {
+              contents: { [contentKey]: null },
+              updatedAt: now,
+              ...localSpaceAuthorityPatchStamp(sourceSpaceData)
+            }
+          })
+        ).unwrap();
+      } catch (sourcePatchError) {
+        throw new Error(
+          `\u5185\u5BB9\u5DF2\u5199\u5165\u76EE\u6807\u7A7A\u95F4\uFF0C\u4F46\u4ECE\u6E90\u7A7A\u95F4\u79FB\u9664\u5F15\u7528\u5931\u8D25\uFF08\u53EF\u91CD\u8BD5\uFF09: ${sourcePatchError?.message || "\u672A\u77E5\u9519\u8BEF"}`
+        );
+      }
+    }
+    sourcePruned = true;
+    logger3.info("Source reference pruned; move converged.");
   } catch (error) {
-    logger2.error(
+    logger3.error(
       { error: error.message, stack: error.stack },
       "Error during move content action execution."
     );
     overallError = error.message || "\u79FB\u52A8\u5185\u5BB9\u65F6\u53D1\u751F\u672A\u77E5\u9519\u8BEF";
   } finally {
-    logger2.info("Attempting to re-read final space data.");
+    logger3.info("Attempting to re-read final space data.");
     const sourceSpaceKey = createSpaceKey.space(sourceSpaceId);
     const targetSpaceKey = createSpaceKey.space(targetSpaceId);
     const [finalSourceResult, finalTargetResult] = await Promise.allSettled([
@@ -1751,7 +1903,7 @@ var moveContentAction = async (input, thunkAPI) => {
     if (finalSourceResult.status === "fulfilled") {
       finalSourceData = finalSourceResult.value;
     } else {
-      logger2.error(
+      logger3.error(
         { sourceSpaceId, reason: finalSourceResult.reason },
         "Failed to re-read final source space data."
       );
@@ -1759,24 +1911,33 @@ var moveContentAction = async (input, thunkAPI) => {
     if (finalTargetResult.status === "fulfilled") {
       finalTargetData = finalTargetResult.value;
     } else {
-      logger2.error(
+      logger3.error(
         { targetSpaceId, reason: finalTargetResult.reason },
         "Failed to re-read final target space data."
       );
     }
-    logger2.info(
+    logger3.info(
       {
         hasError: !!overallError,
         sourceReadSuccess: !!finalSourceData,
-        targetReadSuccess: !!finalTargetData
+        targetReadSuccess: !!finalTargetData,
+        targetWritten,
+        sourcePruned,
+        resumedFromTarget,
+        contentSpaceSync
       },
       "Move content action finished."
     );
+    notifyUserDataUpdated();
     const result = {
       sourceSpaceId,
       updatedSourceSpaceData: finalSourceData,
       targetSpaceId,
       updatedTargetSpaceData: finalTargetData,
+      contentSpaceSync,
+      targetWritten,
+      sourcePruned,
+      resumedFromTarget,
       error: overallError
       // 如果过程中有错误，则传递错误信息
     };
@@ -1784,62 +1945,6 @@ var moveContentAction = async (input, thunkAPI) => {
   }
 };
 
-// packages/create/space/content/spaceContentPatch.ts
-var notifyUserDataUpdated = () => {
-  if (typeof window !== "undefined" && typeof window.dispatchEvent === "function" && typeof window.Event === "function") {
-    window.dispatchEvent(new window.Event("nolo-user-data-updated"));
-  }
-};
-var loadSpaceContentOrThrow = async (dispatch, spaceId, contentKey, sourceServerOrigin) => {
-  if (!contentKey || typeof contentKey !== "string" || contentKey.trim() === "") {
-    throw new Error("Invalid contentKey provided.");
-  }
-  const spaceKey = createSpaceKey.space(spaceId);
-  let spaceData = null;
-  try {
-    spaceData = await dispatch(
-      read({ dbKey: spaceKey, preferredServerOrigin: sourceServerOrigin })
-    ).unwrap();
-  } catch (readError) {
-    throw new Error(`\u65E0\u6CD5\u52A0\u8F7D\u7A7A\u95F4\u6570\u636E: ${spaceId}`);
-  }
-  if (!spaceData) {
-    throw new Error("Space not found");
-  }
-  const content = spaceData.contents?.[contentKey];
-  if (!content) {
-    throw new Error("Content not found in space");
-  }
-  return { spaceKey, spaceData, content };
-};
-var patchIndividualContentRecord = async (dispatch, contentKey, changes, sourceServerOrigin, failMessagePrefix) => {
-  let hasIndividualRecord = false;
-  try {
-    const existing = await dispatch(
-      read({ dbKey: contentKey, preferredServerOrigin: sourceServerOrigin })
-    ).unwrap();
-    hasIndividualRecord = Boolean(existing);
-  } catch {
-    hasIndividualRecord = false;
-  }
-  if (hasIndividualRecord) {
-    try {
-      await dispatch(
-        patch({
-          dbKey: contentKey,
-          changes,
-          preferredServerOrigin: sourceServerOrigin
-        })
-      ).unwrap();
-      notifyUserDataUpdated();
-    } catch (contentPatchError) {
-      throw new Error(
-        `${failMessagePrefix}: ${contentPatchError?.message || "\u672A\u77E5\u9519\u8BEF"}`
-      );
-    }
-  }
-};
-
 // packages/create/space/content/updateContentTitleAction.ts
 var buildContentRecordTitleChanges = (content, title, updatedAt) => {
   const changes = { title, updatedAt };
@@ -2067,17 +2172,17 @@ var updateContentCategoryAction = async (input, thunkAPI) => {
 };
 
 // packages/create/space/content/deleteMultipleContentAction.ts
-var logger3 = createClientLogger("delete-multiple-content");
+var logger4 = createClientLogger("delete-multiple-content");
 var deleteMultipleContentAction = async (input, thunkAPI) => {
   const { contentKeys, spaceId } = input;
   if (!contentKeys || contentKeys.length === 0) {
-    logger3.warn("deleteMultipleContentAction called with no contentKeys.");
+    logger4.warn("deleteMultipleContentAction called with no contentKeys.");
     return { spaceId, updatedSpaceData: null };
   }
   const { dispatch, getState } = thunkAPI;
   const state3 = getState();
   const userId = selectIdentityUserId(state3);
-  logger3.info(
+  logger4.info(
     { count: contentKeys.length, spaceId, userId },
     "Initiating deleteMultipleContentAction"
   );
@@ -2088,11 +2193,11 @@ var deleteMultipleContentAction = async (input, thunkAPI) => {
     })
   ).unwrap();
   if (!spaceData) {
-    logger3.error({ spaceKey }, "Space data not found for batch delete");
+    logger4.error({ spaceKey }, "Space data not found for batch delete");
     throw new Error("\u7A7A\u95F4\u4E0D\u5B58\u5728");
   }
   if (!userId || !spaceData.members.includes(userId)) {
-    logger3.warn({ userId, spaceId }, "Unauthorized attempt for batch delete");
+    logger4.warn({ userId, spaceId }, "Unauthorized attempt for batch delete");
     throw new Error("\u65E0\u6743\u4FEE\u6539\u6B64\u7A7A\u95F4");
   }
   const changes = {
@@ -2106,12 +2211,12 @@ var deleteMultipleContentAction = async (input, thunkAPI) => {
   };
   try {
     await dispatch(patch({ dbKey: spaceKey, changes })).unwrap();
-    logger3.info(
+    logger4.info(
       { spaceKey, count: contentKeys.length },
       "Successfully batched patch to remove content references"
     );
   } catch (patchError) {
-    logger3.error(
+    logger4.error(
       { error: patchError, spaceKey },
       "Failed to batch patch space data. Aborting."
     );
@@ -2123,9 +2228,9 @@ var deleteMultipleContentAction = async (input, thunkAPI) => {
   const results = await Promise.allSettled(removePromises);
   results.forEach((result, index) => {
     if (result.status === "fulfilled") {
-      logger3.info({ contentKey: contentKeys[index] }, "Entity removed");
+      logger4.info({ contentKey: contentKeys[index] }, "Entity removed");
     } else {
-      logger3.error(
+      logger4.error(
         { contentKey: contentKeys[index], error: result.reason },
         "Failed to remove an entity"
       );
@@ -2136,7 +2241,7 @@ var deleteMultipleContentAction = async (input, thunkAPI) => {
       dbKey: spaceKey
     })
   ).unwrap();
-  logger3.info({ spaceId }, "Finished batch delete and refetched space data.");
+  logger4.info({ spaceId }, "Finished batch delete and refetched space data.");
   return {
     spaceId,
     updatedSpaceData: finalSpaceData
@@ -2579,6 +2684,22 @@ var moveContentToSpace = createAsyncThunk(
     if (getCurrentSpaceIdRaw() === targetSpaceId && updatedTargetSpaceData) {
       updateCurrentSpaceIfMatch(targetSpaceId, updatedTargetSpaceData);
     }
+    if (payload.error) {
+      throw new Error(payload.error);
+    }
+    return payload;
+  }
+);
+var unlinkSpaceContent = createAsyncThunk(
+  "space/unlinkSpaceContent",
+  async (arg, thunkAPI) => {
+    const payload = await unlinkSpaceContentAction(arg, thunkAPI);
+    if (payload.updatedSpaceData && getCurrentSpaceIdRaw() === payload.spaceId) {
+      updateCurrentSpaceIfMatch(payload.spaceId, payload.updatedSpaceData);
+    }
+    if (payload.error) {
+      throw new Error(payload.error);
+    }
     return payload;
   }
 );
@@ -2687,6 +2808,7 @@ export {
   expandCategoryInCollapsed,
   addContentToSpace,
   moveContentToSpace,
+  unlinkSpaceContent,
   deleteContentFromSpace,
   deleteMultipleContent,
   uploadAndAddFileToSpace,