@im-nobsidian/core 0.20.0 → 0.22.0

package/dist/index.js

@@ -3753,7 +3753,7 @@ var NotionClient2 = class _NotionClient {
     return blocks;
   }
   /**
-   * 자식 블록을 덧붙인다. `options.after` 를 주면 그 블록 **바로 뒤**에 삽입한다
+   * 자식 블록을 덧붙인다. `options.after` 를 주면 그 블록 **바로 뒤**에, `options.atStart` 면 맨 앞에 삽입한다
    * (기본은 맨 끝). 자리표시자를 실제 미디어 블록으로 제자리 교체할 때 필요하다.
    *
    * 실측(2025-09-03): position 삽입 응답의 `results` 는 방금 넣은 블록뿐 아니라
@@ -3771,19 +3771,24 @@ var NotionClient2 = class _NotionClient {
     const batchSize = this.batchSize;
     const created = [];
     let after = options?.after;
+    let atStart = after === void 0 && options?.atStart === true;
     for (let i = 0; i < children.length; i += batchSize) {
       const batch = children.slice(i, i + batchSize);
+      const position = after ? { position: { type: "after_block", after_block: { id: after } } } : atStart ? { position: { type: "start" } } : {};
       const response = await this.withRateLimit(
         () => this.client.blocks.children.append({
           block_id: blockId,
           children: batch,
-          ...after ? { position: { type: "after_block", after_block: { id: after } } } : {}
+          ...position
         }),
         CREATES_BLOCKS
       );
       const blocks = response.results.slice(0, batch.length);
       created.push(...blocks);
-      if (after && blocks.length > 0) after = blocks[blocks.length - 1].id;
+      if ((after || atStart) && blocks.length > 0) {
+        after = blocks[blocks.length - 1].id;
+        atStart = false;
+      }
     }
     return created;
   }
@@ -3792,9 +3797,11 @@ var NotionClient2 = class _NotionClient {
    * 자식은 부모를 만든 뒤 그 아래에 마저 붙인다({@link shapeAppendRequests}). 더 깊은 블록의 id 는
    * 응답에 없어 부모의 자식 목록을 읽어 찾는다.
    *
+   * `options.atStart` 면 맨 위 블록을 맨 앞에 넣는다 — 본문 뒤에 둘 블록(폴더 첨부)을 남기고 본문만 바꿀 때.
+   *
    * 중간에 실패하면 그때까지 만든 블록은 남는다 — 호출측이 실패로 알린다.
    */
-  async appendBlockTree(parentId, blocks) {
+  async appendBlockTree(parentId, blocks, options) {
     const listed = /* @__PURE__ */ new Map();
     const childIds = async (id) => {
       let ids = listed.get(id);
@@ -3805,15 +3812,19 @@ var NotionClient2 = class _NotionClient {
       return ids;
     };
     const queue = [
-      { parentId, blocks }
+      { parentId, blocks, top: true }
     ];
+    let topAfter;
     while (queue.length > 0) {
       const next = queue.shift();
       for (const request of shapeAppendRequests(next.blocks)) {
+        const position = next.top && options?.atStart ? topAfter ? { after: topAfter } : { atStart: true } : void 0;
         const created = await this.appendChildren(
           next.parentId,
-          request.map((shaped) => shaped.body)
+          request.map((shaped) => shaped.body),
+          position
         );
+        if (position) topAfter = created[created.length - 1] ?? topAfter;
         for (const [k, shaped] of request.entries()) {
           for (const pending of shaped.pending) {
             let id = created[k];
@@ -15174,6 +15185,21 @@ function selectStaleDbArtifacts(files, localFolder, keepPaths) {
   return stale;
 }
 
+// src/sync/parent-mode.ts
+function isDatabaseMode(config) {
+  return config.notion.parentMode === "database" && !!config.notion.databaseId;
+}
+function rowDatabaseOf(config, record) {
+  if (record.fileType === "db-row") {
+    if (!record.notionParentId) {
+      throw new Error(`DB \uD589\uC778\uB370 \uC18C\uC18D DB \uB97C \uC54C \uC218 \uC5C6\uC74C: ${record.obsidianPath}`);
+    }
+    return record.notionParentId;
+  }
+  if (isDatabaseMode(config)) return config.notion.databaseId;
+  return null;
+}
+
 // src/sync/folder-files.ts
 function unescapeCaption(caption) {
   return caption.replace(/\\([\\`*_{}[\]()#+\-.!|~<>$&])/g, "$1").trim();
@@ -15184,12 +15210,89 @@ 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);
+}
+function uploadedFileOfBlock(block) {
+  const media = block[block.type];
+  const url = media?.type === "file" ? media.file?.url : void 0;
+  if (!url) return null;
+  return { url, caption: (media?.caption ?? []).map((part) => part.plain_text ?? "").join("") };
+}
+function isFolderFileBlock(block, knownIds) {
+  const file = uploadedFileOfBlock(block);
+  if (!file) return false;
+  const name = uploadedFileNameFromUrl(file.url);
+  const fileId = notionFileIdOf(file.url);
+  return fileId !== null && knownIds.has(fileId) || name !== null && file.caption === folderFileCaption(name);
+}
+var FENCE_RE = /^\s*(`{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.trim();
+    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
+  };
+}
+function noteFolderFilesOfPage(stateDb, pageId, markdown, embedded) {
+  const ids = new Set(folderFileIdsOf(stateDb, pageId).values());
+  const media = recallUploadedMedia(stateDb, pageId);
+  const found2 = folderFilesInNote(markdown, {
+    knownIds: ids,
+    exclude: (file) => {
+      const fileId = notionFileIdOf(file.url);
+      return embedded?.has(file.name) === true || fileId !== null && media.has(fileId);
+    }
+  });
+  const rest = found2?.markdown ?? markdown;
+  return {
+    found: found2,
+    holdsAll: ids.size === 0 || !notionMediaSpans(rest).some((span) => ids.has(notionFileIdOf(span.url) ?? ""))
+  };
+}
+function rootFilesPageOf(config) {
+  if (isDatabaseMode(config) || !config.notion.rootPageId) return null;
+  return normalizeNotionId(config.notion.rootPageId);
+}
 var WIKI_EMBED_RE = /!\[\[([^\]|#^\n]+)/g;
 var MD_EMBED_RE = /!\[[^\]\n]*\]\(<?([^)>\s]+)/g;
 var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
@@ -15217,8 +15320,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,19 +15329,45 @@ 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
+function flattenBlockTree2(blocks) {
+  return blocks.flatMap((block) => [block, ...flattenBlockTree2(block.children ?? [])]);
+}
 function isHiddenPath(path) {
   return path.split("/").some((part) => part.startsWith("."));
 }
@@ -15246,6 +15375,15 @@ 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 isNamedNote(record) ? stripMarkdownExtension(record.obsidianPath) : null;
+}
+function isNamedNote(record) {
+  return record.fileType === "file" || record.fileType === "db-row";
+}
 var LOGGED_NAMES = 5;
 var FileHandler = class {
   constructor(vaultFs, notionClient, stateDb, concurrency = DEFAULT_CONFIG.advanced.fileConcurrency, options) {
@@ -15257,6 +15395,7 @@ var FileHandler = class {
     this.downloadTimeoutMs = options?.downloadTimeoutMs ?? DEFAULT_CONFIG.advanced.mediaDownloadTimeoutMs;
     this.itemTimeoutMs = options?.itemTimeoutMs ?? DEFAULT_CONFIG.advanced.itemTimeoutMs;
     this.deleteSync = options?.deleteSync ?? false;
+    this.rootPageId = options?.rootPageId ?? null;
     this.attachmentsFolder = (options?.attachmentsFolder ?? DEFAULT_CONFIG.paths.attachments).replace(/^\/+|\/+$/g, "");
   }
   vaultFs;
@@ -15268,6 +15407,7 @@ var FileHandler = class {
   itemTimeoutMs;
   attachmentsFolder;
   deleteSync;
+  rootPageId;
   get fetchFn() {
     return this.customFetch ?? globalThis.fetch;
   }
@@ -15325,21 +15465,58 @@ 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/행/`)는 그 행의 페이지 끝. DB 폴더는 둘 곳이 없다 — Notion 의 DB 는 본문이 없다.
+   */
   folderPageOf(folder) {
-    const record = this.stateDb.getByPath(folder || "__root__");
-    if (!record?.notionPageId) return null;
-    return folder === "" || isFolderRecord(record) ? record.notionPageId : null;
+    return this.notePageOf(folder) ?? this.folderRecordPageOf(folder);
+  }
+  /**
+   * 이 폴더를 품은 노트의 페이지 — 폴더 노트 · 노트(행 포함) 이름의 폴더 · 볼트 맨 위는 루트 페이지. 본문이 이 도구의 것이
+   * 아니거나(루트) 노트의 것이라, 적어 둔 폴더 첨부만 제 것으로 본다. 없으면 null.
+   */
+  notePageOf(folder) {
+    if (folder === "") return this.rootPageId;
+    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 && isNamedNote(named) ? 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 +15544,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 +15553,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 +15581,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 +15606,42 @@ var FileHandler = class {
    * 볼트에서 지운 폴더 첨부를 Notion 에서도 지운다(deleteSync) — 폴더 페이지에 적힌 파일 가운데 볼트에 없는 것의 블록과 기록.
    * 포함 · 제외 패턴으로 빠진 파일은 볼트에 있어 지우지 않는다.
    */
-  async removeDeletedFolderFiles() {
+  async removeDeletedFolderFiles(noteWrites) {
     const removed = [];
+    const pages = [];
     for (const record of this.stateDb.getAll()) {
-      if (!record.notionPageId || !isFolderRecord(record)) continue;
-      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 (!record.notionPageId) continue;
+      const folder = isFolderRecord(record) ? record.obsidianPath : filesFolderOfNote(record);
+      if (folder !== null) {
+        pages.push({ pageId: record.notionPageId, folder, onNote: !isFolderRecord(record) });
+      }
+    }
+    if (this.rootPageId) pages.push({ pageId: this.rootPageId, folder: "", onNote: true });
+    for (const { pageId, folder, onNote } of pages) {
+      const ids = folderFileIdsOf(this.stateDb, pageId);
+      if (onNote && ids.size === 0) continue;
+      const gone = [];
+      for (const entry of this.stateDb.getFilesByPageId(pageId)) {
+        if (getFolderPath(entry.localPath) !== folder) continue;
+        if (onNote && !ids.has(entry.localPath)) continue;
+        if (!await this.vaultFs.exists(entry.localPath)) gone.push(entry);
       }
+      if (gone.length === 0) continue;
+      await this.writingNotePage(onNote, 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 +15649,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 \u2014 DB \uBAA8\uB4DC\uC758 \uB8E8\uD2B8\uB294 DB \uB77C \uBCF8\uBB38\uC774 \uC5C6\uB2E4" : "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 +15811,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 +15854,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 +15868,79 @@ 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) {
-    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;
-      await this.notionClient.deleteBlock(block.id);
+  /**
+   * 처음 보는 파일이 이 페이지에 적어 둔 같은 이름의 폴더 첨부를 옮긴 것인가 — 그 기록의 경로가 볼트에서 사라졌으면 옮겼다(폴더 ·
+   * 폴더 노트 · 노트의 이름 바꾸기). 기록 · 파일 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;
   }
   /**
-   * 폴더 첨부의 파일 블록 — 캡션에 파일 이름을 적는다. 받는 쪽이 그 표시로 폴더 첨부를 알아본다({@link folderFilesOf}) —
-   * 자식 페이지가 없는 폴더 페이지는 PDF 하나만 붙인 노트와 모양이 같다.
+   * 이 페이지에서 그 폴더 첨부의 블록 중 방금 붙인 것(`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) || this.rootPageId !== null && notionIdsEqual(pageId, this.rootPageId);
+    const fileId = folderFileIdsOf(this.stateDb, pageId).get(localPath);
+    const isOlder = (block) => {
+      if (block.id === keep) return false;
+      const media = uploadedFileOfBlock(block);
+      if (!media || uploadedFileNameFromUrl(media.url) !== name) return false;
+      if (keep === void 0 && fileId !== void 0) {
+        return notionFileIdOf(media.url) === fileId;
+      }
+      if (!onNote) return true;
+      return fileId !== void 0 && notionFileIdOf(media.url) === fileId || media.caption === folderFileCaption(name);
+    };
+    let older = (await this.notionClient.fetchAllChildren(pageId)).filter(isOlder);
+    if (older.length === 0 && onNote) {
+      older = flattenBlockTree2(await this.notionClient.getBlockTree(pageId)).filter(isOlder);
+    }
+    for (const block of older) await this.notionClient.deleteBlock(block.id);
+  }
+  /**
+   * 폴더 첨부의 파일 블록 — 캡션에 표시를 단 파일 이름을 적는다({@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":
@@ -16693,21 +16965,6 @@ function loadLinkedDbMap(stateDb) {
   }
 }
 
-// src/sync/parent-mode.ts
-function isDatabaseMode(config) {
-  return config.notion.parentMode === "database" && !!config.notion.databaseId;
-}
-function rowDatabaseOf(config, record) {
-  if (record.fileType === "db-row") {
-    if (!record.notionParentId) {
-      throw new Error(`DB \uD589\uC778\uB370 \uC18C\uC18D DB \uB97C \uC54C \uC218 \uC5C6\uC74C: ${record.obsidianPath}`);
-    }
-    return record.notionParentId;
-  }
-  if (isDatabaseMode(config)) return config.notion.databaseId;
-  return null;
-}
-
 // src/sync/remote-scan.ts
 var LAST_FULL_PULL_META_KEY = "last_full_pull_at";
 var LAST_PULL_META_KEY = "last_pull_at";
@@ -19167,7 +19424,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 +19659,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 +19668,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 };
@@ -19676,6 +19935,7 @@ function emptyDatabaseSyncResult() {
 }
 var DatabaseSyncer = class {
   constructor(config, stateDb, notionClient, vaultFs, pipeline, imageHandler, observation = () => NO_OBSERVATION, noteRowBody = () => {
+  }, receiveRowFiles = async () => {
   }) {
     this.config = config;
     this.stateDb = stateDb;
@@ -19685,6 +19945,7 @@ var DatabaseSyncer = class {
     this.imageHandler = imageHandler;
     this.observation = observation;
     this.noteRowBody = noteRowBody;
+    this.receiveRowFiles = receiveRowFiles;
     this.baseFileInfo = new DbBaseFiles(stateDb);
     this.journal = new UpdateJournal(stateDb);
     this.sidecarBases = new SidecarBases(stateDb);
@@ -19709,6 +19970,7 @@ var DatabaseSyncer = class {
   imageHandler;
   observation;
   noteRowBody;
+  receiveRowFiles;
   propertyMapper;
   decorationsCache;
   /**
@@ -20791,7 +21053,18 @@ var DatabaseSyncer = class {
     this.noteRowBody(page.id, mdResult.markdown);
     const bodyFingerprint = remoteBodyFingerprint(mdResult.markdown);
     const exportCompact = isCompactExport(mdResult.markdown);
-    let markdown = await notionBodyToObsidian(this.notionClient, mdResult.markdown, page.id);
+    const localContent = await readLocalNote(this.vaultFs, options?.localPath ?? filePath);
+    const noteFiles = noteFolderFilesOfPage(
+      this.stateDb,
+      page.id,
+      mdResult.markdown,
+      embeddedNamesOf(localContent === void 0 ? [] : [localContent])
+    );
+    let markdown = await notionBodyToObsidian(
+      this.notionClient,
+      noteFiles.found?.markdown ?? mdResult.markdown,
+      page.id
+    );
     markdown = await this.imageHandler.restoreUploadedMedia(
       markdown,
       page.id,
@@ -20825,7 +21098,7 @@ var DatabaseSyncer = class {
       {
         properties,
         notionExportCompact: exportCompact,
-        localContent: await readLocalNote(this.vaultFs, options?.localPath ?? filePath),
+        localContent,
         // 이 렌더러가 적는 키 — 속성과 제목 · 커버 · 아이콘. 나머지는 로컬 키다(F-08).
         notionKeys: [...this.propertyMapper.ownedKeys(rawProperties), "title", ...DECORATION_KEYS]
       }
@@ -20835,7 +21108,11 @@ var DatabaseSyncer = class {
       title,
       properties,
       bodyFingerprint,
-      propertiesBlock: hasPropertiesBlock(mdResult.markdown)
+      propertiesBlock: hasPropertiesBlock(mdResult.markdown),
+      folderFiles: {
+        files: noteFiles.found?.files ?? [],
+        complete: !mdResult.truncated && noteFiles.holdsAll
+      }
     };
   }
   /**
@@ -21132,8 +21409,19 @@ var DatabaseSyncer = class {
    */
   adoptedChildrenOf(record, rowPath) {
     const from = record.fileType === "folder-note" ? parentFolderOf(record.obsidianPath) : stripMarkdownExtension(record.obsidianPath);
-    const hasChildren = this.stateDb.getAll().some((r) => r.id !== record.id && within(r.obsidianPath, from));
-    return hasChildren ? { from, to: stripMarkdownExtension(rowPath) } : null;
+    return this.holdsChildren(record, from) ? { from, to: stripMarkdownExtension(rowPath) } : null;
+  }
+  /**
+   * 이 노트 · 행 옆의 폴더(`from`)가 그것의 것인가 — 하위 페이지가 있거나, 그 페이지에 올린 폴더 첨부(ADR-056)가 든 폴더.
+   * 예전에는 하위 페이지만 보아 행의 이름을 따라 옮길 때 폴더 첨부만 든 폴더가 옛 이름에 남았다.
+   */
+  holdsChildren(record, from) {
+    if (this.stateDb.getAll().some((r) => r.id !== record.id && within(r.obsidianPath, from))) {
+      return true;
+    }
+    return record.notionPageId !== null && [...folderFileIdsOf(this.stateDb, record.notionPageId).keys()].some(
+      (path) => within(path, from)
+    );
   }
   /**
    * Notion 에서 바꾼 제목으로 행 이름을 바꿀 자리(`sync.renameOnTitleChange`) — 바꿀 것이 없으면 null.
@@ -21155,14 +21443,32 @@ var DatabaseSyncer = class {
     );
     if (to === recordPath) return null;
     const from = stripMarkdownExtension(recordPath);
-    if (!this.stateDb.getAll().some((r) => within(r.obsidianPath, from))) {
+    if (!this.holdsChildren(record, from)) {
       return { to, children: null };
     }
     const children = { from, to: stripMarkdownExtension(to) };
     const blocked = await this.relocator.blocked(children);
     return blocked ? { reason: `\uD558\uC704 \uD398\uC774\uC9C0 \uD3F4\uB354 \u2014 ${blocked}` } : { to, children };
   }
+  /**
+   * 행 하나를 받고 그 행 페이지의 폴더 첨부를 행 이름의 폴더에 받는다(ADR-056) — 노트가 충돌로 남거나 로컬을 지켜도 파일은
+   * 제 규칙대로 받는다(페이지와 같다). 행을 옮겼으면 옮긴 자리로.
+   */
   async pullDatabasePage(page, dbConfig) {
+    const rendered = {};
+    const outcome = await this.pullDatabaseRow(page, dbConfig, rendered);
+    const path = outcome.path ?? this.stateDb.getByNotionId(page.id)?.obsidianPath;
+    if (rendered.folderFiles && path) {
+      await this.receiveRowFiles(
+        stripMarkdownExtension(path),
+        page.id,
+        rendered.folderFiles.files,
+        rendered.folderFiles.complete
+      );
+    }
+    return outcome;
+  }
+  async pullDatabaseRow(page, dbConfig, seen) {
     const safeName = sanitizeFileName(this.notionClient.extractTitle(page));
     const existingRecord = this.stateDb.getByNotionId(page.id);
     const recordPath = existingRecord?.obsidianPath;
@@ -21216,6 +21522,7 @@ var DatabaseSyncer = class {
       localPath: recordPath ?? filePath,
       ...local !== void 0 ? { adoptFrom: local } : {}
     });
+    seen.folderFiles = rendered.folderFiles;
     let relinked = false;
     if (adopt) {
       const outcome = local === void 0 ? null : await this.relinkExistingRow(
@@ -21238,6 +21545,7 @@ var DatabaseSyncer = class {
           await this.rowPathOwners(dbConfig.localFolder, safeName, page.id)
         );
         rendered = await this.renderRow(page, filePath, { localPath: filePath });
+        seen.folderFiles = rendered.folderFiles;
       }
     }
     const { title, properties, bodyFingerprint } = rendered;
@@ -23709,7 +24017,8 @@ var DatabaseDiscovery = class {
    * `markScanned` 일 때 적는다.
    *
    * @param failed 읽지 못한 페이지 · DB — 이유와 함께 싣는다.
-   * @param options.notePathOf 페이지 → 볼트 경로. 새 DB 폴더를 부모 노트 옆에 둔다 — dry-run 은 다시 이을 노트의 자리를 준다.
+   * @param options.notePathOf 페이지 → 볼트 경로. 새 DB 폴더를 부모 노트 옆에 둔다 — dry-run 은 다시 이을 노트 · 새로 받을 페이지의
+   *   자리를 준다.
    */
   async openRegistry(failed, options) {
     const { forceRediscovery, signal } = options;
@@ -23889,6 +24198,41 @@ var DatabaseDiscovery = class {
       )
     };
   }
+  /**
+   * dry-run — 새로 받을 페이지의 본문을 읽어 그 안의 DB 를 찾는다({@link plannedNewDatabases} 가 그 행을 센다). 실제 pull 은
+   * 받으며 찾는다 — 같은 길로 읽는다: Markdown API(잘린 본문은 채운 것 · 권한 없는 자리표시는 그대로), 실패하거나 블록 방식이면
+   * 블록 트리. 예전에는 100개까지만 읽고 넘는 페이지 안의 DB 를 «미리 세지 않았습니다» 로만 알렸다 — 미리 보기는 사용자가
+   * 부르고 멈출 수 있어(`signal`) 모두 읽는다. 둘 다 읽지 못한 페이지만 {@link bodyRead} 가 아니어서 알림으로 남는다.
+   */
+  async readNewPageBodies(pageIds, signal) {
+    if (isDatabaseMode(this.config)) return;
+    const unread = pageIds.filter((pageId) => !this.bodyRead(pageId));
+    if (unread.length > 0) {
+      getLogger().info(
+        `[Im-Nobsidian] \uBBF8\uB9AC \uBCF4\uAE30: \uC0C8 \uD398\uC774\uC9C0 ${unread.length}\uAC1C\uC758 \uBCF8\uBB38\uC5D0\uC11C DB \uB97C \uCC3E\uC74C`
+      );
+    }
+    for (const pageId of unread) {
+      if (signal?.aborted) return;
+      try {
+        this.collectInlineDbRefs(pageId, await this.previewBodyOf(pageId));
+      } 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 의 `PagePuller.fetchPageMarkdown` 과 같은 차례. */
+  async previewBodyOf(pageId) {
+    if (this.config.conversion.preferMarkdownApi !== false) {
+      try {
+        return (await this.notionClient.getPageMarkdown(pageId)).markdown;
+      } catch {
+      }
+    }
+    return blocksToNfm(await this.notionClient.getBlockTree(pageId), { pageId });
+  }
   /** 이번 pull 에서 본문을 받은 페이지인가 — 그 본문의 `<database>` 로 새 DB 를 찾았다. */
   bodyRead(pageId) {
     return this._bodyReadPages.has(normalizeNotionId(pageId));
@@ -23971,7 +24315,7 @@ var DatabaseDiscovery = class {
       getLogger().warn(`[Im-Nobsidian] \uC790\uB3D9 \uBC1C\uACAC DB ${dbId} \uC124\uC815 \uC0DD\uC131 \uC2E4\uD328:`, error);
       return { kind: "error", error: error instanceof Error ? error.message : String(error) };
     }
-    const obsPath = parentPageId ? notePathOf(parentPageId) : null;
+    const obsPath = parentPageId ? await notePathOf(parentPageId) : null;
     let parentFolder = "";
     if (obsPath) {
       if (isMarkdownPath(obsPath)) {
@@ -24725,7 +25069,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 +25085,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;
@@ -27348,18 +27722,22 @@ var PagePusher = class {
    * 실패로 알린다. 예전처럼 조용히 건너뛰면 동기화됨으로 기록돼 편집이 영영 가지 않는다.
    *
    * 바뀌지 않은 미디어는 다시 올리지 않고 Notion 의 그 블록을 둔다({@link ImageHandler.keepUploadedMedia}).
-   * 블록 방식은 블록을 모두 지우므로 둘 수 없다 — 예전처럼 모두 다시 올린다.
+   * 블록 방식은 노트의 미디어를 둘 수 없다 — 예전처럼 모두 다시 올린다. 페이지 끝의 폴더 첨부(ADR-056)는 노트 밖의 것이라
+   * 블록째 두고 새 본문을 그 앞(맨 앞)에 넣는다.
    *
    * @returns 보낸 본문 · 그 지문 · 그대로 둔 미디어({@link PushedBody})
    */
   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 folderFiles2 = await this.folderFileLines(pageId);
+      const markdown = folderFiles2 ? `${body}
+${folderFiles2}` : body;
       const written = await replacePageBody(this.notionClient, pageId, markdown, {
         databaseIdsOfBase: (basePath) => this.databaseIdsOfBase(basePath),
         unknownTagFallbacks: unknownTagFallbacks(markdownContent)
@@ -27379,13 +27757,19 @@ 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"
       );
     }
+    const folderFiles = this.folderFileBlocks(existingBlocks, pageId, notePath);
     const { nfm, blocks } = blockModeBody(markdownContent);
     if (blocks.length > 0) {
-      await this.notionClient.appendBlockTree(pageId, blocks);
+      await this.notionClient.appendBlockTree(
+        pageId,
+        blocks,
+        folderFiles.size > 0 ? { atStart: true } : void 0
+      );
     }
     const deleteSema = new Sema(this.config.advanced.concurrency);
     await Promise.all(
       existingBlocks.map(async (block) => {
+        if (folderFiles.has(block.id)) return;
         await deleteSema.acquire();
         try {
           await this.notionClient.deleteBlock(block.id);
@@ -27396,6 +27780,41 @@ 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");
+  }
+  /**
+   * 블록 방식으로 바꿀 본문에서 남길 폴더 첨부 블록(ADR-056) — 맨 위 블록 가운데 {@link isFolderFileBlock}. 예전에는 함께 지우고
+   * 기록을 놓아 노트를 고칠 때마다 폴더 첨부를 다시 올렸다.
+   *
+   * 맨 위에 없는 폴더 첨부(Notion 에서 토글 안으로 옮긴 것)는 그 토글과 함께 지워진다 — 기록을 놓아 이어지는 첨부 push 가
+   * 페이지 끝에 다시 올리게 한다. 두면 볼트의 기록만 남아 다음 pull 이 Notion 에서 지운 파일로 본다.
+   */
+  folderFileBlocks(blocks, pageId, notePath) {
+    const recorded = folderFileIdsOf(this.stateDb, pageId);
+    const ids = new Set(recorded.values());
+    const kept = blocks.filter((block) => isFolderFileBlock(block, ids));
+    const keptIds = new Set(kept.map((block) => notionFileIdOf(fileUrlOfBlock(block) ?? "")));
+    const lost = [...recorded].filter(([, fileId]) => !keptIds.has(fileId));
+    for (const [localPath] of lost) {
+      this.stateDb.deleteFileRegistry(localPath);
+      forgetFolderFileId(this.stateDb, pageId, localPath);
+    }
+    if (lost.length > 0) {
+      getLogger().info(
+        `[Im-Nobsidian] \uBE14\uB85D \uBC29\uC2DD\uC73C\uB85C \uBCF8\uBB38\uC744 \uBC14\uAFB8\uBA70 \uB9E8 \uC704\uC5D0 \uC5C6\uB358 \uD3F4\uB354 \uCCA8\uBD80 ${lost.length}\uAC1C\uB97C \uB2E4\uC2DC \uC62C\uB9BC (${notePath})`
+      );
+    }
+    return new Set(kept.map((block) => block.id));
+  }
   /**
    * 자리표시로 보낸 코드를 채우고(S-22) 동기화 블록 참조를 붙인다({@link deferSyncedReferences}) — 본문을
    * 바꾼 뒤(블록 방식이면 옛 블록을 지운 뒤) 부른다.
@@ -27634,6 +28053,17 @@ var PagePuller = class {
       sanitizeFileName(this.notionClient.extractTitle(page))
     );
   }
+  /**
+   * dry-run — 새 페이지를 실제 pull 이 받을 자리(부모의 자리 + 제목). 그 안에서 찾은 DB 의 폴더를 실제처럼 그 옆에 둔다 — 예전에는
+   * 자리를 몰라 `databases/` 아래로 보였다. 같은 이름이 있으면 실제 pull 은 접미사를 붙이지만 여기서는 붙이지 않는다(선점하지
+   * 않는다). 볼트도 상태 DB 도 바꾸지 않는다.
+   */
+  async plannedNotePath(pageId) {
+    const page = this.detector.discoveredPage(pageId) ?? await this.notionClient.getPage(pageId);
+    const parent = await this.resolveParentPath(page);
+    const name = `${sanitizeFileName(this.notionClient.extractTitle(page))}.md`;
+    return parent ? `${parent}/${name}` : name;
+  }
   /**
    * dry-run — 실제 pull({@link createPulledPage})이 이 새 페이지를 새로 받지 않고 상태 기록에 없던 노트 · 폴더와 다시 잇는가(P7).
    * 다시 이을 노트(`note` — 충돌로 남길 것이면 `conflict`) · 이미 있는 폴더(`folder` — 폴더로만 받는 페이지), 아니면 null.
@@ -27773,7 +28203,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 +28219,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 +28390,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 +28541,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 +28555,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 +28633,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) => noteFolderFilesOfPage(this.stateDb, pageId, markdown, options.embedded);
     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 { found: found2, holdsAll } = 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 +28663,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 && holdsAll
         };
       } catch (error) {
         getLogger().warn(
@@ -28202,7 +28673,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 { found: found2, holdsAll } = noteFilesOf(markdown);
+      noteFiles = found2?.files ?? [];
+      noteFilesComplete = holdsAll;
+      return found2?.markdown ?? markdown;
+    });
     this.discovery.collectInlineDbRefs(pageId, fallback.markdown);
     this.detector.noteBodyChildren(pageId, fallback.markdown);
     return {
@@ -28214,10 +28692,44 @@ var PagePuller = class {
       children: extractChildTags(fallback.markdown),
       fingerprint: null,
       hasBody: hasBodyBesidesChildren(fallback.markdown),
-      folderFiles: folderFilesInBody(fallback.markdown)
+      folderFiles: folderFilesInBody(fallback.markdown),
+      noteFiles,
+      noteFilesComplete
     };
   }
-  /** 폴더 첨부를 받아 받은 파일 수에 더한다. */
+  /**
+   * 볼트 맨 위 파일 — 루트 페이지 끝의 폴더 첨부(「📁 이름」 · 적어 둔 것)를 볼트 맨 위에 받는다({@link rootFilesPageOf}).
+   * 루트의 다른 블록(사용자가 붙인 파일 포함)은 받지 않는다. Markdown API 로 읽지 못하면 맨 위 블록에서 찾되 빠진 파일을
+   * 지운 것으로 보지 않는다 — 토글 안으로 옮긴 것은 보이지 않는다. 읽지 못하면 경고만 남긴다(다음 pull 이 다시 읽는다).
+   */
+  async receiveRootFiles() {
+    const rootId = rootFilesPageOf(this.config);
+    if (!rootId) return;
+    try {
+      let files;
+      let complete2;
+      try {
+        const result = await this.notionClient.getPageMarkdown(rootId);
+        const { found: found2, holdsAll } = noteFolderFilesOfPage(this.stateDb, rootId, result.markdown);
+        files = found2?.files ?? [];
+        complete2 = !result.truncated && holdsAll;
+      } catch {
+        const ids = new Set(folderFileIdsOf(this.stateDb, rootId).values());
+        files = (await this.notionClient.fetchAllChildren(rootId)).flatMap((block) => {
+          const url = isFolderFileBlock(block, ids) ? fileUrlOfBlock(block) : null;
+          const name = url ? uploadedFileNameFromUrl(url) : null;
+          return url && name ? [{ url, name }] : [];
+        });
+        complete2 = false;
+      }
+      await this.receiveFolderFiles("", rootId, files, complete2);
+    } catch (error) {
+      getLogger().warn(
+        `[Im-Nobsidian] \uBCFC\uD2B8 \uB9E8 \uC704 \uD30C\uC77C\uC744 \uB8E8\uD2B8 \uD398\uC774\uC9C0\uC5D0\uC11C \uBC1B\uC9C0 \uBABB\uD568: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /** 폴더 첨부를 받아 받은 파일 수에 더한다 — 행의 폴더 첨부도 여기로 받는다(`DatabaseSyncer`). */
   async receiveFolderFiles(folder, pageId, files, complete2 = false) {
     this._pullFileCount += await this.fileHandler.receiveFolderFiles(
       folder,
@@ -28688,9 +29200,12 @@ var PullPlanner = class {
     const relinkPaths = new Map(
       [...relinks.byPage].map(([pageId, relink]) => [compactNotionId(pageId), relink.path])
     );
+    const created = planned.filter((change) => change.type === "created").map((change) => change.pageId);
+    await this.discovery.readNewPageBodies(created, options.signal);
+    const createdIds = new Set(created.map(compactNotionId));
     const newDatabases = await this.discovery.plannedNewDatabases(failed, {
       rescanRoot: this.detector.rootChanged(),
-      notePathOf: (pageId) => relinkPaths.get(compactNotionId(pageId)) ?? this.stateDb.getByNotionId(pageId)?.obsidianPath ?? null
+      notePathOf: async (pageId) => relinkPaths.get(compactNotionId(pageId)) ?? this.stateDb.getByNotionId(pageId)?.obsidianPath ?? (createdIds.has(compactNotionId(pageId)) ? await this.puller.plannedNotePath(pageId) : null)
     });
     const rows = [];
     for (const row of await this.planDatabaseRows(
@@ -29645,7 +30160,8 @@ var SyncOrchestrator = class {
         downloadTimeoutMs: config.advanced.mediaDownloadTimeoutMs,
         itemTimeoutMs: config.advanced.itemTimeoutMs,
         attachmentsFolder: config.paths.attachments,
-        deleteSync: config.sync.deleteSync
+        deleteSync: config.sync.deleteSync,
+        rootPageId: rootFilesPageOf(config)
       }
     );
     const propertyMapper = PropertyMapper.fromConfig(config);
@@ -29657,7 +30173,8 @@ var SyncOrchestrator = class {
       pipeline,
       imageHandler,
       () => this.observation.context,
-      (pageId, rawMarkdown) => this.detector.noteBodyChildren(pageId, rawMarkdown)
+      (pageId, rawMarkdown) => this.detector.noteBodyChildren(pageId, rawMarkdown),
+      (folder, pageId, files, complete2) => this.puller.receiveFolderFiles(folder, pageId, files, complete2)
     );
     this.discovery = new DatabaseDiscovery(
       config,
@@ -29880,7 +30397,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 +30411,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 은 받지 않아 원격이 바뀐 그대로라, 원격을 보고 거절하지 않는다.
@@ -30457,6 +31014,7 @@ var SyncOrchestrator = class {
       pendingDatabases
     );
     const finalize = async (created, updated, deleted, restored = 0) => {
+      if (!options?.dryRun && this.detector.rootChanged()) await this.puller.receiveRootFiles();
       await this.puller.removeVacatedFolders();
       const renamedRows = this.databaseSyncer.takeRenamedRows();
       restoredPaths.push(...this.databaseSyncer.takeRestoredRows());
@@ -32468,7 +33026,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 +33050,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;