@im-nobsidian/core 0.17.1 → 0.19.0

package/dist/index.js

@@ -5994,6 +5994,9 @@ function anchorBlockOf(block) {
     text: (body?.rich_text ?? []).map((t) => t.plain_text ?? "").join("")
   };
 }
+function flattenBlockTree(blocks) {
+  return blocks.flatMap((block) => [block, ...flattenBlockTree(block.children ?? [])]);
+}
 var ANCHORED_WIKILINK_RE = new LookbehindRegExp(
   /\[\[([^[\]|]*#[^[\]|]*?)\\?(?:\|[^[\]]+)?\]\]/g,
   void 0,
@@ -6037,7 +6040,7 @@ var WikilinkResolver = class {
           const target = display === void 0 ? written : withoutTableAliasEscape(written);
           const label = display ?? target;
           const anchored = this.anchorLink(target, display, input.context.anchors);
-          if (anchored) return anchored;
+          if (anchored?.link) return anchored.link;
           if (this.resolve) {
             const entry = this.resolve(target);
             if (entry) {
@@ -6048,6 +6051,7 @@ var WikilinkResolver = class {
             }
           }
           const params = display ? { text: target, display } : { text: target };
+          if (anchored?.miss) params.anchor = anchored.miss;
           params.__anchor = computeAnchor(input.content, base + offset);
           preserveMarkers.push({
             type: "wikilink",
@@ -6065,16 +6069,19 @@ var WikilinkResolver = class {
   }
   /**
    * `[[노트#제목]]` · `[[노트#^블록]]` · `[[#제목]]` → `[글자](https://www.notion.so/<페이지>#<블록>)`. 글자는 별칭,
-   * 없으면 Obsidian 이 보이는 「노트 > 제목」 — pull 이 그 글자면 별칭을 붙이지 않는다. 대상 페이지 · 블록을 못 찾으면 null.
+   * 없으면 Obsidian 이 보이는 「노트 > 제목」 — pull 이 그 글자면 별칭을 붙이지 않는다. 앵커 링크가 아니면 null, 못 풀면
+   * 그 까닭({@link AnchorMiss}).
    */
   anchorLink(target, display, anchors) {
     const split = anchors ? splitAnchor(target) : null;
     if (!anchors || !split) return null;
     const pageId = split.note === "" ? anchors.selfPageId : this.resolve?.(split.note)?.notionPageId ?? null;
-    if (!pageId) return null;
+    if (!pageId) return { miss: "page" };
     const blockId = anchors.blockOf(pageId, split.anchor);
-    if (!blockId) return null;
-    return `[${display ?? anchorDisplay(split.note, split.anchor)}](${notionBlockUrl(pageId, blockId)})`;
+    if (!blockId) return { miss: "block" };
+    return {
+      link: `[${display ?? anchorDisplay(split.note, split.anchor)}](${notionBlockUrl(pageId, blockId)})`
+    };
   }
 };
 
@@ -12897,6 +12904,76 @@ function createDefaultPipeline(options) {
   return pipeline;
 }
 
+// src/sync/vault-file-index.ts
+var INDEX_MAX_AGE_MS = 5e3;
+function keyOf(path) {
+  return path.normalize("NFC").toLowerCase();
+}
+function baseNameOf(path) {
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+function folderOf(path) {
+  const slash = path.lastIndexOf("/");
+  return slash === -1 ? "" : path.slice(0, slash);
+}
+var VaultFileIndex = class {
+  constructor(vaultFs, now = Date.now) {
+    this.vaultFs = vaultFs;
+    this.now = now;
+  }
+  vaultFs;
+  now;
+  byName = null;
+  builtAt = 0;
+  /**
+   * `linkpath`(이름 또는 경로 끝)로 끝나는 볼트 파일 — 가까운 것부터: 노트 폴더 안(얕은 것 먼저) → 짧은 경로 → 가나다. 지금
+   * 있는 것만 돌려준다.
+   */
+  async find(linkpath, noteFolder) {
+    if (this.byName === null || this.now() - this.builtAt > INDEX_MAX_AGE_MS) await this.rebuild();
+    const key = keyOf(linkpath.replace(/^\/+/, ""));
+    const suffix = `/${key}`;
+    const matches = (this.byName?.get(keyOf(baseNameOf(key))) ?? []).filter((path) => {
+      const k = keyOf(path);
+      return k === key || k.endsWith(suffix);
+    });
+    const existing = [];
+    for (const path of rank(matches, noteFolder)) {
+      if (await this.vaultFs.exists(path)) existing.push(path);
+    }
+    return existing;
+  }
+  async rebuild() {
+    const byName2 = /* @__PURE__ */ new Map();
+    let files = [];
+    try {
+      files = await this.vaultFs.listNonMarkdownFiles() ?? [];
+    } catch {
+    }
+    for (const file of files) {
+      const key = keyOf(baseNameOf(file.path));
+      const list = byName2.get(key) ?? [];
+      list.push(file.path);
+      byName2.set(key, list);
+    }
+    this.byName = byName2;
+    this.builtAt = this.now();
+  }
+};
+function rank(paths, noteFolder) {
+  const inside2 = (path) => {
+    if (noteFolder === void 0) return Number.POSITIVE_INFINITY;
+    const folder = folderOf(path);
+    if (noteFolder === "") return folder.split("/").filter(Boolean).length;
+    if (folder !== noteFolder && !folder.startsWith(`${noteFolder}/`))
+      return Number.POSITIVE_INFINITY;
+    return folder.slice(noteFolder.length).split("/").filter(Boolean).length;
+  };
+  return [...paths].sort(
+    (a, b) => inside2(a) - inside2(b) || a.length - b.length || a.localeCompare(b)
+  );
+}
+
 // src/utils/mime.ts
 var EXTENSION_TO_BLOCK_TYPE = {
   ".png": "image",
@@ -13018,11 +13095,11 @@ function getMimeType(filename) {
 }
 
 // src/sync/uploaded-media.ts
-function keyOf(pageId) {
+function keyOf2(pageId) {
   return `uploaded_media:${compactNotionId(pageId)}`;
 }
 function rememberUploadedMedia(stateDb, pageId, media) {
-  const key = keyOf(pageId);
+  const key = keyOf2(pageId);
   if (media.length === 0 && stateDb.getMeta(key) === null) return;
   stateDb.setMeta(key, JSON.stringify(media.map(rowOf)));
 }
@@ -13030,14 +13107,14 @@ function rememberReceivedMedia(stateDb, pageId, media) {
   if (media.length === 0) return;
   const merged = recallUploadedMedia(stateDb, pageId);
   for (const item of media) merged.set(item.fileId, item);
-  stateDb.setMeta(keyOf(pageId), JSON.stringify([...merged.values()].map(rowOf)));
+  stateDb.setMeta(keyOf2(pageId), JSON.stringify([...merged.values()].map(rowOf)));
 }
 function rowOf({ fileId, target, localPath, fileHash }) {
   return fileHash === void 0 ? { fileId, target, localPath } : { fileId, target, localPath, fileHash };
 }
 function recallUploadedMedia(stateDb, pageId) {
   const known = /* @__PURE__ */ new Map();
-  const value = stateDb?.getMeta(keyOf(pageId));
+  const value = stateDb?.getMeta(keyOf2(pageId));
   if (!value) return known;
   try {
     for (const row of JSON.parse(value)) {
@@ -13226,8 +13303,11 @@ function nameHashOf(fullHash) {
 var IMAGE_STEM_MAX = 50;
 function withoutOwnHash(name, hash) {
   if (hash.length !== NAME_HASH_LENGTH || !/^[0-9a-f]+$/.test(hash)) return name;
-  const stripped = name.replace(new RegExp(`-${hash}(\\.[^./]*)?$`), "");
-  return stripped === "" ? name : stripped;
+  const tail = new RegExp(`-${hash}(\\.[^./]*)?$`).exec(name);
+  const stem = tail ? name.slice(0, tail.index) : "";
+  if (stem === "") return name;
+  const extension = tail?.[1] ?? "";
+  return extension && !stem.toLowerCase().endsWith(extension.toLowerCase()) ? `${stem}${extension}` : stem;
 }
 function imageStemOf(uploadedName, pageTitle) {
   const stem = safeImageStem(uploadedName.replace(/\.[^.]*$/, ""));
@@ -13270,7 +13350,7 @@ function localEmbedTargets(note) {
   }
   return targets;
 }
-function folderOf(notePath) {
+function folderOf2(notePath) {
   return notePath?.includes("/") ? notePath.slice(0, notePath.lastIndexOf("/")) : void 0;
 }
 function messageOf2(error) {
@@ -13371,7 +13451,7 @@ var ImageHandler = class {
     if (!target || /^https?:\/\//.test(target) || target.includes("\n")) return null;
     const vaultPath = stripAlias2(target);
     if (baseName(vaultPath) !== uploadedName) return null;
-    for (const candidate of this.vaultCandidates(vaultPath, noteFolder)) {
+    for await (const candidate of this.vaultCandidates(vaultPath, noteFolder)) {
       try {
         if (await this.vaultFs.exists(candidate)) return target;
       } catch {
@@ -13411,7 +13491,7 @@ var ImageHandler = class {
     const spans = notionMediaSpans(markdown);
     if (spans.length === 0) return markdown;
     const known = pageId ? recallUploadedMedia(this.stateDb, pageId) : /* @__PURE__ */ new Map();
-    const noteFolder = folderOf(notePath);
+    const noteFolder = folderOf2(notePath);
     let result = markdown;
     for (const span of spans) {
       const uploadedName = this.uploadedNameOf(span.url);
@@ -13441,7 +13521,7 @@ var ImageHandler = class {
       return null;
     }
     for (const target of targets) {
-      for (const candidate of this.vaultCandidates(stripAlias2(target), noteFolder)) {
+      for await (const candidate of this.vaultCandidates(stripAlias2(target), noteFolder)) {
         let localHash;
         try {
           localHash = sha256Of(await this.vaultFs.readBinary(candidate));
@@ -13584,7 +13664,7 @@ var ImageHandler = class {
    * @returns 보일 이름은 받을 때 붙인 내용 해시를 뗀 것이다 — 다시 받으면 같은 이름 · 같은 경로가 된다.
    */
   async uploadNoteAttachment(target, notePath) {
-    const uploaded = await this.uploadLocalImage(target, folderOf(notePath));
+    const uploaded = await this.uploadLocalImage(target, folderOf2(notePath));
     const base = uploaded.localPath.split("/").pop() ?? uploaded.localPath;
     const name = withoutOwnHash(base, nameHashOf(uploaded.fileHash));
     const extension = /\.[^./]+$/.exec(base)?.[0] ?? "";
@@ -13597,7 +13677,7 @@ var ImageHandler = class {
     if (!this.notionClient) return [];
     const localImages = images.filter((img) => !img.isExternal && img.localPath);
     if (localImages.length === 0) return [];
-    const noteFolder = folderOf(notePath);
+    const noteFolder = folderOf2(notePath);
     const results = [];
     const imageBlocks = [];
     for (const img of localImages) {
@@ -13684,7 +13764,7 @@ var ImageHandler = class {
       }
       return segment;
     });
-    const noteFolder = folderOf(notePath);
+    const noteFolder = folderOf2(notePath);
     const kept = [];
     let result = "";
     let cursor = 0;
@@ -13775,7 +13855,7 @@ var ImageHandler = class {
       if (kept.length > 0) this.rememberUploads(pageId, kept);
       return empty;
     }
-    const noteFolder = folderOf(notePath);
+    const noteFolder = folderOf2(notePath);
     const uploaded = [];
     const remembered = [...kept];
     const unsupported2 = [];
@@ -13933,29 +14013,37 @@ var ImageHandler = class {
   /**
    * 임베드 경로가 가리킬 수 있는 볼트 실제 파일 후보를 우선순위대로 만든다(F23).
    * Obsidian 위키링크 임베드는 노트 옆 파일을 파일명만으로 참조하는 게 관례라
-   * 노트 폴더 → 볼트 루트 → attachments/ 순.
+   * 노트 폴더 → 볼트 루트 → attachments/ 순. 세 곳에 없으면 볼트 어디서든 이름으로 찾는다({@link VaultFileIndex}).
    *
    * push(업로드)와 pull(원본 복원)이 **같은 사다리**를 봐야 왕복이 닫힌다. 예전에는
    * pull 쪽이 볼트 루트만 확인해서, `__e2e_probe__/노트.md` 안의 `![[t-img.png]]` 는
    * 올라갈 때는 노트 폴더에서 잘 찾아 올리고도 내려올 때는 원본을 못 찾아 사본을
    * 새로 받았다(실측) — 왕복할 때마다 첨부가 한 벌씩 늘어난다.
    */
-  vaultCandidates(localPath, noteFolder) {
-    const candidates = [];
+  async *vaultCandidates(localPath, noteFolder) {
+    const ladder = [];
     if (noteFolder && !localPath.includes("/")) {
-      candidates.push(`${noteFolder}/${localPath}`);
+      ladder.push(`${noteFolder}/${localPath}`);
+    }
+    ladder.push(localPath, `${this.attachmentFolder}/${localPath}`);
+    yield* ladder;
+    for (const found2 of await this.fileIndex.find(localPath, noteFolder)) {
+      if (!ladder.includes(found2)) yield found2;
     }
-    candidates.push(localPath, `${this.attachmentFolder}/${localPath}`);
-    return candidates;
+  }
+  indexOfFiles = null;
+  /** 볼트의 첨부 이름표 — 처음 쓸 때 만든다. */
+  get fileIndex() {
+    this.indexOfFiles ??= new VaultFileIndex(this.vaultFs);
+    return this.indexOfFiles;
   }
   /**
    * 임베드 경로를 볼트 실제 파일로 해석해 읽는다(F23).
    * 폴백은 조용히 진행하고, 전부 실패했을 때만 마지막 오류를 던진다.
    */
   async readImageFromVault(localPath, noteFolder) {
-    const candidates = this.vaultCandidates(localPath, noteFolder);
     let lastError;
-    for (const candidate of candidates) {
+    for await (const candidate of this.vaultCandidates(localPath, noteFolder)) {
       try {
         return { buffer: await this.vaultFs.readBinary(candidate), resolvedPath: candidate };
       } catch (error) {
@@ -14148,12 +14236,20 @@ var ImageHandler = class {
         const hash = nameHashOf(fileHash);
         const extension = this.guessFileExtension(url, response.headers.get("content-type"));
         const name = withoutOwnHash(caption, hash);
-        const safeName = truncateBytes(
-          name.replace(/[^a-zA-Z0-9가-힣\s._-]/g, "").replace(/\s+/g, "-").slice(0, 80),
-          FILE_SYSTEM_NAME_MAX_BYTES - utf8Bytes(`-${hash}${extension}`)
-        );
-        const fileName2 = `${safeName}-${hash}${extension}`;
-        const localPath = `${this.attachmentFolder}/${fileName2}`;
+        const hasExtension2 = extension !== "" && name.toLowerCase().endsWith(extension.toLowerCase());
+        const stem = hasExtension2 ? name.slice(0, -extension.length) : name;
+        const localPath = `${this.attachmentFolder}/${this.fileNameOf(stem, hash, extension)}`;
+        const legacyPath = `${this.attachmentFolder}/${this.fileNameOf(name, hash, extension)}`;
+        if (hasExtension2 && await this.vaultFs.exists(legacyPath)) {
+          return {
+            originalUrl: url,
+            localPath: legacyPath,
+            hash,
+            size: buffer.length,
+            fileHash,
+            name
+          };
+        }
         await this.vaultFs.ensureFolder(this.attachmentFolder);
         await this.vaultFs.writeBinary(localPath, buffer);
         return { originalUrl: url, localPath, hash, size: buffer.length, fileHash, name };
@@ -14163,6 +14259,14 @@ var ImageHandler = class {
     }
     throw lastError;
   }
+  /** 받은 파일의 이름 — `<줄기>-<해시><확장자>`. */
+  fileNameOf(stem, hash, extension) {
+    const safeName = truncateBytes(
+      stem.replace(/[^a-zA-Z0-9가-힣\s._-]/g, "").replace(/\s+/g, "-").slice(0, 80),
+      FILE_SYSTEM_NAME_MAX_BYTES - utf8Bytes(`-${hash}${extension}`)
+    );
+    return `${safeName}-${hash}${extension}`;
+  }
   isNotionImageUrl(url) {
     return this.isNotionFileUrl(url);
   }
@@ -15049,7 +15153,74 @@ function selectStaleDbArtifacts(files, localFolder, keepPaths) {
   return stale;
 }
 
+// src/sync/folder-files.ts
+function unescapeCaption(caption) {
+  return caption.replace(/\\([\\`*_{}[\]()#+\-.!|~<>$&])/g, "$1").trim();
+}
+function folderFilesOf(markdown, namedOnly) {
+  let rest = markdown.replace(CHILD_PAGE_TAG_RE, "").replace(CHILD_DATABASE_TAG_RE, "").replace(/<empty-block\/>/g, "");
+  const files = [];
+  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;
+    rest = rest.replace(span.full, "");
+    files.push({ url: span.url, name });
+  }
+  return files.length > 0 && rest.trim() === "" ? files : null;
+}
+var WIKI_EMBED_RE = /!\[\[([^\]|#^\n]+)/g;
+var MD_EMBED_RE = /!\[[^\]\n]*\]\(<?([^)>\s]+)/g;
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+var WIKILINK_TARGET_RE = /\[\[([^\]|#^\n]+)/g;
+function baseNameOf2(target) {
+  let decoded = target.trim();
+  try {
+    decoded = decodeURI(decoded);
+  } catch {
+  }
+  return decoded.slice(decoded.lastIndexOf("/") + 1).normalize("NFC");
+}
+function embeddedNamesOf(notes) {
+  const names = /* @__PURE__ */ new Set();
+  for (const text of notes) {
+    for (const m of text.matchAll(WIKI_EMBED_RE)) names.add(baseNameOf2(m[1]));
+    for (const m of text.matchAll(MD_EMBED_RE)) names.add(baseNameOf2(m[1]));
+    const frontmatter = FRONTMATTER_RE.exec(text)?.[1];
+    if (frontmatter) {
+      for (const m of frontmatter.matchAll(WIKILINK_TARGET_RE)) names.add(baseNameOf2(m[1]));
+    }
+  }
+  return names;
+}
+function keyOf3(pageId) {
+  return `folder_files:${compactNotionId(pageId)}`;
+}
+function folderFileIdsOf(stateDb, pageId) {
+  const raw = stateDb.getMeta(keyOf3(pageId));
+  if (!raw) return /* @__PURE__ */ new Map();
+  try {
+    return new Map(Object.entries(JSON.parse(raw)));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function forgetFolderFileId(stateDb, pageId, localPath) {
+  const ids = folderFileIdsOf(stateDb, pageId);
+  if (!ids.delete(localPath)) return;
+  stateDb.setMeta(keyOf3(pageId), JSON.stringify(Object.fromEntries(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)));
+}
+
 // src/sync/file-handler.ts
+function isHiddenPath(path) {
+  return path.split("/").some((part) => part.startsWith("."));
+}
 function getFolderPath(filePath) {
   const parts = filePath.split("/");
   return parts.length > 1 ? parts.slice(0, -1).join("/") : "";
@@ -15064,6 +15235,8 @@ var FileHandler = class {
     this.customFetch = options?.fetch;
     this.downloadTimeoutMs = options?.downloadTimeoutMs ?? DEFAULT_CONFIG.advanced.mediaDownloadTimeoutMs;
     this.itemTimeoutMs = options?.itemTimeoutMs ?? DEFAULT_CONFIG.advanced.itemTimeoutMs;
+    this.deleteSync = options?.deleteSync ?? false;
+    this.attachmentsFolder = (options?.attachmentsFolder ?? DEFAULT_CONFIG.paths.attachments).replace(/^\/+|\/+$/g, "");
   }
   vaultFs;
   notionClient;
@@ -15072,6 +15245,8 @@ var FileHandler = class {
   customFetch;
   downloadTimeoutMs;
   itemTimeoutMs;
+  attachmentsFolder;
+  deleteSync;
   get fetchFn() {
     return this.customFetch ?? globalThis.fetch;
   }
@@ -15081,7 +15256,9 @@ var FileHandler = class {
     if (folderFiles.length === 0) return [];
     const results = [];
     for (const file of folderFiles) {
-      const result = await this.pushSingleFile(file, folderPageId);
+      const existing = this.stateDb.getFileRegistry(file.path);
+      if (existing && await this.isUnchanged(existing, file)) continue;
+      const result = await this.pushSingleFile(file, folderPageId, existing);
       if (result) results.push(result);
     }
     return results;
@@ -15102,18 +15279,11 @@ var FileHandler = class {
    *   내면 같은 말이 두 번 나온다). 없으면 경고 로그로만 남는다.
    * @returns 업로드 결과. 변경 없음(스킵)이거나 실패했으면 null.
    */
-  async pushSingleFile(file, folderPageId, failed) {
-    const existing = this.stateDb.getFileRegistry(file.path);
-    if (existing) {
-      if (existing.fileSize === file.size) return null;
-      const buffer = await this.vaultFs.readBinary(file.path);
-      const currentHash = createHash("sha256").update(buffer).digest("hex");
-      if (existing.fileHash === currentHash) return null;
-    }
+  async pushSingleFile(file, folderPageId, existing, failed) {
     await this.sema.acquire();
     try {
       return await withDeadline(
-        () => this.uploadFile(file, folderPageId),
+        () => this.uploadFile(file, folderPageId, existing),
         this.itemTimeoutMs,
         `\uCCA8\uBD80 \uC5C5\uB85C\uB4DC ${file.path}`
       );
@@ -15134,6 +15304,22 @@ var FileHandler = class {
       this.sema.release();
     }
   }
+  /** 올린 뒤 바뀌지 않았나 — 크기가 같으면 읽지 않는다. */
+  async isUnchanged(existing, file) {
+    if (existing.fileSize === file.size) return true;
+    const buffer = await this.vaultFs.readBinary(file.path);
+    return existing.fileHash === createHash("sha256").update(buffer).digest("hex");
+  }
+  /** pull 이 받은 것을 두는 폴더 안인가. */
+  inAttachmentsFolder(path) {
+    return this.attachmentsFolder !== "" && path.startsWith(`${this.attachmentsFolder}/`);
+  }
+  /** 폴더 첨부를 둘 Notion 페이지 — 폴더 노트 없는 폴더의 페이지(폴더 레코드)만. 맨 위는 루트 기록이 있을 때만. */
+  folderPageOf(folder) {
+    const record = this.stateDb.getByPath(folder || "__root__");
+    if (!record?.notionPageId) return null;
+    return folder === "" || isFolderRecord(record) ? record.notionPageId : null;
+  }
   /**
    * 업로드 후보 목록 — 도구 내부 산출물(`.base`/`.notion.json`)은 아예 빼고, Notion 이 받지 않는
    * 형식은 따로 모은다.
@@ -15160,7 +15346,7 @@ var FileHandler = class {
    * @param failed 올리지 못한 첨부를 담을 곳 — push 결과의 `failed` 를 넘기면 CLI · 플러그인이 처리하지 못한 것으로
    *   보인다. 예전엔 경고 로그로만 남아 push 가 「실패 0」 으로 끝났다.
    */
-  async pushAllFiles(failed) {
+  async pushAllFiles(failed, folders) {
     const { uploadable: allFiles, unsupported: unsupported2 } = await this.listUploadableFiles();
     if (unsupported2.length > 0) {
       const names = unsupported2.slice(0, LOGGED_NAMES).map((f) => f.path);
@@ -15169,32 +15355,225 @@ 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 (allFiles.length === 0) return [];
-    const filesByFolder = /* @__PURE__ */ new Map();
+    if (this.deleteSync) await this.removeDeletedFolderFiles();
+    const pending = [];
     for (const file of allFiles) {
-      const folder = getFolderPath(file.path);
-      const list = filesByFolder.get(folder) ?? [];
-      list.push(file);
-      filesByFolder.set(folder, list);
+      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 (await this.isUnchanged(existing, file)) continue;
+      }
+      pending.push({ file, existing });
+    }
+    if (pending.length === 0) return [];
+    const embedded = pending.some((p) => !p.existing) ? await this.embeddedNames() : /* @__PURE__ */ new Set();
+    const byFolder = /* @__PURE__ */ new Map();
+    for (const item of pending) {
+      if (!item.existing && embedded.has(item.file.path.slice(item.file.path.lastIndexOf("/") + 1).normalize("NFC"))) {
+        continue;
+      }
+      const folder = getFolderPath(item.file.path);
+      const list = byFolder.get(folder) ?? [];
+      list.push(item);
+      byFolder.set(folder, list);
     }
     const results = [];
-    for (const [folderPath, files] of filesByFolder) {
-      const folderRecord = folderPath ? this.stateDb.getByPath(folderPath) : this.stateDb.getByPath("__root__");
-      const folderPageId = folderRecord?.notionPageId;
-      if (!folderPageId) {
-        if (files.length > 0) {
-          getLogger().debug(
-            `\uD3F4\uB354 \uD398\uC774\uC9C0 \uC5C6\uC74C, \uD30C\uC77C \uC2A4\uD0B5: ${folderPath || "(\uB8E8\uD2B8)"} (${files.length}\uAC1C)`
+    const stranded = [];
+    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);
+      }
+    }
+    this.reportStranded(stranded);
+    return results;
+  }
+  /**
+   * 볼트에서 지운 폴더 첨부를 Notion 에서도 지운다(deleteSync) — 폴더 페이지에 적힌 파일 가운데 볼트에 없는 것의 블록과 기록.
+   * 포함 · 제외 패턴으로 빠진 파일은 볼트에 있어 지우지 않는다.
+   */
+  async removeDeletedFolderFiles() {
+    const removed = [];
+    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 (removed.length > 0) {
+      getLogger().info(
+        `[Im-Nobsidian] \uBCFC\uD2B8\uC5D0\uC11C \uC9C0\uC6B4 \uD3F4\uB354 \uCCA8\uBD80 ${removed.length}\uAC1C\uB97C Notion \uC5D0\uC11C \uC9C0\uC6C0`
+      );
+    }
+  }
+  /** 폴더 첨부를 둘 페이지 — 노트 없는 폴더면 마련한다. 둘 곳이 없으면 그 파일들을 `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";
+    if (!pageId && folder !== "" && folders && !this.stateDb.getByPath(folder)) {
+      try {
+        await folders.ensureFolderPage(folder);
+        pageId = this.folderPageOf(folder);
+      } catch (error) {
+        reason = error instanceof Error ? error.message : String(error);
+      }
+    }
+    if (!pageId) stranded.push(...items.map(({ file }) => ({ path: file.path, reason })));
+    return pageId;
+  }
+  /**
+   * 둘 곳이 없어 올리지 않은 폴더 첨부 — 경고로 알린다. 예전에는 디버그 로그로만 남아 파일이 Notion 에 가지 않은 것을 알 수
+   * 없었다. 노트에 붙이면 그 노트와 함께 올라간다.
+   */
+  reportStranded(stranded) {
+    if (stranded.length === 0) return;
+    const names = stranded.slice(0, LOGGED_NAMES).map((f) => `${f.path}(${f.reason})`);
+    const rest = stranded.length - names.length;
+    getLogger().warn(
+      `[Im-Nobsidian] \uD3F4\uB354\uC5D0 Notion \uC790\uB9AC\uAC00 \uC5C6\uC5B4 \uC62C\uB9AC\uC9C0 \uC54A\uC740 \uCCA8\uBD80 ${stranded.length}\uAC1C \u2014 \uB178\uD2B8\uC5D0 \uBD99\uC774\uBA74 \uD568\uAED8 \uC62C\uB77C\uAC04\uB2E4: ${names.join(", ")}${rest > 0 ? ` \uC678 ${rest}\uAC1C` : ""}`
+    );
+  }
+  /** 볼트의 노트가 붙인 파일 이름 — {@link embeddedNamesOf}. 읽지 못한 노트는 건너뛴다. */
+  async embeddedNames() {
+    const texts = [];
+    for (const note of await this.vaultFs.listMarkdownFiles()) {
+      try {
+        texts.push(await this.vaultFs.readFile(note.path));
+      } catch {
+      }
+    }
+    return embeddedNamesOf(texts);
+  }
+  /**
+   * 폴더 페이지의 폴더 첨부를 그 폴더에 받는다 — 올린 이름 그대로. Notion 파일 id 가 적어 둔 것과 같으면(올린 볼트 · 앞서
+   * 받은 볼트) 받지 않는다. Notion 에서 바뀐 파일은 볼트 쪽이 그대로일 때만 덮는다 — 볼트에서도 고쳤으면 두고 알린다(다음
+   * push 가 볼트의 것을 올린다).
+   *
+   * @param complete 본문을 끝까지 받았나 — 그럴 때만 Notion 에서 지운 파일을 볼트에서 지운다(deleteSync). 잘린 본문에 없는
+   *   파일은 지운 것이 아니다.
+   * @returns 새로 받거나 바꾼 파일 수
+   */
+  async receiveFolderFiles(folder, pageId, files, complete2 = false) {
+    const known = new Map(
+      this.stateDb.getFilesByPageId(pageId).map((entry) => [entry.localPath, entry])
+    );
+    const ids = folderFileIdsOf(this.stateDb, pageId);
+    let received = 0;
+    for (const file of files) {
+      const localPath = folder ? `${folder}/${file.name}` : file.name;
+      const fileId = notionFileIdOf(file.url);
+      const entry = known.get(localPath);
+      if (entry && fileId && ids.get(localPath) === fileId) continue;
+      if (entry && fileId && !ids.has(localPath)) {
+        rememberFolderFileId(this.stateDb, pageId, localPath, fileId);
         continue;
       }
-      for (const file of files) {
-        const result = await this.pushSingleFile(file, folderPageId, failed);
-        if (result) results.push(result);
+      if (entry && !fileId) continue;
+      await this.sema.acquire();
+      try {
+        if (await this.receiveOne(localPath, folder, pageId, file, entry ?? null)) received++;
+        if (fileId) rememberFolderFileId(this.stateDb, pageId, localPath, fileId);
+      } catch (error) {
+        getLogger().warn(
+          `[Im-Nobsidian] \uD3F4\uB354 \uCCA8\uBD80\uB97C \uBC1B\uC9C0 \uBABB\uD568 (${localPath}): ${error instanceof Error ? error.message : String(error)}`
+        );
+      } finally {
+        this.sema.release();
       }
     }
-    return results;
+    if (complete2 && this.deleteSync) {
+      const names = new Set(files.map((file) => file.name));
+      for (const entry of known.values()) {
+        const name = entry.localPath.slice(entry.localPath.lastIndexOf("/") + 1);
+        if (getFolderPath(entry.localPath) !== folder || names.has(name)) continue;
+        if (!ids.has(entry.localPath)) continue;
+        await this.removeLocalFolderFile(pageId, entry);
+      }
+    }
+    return received;
+  }
+  /**
+   * Notion 에서 지운 폴더 첨부를 볼트에서 지운다 — 지난 동기화 그대로일 때만. 볼트에서 고쳤으면 두고 기록만 놓는다 — 다음 push
+   * 가 다시 올린다(노트의 원격 삭제와 같은 규칙).
+   */
+  async removeLocalFolderFile(pageId, entry) {
+    try {
+      if (await this.vaultFs.exists(entry.localPath)) {
+        const local = createHash("sha256").update(await this.vaultFs.readBinary(entry.localPath)).digest("hex");
+        if (local === entry.fileHash) {
+          await this.vaultFs.deleteFile(entry.localPath);
+          getLogger().info(
+            `[Im-Nobsidian] Notion \uC5D0\uC11C \uC9C0\uC6B4 \uD3F4\uB354 \uCCA8\uBD80\uB97C \uBCFC\uD2B8\uC5D0\uC11C \uC9C0\uC6C0: ${entry.localPath}`
+          );
+        } else {
+          getLogger().warn(
+            `[Im-Nobsidian] Notion \uC5D0\uC11C \uC9C0\uC6B4 \uD3F4\uB354 \uCCA8\uBD80\uB97C \uBCFC\uD2B8\uC5D0\uC11C \uACE0\uCCD0 \uB450\uC5C8\uC74C \u2014 \uB2E4\uC74C push \uAC00 \uB2E4\uC2DC \uC62C\uB9B0\uB2E4: ${entry.localPath}`
+          );
+        }
+      }
+      this.stateDb.deleteFileRegistry(entry.localPath);
+      forgetFolderFileId(this.stateDb, pageId, entry.localPath);
+    } catch (error) {
+      getLogger().warn(
+        `[Im-Nobsidian] Notion \uC5D0\uC11C \uC9C0\uC6B4 \uD3F4\uB354 \uCCA8\uBD80\uB97C \uBCFC\uD2B8\uC5D0\uC11C \uC9C0\uC6B0\uC9C0 \uBABB\uD568 (${entry.localPath}): ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * 폴더 첨부 하나를 받는다. 볼트에 같은 경로가 있으면: 같은 내용이면 적기만 하고, 지난 동기화 뒤 볼트에서 그대로인 파일은
+   * 덮고(`entry`), 그 밖(볼트에서 고친 것 · 처음 보는 다른 파일)은 두고 알린다.
+   *
+   * @returns 볼트에 썼는가
+   */
+  async receiveOne(localPath, folder, pageId, file, entry) {
+    const response = await fetchForDownload(this.fetchFn, file.url, this.downloadTimeoutMs);
+    if (!response.ok) {
+      throw new Error(`\uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: ${response.status} ${response.statusText}`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const hash = createHash("sha256").update(buffer).digest("hex");
+    let wrote = false;
+    if (await this.vaultFs.exists(localPath)) {
+      const localHash = createHash("sha256").update(await this.vaultFs.readBinary(localPath)).digest("hex");
+      if (localHash !== hash) {
+        if (entry?.fileHash !== localHash) {
+          getLogger().warn(
+            `[Im-Nobsidian] \uD3F4\uB354 \uCCA8\uBD80\uB97C \uBC1B\uC9C0 \uC54A\uC74C \u2014 \uBCFC\uD2B8\uC758 ${localPath} \uAC00 Notion \uC758 \uAC83\uACFC \uB2E4\uB974\uB2E4${entry ? "(\uC591\uCABD\uC5D0\uC11C \uACE0\uCE68 \u2014 \uB2E4\uC74C push \uAC00 \uBCFC\uD2B8\uC758 \uAC83\uC744 \uC62C\uB9B0\uB2E4)" : "(\uAC19\uC740 \uC774\uB984\uC758 \uB2E4\uB978 \uD30C\uC77C)"}`
+          );
+          return false;
+        }
+        await this.vaultFs.writeBinary(localPath, buffer);
+        wrote = true;
+      }
+    } else {
+      await this.vaultFs.ensureFolder(folder || ".");
+      await this.vaultFs.writeBinary(localPath, buffer);
+      wrote = true;
+    }
+    this.stateDb.registerFile({
+      localPath,
+      notionPageId: pageId,
+      fileUploadId: "",
+      fileType: getBlockType(file.name),
+      fileHash: hash,
+      fileSize: buffer.length
+    });
+    return wrote;
   }
   async downloadFileBlock(url, filename, targetFolder) {
     const response = await fetchForDownload(this.fetchFn, url, this.downloadTimeoutMs);
@@ -15225,7 +15604,7 @@ var FileHandler = class {
     }
     return results;
   }
-  async uploadFile(file, parentPageId) {
+  async uploadFile(file, parentPageId, previous) {
     const buffer = await this.vaultFs.readBinary(file.path);
     const filename = file.path.split("/").pop() ?? "file";
     const contentType = getMimeType(filename);
@@ -15233,8 +15612,12 @@ var FileHandler = class {
     const hash = createHash("sha256").update(buffer).digest("hex");
     const blob = new Blob([buffer], { type: contentType });
     const fileUploadId = await this.notionClient.uploadFile(blob, filename, contentType);
-    const block = this.createFileBlock(blockType, fileUploadId);
-    await this.notionClient.appendChildren(parentPageId, [block]);
+    const block = this.createFileBlock(blockType, fileUploadId, filename);
+    const [created] = await this.notionClient.appendChildBlocks(parentPageId, [block]);
+    if (previous) await this.removeOlderBlocks(parentPageId, filename, created?.id);
+    const url = created ? fileUrlOfBlock(created) : null;
+    const fileId = url ? notionFileIdOf(url) : null;
+    if (fileId) rememberFolderFileId(this.stateDb, parentPageId, file.path, fileId);
     this.stateDb.registerFile({
       localPath: file.path,
       notionPageId: parentPageId,
@@ -15246,10 +15629,25 @@ var FileHandler = class {
     getLogger().info(`\uD30C\uC77C \uC5C5\uB85C\uB4DC \uC644\uB8CC: ${file.path} \u2192 ${blockType} \uBE14\uB85D`);
     return { localPath: file.path, fileUploadId, blockType };
   }
-  createFileBlock(blockType, fileUploadId) {
+  /** 이 페이지에서 같은 이름의 파일 블록 중 방금 붙인 것 말고를 지운다. */
+  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);
+    }
+  }
+  /**
+   * 폴더 첨부의 파일 블록 — 캡션에 파일 이름을 적는다. 받는 쪽이 그 표시로 폴더 첨부를 알아본다({@link folderFilesOf}) —
+   * 자식 페이지가 없는 폴더 페이지는 PDF 하나만 붙인 노트와 모양이 같다.
+   */
+  createFileBlock(blockType, fileUploadId, name) {
     const fileRef = {
       type: "file_upload",
-      file_upload: { id: fileUploadId }
+      file_upload: { id: fileUploadId },
+      caption: [{ type: "text", text: { content: name } }]
     };
     switch (blockType) {
       case "image":
@@ -15295,6 +15693,77 @@ async function readLocalNote(vaultFs, path) {
   }
 }
 
+// src/utils/db-row-path.ts
+function selectDbRowFiles(files, localFolder) {
+  const prefix = localFolder.endsWith("/") ? localFolder : `${localFolder}/`;
+  return files.filter((file) => {
+    if (!file.path.startsWith(prefix)) return false;
+    const rel = file.path.slice(prefix.length);
+    return rel.length > 0 && !rel.includes("/");
+  });
+}
+var PAGE_ID_SUFFIX_LENGTHS = [8, 16, 32];
+var PAGE_ID_SUFFIX = new RegExp(
+  ` \\((?:${PAGE_ID_SUFFIX_LENGTHS.map((length) => `[0-9a-f]{${length}}`).join("|")})\\)$`,
+  "i"
+);
+function withoutPageIdSuffix(name) {
+  return name.replace(PAGE_ID_SUFFIX, "");
+}
+function pagePathCandidates(dir, safeName, pageId) {
+  const base = dir ? `${dir}/${safeName}` : safeName;
+  const raw = pageId.replace(/-/g, "");
+  return [
+    `${base}.md`,
+    ...PAGE_ID_SUFFIX_LENGTHS.map((len) => `${base} (${raw.slice(0, len)}).md`)
+  ];
+}
+function resolveDbRowPath(localFolder, safeName, pageId, lookupByPath) {
+  const ownedBySelf = (candidate) => {
+    const owner = lookupByPath(candidate);
+    if (!owner) return true;
+    return owner.notionPageId != null && notionIdsEqual(owner.notionPageId, pageId);
+  };
+  const candidates = pagePathCandidates(localFolder, safeName, pageId);
+  return candidates.find(ownedBySelf) ?? candidates[candidates.length - 1];
+}
+function inClaimOrder(items, chosen, idOf2) {
+  const slots = items.flatMap((item, index) => chosen(item) ? [index] : []);
+  const key = (item) => compactNotionId(idOf2(item));
+  const members = slots.map((index) => items[index]).sort((a, b) => key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0);
+  const ordered = [...items];
+  slots.forEach((slot, k) => ordered[slot] = members[k]);
+  return ordered;
+}
+
+// src/utils/path-key.ts
+function pathKey(path) {
+  return path.normalize("NFC").toLowerCase();
+}
+function foldedOwnerOf(stateDb, candidate, pageId) {
+  return stateDb.getByPathKey(candidate).some(
+    (record) => record.obsidianPath !== candidate && !(record.notionPageId != null && notionIdsEqual(record.notionPageId, pageId))
+  );
+}
+
+// src/sync/untracked-note.ts
+async function findUntrackedNote(stateDb, vaultFs, dir, safeName, pageId, taken) {
+  const [natural, ...suffixed] = pagePathCandidates(dir, safeName, pageId);
+  const order = [
+    ...suffixed.map((path) => ({ path, existing: "own" })),
+    { path: natural, existing: "name" }
+  ];
+  for (const candidate of order) {
+    if (taken(pathKey(candidate.path)) || stateDb.getByPath(candidate.path)) continue;
+    if (foldedOwnerOf(stateDb, candidate.path, pageId)) continue;
+    if (await vaultFs.exists(candidate.path)) return candidate;
+  }
+  return null;
+}
+function relinksWithoutContent(note, unlinkedVault) {
+  return note.existing === "own" || unlinkedVault;
+}
+
 // src/conflict/merger.ts
 function threeWayMerge(base, local, remote) {
   const baseLines = base.split("\n");
@@ -15760,49 +16229,6 @@ function withUnsentProperties(content, keys, before) {
   return (lines && replaceFrontmatterLines(content, lines)) ?? content;
 }
 
-// src/utils/db-row-path.ts
-function selectDbRowFiles(files, localFolder) {
-  const prefix = localFolder.endsWith("/") ? localFolder : `${localFolder}/`;
-  return files.filter((file) => {
-    if (!file.path.startsWith(prefix)) return false;
-    const rel = file.path.slice(prefix.length);
-    return rel.length > 0 && !rel.includes("/");
-  });
-}
-var PAGE_ID_SUFFIX_LENGTHS = [8, 16, 32];
-var PAGE_ID_SUFFIX = new RegExp(
-  ` \\((?:${PAGE_ID_SUFFIX_LENGTHS.map((length) => `[0-9a-f]{${length}}`).join("|")})\\)$`,
-  "i"
-);
-function withoutPageIdSuffix(name) {
-  return name.replace(PAGE_ID_SUFFIX, "");
-}
-function pagePathCandidates(dir, safeName, pageId) {
-  const base = dir ? `${dir}/${safeName}` : safeName;
-  const raw = pageId.replace(/-/g, "");
-  return [
-    `${base}.md`,
-    ...PAGE_ID_SUFFIX_LENGTHS.map((len) => `${base} (${raw.slice(0, len)}).md`)
-  ];
-}
-function resolveDbRowPath(localFolder, safeName, pageId, lookupByPath) {
-  const ownedBySelf = (candidate) => {
-    const owner = lookupByPath(candidate);
-    if (!owner) return true;
-    return owner.notionPageId != null && notionIdsEqual(owner.notionPageId, pageId);
-  };
-  const candidates = pagePathCandidates(localFolder, safeName, pageId);
-  return candidates.find(ownedBySelf) ?? candidates[candidates.length - 1];
-}
-function inClaimOrder(items, chosen, idOf2) {
-  const slots = items.flatMap((item, index) => chosen(item) ? [index] : []);
-  const key = (item) => compactNotionId(idOf2(item));
-  const members = slots.map((index) => items[index]).sort((a, b) => key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0);
-  const ordered = [...items];
-  slots.forEach((slot, k) => ordered[slot] = members[k]);
-  return ordered;
-}
-
 // src/sync/note-title.ts
 function explicitTitle(frontmatter) {
   const title = frontmatter.title;
@@ -18770,16 +19196,6 @@ function joinPath(folder, name) {
   return folder === "" ? name : `${folder}/${name}`;
 }
 
-// src/utils/path-key.ts
-function pathKey(path) {
-  return path.normalize("NFC").toLowerCase();
-}
-function foldedOwnerOf(stateDb, candidate, pageId) {
-  return stateDb.getByPathKey(candidate).some(
-    (record) => record.obsidianPath !== candidate && !(record.notionPageId != null && notionIdsEqual(record.notionPageId, pageId))
-  );
-}
-
 // src/converter/unknown-tag-fallback.ts
 var UNKNOWN_BLOCK_TAG_RE2 = /<unknown (url|id)="([^"]*)"[^>]*\/>/g;
 var UNKNOWN_MENTION_TAG_RE = /<unknown_mention\s+url="([^"]*)"[^>]*?\/>/g;
@@ -19114,7 +19530,7 @@ var PageDecorations = class {
       }
       case "local":
         try {
-          const uploaded = await this.imageHandler.uploadLocalImage(source.target, folderOf2(path));
+          const uploaded = await this.imageHandler.uploadLocalImage(source.target, folderOf3(path));
           return { type: "file_upload", file_upload: { id: uploaded.fileUploadId } };
         } catch (error) {
           getLogger().warn(
@@ -19159,7 +19575,7 @@ function sameText(a, b) {
   if (isEmptyFrontmatterValue(before) && isEmptyFrontmatterValue(after)) return true;
   return String(before) === String(after);
 }
-function folderOf2(notePath) {
+function folderOf3(notePath) {
   return notePath.includes("/") ? notePath.slice(0, notePath.lastIndexOf("/")) : void 0;
 }
 
@@ -19455,7 +19871,13 @@ var DatabaseSyncer = class {
     const target = await this.queryRows(dbConfig, opts);
     if (target.kind !== "rows") return [];
     const folderMove = opts?.followPlacement && !opts.paths ? await this.unblocked(this.placementMoveOf(dbConfig, target.meta, opts.movingInVault)) : null;
-    const planned = await this.planRows(dbConfig, target, opts?.paths, opts?.movingInVault);
+    const planned = await this.planRows(
+      dbConfig,
+      target,
+      opts?.paths,
+      opts?.movingInVault,
+      opts?.relinkTaken
+    );
     if (!folderMove) return planned;
     const moved = (path) => within(path, folderMove.from) ? folderMove.to + path.slice(folderMove.from.length) : path;
     return [
@@ -19534,7 +19956,7 @@ var DatabaseSyncer = class {
       return false;
     }
   }
-  async planRows(dbConfig, target, paths, movingInVault = /* @__PURE__ */ new Set()) {
+  async planRows(dbConfig, target, paths, movingInVault = /* @__PURE__ */ new Set(), relinkTaken = /* @__PURE__ */ new Set()) {
     const opts = { paths };
     const planned = [];
     const claimed = /* @__PURE__ */ new Map();
@@ -19555,6 +19977,24 @@ var DatabaseSyncer = class {
       if (action === "skip") continue;
       if (!record) {
         const name = sanitizeFileName(this.notionClient.extractTitle(page));
+        const untracked = await findUntrackedNote(
+          this.stateDb,
+          this.vaultFs,
+          dbConfig.localFolder,
+          name,
+          page.id,
+          (key) => relinkTaken.has(key) || claimed.has(key)
+        );
+        if (untracked && relinksWithoutContent(untracked, this.unlinkedVault)) {
+          relinkTaken.add(pathKey(untracked.path));
+          planned.push({
+            pageId: page.id,
+            path: untracked.path,
+            operation: "create",
+            relink: true
+          });
+          continue;
+        }
         const ownerOf = await this.rowPathOwners(dbConfig.localFolder, name, page.id);
         const path = resolveDbRowPath(dbConfig.localFolder, name, page.id, (p) => {
           const owner = claimed.get(pathKey(p));
@@ -20370,20 +20810,16 @@ var DatabaseSyncer = class {
    * `claimExistingNote` 와 같은 규칙이다.
    */
   async claimExistingRow(localFolder, safeName, pageId) {
-    const [natural, ...suffixed] = pagePathCandidates(localFolder, safeName, pageId);
-    const order = [
-      ...suffixed.map((path) => [path, "own"]),
-      [natural, "name"]
-    ];
-    for (const [candidate, existing] of order) {
-      const key = pathKey(candidate);
-      if (this.relinkClaims.has(key) || this.stateDb.getByPath(candidate)) continue;
-      if (foldedOwnerOf(this.stateDb, candidate, pageId)) continue;
-      if (!await this.vaultFs.exists(candidate)) continue;
-      this.relinkClaims.add(key);
-      return { path: candidate, existing };
-    }
-    return null;
+    const found2 = await findUntrackedNote(
+      this.stateDb,
+      this.vaultFs,
+      localFolder,
+      safeName,
+      pageId,
+      (key) => this.relinkClaims.has(key)
+    );
+    if (found2) this.relinkClaims.add(pathKey(found2.path));
+    return found2;
   }
   /**
    * 상태 기록에 없던 행 노트를 이 행과 다시 잇는다(P7) — 페이지의 `relinkExistingNote` 와 같은 규칙. 글이 같으면 잇고, 다르면
@@ -20963,7 +21399,7 @@ async function verifyPageCompleteness(remote, local, rootPageId) {
 var ID_SUFFIX = new RegExp(
   ` \\((?:${PAGE_ID_SUFFIX_LENGTHS.map((len) => `[0-9a-f]{${len}}`).join("|")})\\)$`
 );
-function folderOf3(record) {
+function folderOf4(record) {
   if (record.fileType === "db-row") return null;
   if (isFolderRecord(record)) return record.obsidianPath;
   const slash = record.obsidianPath.lastIndexOf("/");
@@ -20980,10 +21416,10 @@ function findNestedFolderPages(records) {
   const found2 = [];
   for (const inner of records) {
     if (inner.notionPageId === null || inner.notionParentId === null) continue;
-    const folder = folderOf3(inner);
+    const folder = folderOf4(inner);
     if (folder === null) continue;
     const outer = byPage.get(compactNotionId(inner.notionParentId));
-    if (!outer || outer === inner || folderOf3(outer) !== folder) continue;
+    if (!outer || outer === inner || folderOf4(outer) !== folder) continue;
     found2.push({
       folder,
       outer: { path: outer.obsidianPath, notionPageId: outer.notionPageId },
@@ -21358,7 +21794,7 @@ var VaultSchemaRenames = class {
       const meta = await this.notionClient.getDatabaseMeta(databaseId);
       for (const [from, to] of pairs) {
         const carrying = rows.filter((row) => Object.hasOwn(row.current, to));
-        const folder = folderOf4(carrying[0].record.obsidianPath);
+        const folder = folderOf5(carrying[0].record.obsidianPath);
         const owners = meta.dataSources.filter(
           (ds) => ds.properties?.[from] !== void 0
         );
@@ -21524,7 +21960,7 @@ function sameRow(a, b) {
   const keys = Object.keys(left.data);
   return left.content === right.content && keys.length === Object.keys(right.data).length && keys.every((key) => sameFrontmatterValue(left.data[key], right.data[key]));
 }
-function folderOf4(path) {
+function folderOf5(path) {
   const at = path.lastIndexOf("/");
   return at === -1 ? "" : path.slice(0, at);
 }
@@ -24450,7 +24886,7 @@ function rewriteTarget(target, source, context, kind) {
   const shown = keepExtension ? destination : destination.slice(0, -".md".length);
   let next;
   if (resolved.relative) {
-    next = relativePath(folderOf5(source.to), shown);
+    next = relativePath(folderOf6(source.to), shown);
     if (!linkpath.startsWith("./") && next.startsWith("./")) next = next.slice(2);
   } else if (style === "name") {
     const name = baseName3(shown);
@@ -24472,14 +24908,14 @@ function resolveLinkpath(linkpath, sourcePath, files) {
     const matches = byName(files, baseName3(candidate)).filter((file) => file.endsWith(suffix));
     if (matches.length === 1) return found(matches[0], linkpath);
     if (matches.length > 1) {
-      const local = `${folderPrefix(folderOf5(sourcePath))}${candidate}`;
+      const local = `${folderPrefix(folderOf6(sourcePath))}${candidate}`;
       return matches.includes(local) ? found(local, linkpath) : null;
     }
   }
   return null;
 }
 function resolveRelative(linkpath, sourcePath, files) {
-  const joined = normalizeSegments(`${folderPrefix(folderOf5(sourcePath))}${linkpath}`);
+  const joined = normalizeSegments(`${folderPrefix(folderOf6(sourcePath))}${linkpath}`);
   if (joined === null) return null;
   for (const candidate of withExtension(joined)) {
     if (files.has(candidate)) return { ...found(candidate, linkpath), relative: true };
@@ -24538,7 +24974,7 @@ function relativePath(from, to) {
 function encodeMarkdownTarget(next, original) {
   return original.includes("%") || next.includes(" ") ? next.replace(/ /g, "%20") : next;
 }
-function folderOf5(path) {
+function folderOf6(path) {
   const slash = path.lastIndexOf("/");
   return slash === -1 ? "" : path.slice(0, slash);
 }
@@ -25708,23 +26144,32 @@ var PagePusher = class {
     return uploads;
   }
   /**
-   * 노트의 제목 · 블록 링크(`[[노트#제목]]`)가 가리키는 페이지의 맨 위 블록을 읽어 둔다 — 변환은 기다리지 않는다
-   * (anchor-links). 그런 링크가 없으면 읽지 않는다. 읽지 못한 페이지의 링크는 예전처럼 간다.
+   * 노트의 제목 · 블록 링크(`[[노트#제목]]`)가 가리키는 페이지의 블록을 읽어 둔다 — 변환은 기다리지 않는다
+   * (anchor-links). 맨 위 블록에서 모두 찾으면 거기서 멈추고, 못 찾은 앵커가 있으면 콜아웃 · 토글 · 목록 자식까지 읽는다.
+   * 그런 링크가 없으면 읽지 않는다. 읽지 못한 페이지의 링크는 예전처럼 간다.
    *
-   * @param selfPageId 이 노트의 페이지 — `[[#제목]]` 의 대상. 새로 만드는 노트는 아직 없다(그 링크는 다음 push 에 걸린다).
+   * @param selfPageId 이 노트의 페이지 — `[[#제목]]` 의 대상. 새로 만드는 노트는 아직 없다(그 링크는 push 뒤 패스가 다시 보낸다 — `push-link-pass`).
    */
   async anchorLookup(content, selfPageId) {
-    const pages = /* @__PURE__ */ new Set();
+    const pages = /* @__PURE__ */ new Map();
     for (const target of anchoredWikilinkTargets(content)) {
-      const { note } = splitAnchor(target);
+      const { note, anchor } = splitAnchor(target);
       const pageId = note === "" ? selfPageId : this.stateDb.resolveWikilink(note)?.notionPageId ?? null;
-      if (pageId) pages.add(compactNotionId(pageId));
+      if (!pageId) continue;
+      const key = compactNotionId(pageId);
+      pages.set(key, [...pages.get(key) ?? [], anchor]);
     }
     if (pages.size === 0) return void 0;
     const blocks = /* @__PURE__ */ new Map();
-    for (const pageId of pages) {
+    for (const [pageId, anchors] of pages) {
       try {
-        blocks.set(pageId, (await this.notionClient.fetchAllChildren(pageId)).map(anchorBlockOf));
+        const top = (await this.notionClient.fetchAllChildren(pageId)).map(anchorBlockOf);
+        blocks.set(pageId, top);
+        if (anchors.every((anchor) => anchorBlockId(top, anchor) !== null)) continue;
+        blocks.set(
+          pageId,
+          flattenBlockTree(await this.notionClient.getBlockTree(pageId)).map(anchorBlockOf)
+        );
       } catch (error) {
         getLogger().debug(
           `[Im-Nobsidian] \uC81C\uBAA9 \uB9C1\uD06C\uC758 \uB300\uC0C1 \uD398\uC774\uC9C0 \uBE14\uB85D\uC744 \uC77D\uC9C0 \uBABB\uD568 (${pageId}): ${error instanceof Error ? error.message : String(error)}`
@@ -26841,7 +27286,7 @@ async function resolveBlockToPageId(notionClient, blockId) {
 
 // src/sync/page-puller.ts
 var PagePuller = class {
-  constructor(config, stateDb, notionClient, vaultFs, pipeline, imageHandler, propertyMapper, databaseSyncer, observation, drift, placement, detector, discovery) {
+  constructor(config, stateDb, notionClient, vaultFs, pipeline, imageHandler, propertyMapper, databaseSyncer, observation, drift, placement, detector, discovery, fileHandler) {
     this.config = config;
     this.stateDb = stateDb;
     this.notionClient = notionClient;
@@ -26855,6 +27300,7 @@ var PagePuller = class {
     this.placement = placement;
     this.detector = detector;
     this.discovery = discovery;
+    this.fileHandler = fileHandler;
   }
   config;
   stateDb;
@@ -26869,6 +27315,7 @@ var PagePuller = class {
   placement;
   detector;
   discovery;
+  fileHandler;
   dbSchemaLoaded = false;
   _pullImageCount = 0;
   _pullFileCount = 0;
@@ -27003,6 +27450,36 @@ var PagePuller = class {
       sanitizeFileName(this.notionClient.extractTitle(page))
     );
   }
+  /**
+   * dry-run — 실제 pull 이 이 새 페이지를 새로 받지 않고 상태 기록에 없던 노트 · 폴더와 다시 잇는가(P7). 다시 이을 노트(`note`) ·
+   * 이미 있는 폴더(`folder` — 이은 노트가 없는 볼트에서 폴더로만 받으면 만들지 않는다), 아니면 null. 받기 전에는 폴더 노트가 될지
+   * 모른다 — 노트 자리 · 폴더 노트 자리를 차례로 본다. `taken` 은 이번 미리 보기가 이미 이은 자리({@link pathKey}) — 고르면
+   * 더한다. 볼트도 상태 DB 도 바꾸지 않는다.
+   */
+  async plannedRelink(pageId, taken) {
+    const page = this.detector.discoveredPage(pageId) ?? await this.notionClient.getPage(pageId);
+    const safeName = sanitizeFileName(this.notionClient.extractTitle(page));
+    const parentPath = await this.resolveParentPath(page);
+    const folder = parentPath ? `${parentPath}/${safeName}` : safeName;
+    for (const dir of [parentPath, folder]) {
+      const found2 = await findUntrackedNote(
+        this.stateDb,
+        this.vaultFs,
+        dir,
+        safeName,
+        pageId,
+        (key) => taken.has(key)
+      );
+      if (found2 && relinksWithoutContent(found2, this.unlinkedVault)) {
+        taken.add(pathKey(found2.path));
+        return { path: found2.path, kind: "note" };
+      }
+    }
+    const folderExists = this.unlinkedVault && !taken.has(pathKey(folder)) && this.stateDb.getByPath(folder) === null && await this.vaultFs.exists(folder);
+    if (!folderExists) return null;
+    taken.add(pathKey(folder));
+    return { path: folder, kind: "folder" };
+  }
   /**
    * 새 페이지가 놓일 자리가 뺀 자리인가 — 부모 폴더 · 노트 이름 · 폴더 노트가 될 때의 폴더를 본다. 받기 전에는 폴더 노트가
    * 될지 모른다(본문을 받아 봐야 안다) — 어느 쪽이든 빠지면 뺀다. 자연 이름으로 보고, 같은 이름이 있을 때 붙는 id 접미사는
@@ -27025,8 +27502,17 @@ var PagePuller = class {
     if (excluded !== null) return { path: excluded, excluded: true };
     const fetched = await this.fetchPageMarkdown(pageId);
     const hasChildPages = this.hasChildContainers(pageId, fetched.children);
-    if (hasChildPages && !fetched.hasBody) {
-      return this.createFolderOnly(pageId, page, fetched.fingerprint, parentPath, safeName);
+    const folderFiles = fetched.folderFiles && (hasChildPages || fetched.folderFiles.named) ? fetched.folderFiles.files : null;
+    if (hasChildPages && !fetched.hasBody || folderFiles) {
+      const created = await this.createFolderOnly(
+        pageId,
+        page,
+        fetched.fingerprint,
+        parentPath,
+        safeName
+      );
+      if (folderFiles) await this.receiveFolderFiles(created.path, pageId, folderFiles);
+      return created;
     }
     const fileType = hasChildPages ? "folder-note" : "file";
     const noteDir = hasChildPages ? parentPath ? `${parentPath}/${safeName}` : safeName : parentPath;
@@ -27489,7 +27975,8 @@ var PagePuller = class {
           compact: isCompactExport(result.markdown),
           children: extractChildTags(result.markdown),
           fingerprint: remoteBodyFingerprint(result.markdown),
-          hasBody: hasBodyBesidesChildren(result.markdown)
+          hasBody: hasBodyBesidesChildren(result.markdown),
+          folderFiles: folderFilesInBody(result.markdown)
         };
       } catch (error) {
         getLogger().warn(
@@ -27508,9 +27995,34 @@ var PagePuller = class {
       compact: isCompactExport(fallback.markdown),
       children: extractChildTags(fallback.markdown),
       fingerprint: null,
-      hasBody: hasBodyBesidesChildren(fallback.markdown)
+      hasBody: hasBodyBesidesChildren(fallback.markdown),
+      folderFiles: folderFilesInBody(fallback.markdown)
     };
   }
+  /** 폴더 첨부를 받아 받은 파일 수에 더한다. */
+  async receiveFolderFiles(folder, pageId, files, complete2 = false) {
+    this._pullFileCount += await this.fileHandler.receiveFolderFiles(
+      folder,
+      pageId,
+      files,
+      complete2
+    );
+  }
+  /**
+   * 이 폴더 레코드의 Notion 페이지에서 받을 본문이 있나 — dry-run 이 실제 pull({@link pullFolderRecord})과 같게 센다.
+   * 본문이 하위 페이지뿐이면 실제 pull 은 본 것만 적고 고친 것으로 세지 않는다.
+   */
+  async folderPageHasBody(record) {
+    const page = await this.notionClient.getPage(record.notionPageId);
+    if (isTrashedOrArchived(page)) return false;
+    const { markdown } = await this.notionClient.getPageMarkdown(page.id);
+    return hasBodyBesidesChildren(markdown) && folderFilesOf(markdown, false) === null && this.folderNoteRefusal(record.obsidianPath) === null;
+  }
+  /** 이 폴더에 폴더 노트를 둘 수 없는 까닭 — 둘 수 있으면 null. */
+  folderNoteRefusal(folder) {
+    if (isDatabaseMode(this.config)) return "DB \uBAA8\uB4DC\uB294 \uD3F4\uB354 \uB178\uD2B8\uB97C \uBC1B\uC9C0 \uC54A\uC74C";
+    return this.placement.folderLookup().databaseAt(folder) ? "\uADF8 \uD3F4\uB354\uB294 DB \uB77C \uD3F4\uB354 \uB178\uD2B8\uB97C \uB458 \uC218 \uC5C6\uC74C" : null;
+  }
   /**
    * push 가 만든 폴더 페이지(폴더 레코드)의 원격 변경을 받는다(S-17). 폴더 레코드에는 볼트 파일이
    * 없다 — 예전에는 폴더 경로를 파일로 읽어 «빈 로컬 파일» 과 원격 본문의 충돌로 남겼다.
@@ -27527,26 +28039,18 @@ var PagePuller = class {
    * @throws 받을 자리가 없을 때 — 이유와 함께 실패로 남고, 다음 pull 이 다시 본다(기준 시각이
    *         이 변경 앞에 묶인다).
    */
-  /**
-   * 이 폴더 레코드의 Notion 페이지에서 받을 본문이 있나 — dry-run 이 실제 pull({@link pullFolderRecord})과 같게 센다.
-   * 본문이 하위 페이지뿐이면 실제 pull 은 본 것만 적고 고친 것으로 세지 않는다.
-   */
-  async folderPageHasBody(record) {
-    const page = await this.notionClient.getPage(record.notionPageId);
-    if (isTrashedOrArchived(page)) return false;
-    const { markdown } = await this.notionClient.getPageMarkdown(page.id);
-    return hasBodyBesidesChildren(markdown) && this.folderNoteRefusal(record.obsidianPath) === null;
-  }
-  /** 이 폴더에 폴더 노트를 둘 수 없는 까닭 — 둘 수 있으면 null. */
-  folderNoteRefusal(folder) {
-    if (isDatabaseMode(this.config)) return "DB \uBAA8\uB4DC\uB294 \uD3F4\uB354 \uB178\uD2B8\uB97C \uBC1B\uC9C0 \uC54A\uC74C";
-    return this.placement.folderLookup().databaseAt(folder) ? "\uADF8 \uD3F4\uB354\uB294 DB \uB77C \uD3F4\uB354 \uB178\uD2B8\uB97C \uB458 \uC218 \uC5C6\uC74C" : null;
-  }
   async pullFolderRecord(record, page) {
     const folder = record.obsidianPath;
     if (isTrashedOrArchived(page)) return null;
-    const { markdown } = await this.notionClient.getPageMarkdown(page.id);
+    const { markdown, truncated } = await this.notionClient.getPageMarkdown(page.id);
     if (!hasBodyBesidesChildren(markdown)) {
+      await this.receiveFolderFiles(folder, page.id, [], !truncated);
+      this.observation.record(record.id, page, remoteBodyFingerprint(markdown));
+      return null;
+    }
+    const files = folderFilesOf(markdown, false);
+    if (files) {
+      await this.receiveFolderFiles(folder, page.id, files, !truncated);
       this.observation.record(record.id, page, remoteBodyFingerprint(markdown));
       return null;
     }
@@ -27661,21 +28165,22 @@ var PagePuller = class {
    * 이름. 다시 이을지는 받은 글과 견줘 호출측이 정한다({@link relinkExistingNote}) — 잇지 않으면 장부에서 지운다.
    */
   async claimExistingNote(dir, safeName, pageId) {
-    const [natural, ...suffixed] = pagePathCandidates(dir, safeName, pageId);
-    const order = [
-      ...suffixed.map((path) => [path, "own"]),
-      [natural, "name"]
-    ];
-    for (const [candidate, existing] of order) {
-      const key = pathKey(candidate);
-      if (this.claimedPaths.has(key) || this.stateDb.getByPath(candidate)) continue;
-      if (this.foldedOwner(candidate, pageId)) continue;
-      if (!await this.vaultFs.exists(candidate)) continue;
+    const taken = (key) => this.claimedPaths.has(key);
+    for (; ; ) {
+      const found2 = await findUntrackedNote(
+        this.stateDb,
+        this.vaultFs,
+        dir,
+        safeName,
+        pageId,
+        taken
+      );
+      if (!found2) return null;
+      const key = pathKey(found2.path);
       if (this.claimedPaths.has(key)) continue;
-      this.claimedPaths.set(key, candidate);
-      return { path: candidate, existing };
+      this.claimedPaths.set(key, found2.path);
+      return found2;
     }
-    return null;
   }
   async claimFilePath(dir, safeName, pageId) {
     const candidates = pagePathCandidates(dir, safeName, pageId);
@@ -27735,6 +28240,10 @@ var PagePuller = class {
     this.dbSchemaLoaded = true;
   }
 };
+function folderFilesInBody(markdown) {
+  const files = folderFilesOf(markdown, false);
+  return files ? { files, named: folderFilesOf(markdown, true) !== null } : null;
+}
 
 // src/sync/frontmatter-link-resolver.ts
 function resolveFrontmatterRelations(content, idToTitle) {
@@ -27873,17 +28382,31 @@ async function resolveNotionLinks(stateDb, vaultFs, paths, pageTitle, blockAncho
 }
 
 // src/sync/push-link-pass.ts
-function notesWithResolvableWikilinks(stateDb) {
+function notesWithResolvableWikilinks(stateDb, pushed = /* @__PURE__ */ new Set()) {
   const paths = [];
   for (const record of stateDb.getAll()) {
     if (!record.notionPageId || record.status !== "synced") continue;
-    const resolvable = stateDb.getPreserveMarkers(record.obsidianPath).some(
-      (marker) => marker.type === "wikilink" && marker.params.text !== void 0 && stateDb.resolveWikilink(marker.params.text) !== null
-    );
+    const resolvable = stateDb.getPreserveMarkers(record.obsidianPath).some((marker) => marker.type === "wikilink" && resolvesNow(stateDb, record, marker, pushed));
     if (resolvable) paths.push(record.obsidianPath);
   }
   return paths.sort();
 }
+function resolvesNow(stateDb, record, marker, pushed) {
+  const text = marker.params.text;
+  if (text === void 0) return false;
+  const split = splitAnchor(text);
+  if (!split) return stateDb.resolveWikilink(text) !== null;
+  const target = split.note === "" ? null : stateDb.resolveWikilink(split.note);
+  if (split.note !== "" && target === null) return false;
+  switch (marker.params.anchor) {
+    case "page":
+      return true;
+    case "block":
+      return target !== null && target.obsidianPath !== record.obsidianPath && pushed.has(target.obsidianPath);
+    default:
+      return true;
+  }
+}
 
 // src/sync/pull-planner.ts
 var PullPlanner = class {
@@ -27932,12 +28455,19 @@ var PullPlanner = class {
       }
       planned.push(change);
     }
+    const relinks = await this.plannedRelinks(planned);
     const queued = new Set(
       [...filtered, ...restoreChanges].map((change) => compactNotionId(change.pageId))
     );
     const movingInVault = new Set(localPlan?.scan.adoptions.map((adoption) => adoption.record.id));
     const rows = [];
-    for (const row of await this.planDatabaseRows(options.paths, failed, ledger, movingInVault)) {
+    for (const row of await this.planDatabaseRows(
+      options.paths,
+      failed,
+      ledger,
+      movingInVault,
+      relinks.taken
+    )) {
       if (queued.has(compactNotionId(row.pageId))) continue;
       if (row.resolution?.action === "conflict") conflicts.push(row.resolution.conflict);
       else if (row.resolution?.action === "merge") mergedPaths.push(row.path);
@@ -27947,16 +28477,27 @@ var PullPlanner = class {
     const items = [];
     const plannedPath = this.planner.plannedPaths(localPlan);
     for (const change of [...planned, ...restoreChanges]) {
+      const relink = relinks.byPage.get(change.pageId);
+      if (relink) {
+        items.push({ path: relink.path, operation: "create", unchanged: true });
+        continue;
+      }
       const record = this.stateDb.getByNotionId(change.pageId);
       items.push({
         path: (record && plannedPath.get(record.id)) ?? record?.obsidianPath ?? change.title ?? change.pageId,
         operation: change.type === "created" ? "create" : change.type === "deleted" ? "delete" : "update"
       });
     }
-    for (const row of rows) items.push({ path: row.path, operation: row.operation });
+    for (const row of rows) {
+      items.push({
+        path: row.path,
+        operation: row.operation,
+        ...row.relink ? { unchanged: true } : {}
+      });
+    }
     const movedRows = rows.filter((row) => row.moves !== void 0);
     items.forEach((item, index) => options.onProgress?.(index + 1, items.length, item));
-    const count = (type) => planned.filter((c) => c.type === type).length;
+    const count = (type) => planned.filter((c) => c.type === type && !relinks.byPage.has(c.pageId)).length;
     const restoredModified = planned.filter(
       (c) => c.type === "modified" && restoreIds.has(c.pageId)
     ).length;
@@ -27967,7 +28508,13 @@ var PullPlanner = class {
       ].map((change) => this.stateDb.getByNotionId(change.pageId)?.obsidianPath).filter((path) => path !== void 0),
       ...rows.filter((row) => row.operation === "update" && row.restore).map((row) => row.path)
     ];
-    const rowCount = (operation, restore = false) => rows.filter((row) => row.operation === operation && (row.restore ?? false) === restore).length;
+    const rowCount = (operation, restore = false) => rows.filter(
+      (row) => row.operation === operation && (row.restore ?? false) === restore && !row.relink
+    ).length;
+    const relinkedPaths = [
+      ...[...relinks.byPage.values()].filter((relink) => relink.kind === "note").map((relink) => relink.path),
+      ...rows.filter((row) => row.relink).map((row) => row.path)
+    ];
     return {
       created: count("created") + rowCount("create"),
       updated: count("modified") - restoredModified + rowCount("update"),
@@ -27979,6 +28526,7 @@ var PullPlanner = class {
       ...movedRows.length > 0 ? { moved: movedRows.flatMap((row) => row.moves) } : {},
       conflicts,
       ...mergedPaths.length > 0 ? { mergedPaths } : {},
+      ...relinkedPaths.length > 0 ? { relinkedPaths, relinkPending: true } : {},
       writtenPaths: [],
       failed,
       duration: Date.now() - startTime,
@@ -27995,6 +28543,27 @@ var PullPlanner = class {
       }
     };
   }
+  /**
+   * 새 페이지 가운데 실제 pull 이 상태 기록에 없던 노트 · 폴더와 다시 이을 것({@link PagePuller.plannedRelink}) — 페이지 id →
+   * 자리. `taken` 은 고른 자리라 행도 피한다.
+   */
+  async plannedRelinks(planned) {
+    const byPage = /* @__PURE__ */ new Map();
+    const taken = /* @__PURE__ */ new Set();
+    for (const change of planned) {
+      if (change.type !== "created") continue;
+      try {
+        const relink = await this.puller.plannedRelink(change.pageId, taken);
+        if (relink) byPage.set(change.pageId, relink);
+      } catch (error) {
+        getLogger().debug(
+          `[Im-Nobsidian] \uB2E4\uC2DC \uC774\uC744 \uC790\uB9AC\uB97C \uBBF8\uB9AC \uBCF4\uC9C0 \uBABB\uD568 (${change.pageId}):`,
+          error
+        );
+      }
+    }
+    return { byPage, taken };
+  }
   /**
    * 고친 페이지를 실제 pull 이 받는가 — 폴더로만 추적하는 페이지는 본문이 생겼을 때만 폴더 노트로 받는다. 하위 페이지 ·
    * DB 를 옮기기만 해도 그 페이지의 수정 시각이 바뀌어 고친 것으로 보였다. 확인하지 못하면 센다(실제 pull 이 받아 본다).
@@ -28043,7 +28612,7 @@ var PullPlanner = class {
    * (`DatabaseDiscovery.pullDiscoveredDatabases`)를 같은 규칙으로 고른다. 세지 못한 DB 는 이유와
    * 함께 `failed` 에 싣는다 — 세지 못한 것을 없다고 하지 않는다.
    */
-  async planDatabaseRows(paths, failed, ledger, movingInVault) {
+  async planDatabaseRows(paths, failed, ledger, movingInVault, relinkTaken) {
     const configured = this.config.notion.databases ?? [];
     const rows = [];
     const plan = async (dbConfig, resolveDbFolder2) => {
@@ -28057,7 +28626,8 @@ var PullPlanner = class {
             paths,
             resolveDbFolder: resolveDbFolder2,
             followPlacement: resolveDbFolder2 !== void 0,
-            movingInVault
+            movingInVault,
+            relinkTaken
           })
         );
       } catch (error) {
@@ -28844,7 +29414,9 @@ var SyncOrchestrator = class {
       {
         fetch: customFetch,
         downloadTimeoutMs: config.advanced.mediaDownloadTimeoutMs,
-        itemTimeoutMs: config.advanced.itemTimeoutMs
+        itemTimeoutMs: config.advanced.itemTimeoutMs,
+        attachmentsFolder: config.paths.attachments,
+        deleteSync: config.sync.deleteSync
       }
     );
     const propertyMapper = PropertyMapper.fromConfig(config);
@@ -28954,7 +29526,8 @@ var SyncOrchestrator = class {
       this.drift,
       this.placement,
       this.detector,
-      this.discovery
+      this.discovery,
+      this.fileHandler
     );
     this.pullPlanner = new PullPlanner(
       config,
@@ -29074,14 +29647,16 @@ var SyncOrchestrator = class {
    * 있든 없든 push 마다 부른다 — 바뀌지 않은 첨부는 파일 기록이 건너뛴다.
    */
   async pushVaultFiles(failed) {
-    if (this.config.sync.syncFiles === false) return;
+    if (this.config.sync.syncFiles === false) return 0;
     try {
-      const fileResults = await this.fileHandler.pushAllFiles(failed);
+      const fileResults = await this.fileHandler.pushAllFiles(failed, this.placement);
       if (fileResults.length > 0) {
         getLogger().info(`[Im-Nobsidian] ${fileResults.length}\uAC1C \uD30C\uC77C \uC5C5\uB85C\uB4DC \uC644\uB8CC`);
       }
+      return fileResults.length;
     } catch (error) {
       getLogger().warn("[Im-Nobsidian] \uD30C\uC77C \uC5C5\uB85C\uB4DC \uC911 \uC624\uB958:", error);
+      return 0;
     }
   }
   /**
@@ -29089,7 +29664,7 @@ var SyncOrchestrator = class {
    *   적어 push 가 올린다 — dry-run 은 받지 않아 원격이 바뀐 그대로라, 원격을 보고 거절하지 않는다.
    */
   /**
-   * @param relinkedByPull 같은 sync 의 dry-run pull 이 다시 이을 것이라고 미리 봤다 — 실제 sync 는 받으며 먼저 잇고 올리므로
+   * @param relinkedByPull 같은 sync 의 dry-run pull 이 받거나 다시 이을 것이 있다 — 실제 sync 는 받으며 먼저 잇고 올리므로
    *   상태 기록이 비었어도 막지 않는다({@link assertVaultLinked}).
    */
   async executePush(options, mergedByPull = /* @__PURE__ */ new Set(), relinkedByPull = false) {
@@ -29170,12 +29745,13 @@ var SyncOrchestrator = class {
         ...viewPlan.refused,
         ...viewed2.failed
       ];
-      if (!options?.dryRun && !options?.signal?.aborted) await this.pushVaultFiles(failed2);
+      const uploadedFiles2 = !options?.dryRun && !options?.signal?.aborted ? await this.pushVaultFiles(failed2) : 0;
       return {
         created: 0,
         updated: 0,
         deleted: 0,
         moved: 0,
+        ...uploadedFiles2 > 0 ? { uploadedFiles: uploadedFiles2 } : {},
         failed: failed2,
         duration: Date.now() - startTime,
         ...edited2.applied.length > 0 ? { schemaEdits: edited2.applied } : {},
@@ -29446,7 +30022,7 @@ var SyncOrchestrator = class {
           );
         }
       };
-      const relinkable = notesWithResolvableWikilinks(this.stateDb).filter(
+      const relinkable = notesWithResolvableWikilinks(this.stateDb, pushedBodies).filter(
         (path) => inAnyPathScope(path, options?.paths) && !excludeSet?.has(path)
       );
       await runPool(relinkable, relink, {
@@ -29454,7 +30030,7 @@ var SyncOrchestrator = class {
         signal: options?.signal
       });
     }
-    await this.pushVaultFiles(failed);
+    const uploadedFiles = await this.pushVaultFiles(failed);
     this.stateDb.setMeta("last_push_at", (/* @__PURE__ */ new Date()).toISOString());
     this.stateDb.setMeta(LAST_SYNC_META_KEY, (/* @__PURE__ */ new Date()).toISOString());
     this.stateDb.setMeta(PUSH_IN_PROGRESS_META_KEY, "");
@@ -29466,6 +30042,7 @@ var SyncOrchestrator = class {
       updated: counts.updated,
       deleted: counts.deleted,
       moved: counts.moved,
+      ...uploadedFiles > 0 ? { uploadedFiles } : {},
       failed,
       duration: Date.now() - startTime,
       readOnlySkipped: this.pusher.takeReadOnlySkips(),
@@ -29759,8 +30336,7 @@ var SyncOrchestrator = class {
         },
         moved: [...relocated.moved, ...plan.moved ?? []],
         moveSkipped: relocated.skipped,
-        excluded: [...exclusions.values()],
-        ...this.puller.unlinkedVaultAtStart && plan.created > 0 ? { relinkPending: true } : {}
+        excluded: [...exclusions.values()]
       };
     }
     let pullTotal = workItems.length;
@@ -29972,15 +30548,16 @@ var SyncOrchestrator = class {
     const tagged = (direction) => onProgress && ((current, total, item) => onProgress(current, total, { ...item, direction }));
     const pullResult = await this.executePull({ ...options, onProgress: tagged("pull") });
     const conflicted = options?.dryRun ? pullResult.conflicts.map((conflict) => conflict.syncRecord.obsidianPath) : [];
+    const relinked = options?.dryRun ? pullResult.relinkedPaths ?? [] : [];
     const pushResult = await this.executePush(
       {
         ...options,
         onProgress: tagged("push"),
         paths: options?.paths,
-        excludePaths: [...pullResult.writtenPaths, ...conflicted]
+        excludePaths: [...pullResult.writtenPaths, ...conflicted, ...relinked]
       },
       new Set(options?.dryRun ? pullResult.mergedPaths ?? [] : []),
-      pullResult.relinkPending === true
+      options?.dryRun === true && (pullResult.created > 0 || relinked.length > 0)
     );
     return {
       pull: pullResult,