@im-nobsidian/core 0.21.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();
@@ -15200,7 +15226,20 @@ function folderFileCaption(name) {
 function isMarkedCaption(label, name) {
   return unescapeCaption(label) === folderFileCaption(name);
 }
-var FENCE_RE = /^(`{3,}|~{3,})/;
+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();
@@ -15214,7 +15253,7 @@ function folderFilesInNote(markdown, options = {}) {
       return;
     }
     if (fence !== null) return;
-    const full = line.trimEnd();
+    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);
@@ -15234,6 +15273,26 @@ function folderFilesInNote(markdown, options = {}) {
     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---/;
@@ -15306,6 +15365,9 @@ function rememberFolderFileStamp(stateDb, pageId, localPath, stamp) {
 }
 
 // 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("."));
 }
@@ -15317,7 +15379,10 @@ function filesFolderOfNote(record) {
   if (record.fileType === "folder-note" && isFolderNotePath(record.obsidianPath)) {
     return getFolderPath(record.obsidianPath);
   }
-  return record.fileType === "file" ? stripMarkdownExtension(record.obsidianPath) : null;
+  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 {
@@ -15330,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;
@@ -15341,6 +15407,7 @@ var FileHandler = class {
   itemTimeoutMs;
   attachmentsFolder;
   deleteSync;
+  rootPageId;
   get fetchFn() {
     return this.customFetch ?? globalThis.fetch;
   }
@@ -15420,19 +15487,22 @@ var FileHandler = class {
   }
   /**
    * 폴더 첨부를 둘 Notion 페이지 — 그 폴더의 Notion 자리({@link folderContainer} 와 같은 차례). 폴더 노트(`X/X.md`)나 노트
-   * 이름의 폴더(`X.md` 옆 `X/`)면 그 노트의 페이지 끝(ADR-056), 아니면 push 가 만든 폴더 페이지. 맨 위는 루트 기록이 있을 때만.
-   * 행 · DB 폴더는 둘 곳이 없다 — 행의 본문은 행의 것이다.
+   * 이름의 폴더(`X.md` 옆 `X/`)면 그 노트의 페이지 끝(ADR-056), 아니면 push 가 만든 폴더 페이지. 맨 위는 루트 페이지 끝.
+   * 행 이름의 폴더(`DB/행/`)는 그 행의 페이지 끝. DB 폴더는 둘 곳이 없다 — Notion 의 DB 는 본문이 없다.
    */
   folderPageOf(folder) {
-    if (folder === "") return this.stateDb.getByPath("__root__")?.notionPageId ?? null;
     return this.notePageOf(folder) ?? this.folderRecordPageOf(folder);
   }
-  /** 이 폴더를 품은 노트의 페이지 — 폴더 노트 · 노트 이름의 폴더. 없거나 행이면 null. */
+  /**
+   * 이 폴더를 품은 노트의 페이지 — 폴더 노트 · 노트(행 포함) 이름의 폴더 · 볼트 맨 위는 루트 페이지. 본문이 이 도구의 것이
+   * 아니거나(루트) 노트의 것이라, 적어 둔 폴더 첨부만 제 것으로 본다. 없으면 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 && named.fileType === "file" ? named.notionPageId : null;
+    return named?.notionPageId && isNamedNote(named) ? named.notionPageId : null;
   }
   folderRecordPageOf(folder) {
     const record = this.stateDb.getByPath(folder);
@@ -15538,21 +15608,26 @@ var FileHandler = class {
    */
   async removeDeletedFolderFiles(noteWrites) {
     const removed = [];
+    const pages = [];
     for (const record of this.stateDb.getAll()) {
       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;
+      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(record.notionPageId)) {
+      for (const entry of this.stateDb.getFilesByPageId(pageId)) {
         if (getFolderPath(entry.localPath) !== folder) continue;
-        if (!isFolderRecord(record) && !ids.has(entry.localPath)) continue;
+        if (onNote && !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 () => {
+      await this.writingNotePage(onNote, pageId, noteWrites, async () => {
         for (const entry of gone) {
           try {
             const name = entry.localPath.slice(entry.localPath.lastIndexOf("/") + 1);
@@ -15587,7 +15662,7 @@ var FileHandler = class {
   /** 폴더 첨부를 둘 페이지 — 노트 없는 폴더면 마련한다. 둘 곳이 없으면 그 파일들을 `stranded` 에 담고 null. */
   async provideFolderPage(folder, folders, items, stranded) {
     let pageId = this.folderPageOf(folder);
-    let reason = folder === "" ? "\uBCFC\uD2B8 \uB9E8 \uC704" : "DB \uD3F4\uB354 \xB7 \uC544\uC9C1 \uC62C\uB9AC\uC9C0 \uC54A\uC740 \uD3F4\uB354 \uB178\uD2B8";
+    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);
@@ -15838,22 +15913,23 @@ var FileHandler = class {
    */
   async removeOlderBlocks(pageId, localPath, name, keep) {
     const record = this.stateDb.getByNotionId(pageId);
-    const onNote = record !== null && !isFolderRecord(record);
+    const onNote = record !== null && !isFolderRecord(record) || this.rootPageId !== null && notionIdsEqual(pageId, this.rootPageId);
     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;
+    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) {
-        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;
+        return notionFileIdOf(media.url) === fileId;
       }
-      await this.notionClient.deleteBlock(block.id);
+      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}). 받는 쪽이 그 표시로 폴더 첨부를
@@ -16889,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";
@@ -19874,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;
@@ -19883,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);
@@ -19907,6 +19970,7 @@ var DatabaseSyncer = class {
   imageHandler;
   observation;
   noteRowBody;
+  receiveRowFiles;
   propertyMapper;
   decorationsCache;
   /**
@@ -20989,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,
@@ -21023,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]
       }
@@ -21033,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
+      }
     };
   }
   /**
@@ -21330,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.
@@ -21353,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;
@@ -21414,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(
@@ -21436,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;
@@ -23690,7 +23800,6 @@ 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 {
@@ -23908,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;
@@ -24090,18 +24200,22 @@ var DatabaseDiscovery = class {
   }
   /**
    * dry-run — 새로 받을 페이지의 본문을 읽어 그 안의 DB 를 찾는다({@link plannedNewDatabases} 가 그 행을 센다). 실제 pull 은
-   * 받으며 찾는다. 예전에는 읽지 않고 «미리 세지 않았습니다» 만 알렸다. {@link PREVIEW_BODY_READ_BUDGET} 개까지만 읽는다 —
-   * 넘거나 읽지 못한(다 받지 못한) 페이지는 {@link bodyRead} 가 아니어서 알림으로 남는다.
+   * 받으며 찾는다 — 같은 길로 읽는다: Markdown API(잘린 본문은 채운 것 · 권한 없는 자리표시는 그대로), 실패하거나 블록 방식이면
+   * 블록 트리. 예전에는 100개까지만 읽고 넘는 페이지 안의 DB 를 «미리 세지 않았습니다» 로만 알렸다 — 미리 보기는 사용자가
+   * 부르고 멈출 수 있어(`signal`) 모두 읽는다. 둘 다 읽지 못한 페이지만 {@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 (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 {
-        const result = await this.notionClient.getPageMarkdown(pageId);
-        if (result.truncated || (result.unknown_block_ids ?? []).length > 0) continue;
-        this.collectInlineDbRefs(pageId, result.markdown);
+        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)}`
@@ -24109,6 +24223,16 @@ var DatabaseDiscovery = class {
       }
     }
   }
+  /** 미리 보기가 읽는 새 페이지 본문 — 실제 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));
@@ -24191,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)) {
@@ -27598,7 +27722,8 @@ var PagePusher = class {
    * 실패로 알린다. 예전처럼 조용히 건너뛰면 동기화됨으로 기록돼 편집이 영영 가지 않는다.
    *
    * 바뀌지 않은 미디어는 다시 올리지 않고 Notion 의 그 블록을 둔다({@link ImageHandler.keepUploadedMedia}).
-   * 블록 방식은 블록을 모두 지우므로 둘 수 없다 — 예전처럼 모두 다시 올린다.
+   * 블록 방식은 노트의 미디어를 둘 수 없다 — 예전처럼 모두 다시 올린다. 페이지 끝의 폴더 첨부(ADR-056)는 노트 밖의 것이라
+   * 블록째 두고 새 본문을 그 앞(맨 앞)에 넣는다.
    *
    * @returns 보낸 본문 · 그 지문 · 그대로 둔 미디어({@link PushedBody})
    */
@@ -27610,9 +27735,9 @@ var PagePusher = class {
         deferred.nfm,
         notePath
       );
-      const folderFiles = await this.folderFileLines(pageId);
-      const markdown = folderFiles ? `${body}
-${folderFiles}` : body;
+      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)
@@ -27632,14 +27757,19 @@ ${folderFiles}` : body;
         "\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 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);
@@ -27662,19 +27792,28 @@ ${folderFiles}` : body;
     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()) {
+   * 블록 방식으로 바꿀 본문에서 남길 폴더 첨부 블록(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);
     }
-    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})`
-    );
+    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}) — 본문을
@@ -27914,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.
@@ -28489,13 +28639,13 @@ var PagePuller = class {
    *   받았으면 null — 지문은 Markdown API 의 본문으로만 견준다.
    */
   async fetchPageMarkdown(pageId, options = {}) {
-    const noteFilesOf = (markdown) => this.noteFolderFilesOf(pageId, markdown, 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 found2 = noteFilesOf(result.markdown);
+        const { found: found2, holdsAll } = noteFilesOf(result.markdown);
         return {
           content: await this.resolveBlockLinks(
             this.resolveNotionIdWikilinks(
@@ -28515,7 +28665,7 @@ var PagePuller = class {
           hasBody: hasBodyBesidesChildren(result.markdown),
           folderFiles: folderFilesInBody(result.markdown),
           noteFiles: found2?.files ?? [],
-          noteFilesComplete: !result.truncated && this.noteFilesHoldAll(pageId, found2?.markdown ?? result.markdown)
+          noteFilesComplete: !result.truncated && holdsAll
         };
       } catch (error) {
         getLogger().warn(
@@ -28526,9 +28676,9 @@ var PagePuller = class {
     let noteFiles = [];
     let noteFilesComplete = true;
     const fallback = await pageBlocksToObsidian(this.notionClient, pageId, (markdown) => {
-      const found2 = noteFilesOf(markdown);
+      const { found: found2, holdsAll } = noteFilesOf(markdown);
       noteFiles = found2?.files ?? [];
-      noteFilesComplete = this.noteFilesHoldAll(pageId, found2?.markdown ?? markdown);
+      noteFilesComplete = holdsAll;
       return found2?.markdown ?? markdown;
     });
     this.discovery.collectInlineDbRefs(pageId, fallback.markdown);
@@ -28547,24 +28697,39 @@ var PagePuller = class {
       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 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;
       }
-    });
-  }
-  /** 폴더 첨부를 뗀 본문에 적어 둔 폴더 첨부가 남지 않았나 — {@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) ?? ""));
+      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,
@@ -29035,13 +29200,12 @@ 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 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(
@@ -29996,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);
@@ -30008,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,
@@ -30848,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());