@im-nobsidian/core 0.20.0 → 0.21.0

package/dist/index.js

@@ -15184,12 +15184,56 @@ function folderFilesOf(markdown, namedOnly) {
   for (const span of notionMediaSpans(rest)) {
     if (!/^https?:\/\//.test(span.url)) return null;
     const name = uploadedFileNameFromUrl(span.url);
-    if (!name || namedOnly && unescapeCaption(span.label) !== name) return null;
+    if (!name) return null;
+    if (namedOnly && unescapeCaption(span.label) !== name && !isMarkedCaption(span.label, name)) {
+      return null;
+    }
     rest = rest.replace(span.full, "");
     files.push({ url: span.url, name });
   }
   return files.length > 0 && rest.trim() === "" ? files : null;
 }
+var FOLDER_FILE_MARK = "\u{1F4C1}";
+function folderFileCaption(name) {
+  return `${FOLDER_FILE_MARK} ${name}`;
+}
+function isMarkedCaption(label, name) {
+  return unescapeCaption(label) === folderFileCaption(name);
+}
+var FENCE_RE = /^(`{3,}|~{3,})/;
+function folderFilesInNote(markdown, options = {}) {
+  const all = markdown.split("\n");
+  const drop = /* @__PURE__ */ new Set();
+  const files = [];
+  const lines = [];
+  let fence = null;
+  all.forEach((line, i) => {
+    const opener = FENCE_RE.exec(line)?.[1];
+    if (opener !== void 0 && (fence === null || opener.startsWith(fence))) {
+      fence = fence === null ? opener : null;
+      return;
+    }
+    if (fence !== null) return;
+    const full = line.trimEnd();
+    const [span, ...more] = notionMediaSpans(full);
+    if (!span || more.length > 0 || span.full !== full || !/^https?:\/\//.test(span.url)) return;
+    const name = uploadedFileNameFromUrl(span.url);
+    if (!name) return;
+    const fileId = notionFileIdOf(span.url);
+    const marked = isMarkedCaption(span.label, name) || fileId !== null && options.knownIds?.has(fileId) === true;
+    const file = { url: span.url, name };
+    if (!marked || options.exclude?.(file)) return;
+    drop.add(i);
+    files.push(file);
+    lines.push(full);
+  });
+  if (files.length === 0) return null;
+  return {
+    markdown: all.filter((_, i) => !drop.has(i)).join("\n"),
+    files,
+    lines
+  };
+}
 var WIKI_EMBED_RE = /!\[\[([^\]|#^\n]+)/g;
 var MD_EMBED_RE = /!\[[^\]\n]*\]\(<?([^)>\s]+)/g;
 var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
@@ -15217,8 +15261,8 @@ function embeddedNamesOf(notes) {
 function keyOf3(pageId) {
   return `folder_files:${compactNotionId(pageId)}`;
 }
-function folderFileIdsOf(stateDb, pageId) {
-  const raw = stateDb.getMeta(keyOf3(pageId));
+function readPathMap(stateDb, key) {
+  const raw = stateDb.getMeta(key);
   if (!raw) return /* @__PURE__ */ new Map();
   try {
     return new Map(Object.entries(JSON.parse(raw)));
@@ -15226,16 +15270,39 @@ function folderFileIdsOf(stateDb, pageId) {
     return /* @__PURE__ */ new Map();
   }
 }
+function writePathMap(stateDb, key, map) {
+  stateDb.setMeta(key, JSON.stringify(Object.fromEntries(map)));
+}
+function folderFileIdsOf(stateDb, pageId) {
+  return readPathMap(stateDb, keyOf3(pageId));
+}
 function forgetFolderFileId(stateDb, pageId, localPath) {
+  rememberFolderFileStamp(stateDb, pageId, localPath, null);
   const ids = folderFileIdsOf(stateDb, pageId);
   if (!ids.delete(localPath)) return;
-  stateDb.setMeta(keyOf3(pageId), JSON.stringify(Object.fromEntries(ids)));
+  writePathMap(stateDb, keyOf3(pageId), ids);
 }
 function rememberFolderFileId(stateDb, pageId, localPath, fileId) {
   const ids = folderFileIdsOf(stateDb, pageId);
   if (ids.get(localPath) === fileId) return;
   ids.set(localPath, fileId);
-  stateDb.setMeta(keyOf3(pageId), JSON.stringify(Object.fromEntries(ids)));
+  writePathMap(stateDb, keyOf3(pageId), ids);
+}
+function fileStampOf(file) {
+  return `${file.size}:${file.mtime}`;
+}
+function stampKeyOf(pageId) {
+  return `folder_file_stamps:${compactNotionId(pageId)}`;
+}
+function folderFileStampsOf(stateDb, pageId) {
+  return readPathMap(stateDb, stampKeyOf(pageId));
+}
+function rememberFolderFileStamp(stateDb, pageId, localPath, stamp) {
+  const stamps = folderFileStampsOf(stateDb, pageId);
+  if ((stamps.get(localPath) ?? null) === stamp) return;
+  if (stamp === null) stamps.delete(localPath);
+  else stamps.set(localPath, stamp);
+  writePathMap(stateDb, stampKeyOf(pageId), stamps);
 }
 
 // src/sync/file-handler.ts
@@ -15246,6 +15313,12 @@ function getFolderPath(filePath) {
   const parts = filePath.split("/");
   return parts.length > 1 ? parts.slice(0, -1).join("/") : "";
 }
+function filesFolderOfNote(record) {
+  if (record.fileType === "folder-note" && isFolderNotePath(record.obsidianPath)) {
+    return getFolderPath(record.obsidianPath);
+  }
+  return record.fileType === "file" ? stripMarkdownExtension(record.obsidianPath) : null;
+}
 var LOGGED_NAMES = 5;
 var FileHandler = class {
   constructor(vaultFs, notionClient, stateDb, concurrency = DEFAULT_CONFIG.advanced.fileConcurrency, options) {
@@ -15325,21 +15398,55 @@ var FileHandler = class {
       this.sema.release();
     }
   }
-  /** 올린 뒤 바뀌지 않았나 — 크기가 같으면 읽지 않는다. */
+  /**
+   * 올리거나 받은 뒤 바뀌지 않았나 — 그때의 표(크기 · 수정 시각, {@link fileStampOf})와 같으면 읽지 않는다. 크기가 다르면 바뀌었다.
+   * 크기만 같으면 내용으로 견주고, 같으면 지금 표를 적어 다음에는 읽지 않는다. 예전에는 크기가 같으면 바뀌지 않았다고 봐, 같은
+   * 크기로 고친 파일을 올리지 않았다.
+   */
   async isUnchanged(existing, file) {
-    if (existing.fileSize === file.size) return true;
+    const stamp = fileStampOf(file);
+    if (folderFileStampsOf(this.stateDb, existing.notionPageId).get(file.path) === stamp) {
+      return true;
+    }
+    if (existing.fileSize !== file.size) return false;
     const buffer = await this.vaultFs.readBinary(file.path);
-    return existing.fileHash === createHash("sha256").update(buffer).digest("hex");
+    const same = existing.fileHash === createHash("sha256").update(buffer).digest("hex");
+    if (same) rememberFolderFileStamp(this.stateDb, existing.notionPageId, file.path, stamp);
+    return same;
   }
   /** pull 이 받은 것을 두는 폴더 안인가. */
   inAttachmentsFolder(path) {
     return this.attachmentsFolder !== "" && path.startsWith(`${this.attachmentsFolder}/`);
   }
-  /** 폴더 첨부를 둘 Notion 페이지 — 폴더 노트 없는 폴더의 페이지(폴더 레코드)만. 맨 위는 루트 기록이 있을 때만. */
+  /**
+   * 폴더 첨부를 둘 Notion 페이지 — 그 폴더의 Notion 자리({@link folderContainer} 와 같은 차례). 폴더 노트(`X/X.md`)나 노트
+   * 이름의 폴더(`X.md` 옆 `X/`)면 그 노트의 페이지 끝(ADR-056), 아니면 push 가 만든 폴더 페이지. 맨 위는 루트 기록이 있을 때만.
+   * 행 · DB 폴더는 둘 곳이 없다 — 행의 본문은 행의 것이다.
+   */
   folderPageOf(folder) {
-    const record = this.stateDb.getByPath(folder || "__root__");
-    if (!record?.notionPageId) return null;
-    return folder === "" || isFolderRecord(record) ? record.notionPageId : null;
+    if (folder === "") return this.stateDb.getByPath("__root__")?.notionPageId ?? null;
+    return this.notePageOf(folder) ?? this.folderRecordPageOf(folder);
+  }
+  /** 이 폴더를 품은 노트의 페이지 — 폴더 노트 · 노트 이름의 폴더. 없거나 행이면 null. */
+  notePageOf(folder) {
+    const note = this.stateDb.getByPath(folderNoteOf(folder));
+    if (note?.notionPageId && note.fileType === "folder-note") return note.notionPageId;
+    const named = this.stateDb.getByPath(`${folder}.md`);
+    return named?.notionPageId && named.fileType === "file" ? named.notionPageId : null;
+  }
+  folderRecordPageOf(folder) {
+    const record = this.stateDb.getByPath(folder);
+    return record?.notionPageId && isFolderRecord(record) ? record.notionPageId : null;
+  }
+  /**
+   * 이 기록이 그 폴더의 폴더 첨부인가. 노트의 페이지에는 그 노트가 임베드해 올린 파일도 같은 페이지로 적혀 있다 — 폴더
+   * 첨부로 적어 둔 것({@link folderFileIdsOf})만이다.
+   */
+  isFolderFileEntry(entry, folder) {
+    const pageId = this.folderPageOf(folder);
+    if (!pageId || entry.notionPageId !== pageId) return false;
+    if (pageId !== this.notePageOf(folder)) return true;
+    return folderFileIdsOf(this.stateDb, pageId).has(entry.localPath);
   }
   /**
    * 업로드 후보 목록 — 도구 내부 산출물(`.base`/`.notion.json`)은 아예 빼고, Notion 이 받지 않는
@@ -15367,7 +15474,7 @@ var FileHandler = class {
    * @param failed 올리지 못한 첨부를 담을 곳 — push 결과의 `failed` 를 넘기면 CLI · 플러그인이 처리하지 못한 것으로
    *   보인다. 예전엔 경고 로그로만 남아 push 가 「실패 0」 으로 끝났다.
    */
-  async pushAllFiles(failed, folders) {
+  async pushAllFiles(failed, folders, noteWrites) {
     const { uploadable: allFiles, unsupported: unsupported2 } = await this.listUploadableFiles();
     if (unsupported2.length > 0) {
       const names = unsupported2.slice(0, LOGGED_NAMES).map((f) => f.path);
@@ -15376,13 +15483,13 @@ var FileHandler = class {
         `[Im-Nobsidian] Notion \uC774 \uBC1B\uC9C0 \uC54A\uB294 \uD615\uC2DD\uC774\uB77C \uC62C\uB9AC\uC9C0 \uC54A\uC740 \uCCA8\uBD80 ${unsupported2.length}\uAC1C: ${names.join(", ")}${rest > 0 ? ` \uC678 ${rest}\uAC1C` : ""}`
       );
     }
-    if (this.deleteSync) await this.removeDeletedFolderFiles();
+    if (this.deleteSync) await this.removeDeletedFolderFiles(noteWrites);
     const pending = [];
     for (const file of allFiles) {
       if (this.inAttachmentsFolder(file.path) || isHiddenPath(file.path)) continue;
       const existing = this.stateDb.getFileRegistry(file.path);
       if (existing) {
-        if (existing.notionPageId !== this.folderPageOf(getFolderPath(file.path))) continue;
+        if (!this.isFolderFileEntry(existing, getFolderPath(file.path))) continue;
         if (await this.isUnchanged(existing, file)) continue;
       }
       pending.push({ file, existing });
@@ -15404,10 +15511,23 @@ var FileHandler = class {
     for (const [folder, items] of byFolder) {
       const pageId = await this.provideFolderPage(folder, folders, items, stranded);
       if (!pageId) continue;
-      for (const { file, existing } of items) {
-        const result = await this.pushSingleFile(file, pageId, existing, failed);
-        if (result) results.push(result);
-      }
+      await this.writingNotePage(
+        pageId === this.notePageOf(folder),
+        pageId,
+        noteWrites,
+        async () => {
+          for (const { file, existing } of items) {
+            let previous = existing;
+            if (!previous) {
+              const moved = await this.movedHere(file, pageId);
+              if (moved?.same) continue;
+              previous = moved?.entry ?? null;
+            }
+            const result = await this.pushSingleFile(file, pageId, previous, failed);
+            if (result) results.push(result);
+          }
+        }
+      );
     }
     this.reportStranded(stranded);
     return results;
@@ -15416,25 +15536,37 @@ var FileHandler = class {
    * 볼트에서 지운 폴더 첨부를 Notion 에서도 지운다(deleteSync) — 폴더 페이지에 적힌 파일 가운데 볼트에 없는 것의 블록과 기록.
    * 포함 · 제외 패턴으로 빠진 파일은 볼트에 있어 지우지 않는다.
    */
-  async removeDeletedFolderFiles() {
+  async removeDeletedFolderFiles(noteWrites) {
     const removed = [];
     for (const record of this.stateDb.getAll()) {
-      if (!record.notionPageId || !isFolderRecord(record)) continue;
+      if (!record.notionPageId) continue;
+      const folder = isFolderRecord(record) ? record.obsidianPath : filesFolderOfNote(record);
+      if (folder === null) continue;
+      const ids = folderFileIdsOf(this.stateDb, record.notionPageId);
+      if (!isFolderRecord(record) && ids.size === 0) continue;
+      const gone = [];
       for (const entry of this.stateDb.getFilesByPageId(record.notionPageId)) {
-        if (getFolderPath(entry.localPath) !== record.obsidianPath) continue;
-        if (await this.vaultFs.exists(entry.localPath)) continue;
-        try {
-          const name = entry.localPath.slice(entry.localPath.lastIndexOf("/") + 1);
-          await this.removeOlderBlocks(record.notionPageId, name, void 0);
-          this.stateDb.deleteFileRegistry(entry.localPath);
-          forgetFolderFileId(this.stateDb, record.notionPageId, entry.localPath);
-          removed.push(entry.localPath);
-        } catch (error) {
-          getLogger().warn(
-            `[Im-Nobsidian] \uBCFC\uD2B8\uC5D0\uC11C \uC9C0\uC6B4 \uD3F4\uB354 \uCCA8\uBD80\uB97C Notion \uC5D0\uC11C \uC9C0\uC6B0\uC9C0 \uBABB\uD568 (${entry.localPath}): ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
+        if (getFolderPath(entry.localPath) !== folder) continue;
+        if (!isFolderRecord(record) && !ids.has(entry.localPath)) continue;
+        if (!await this.vaultFs.exists(entry.localPath)) gone.push(entry);
       }
+      if (gone.length === 0) continue;
+      const pageId = record.notionPageId;
+      await this.writingNotePage(!isFolderRecord(record), pageId, noteWrites, async () => {
+        for (const entry of gone) {
+          try {
+            const name = entry.localPath.slice(entry.localPath.lastIndexOf("/") + 1);
+            await this.removeOlderBlocks(pageId, entry.localPath, name, void 0);
+            this.stateDb.deleteFileRegistry(entry.localPath);
+            forgetFolderFileId(this.stateDb, pageId, entry.localPath);
+            removed.push(entry.localPath);
+          } catch (error) {
+            getLogger().warn(
+              `[Im-Nobsidian] \uBCFC\uD2B8\uC5D0\uC11C \uC9C0\uC6B4 \uD3F4\uB354 \uCCA8\uBD80\uB97C Notion \uC5D0\uC11C \uC9C0\uC6B0\uC9C0 \uBABB\uD568 (${entry.localPath}): ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+        }
+      });
     }
     if (removed.length > 0) {
       getLogger().info(
@@ -15442,10 +15574,20 @@ var FileHandler = class {
       );
     }
   }
+  /** 노트의 페이지에 쓰는 동안을 알린다({@link NotePageWrites}) — 폴더 페이지는 노트가 없어 알릴 것이 없다. */
+  async writingNotePage(isNotePage, pageId, noteWrites, write) {
+    if (!isNotePage || !noteWrites) return write();
+    await noteWrites.begin(pageId);
+    try {
+      await write();
+    } finally {
+      await noteWrites.end(pageId);
+    }
+  }
   /** 폴더 첨부를 둘 페이지 — 노트 없는 폴더면 마련한다. 둘 곳이 없으면 그 파일들을 `stranded` 에 담고 null. */
   async provideFolderPage(folder, folders, items, stranded) {
     let pageId = this.folderPageOf(folder);
-    let reason = folder === "" ? "\uBCFC\uD2B8 \uB9E8 \uC704" : "\uD3F4\uB354 \uB178\uD2B8\uAC00 \uC788\uB294 \uD3F4\uB354 \xB7 DB \uD3F4\uB354";
+    let reason = folder === "" ? "\uBCFC\uD2B8 \uB9E8 \uC704" : "DB \uD3F4\uB354 \xB7 \uC544\uC9C1 \uC62C\uB9AC\uC9C0 \uC54A\uC740 \uD3F4\uB354 \uB178\uD2B8";
     if (!pageId && folder !== "" && folders && !this.stateDb.getByPath(folder)) {
       try {
         await folders.ensureFolderPage(folder);
@@ -15594,6 +15736,8 @@ var FileHandler = class {
       fileHash: hash,
       fileSize: buffer.length
     });
+    const stat2 = await this.vaultFs.getFileStat(localPath);
+    if (stat2) rememberFolderFileStamp(this.stateDb, pageId, localPath, fileStampOf(stat2));
     return wrote;
   }
   async downloadFileBlock(url, filename, targetFolder) {
@@ -15635,7 +15779,9 @@ var FileHandler = class {
     const fileUploadId = await this.notionClient.uploadFile(blob, filename, contentType);
     const block = this.createFileBlock(blockType, fileUploadId, filename);
     const [created] = await this.notionClient.appendChildBlocks(parentPageId, [block]);
-    if (previous) await this.removeOlderBlocks(parentPageId, filename, created?.id);
+    if (previous) {
+      await this.removeOlderBlocks(parentPageId, file.path, filename, created?.id);
+    }
     const url = created ? fileUrlOfBlock(created) : null;
     const fileId = url ? notionFileIdOf(url) : null;
     if (fileId) rememberFolderFileId(this.stateDb, parentPageId, file.path, fileId);
@@ -15647,28 +15793,78 @@ var FileHandler = class {
       fileHash: hash,
       fileSize: file.size
     });
+    rememberFolderFileStamp(this.stateDb, parentPageId, file.path, fileStampOf(file));
     getLogger().info(`\uD30C\uC77C \uC5C5\uB85C\uB4DC \uC644\uB8CC: ${file.path} \u2192 ${blockType} \uBE14\uB85D`);
     return { localPath: file.path, fileUploadId, blockType };
   }
-  /** 이 페이지에서 같은 이름의 파일 블록 중 방금 붙인 것 말고를 지운다. */
-  async removeOlderBlocks(pageId, name, keep) {
+  /**
+   * 처음 보는 파일이 이 페이지에 적어 둔 같은 이름의 폴더 첨부를 옮긴 것인가 — 그 기록의 경로가 볼트에서 사라졌으면 옮겼다(폴더 ·
+   * 폴더 노트 · 노트의 이름 바꾸기). 기록 · 파일 id · 표를 새 경로로 옮긴다. `same` 이면 내용이 같아 올리지 않는다. 다르면 옮긴
+   * 기록을 옛 것으로 올려 옛 블록을 지운다. 예전에는 새 파일로 올려 노트 페이지에 같은 파일의 블록이 둘 남았다.
+   */
+  async movedHere(file, pageId) {
+    const name = file.path.slice(file.path.lastIndexOf("/") + 1);
+    const record = this.stateDb.getByNotionId(pageId);
+    const ids = folderFileIdsOf(this.stateDb, pageId);
+    for (const entry of this.stateDb.getFilesByPageId(pageId)) {
+      if (entry.localPath === file.path) continue;
+      if (entry.localPath.slice(entry.localPath.lastIndexOf("/") + 1) !== name) continue;
+      if (record && !isFolderRecord(record) && !ids.has(entry.localPath)) continue;
+      if (await this.vaultFs.exists(entry.localPath)) continue;
+      const buffer = await this.vaultFs.readBinary(file.path);
+      const same = entry.fileSize === file.size && entry.fileHash === createHash("sha256").update(buffer).digest("hex");
+      const fileId = ids.get(entry.localPath);
+      this.stateDb.deleteFileRegistry(entry.localPath);
+      forgetFolderFileId(this.stateDb, pageId, entry.localPath);
+      this.stateDb.registerFile({
+        localPath: file.path,
+        notionPageId: pageId,
+        fileUploadId: entry.fileUploadId,
+        fileType: entry.fileType,
+        fileHash: entry.fileHash,
+        fileSize: entry.fileSize
+      });
+      if (fileId) rememberFolderFileId(this.stateDb, pageId, file.path, fileId);
+      if (same) rememberFolderFileStamp(this.stateDb, pageId, file.path, fileStampOf(file));
+      return { entry: { ...entry, localPath: file.path }, same };
+    }
+    return null;
+  }
+  /**
+   * 이 페이지에서 그 폴더 첨부의 블록 중 방금 붙인 것(`keep`) 말고를 지운다. 폴더 페이지는 같은 이름의 파일 블록 모두(id 를
+   * 적기 전에 올린 블록도). 노트의 페이지는 노트가 임베드한 같은 이름의 파일이 있을 수 있어, 적어 둔 Notion 파일 id 의 블록과
+   * 표시를 단 캡션({@link folderFileCaption})의 블록만 — 다른 볼트가 같은 파일을 먼저 고쳐 올린 블록은 id 를 모르지만 표시가 있다.
+   * 예전에는 id 로만 지워, 두 볼트가 따로 고쳐 올리면 블록이 둘 남았다.
+   */
+  async removeOlderBlocks(pageId, localPath, name, keep) {
+    const record = this.stateDb.getByNotionId(pageId);
+    const onNote = record !== null && !isFolderRecord(record);
+    const fileId = folderFileIdsOf(this.stateDb, pageId).get(localPath);
     for (const block of await this.notionClient.fetchAllChildren(pageId)) {
       if (block.id === keep) continue;
       const media = block[block.type];
       const url = media?.type === "file" ? media.file?.url : void 0;
       if (!url || uploadedFileNameFromUrl(url) !== name) continue;
+      if (keep === void 0 && fileId !== void 0) {
+        if (notionFileIdOf(url) !== fileId) continue;
+      } else if (onNote) {
+        const caption = (media?.caption ?? []).map((part) => part.plain_text ?? "").join("");
+        const ours = fileId !== void 0 && notionFileIdOf(url) === fileId || caption === folderFileCaption(name);
+        if (!ours) continue;
+      }
       await this.notionClient.deleteBlock(block.id);
     }
   }
   /**
-   * 폴더 첨부의 파일 블록 — 캡션에 파일 이름을 적는다. 받는 쪽이 그 표시로 폴더 첨부를 알아본다({@link folderFilesOf}) —
-   * 자식 페이지가 없는 폴더 페이지는 PDF 하나만 붙인 노트와 모양이 같다.
+   * 폴더 첨부의 파일 블록 — 캡션에 표시를 단 파일 이름을 적는다({@link folderFileCaption}). 받는 쪽이 그 표시로 폴더 첨부를
+   * 알아본다 — 자식 페이지가 없는 폴더 페이지는 PDF 하나만 붙인 노트와 모양이 같고, 노트 페이지의 폴더 첨부는 그 노트의
+   * 임베드와 같은 블록이다.
    */
   createFileBlock(blockType, fileUploadId, name) {
     const fileRef = {
       type: "file_upload",
       file_upload: { id: fileUploadId },
-      caption: [{ type: "text", text: { content: name } }]
+      caption: [{ type: "text", text: { content: folderFileCaption(name) } }]
     };
     switch (blockType) {
       case "image":
@@ -19167,7 +19363,9 @@ var NoteRelocator = class {
     if (isFolderRecord(record)) return [record.obsidianPath];
     if (record.fileType === "folder-note") return [parentFolderOf(record.obsidianPath)];
     const children = stripMarkdownExtension(record.obsidianPath);
-    const hasChildren = this.stateDb.getAll().some((r) => within(r.obsidianPath, children));
+    const hasChildren = this.stateDb.getAll().some((r) => within(r.obsidianPath, children)) || record.notionPageId !== null && [...folderFileIdsOf(this.stateDb, record.notionPageId).keys()].some(
+      (path) => within(path, children)
+    );
     return hasChildren ? [record.obsidianPath, children] : [record.obsidianPath];
   }
   /** 옮기지 못할 까닭 — 없으면 null. */
@@ -19400,7 +19598,7 @@ async function notionBodyToObsidian(client, markdown, pageId) {
   const bookmarks = bookmarkIds.length > 0 ? await client.getBookmarks(bookmarkIds) : void 0;
   return notionEnhancedToObsidian(markdown, { userNames, codeTexts, bookmarks });
 }
-async function pageBlocksToObsidian(client, pageId) {
+async function pageBlocksToObsidian(client, pageId, bodyOf5 = (markdown) => markdown) {
   const tree = await client.getBlockTree(pageId);
   const markdown = blocksToNfm(tree, { pageId });
   const content = await notionBodyToObsidian(
@@ -19409,7 +19607,7 @@ async function pageBlocksToObsidian(client, pageId) {
       getCodeBlockTexts: () => Promise.resolve(blocksOfType(tree, "code").map(plainTextOf)),
       getBookmarks: () => Promise.resolve(bookmarksOf(tree))
     },
-    markdown,
+    bodyOf5(markdown),
     pageId
   );
   return { markdown, content };
@@ -23492,6 +23690,7 @@ function dropEmbeddedBaseMarkers(content, basePaths) {
 
 // src/sync/database-discovery.ts
 var DISCOVERY_RETRY_META_KEY = "discovery_retry";
+var PREVIEW_BODY_READ_BUDGET = 100;
 function parseDiscoveryRetry(raw) {
   if (!raw) return { parents: [], dbs: [] };
   try {
@@ -23889,6 +24088,27 @@ var DatabaseDiscovery = class {
       )
     };
   }
+  /**
+   * dry-run — 새로 받을 페이지의 본문을 읽어 그 안의 DB 를 찾는다({@link plannedNewDatabases} 가 그 행을 센다). 실제 pull 은
+   * 받으며 찾는다. 예전에는 읽지 않고 «미리 세지 않았습니다» 만 알렸다. {@link PREVIEW_BODY_READ_BUDGET} 개까지만 읽는다 —
+   * 넘거나 읽지 못한(다 받지 못한) 페이지는 {@link bodyRead} 가 아니어서 알림으로 남는다.
+   */
+  async readNewPageBodies(pageIds, signal) {
+    if (isDatabaseMode(this.config)) return;
+    const unread = pageIds.filter((pageId) => !this.bodyRead(pageId));
+    for (const pageId of unread.slice(0, PREVIEW_BODY_READ_BUDGET)) {
+      if (signal?.aborted) return;
+      try {
+        const result = await this.notionClient.getPageMarkdown(pageId);
+        if (result.truncated || (result.unknown_block_ids ?? []).length > 0) continue;
+        this.collectInlineDbRefs(pageId, result.markdown);
+      } catch (error) {
+        getLogger().debug(
+          `[Im-Nobsidian] \uBBF8\uB9AC \uBCF4\uAE30: \uC0C8 \uD398\uC774\uC9C0 \uBCF8\uBB38\uC744 \uC77D\uC9C0 \uBABB\uD574 \uC548\uC758 DB \uB294 \uBC1B\uC73C\uBA70 \uCC3E\uC74C (${pageId}): ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
   /** 이번 pull 에서 본문을 받은 페이지인가 — 그 본문의 `<database>` 로 새 DB 를 찾았다. */
   bodyRead(pageId) {
     return this._bodyReadPages.has(normalizeNotionId(pageId));
@@ -24725,7 +24945,14 @@ var LocalPlanner = class {
         live.add(target);
       }
     }
-    const pairs = scan.adoptions.map((a) => ({ from: a.record.obsidianPath, to: a.to }));
+    const filePairs = await this.movedFolderFilePairs(
+      [...folderRecords].filter((folder) => !live.has(folder))
+    );
+    for (const { to } of filePairs) for (const folder of foldersOf([to])) live.add(folder);
+    const pairs = [
+      ...scan.adoptions.map((a) => ({ from: a.record.obsidianPath, to: a.to })),
+      ...filePairs
+    ];
     const folderMoves = [];
     const databaseFolderMoves = [];
     for (const move of deriveFolderMoves(tracked, live, pairs, hints)) {
@@ -24734,6 +24961,29 @@ var LocalPlanner = class {
     }
     return { folderMoves, databaseFolderMoves };
   }
+  /**
+   * 사라진 폴더 페이지에 올린 폴더 첨부의 짝 — 노트 없이 파일만 든 폴더는 노트의 짝이 없어 이름을 바꿔도 옮긴 줄 몰랐다. 그
+   * 폴더 페이지에 올린 파일과 이름 · 크기가 같은 파일이 볼트에 하나뿐이면 그리로 옮겼다. 예전에는 새 폴더 페이지를 만들어 다시
+   * 올렸고, 삭제 동기화가 꺼져 있으면 옛 폴더 페이지가 남아 다른 볼트가 두 폴더를 받았다.
+   */
+  async movedFolderFilePairs(missing) {
+    const entries = missing.flatMap((folder) => {
+      const pageId = this.stateDb.getByPath(folder)?.notionPageId;
+      if (!pageId) return [];
+      return this.stateDb.getFilesByPageId(pageId).filter((entry) => entry.localPath.startsWith(`${folder}/`));
+    });
+    if (entries.length === 0) return [];
+    const files = await this.vaultFs.listNonMarkdownFiles();
+    const nameOf = (path) => path.slice(path.lastIndexOf("/") + 1);
+    const pairs = [];
+    for (const entry of entries) {
+      const found2 = files.filter(
+        (file) => nameOf(file.path) === nameOf(entry.localPath) && file.size === entry.fileSize
+      );
+      if (found2.length === 1) pairs.push({ from: entry.localPath, to: found2[0].path });
+    }
+    return pairs;
+  }
   /** 레코드를 새 경로로 옮겨 적는다 — 이동 WAL · 위키링크 · 보존 마커도 함께. */
   moveRecord(record, to) {
     const from = record.obsidianPath;
@@ -27355,11 +27605,14 @@ var PagePusher = class {
   async pushUpdatePage(pageId, markdownContent, notePath) {
     if (this.config.conversion.preferMarkdownApi !== false) {
       const deferred = deferSyncedReferences(obsidianToNotionEnhanced(markdownContent));
-      const { markdown, kept } = await this.imageHandler.keepUploadedMedia(
+      const { markdown: body, kept } = await this.imageHandler.keepUploadedMedia(
         pageId,
         deferred.nfm,
         notePath
       );
+      const folderFiles = await this.folderFileLines(pageId);
+      const markdown = folderFiles ? `${body}
+${folderFiles}` : body;
       const written = await replacePageBody(this.notionClient, pageId, markdown, {
         databaseIdsOfBase: (basePath) => this.databaseIdsOfBase(basePath),
         unknownTagFallbacks: unknownTagFallbacks(markdownContent)
@@ -27379,6 +27632,7 @@ var PagePusher = class {
         "\uC790\uC2DD \uD398\uC774\uC9C0 \xB7 DB \uAC00 \uC788\uB294 \uD398\uC774\uC9C0\uB294 \uBE14\uB85D \uBC29\uC2DD\uC73C\uB85C \uBCF8\uBB38\uC744 \uBCF4\uB0B4\uBA74 \uC790\uC2DD\uAE4C\uC9C0 \uC9C0\uC6CC\uC838 \uBCF4\uB0B4\uC9C0 \uC54A\uC74C \u2014 \uC124\uC815 conversion.preferMarkdownApi \uB97C \uAE30\uBCF8\uAC12(true)\uC73C\uB85C \uB450\uACE0 \uB2E4\uC2DC push \uD558\uC138\uC694"
       );
     }
+    this.forgetFolderFilesForBlockMode(pageId, notePath);
     const { nfm, blocks } = blockModeBody(markdownContent);
     if (blocks.length > 0) {
       await this.notionClient.appendBlockTree(pageId, blocks);
@@ -27396,6 +27650,32 @@ var PagePusher = class {
     );
     return { fingerprint: null, kept: [], sent: nfm, syncedRefs: [], syncedRefText: "" };
   }
+  /**
+   * 노트 페이지의 폴더 첨부 줄(ADR-056) — 본문을 통째로 바꿀 때 받은 줄 그대로 끝에 되실어야 Notion 이 그 블록을 둔다
+   * ({@link ImageHandler.keepUploadedMedia} 와 같은 실측). 이 페이지에 적어 둔 폴더 첨부가 없으면 읽지 않는다. 읽지 못하면
+   * 던진다 — 모르고 바꾸면 폴더 첨부가 지워진다.
+   */
+  async folderFileLines(pageId) {
+    const ids = new Set(folderFileIdsOf(this.stateDb, pageId).values());
+    if (ids.size === 0) return "";
+    const remote = (await this.notionClient.getPageMarkdown(pageId)).markdown;
+    return (folderFilesInNote(remote, { knownIds: ids })?.lines ?? []).join("\n");
+  }
+  /**
+   * 블록 방식은 본문 블록을 모두 지우고 새로 붙인다 — 폴더 첨부 블록을 남기면 새 본문이 그 뒤에 붙는다.
+   * 함께 지우고 기록을 놓는다 — 이어지는 첨부 push 가 볼트의 파일을 다시 끝에 올린다.
+   */
+  forgetFolderFilesForBlockMode(pageId, notePath) {
+    const ids = folderFileIdsOf(this.stateDb, pageId);
+    if (ids.size === 0) return;
+    for (const localPath of ids.keys()) {
+      this.stateDb.deleteFileRegistry(localPath);
+      forgetFolderFileId(this.stateDb, pageId, localPath);
+    }
+    getLogger().info(
+      `[Im-Nobsidian] \uBE14\uB85D \uBC29\uC2DD\uC73C\uB85C \uBCF8\uBB38\uC744 \uBC14\uAFD4 \uD3F4\uB354 \uCCA8\uBD80 ${ids.size}\uAC1C\uB97C \uB2E4\uC2DC \uC62C\uB9BC (${notePath})`
+    );
+  }
   /**
    * 자리표시로 보낸 코드를 채우고(S-22) 동기화 블록 참조를 붙인다({@link deferSyncedReferences}) — 본문을
    * 바꾼 뒤(블록 방식이면 옛 블록을 지운 뒤) 부른다.
@@ -27773,7 +28053,10 @@ var PagePuller = class {
       const local = await readLocalNote(this.vaultFs, filePath);
       rendered = await render2(filePath, local);
       const relinked = local === void 0 ? null : this.relinkExistingNote(filePath, claim.existing, local, rendered, note);
-      if (relinked) return relinked;
+      if (relinked) {
+        await this.receiveNoteFiles(filePath, fileType, pageId, fetched);
+        return relinked;
+      }
       this.claimedPaths.delete(pathKey(filePath));
       filePath = (await this.resolveUniqueFilePath(noteDir, safeName, pageId)).path;
       rendered = await render2(filePath);
@@ -27786,8 +28069,19 @@ var PagePuller = class {
       properties: rendered.properties,
       status: "synced"
     });
+    await this.receiveNoteFiles(filePath, fileType, pageId, fetched);
     return { path: filePath };
   }
+  /** 새로 받은 노트 페이지의 폴더 첨부를 그 노트의 폴더에 받는다(ADR-056) — 폴더 노트는 그 폴더, 노트는 이름의 폴더. */
+  async receiveNoteFiles(filePath, fileType, pageId, fetched) {
+    if (fetched.noteFiles.length === 0) return;
+    await this.receiveFolderFiles(
+      childFolderOf({ fileType, obsidianPath: filePath }, this.placement.folderLookup()),
+      pageId,
+      fetched.noteFiles,
+      fetched.noteFilesComplete
+    );
+  }
   /**
    * 상태 기록에 없는 노트가 이 페이지가 놓일 자리에 이미 있다 — 상태 DB 를 잃었거나 처음 잇는 볼트다(P7).
    * 예전에는 남의 노트로 보고 id 를 붙인 이름으로 또 받아 모든 노트가 두 벌이 됐다(push 는 모든 페이지를 또 만들었다).
@@ -27946,6 +28240,14 @@ var PagePuller = class {
     }
     const rendered = await this.renderRemotePage(record, change.pageId, page);
     const remoteContent = rendered.content;
+    if (rendered.folderFiles && !remoteGone) {
+      await this.receiveFolderFiles(
+        childFolderOf(record, this.placement.folderLookup()),
+        change.pageId,
+        rendered.folderFiles.files,
+        rendered.folderFiles.complete
+      );
+    }
     let localContent;
     let localExists = true;
     try {
@@ -28089,7 +28391,10 @@ var PagePuller = class {
     if (record.fileType === "db-row") {
       return this.databaseSyncer.renderRow(page, record.obsidianPath, { downloadMedia });
     }
-    const fetched = await this.fetchPageMarkdown(pageId);
+    const local = await readLocalNote(this.vaultFs, record.obsidianPath);
+    const fetched = await this.fetchPageMarkdown(pageId, {
+      embedded: embeddedNamesOf(local === void 0 ? [] : [local])
+    });
     const title = this.notionClient.extractTitle(page);
     const { content, properties } = await this.renderPageNote({
       pageId,
@@ -28100,11 +28405,17 @@ var PagePuller = class {
       titleFollowsName: this.titleFollowsName(record, title),
       downloadMedia,
       local: {
-        content: await readLocalNote(this.vaultFs, record.obsidianPath),
+        content: local,
         markers: this.stateDb.getPreserveMarkers(record.obsidianPath)
       }
     });
-    return { content, title, properties, bodyFingerprint: fetched.fingerprint };
+    return {
+      content,
+      title,
+      properties,
+      bodyFingerprint: fetched.fingerprint,
+      folderFiles: { files: fetched.noteFiles, complete: fetched.noteFilesComplete }
+    };
   }
   /**
    * 받은 페이지 본문을 볼트에 쓸 노트로 — 새로 받기(`createPulledPage`)와 다시 받기({@link renderRemotePage})가
@@ -28172,19 +28483,27 @@ var PagePuller = class {
   /**
    * 페이지 본문을 볼트 쪽 markdown 으로 받는다.
    *
+   * @param options.embedded 로컬 노트가 임베드한 파일 이름 — 폴더 첨부({@link folderFilesInNote})를 노트에서 떼어
+   *   `noteFiles` 로 돌려줄 때, 이 이름 · 이 볼트가 노트 첨부로 올린 파일은 노트의 것으로 둔다(ADR-056).
    * @returns `fingerprint` 는 받은 원격 본문의 지문({@link remoteBodyFingerprint}). 블록 API 로
    *   받았으면 null — 지문은 Markdown API 의 본문으로만 견준다.
    */
-  async fetchPageMarkdown(pageId) {
+  async fetchPageMarkdown(pageId, options = {}) {
+    const noteFilesOf = (markdown) => this.noteFolderFilesOf(pageId, markdown, options);
     if (this.config.conversion.preferMarkdownApi !== false) {
       try {
         const result = await this.notionClient.getPageMarkdown(pageId);
         this.discovery.collectInlineDbRefs(pageId, result.markdown);
         this.detector.noteBodyChildren(pageId, result.markdown);
+        const found2 = noteFilesOf(result.markdown);
         return {
           content: await this.resolveBlockLinks(
             this.resolveNotionIdWikilinks(
-              await notionBodyToObsidian(this.notionClient, result.markdown, pageId)
+              await notionBodyToObsidian(
+                this.notionClient,
+                found2?.markdown ?? result.markdown,
+                pageId
+              )
             ),
             pageId
           ),
@@ -28194,7 +28513,9 @@ var PagePuller = class {
           children: extractChildTags(result.markdown),
           fingerprint: remoteBodyFingerprint(result.markdown),
           hasBody: hasBodyBesidesChildren(result.markdown),
-          folderFiles: folderFilesInBody(result.markdown)
+          folderFiles: folderFilesInBody(result.markdown),
+          noteFiles: found2?.files ?? [],
+          noteFilesComplete: !result.truncated && this.noteFilesHoldAll(pageId, found2?.markdown ?? result.markdown)
         };
       } catch (error) {
         getLogger().warn(
@@ -28202,7 +28523,14 @@ var PagePuller = class {
         );
       }
     }
-    const fallback = await pageBlocksToObsidian(this.notionClient, pageId);
+    let noteFiles = [];
+    let noteFilesComplete = true;
+    const fallback = await pageBlocksToObsidian(this.notionClient, pageId, (markdown) => {
+      const found2 = noteFilesOf(markdown);
+      noteFiles = found2?.files ?? [];
+      noteFilesComplete = this.noteFilesHoldAll(pageId, found2?.markdown ?? markdown);
+      return found2?.markdown ?? markdown;
+    });
     this.discovery.collectInlineDbRefs(pageId, fallback.markdown);
     this.detector.noteBodyChildren(pageId, fallback.markdown);
     return {
@@ -28214,9 +28542,28 @@ var PagePuller = class {
       children: extractChildTags(fallback.markdown),
       fingerprint: null,
       hasBody: hasBodyBesidesChildren(fallback.markdown),
-      folderFiles: folderFilesInBody(fallback.markdown)
+      folderFiles: folderFilesInBody(fallback.markdown),
+      noteFiles,
+      noteFilesComplete
     };
   }
+  /** 노트 페이지의 폴더 첨부({@link folderFilesInNote}) — 없으면 null. */
+  noteFolderFilesOf(pageId, markdown, options) {
+    const media = recallUploadedMedia(this.stateDb, pageId);
+    return folderFilesInNote(markdown, {
+      knownIds: new Set(folderFileIdsOf(this.stateDb, pageId).values()),
+      exclude: (file) => {
+        const fileId = notionFileIdOf(file.url);
+        return options.embedded?.has(file.name) === true || fileId !== null && media.has(fileId);
+      }
+    });
+  }
+  /** 폴더 첨부를 뗀 본문에 적어 둔 폴더 첨부가 남지 않았나 — {@link fetchPageMarkdown} 의 `noteFilesComplete`. */
+  noteFilesHoldAll(pageId, rest) {
+    const ids = new Set(folderFileIdsOf(this.stateDb, pageId).values());
+    if (ids.size === 0) return true;
+    return !notionMediaSpans(rest).some((span) => ids.has(notionFileIdOf(span.url) ?? ""));
+  }
   /** 폴더 첨부를 받아 받은 파일 수에 더한다. */
   async receiveFolderFiles(folder, pageId, files, complete2 = false) {
     this._pullFileCount += await this.fileHandler.receiveFolderFiles(
@@ -28688,6 +29035,10 @@ var PullPlanner = class {
     const relinkPaths = new Map(
       [...relinks.byPage].map(([pageId, relink]) => [compactNotionId(pageId), relink.path])
     );
+    await this.discovery.readNewPageBodies(
+      planned.filter((change) => change.type === "created").map((change) => change.pageId),
+      options.signal
+    );
     const newDatabases = await this.discovery.plannedNewDatabases(failed, {
       rescanRoot: this.detector.rootChanged(),
       notePathOf: (pageId) => relinkPaths.get(compactNotionId(pageId)) ?? this.stateDb.getByNotionId(pageId)?.obsidianPath ?? null
@@ -29880,7 +30231,11 @@ var SyncOrchestrator = class {
   async pushVaultFiles(failed) {
     if (this.config.sync.syncFiles === false) return 0;
     try {
-      const fileResults = await this.fileHandler.pushAllFiles(failed, this.placement);
+      const fileResults = await this.fileHandler.pushAllFiles(
+        failed,
+        this.placement,
+        this.notePageWrites()
+      );
       if (fileResults.length > 0) {
         getLogger().info(`[Im-Nobsidian] ${fileResults.length}\uAC1C \uD30C\uC77C \uC5C5\uB85C\uB4DC \uC644\uB8CC`);
       }
@@ -29890,6 +30245,42 @@ var SyncOrchestrator = class {
       return 0;
     }
   }
+  /**
+   * 폴더 첨부를 노트의 페이지에 붙이거나 지울 때({@link NotePageWrites}) — 쓰기 전에 원격과 맞던 노트만 쓴 뒤의 원격을 본
+   * 것으로 적는다. 받지 않은 Notion 편집이 걸린 노트를 적으면 다음 pull 이 그 편집을 받지 않는다. 읽지 못하면 적지 않는다 —
+   * 다음 push 가 그 노트를 올리지 않고 pull 을 먼저 하라고 알릴 뿐이다.
+   */
+  notePageWrites() {
+    const inSync = /* @__PURE__ */ new Map();
+    return {
+      begin: async (pageId) => {
+        const record = this.stateDb.getByNotionId(pageId);
+        if (!record || isFolderRecord(record)) return;
+        try {
+          const page = await this.notionClient.getPage(pageId);
+          if (await this.drift.remoteDrift(record, page) === "none")
+            inSync.set(pageId, record.id);
+        } catch (error) {
+          getLogger().warn(
+            `[Im-Nobsidian] \uD3F4\uB354 \uCCA8\uBD80\uB97C \uBD99\uC77C \uB178\uD2B8\uC758 \uC6D0\uACA9\uC744 \uC77D\uC9C0 \uBABB\uD568 (${record.obsidianPath}): ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      },
+      end: async (pageId) => {
+        const recordId = inSync.get(pageId);
+        if (recordId === void 0) return;
+        inSync.delete(pageId);
+        try {
+          const page = await this.notionClient.getPage(pageId);
+          this.observation.record(recordId, page, await this.drift.remoteBodyFingerprintOf(pageId));
+        } catch (error) {
+          getLogger().warn(
+            `[Im-Nobsidian] \uD3F4\uB354 \uCCA8\uBD80\uB97C \uBD99\uC778 \uB178\uD2B8\uC758 \uC6D0\uACA9\uC744 \uC801\uC9C0 \uBABB\uD568 (${pageId}): ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    };
+  }
   /**
    * @param mergedByPull sync dry-run 만 — 앞선 pull dry-run 이 합칠 노트. 실제 sync 는 합친 뒤 원격을 본 것으로
    *   적어 push 가 올린다 — dry-run 은 받지 않아 원격이 바뀐 그대로라, 원격을 보고 거절하지 않는다.
@@ -32468,7 +32859,7 @@ function hasColumnLayout(text) {
 var START_RE = new RegExp(`^[\\t ]*${COLUMN_LIST_START}[\\t ]*$`);
 var END_RE = new RegExp(`^[\\t ]*${COLUMN_LIST_END}[\\t ]*$`);
 var SEP_RE = new RegExp(`^[\\t ]*${COLUMN_SEP_SOURCE}[\\t ]*$`);
-var FENCE_RE = /^[\t ]*(`{3,}|~{3,})/;
+var FENCE_RE2 = /^[\t ]*(`{3,}|~{3,})/;
 function readColumnLayout(lines) {
   const places = new Array(lines.length);
   let group2 = -1;
@@ -32492,7 +32883,7 @@ function readColumnLayout(lines) {
     open = null;
   };
   lines.forEach((line, i) => {
-    const fenceMatch = FENCE_RE.exec(line);
+    const fenceMatch = FENCE_RE2.exec(line);
     if (fence) {
       if (fenceMatch && fenceMatch[1].startsWith(fence)) fence = null;
       return;