@im-nobsidian/core 0.17.1 → 0.18.0

package/dist/index.js

@@ -12897,6 +12897,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 +13088,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 +13100,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 +13296,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 +13343,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 +13444,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 +13484,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 +13514,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 +13657,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 +13670,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 +13757,7 @@ var ImageHandler = class {
       }
       return segment;
     });
-    const noteFolder = folderOf(notePath);
+    const noteFolder = folderOf2(notePath);
     const kept = [];
     let result = "";
     let cursor = 0;
@@ -13775,7 +13848,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 +14006,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 +14229,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 +14252,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 +15146,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 +15228,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 +15238,8 @@ var FileHandler = class {
   customFetch;
   downloadTimeoutMs;
   itemTimeoutMs;
+  attachmentsFolder;
+  deleteSync;
   get fetchFn() {
     return this.customFetch ?? globalThis.fetch;
   }
@@ -15081,7 +15249,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 +15272,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 +15297,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 +15339,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 +15348,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 +15597,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 +15605,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 +15622,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":
@@ -19114,7 +19505,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 +19550,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;
 }
 
@@ -20963,7 +21354,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 +21371,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 +21749,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 +21915,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 +24841,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 +24863,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 +24929,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);
 }
@@ -26841,7 +27232,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 +27246,7 @@ var PagePuller = class {
     this.placement = placement;
     this.detector = detector;
     this.discovery = discovery;
+    this.fileHandler = fileHandler;
   }
   config;
   stateDb;
@@ -26869,6 +27261,7 @@ var PagePuller = class {
   placement;
   detector;
   discovery;
+  fileHandler;
   dbSchemaLoaded = false;
   _pullImageCount = 0;
   _pullFileCount = 0;
@@ -27025,8 +27418,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 +27891,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 +27911,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 +27955,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;
     }
@@ -27735,6 +28155,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) {
@@ -28844,7 +29268,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 +29380,8 @@ var SyncOrchestrator = class {
       this.drift,
       this.placement,
       this.detector,
-      this.discovery
+      this.discovery,
+      this.fileHandler
     );
     this.pullPlanner = new PullPlanner(
       config,
@@ -29074,14 +29501,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;
     }
   }
   /**
@@ -29170,12 +29599,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 } : {},
@@ -29454,7 +29884,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 +29896,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(),