@im-nobsidian/core 0.2.1 → 0.3.1

package/dist/index.js

@@ -659,6 +659,16 @@ var StateDB = class _StateDB {
   }
 };
 
+// src/utils/notion-file-url.ts
+function isNotionHostedFileUrl(url) {
+  return url.includes("secure.notion-static.com") || url.includes("prod-files-secure") || // 신형 파일 URL (2024+): https://file.notion.so/f/f/<space>/<file>/<name>?table=block&...
+  url.includes("file.notion.so");
+}
+var NOTION_ATTACHMENT_URI_RE = /^attachment:([0-9a-f-]+):(.+)$/;
+function isNotionAttachmentUri(url) {
+  return NOTION_ATTACHMENT_URI_RE.test(url);
+}
+
 // src/notion/property-mapper.ts
 var DATE_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
 var WIKILINK_REGEX = /^\[\[(.+?)(?:\|.+?)?\]\]$/;
@@ -773,6 +783,16 @@ var PropertyMapper = class {
       }
       case "files": {
         const fileList = Array.isArray(value) ? value : [value];
+        const urls = fileList.map((f) => {
+          if (typeof f === "object" && f !== null && "url" in f) {
+            return String(f.url ?? "");
+          }
+          return String(f);
+        });
+        const hasProtected = urls.some(
+          (u) => WIKILINK_REGEX.test(u.trim()) || isNotionHostedFileUrl(u)
+        );
+        if (hasProtected) return null;
         const filesArr = fileList.map((f) => {
           if (typeof f === "object" && f !== null && "url" in f) {
             const obj = f;
@@ -1108,18 +1128,60 @@ var NotionClient = class _NotionClient {
     return titleArr?.[0]?.plain_text ?? "";
   }
   /**
-   * 발견된 DB 가 **동기화 가능한지**(접근 가능한 data source 가 있는지) 1회 호출로 판별한다.
+   * 발견된 DB 가 **동기화 가능한지**(접근 가능한 data source 가 있는지) 판별한다.
    * 신 모델(2025-09-03)에서 링크드 DB·미공유 데이터 소스·삭제 DB 는 `data_sources` 가
    * 비어, 행 조회(`dataSources.query`)가 404 로 실패하고 그 전에 생성된 빈 폴더/`.base` 만
    * 남긴다. 발견 단계에서 미리 걸러 **빈 폴더/.base 오염 + 매 pull 의 404 노이즈**를 차단한다.
    * 제목은 함께 반환해 호출처가 추가 조회 없이 폴더명을 잡게 한다.
+   *
+   * F25: 원본이 같은 공유 범위에 있으면 linked view 컨테이너도 `data_sources` 가 **채워져**
+   * 온다(실측 — 워크스페이스 8건). 이때 data source 의 parent database 는 원본이므로,
+   * 첫 소스의 parent 가 자신이 아니면 `linkedOriginalDbId` 로 알려 컨테이너가 원본과 같은
+   * 행 집합을 이중 pull(폴더 릴레이 재배치 churn)하는 것을 발견 단계에서 차단한다.
    */
   async getDatabaseSyncability(databaseId) {
     const db = await this.withRateLimit(
       () => this.client.databases.retrieve({ database_id: databaseId })
     );
     const title = Array.isArray(db.title) ? db.title[0]?.plain_text ?? "" : "";
-    return { title, queryable: (db.data_sources?.length ?? 0) > 0 };
+    const firstDsId = db.data_sources?.[0]?.id;
+    if (!firstDsId) return { title, queryable: false };
+    try {
+      const ds = await this.withRateLimit(
+        () => this.client.dataSources.retrieve({ data_source_id: firstDsId })
+      );
+      const ownerDbId = ds.parent?.database_id;
+      if (ownerDbId && normalizeNotionId(ownerDbId) !== normalizeNotionId(databaseId)) {
+        return { title, queryable: true, linkedOriginalDbId: ownerDbId };
+      }
+    } catch {
+    }
+    return { title, queryable: true };
+  }
+  /**
+   * linked database view 컨테이너를 원본 DB 로 해소한다.
+   * 컨테이너 자체는 `data_sources` 가 비어 행 조회가 불가능하지만(getDatabaseSyncability
+   * queryable=false), Views API 의 뷰 상세에는 원본 `data_source_id` 가 실리고 그 data source
+   * 의 parent 가 원본 database 다. 해소 실패(뷰 없음/권한 없음/자기참조)는 null — 호출처가
+   * 기존대로 접근 불가 처리한다.
+   */
+  async resolveLinkedDatabase(databaseId) {
+    try {
+      const views = await this.listDatabaseViews(databaseId);
+      for (const view of views) {
+        if (!view.dataSourceId) continue;
+        const ds = await this.withRateLimit(
+          () => this.client.dataSources.retrieve({ data_source_id: view.dataSourceId })
+        );
+        const originalDbId = ds.parent?.database_id;
+        if (!originalDbId) continue;
+        if (originalDbId.replace(/-/g, "") === databaseId.replace(/-/g, "")) continue;
+        return { originalDbId, viewName: view.name ?? "" };
+      }
+      return null;
+    } catch {
+      return null;
+    }
   }
   async getDatabaseSchema(databaseId) {
     const db = await this.fetchDatabaseModern(databaseId);
@@ -1329,7 +1391,17 @@ var NotionClient = class _NotionClient {
     await this.withRateLimit(() => this.client.blocks.delete({ block_id: blockId }));
   }
   // ─── File Upload ───
+  /** single_part 업로드 상한 (Notion API 규격 20MB) */
+  static SINGLE_PART_MAX_BYTES = 20 * 1024 * 1024;
+  /** multi_part 파트 크기 — 규격상 마지막 파트 제외 5~20MB, 10MB 고정 사용 */
+  static MULTI_PART_CHUNK_BYTES = 10 * 1024 * 1024;
   async uploadFile(fileData, filename, contentType) {
+    if (fileData.type !== contentType) {
+      fileData = new Blob([fileData], { type: contentType });
+    }
+    if (fileData.size > _NotionClient.SINGLE_PART_MAX_BYTES) {
+      return this.uploadFileMultiPart(fileData, filename, contentType);
+    }
     const upload = await this.withRateLimit(
       () => this.client.fileUploads.create({ filename, content_type: contentType })
     );
@@ -1348,6 +1420,34 @@ var NotionClient = class _NotionClient {
     }
     return fileUploadId;
   }
+  /** 20MB 초과 파일의 multi_part 업로드 — part_number 는 API 규격상 문자열("1"부터) */
+  async uploadFileMultiPart(fileData, filename, contentType) {
+    const chunkSize = _NotionClient.MULTI_PART_CHUNK_BYTES;
+    const numberOfParts = Math.ceil(fileData.size / chunkSize);
+    const upload = await this.withRateLimit(
+      () => this.client.fileUploads.create({
+        mode: "multi_part",
+        number_of_parts: numberOfParts,
+        filename,
+        content_type: contentType
+      })
+    );
+    const fileUploadId = upload.id;
+    for (let part = 1; part <= numberOfParts; part++) {
+      const chunk = fileData.slice((part - 1) * chunkSize, part * chunkSize, contentType);
+      await this.withRateLimit(
+        () => this.client.fileUploads.send({
+          file_upload_id: fileUploadId,
+          part_number: String(part),
+          file: { data: chunk, filename }
+        })
+      );
+    }
+    await this.withRateLimit(
+      () => this.client.fileUploads.complete({ file_upload_id: fileUploadId })
+    );
+    return fileUploadId;
+  }
   // ─── Search & Navigation ───
   async search(params) {
     const response = await this.withRateLimit(
@@ -2224,7 +2324,23 @@ var COLUMN_LIST_START = compactMarker("column-list:start");
 var COLUMN_LIST_END = compactMarker("column-list:end");
 var COLUMN_SEP = compactMarker("column");
 var TOC_MARKER = compactMarker("toc");
+function syncedStartMarker(kind, url) {
+  return compactMarker(`synced:start:kind=${kind}&url=${encodeURIComponent(url)}`);
+}
+var SYNCED_END = compactMarker("synced:end");
 var BREADCRUMB_MARKER = compactMarker("breadcrumb");
+function calloutStyleMarker(params) {
+  const kv = [];
+  if (params.icon) kv.push(`icon=${encodeURIComponent(params.icon)}`);
+  if (params.color) kv.push(`color=${encodeURIComponent(params.color)}`);
+  return compactMarker(`callout-style:${kv.join("&")}`);
+}
+function toggleColorMarker(color) {
+  return compactMarker(`toggle-color:${color}`);
+}
+function blockColorMarker(color) {
+  return compactMarker(`block-color:${color}`);
+}
 var PROPERTIES_TAG = `# ${MARKER_BRAND}:properties`;
 var MARKER_BRAND_RE = MARKER_BRAND;
 
@@ -2312,6 +2428,50 @@ var FrontmatterExtractor = class {
   }
 };
 
+// src/utils/md-regions.ts
+function computeAnchor(content, idx) {
+  const before = content.slice(Math.max(0, idx - 32), idx);
+  const sameLine = before.split("\n").pop() ?? "";
+  if (sameLine.trim().length >= 4) return sameLine;
+  const prevLines = content.slice(0, idx).split("\n");
+  for (let i = prevLines.length - 2; i >= 0; i--) {
+    const line = prevLines[i].trim();
+    if (line.length > 0) return line.slice(0, 48);
+  }
+  return "";
+}
+function mapOutsideCodeFences(content, fn) {
+  const lines = content.split("\n");
+  const out = [];
+  let buffer = [];
+  let fence = null;
+  const flush = () => {
+    if (buffer.length > 0) {
+      out.push(fn(buffer.join("\n")));
+      buffer = [];
+    }
+  };
+  for (const line of lines) {
+    const fenceMatch = line.match(/^\s*(```+|~~~+)/);
+    if (fence === null && fenceMatch) {
+      flush();
+      fence = fenceMatch[1][0].repeat(3);
+      out.push(line);
+      continue;
+    }
+    if (fence !== null) {
+      out.push(line);
+      if (fenceMatch && fenceMatch[1].startsWith(fence)) {
+        fence = null;
+      }
+      continue;
+    }
+    buffer.push(line);
+  }
+  flush();
+  return out.join("\n");
+}
+
 // src/converter/pre-processors/wikilink.ts
 var WIKILINK_REGEX2 = /(?<!!)\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
 var WikilinkResolver = class {
@@ -2328,7 +2488,7 @@ var WikilinkResolver = class {
     const preserveMarkers = input.metadata.preserveMarkers ? [...input.metadata.preserveMarkers] : [];
     const resolved = input.content.replace(
       WIKILINK_REGEX2,
-      (_match, target, display) => {
+      (_match, target, display, offset) => {
         const label = display ?? target;
         if (this.resolve) {
           const entry = this.resolve(target);
@@ -2336,10 +2496,12 @@ var WikilinkResolver = class {
             return `<mention-page id="${entry.notionPageId}">${label}</mention-page>`;
           }
         }
+        const params = display ? { text: target, display } : { text: target };
+        params.__anchor = computeAnchor(input.content, offset);
         preserveMarkers.push({
           type: "wikilink",
-          params: display ? { text: target, display } : { text: target },
-          startIndex: 0
+          params,
+          startIndex: offset
         });
         const encodedTarget = encodeURIComponent(target);
         return `[${label}](${WIKILINK_PROTOCOL}${encodedTarget})`;
@@ -2444,6 +2606,11 @@ var EmbedResolver = class {
         }
         return `![${target}](${encodeURI(target)})`;
       }
+      if (isPush && !isExternalUrl(target) && isAttachmentFile(target)) {
+        const fileName = target.split("/").pop() ?? target;
+        return `> \u{1F4CE} ${fileName}
+> ${spacedMarker(`local-file:${target}`)}`;
+      }
       const encoded = encodeURIComponent(target);
       return `[${target}](${EMBED_PROTOCOL}${encoded})`;
     });
@@ -2466,6 +2633,11 @@ var EmbedResolver = class {
 function isImageFile(path) {
   return /\.(png|jpg|jpeg|gif|svg|webp|bmp|ico)$/i.test(path);
 }
+function isAttachmentFile(target) {
+  const path = target.split("|")[0];
+  const ext = /\.([a-z0-9]+)$/i.exec(path)?.[1]?.toLowerCase();
+  return ext !== void 0 && ext !== "md" && ext !== "canvas";
+}
 function isVideoUrl(url) {
   return VIDEO_HOSTS.some((host) => url.includes(host));
 }
@@ -2484,7 +2656,7 @@ var PreserveMarkerCollector = class {
     for (const match of matches) {
       markers.push({
         type: match[1],
-        params: parseMarkerParams(match[2]),
+        params: parseMarkerParams(match[2], input.content, match.index),
         startIndex: match.index
       });
     }
@@ -2494,14 +2666,19 @@ var PreserveMarkerCollector = class {
     };
   }
 };
-function parseMarkerParams(paramString) {
+function parseMarkerParams(paramString, content, index) {
   const params = {};
-  for (const pair of paramString.split("&")) {
-    const eqIdx = pair.indexOf("=");
-    if (eqIdx > 0) {
-      params[pair.slice(0, eqIdx)] = decodeURIComponent(pair.slice(eqIdx + 1));
+  if (paramString.includes("=")) {
+    for (const pair of paramString.split("&")) {
+      const eqIdx = pair.indexOf("=");
+      if (eqIdx > 0) {
+        params[pair.slice(0, eqIdx)] = decodeURIComponent(pair.slice(eqIdx + 1));
+      }
     }
+  } else {
+    params.__raw = paramString;
   }
+  params.__anchor = computeAnchor(content, index);
   return params;
 }
 
@@ -2522,7 +2699,20 @@ var UnsupportedBlockStripper = class {
   }
 };
 function stringifyFrontmatter(content, data) {
-  return matter.stringify({ content }, data);
+  const out = matter.stringify(
+    { content },
+    data
+  );
+  return unquoteFrontmatterDates(out);
+}
+var QUOTED_DATE_LINE_RE = /^([ \t]*[^:\n]+:[ \t]*)'(\d{4}-\d{2}-\d{2})'([ \t]*)$/gm;
+function unquoteFrontmatterDates(out) {
+  if (!out.startsWith("---\n")) return out;
+  const close = out.indexOf("\n---\n", 3);
+  if (close === -1) return out;
+  const fmEnd = close + "\n---\n".length;
+  const fm = out.slice(0, fmEnd).replace(QUOTED_DATE_LINE_RE, "$1$2$3");
+  return fm + out.slice(fmEnd);
 }
 
 // src/converter/pre-processors/properties-table.ts
@@ -2557,6 +2747,7 @@ var PropertiesTableInjector = class {
 
 // src/converter/pre-processors/html-annotation.ts
 var UNDERLINE_REGEX = /<u>([\s\S]*?)<\/u>/g;
+var HIGHLIGHT_REGEX = /(?<!=)==([^=\n]+?)==(?!=)/g;
 var COLOR_SPAN_REGEX = /<span class="notion-(\w+)(-bg)?">([\s\S]*?)<\/span>/g;
 var SPACED_COLOR_REGEX = new RegExp(
   `%% ${MARKER_BRAND_RE}:color:(\\w+(?:_background)?) %%([\\s\\S]*?)%% ${MARKER_BRAND_RE}:end %%`,
@@ -2585,10 +2776,147 @@ var InlineAnnotationPreserver = class {
         return `${compactMarker(`color:${color}`)}${text}%%/color%%`;
       }
     );
+    content = mapOutsideCodeFences(
+      content,
+      (segment) => segment.replace(
+        HIGHLIGHT_REGEX,
+        (_m, text) => `${compactMarker("color:yellow_bg")}${text}%%/color%%`
+      )
+    );
     return { content, metadata: input.metadata };
   }
 };
 
+// src/converter/pre-processors/comment-stripper.ts
+var COMMENT_REGEX = /%%([\s\S]*?)%%/g;
+var HTML_COMMENT_REGEX = /<!--([\s\S]*?)-->/g;
+var CommentStripper = class {
+  name = "CommentStripper";
+  // FrontmatterExtractor(10) 뒤 — YAML 값 속 `%%` 를 본문 주석으로 오인하지 않는다.
+  order = 11;
+  process(input) {
+    if (input.context.direction !== "push") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const markers = input.metadata.preserveMarkers ? [...input.metadata.preserveMarkers] : [];
+    const content = mapOutsideCodeFences(input.content, (segment) => {
+      const afterObsidian = segment.replace(
+        COMMENT_REGEX,
+        (match, body, offset) => {
+          const trimmed = body.trimStart();
+          if (trimmed.startsWith(`${MARKER_BRAND}:`) || trimmed.startsWith("/")) {
+            return match;
+          }
+          markers.push({
+            type: "comment",
+            params: { text: body, __anchor: computeAnchor(segment, offset) },
+            startIndex: offset
+          });
+          return "";
+        }
+      );
+      return afterObsidian.replace(HTML_COMMENT_REGEX, (_match, body, offset) => {
+        markers.push({
+          type: "comment",
+          params: { text: body, style: "html", __anchor: computeAnchor(afterObsidian, offset) },
+          startIndex: offset
+        });
+        return "";
+      });
+    });
+    return {
+      content,
+      metadata: { ...input.metadata, preserveMarkers: markers }
+    };
+  }
+};
+
+// src/converter/pre-processors/footnote-guard.ts
+var FOOTNOTE_TOKEN_REGEX = /(?<!\\)\[\^([^\]\s]+)\]/g;
+var FootnoteGuard = class {
+  name = "FootnoteGuard";
+  order = 12;
+  process(input) {
+    if (input.context.direction !== "push") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const content = mapOutsideCodeFences(
+      input.content,
+      (segment) => segment.replace(FOOTNOTE_TOKEN_REGEX, "\\[^$1]")
+    );
+    return { content, metadata: input.metadata };
+  }
+};
+
+// src/converter/pre-processors/table-alignment.ts
+var DELIMITER_CELL_RE = /^:?-{1,}:?$/;
+function parseDelimiterRow(line) {
+  const trimmed = line.trim();
+  if (!trimmed.includes("-") || !trimmed.includes("|")) return null;
+  const inner = trimmed.replace(/^\|/, "").replace(/\|$/, "");
+  const cells = inner.split("|").map((c) => c.trim());
+  if (cells.length === 0) return null;
+  return cells.every((c) => DELIMITER_CELL_RE.test(c)) ? cells : null;
+}
+function cellAlignment(cell) {
+  const l = cell.startsWith(":");
+  const r = cell.endsWith(":");
+  if (l && r) return "center";
+  if (r) return "right";
+  if (l) return "left";
+  return "none";
+}
+function alignmentsToDelimiter(alignments) {
+  const cells = alignments.map((a) => {
+    switch (a) {
+      case "center":
+        return ":---:";
+      case "right":
+        return "---:";
+      case "left":
+        return ":---";
+      default:
+        return "---";
+    }
+  });
+  return `| ${cells.join(" | ")} |`;
+}
+var TableAlignmentGuard = class {
+  name = "TableAlignmentGuard";
+  order = 45;
+  process(input) {
+    if (input.context.direction !== "push") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const markers = input.metadata.preserveMarkers ? [...input.metadata.preserveMarkers] : [];
+    const lines = input.content.split("\n");
+    let changed = false;
+    for (let i = 1; i < lines.length; i++) {
+      const cells = parseDelimiterRow(lines[i]);
+      if (!cells || !lines[i].includes(":")) continue;
+      const prev = lines[i - 1];
+      if (!prev.includes("|")) continue;
+      markers.push({
+        type: "table-align",
+        params: {
+          align: cells.map(cellAlignment).join(","),
+          __anchor: prev.trim().slice(0, 64),
+          // 원본 구분행 원문. 복원 시 정렬뿐 아니라 셀 폭 패딩까지 그대로 되살려
+          // 라운드트립 delta-0 을 만족시킨다(__ 접두라 마커 렌더링에서 제외).
+          __line: lines[i]
+        },
+        startIndex: 0
+      });
+      lines[i] = alignmentsToDelimiter(cells.map(() => "none"));
+      changed = true;
+    }
+    return {
+      content: changed ? lines.join("\n") : input.content,
+      metadata: { ...input.metadata, preserveMarkers: markers }
+    };
+  }
+};
+
 // src/converter/link-restore.ts
 var NOTION_LINK_REGEX = /\[([^\]]+)\]\((?:https:\/\/(?:www\.)?notion\.so\/|notion:\/\/)([a-f0-9-]+)\)/g;
 var WIKILINK_PRESERVE_REGEX = new RegExp(`\\[([^\\]]+)\\]\\(${WIKILINK_PROTOCOL}([^)]+)\\)`, "g");
@@ -2620,6 +2948,91 @@ var MentionToWikilink = class {
   }
 };
 
+// src/converter/post-processors/escape-normalizer.ts
+var EscapeNormalizer = class {
+  name = "EscapeNormalizer";
+  order = 3;
+  process(input) {
+    if (input.context.direction !== "pull") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const content = mapOutsideCodeFences(
+      input.content,
+      (segment) => segment.replace(/\\\[\^([^\]\\\n]+)\\\]/g, "[^$1]").replace(/\\\[\^/g, "[^").replace(/\\:/g, ":")
+    );
+    return { content, metadata: input.metadata };
+  }
+};
+
+// src/converter/post-processors/highlight-restorer.ts
+var COMPACT_YELLOW_RE = new RegExp(
+  `%%${MARKER_BRAND_RE}:color:yellow(?:_background|_bg)%%([^\\n]*?)%%\\/color%%`,
+  "g"
+);
+var SPACED_YELLOW_RE = new RegExp(
+  `%% ${MARKER_BRAND_RE}:color:yellow(?:_background|_bg) %%([^\\n]*?)%% ${MARKER_BRAND_RE}:end %%`,
+  "g"
+);
+var HighlightRestorer = class {
+  name = "HighlightRestorer";
+  order = 25;
+  process(input) {
+    if (input.context.direction !== "pull") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const content = input.content.replace(COMPACT_YELLOW_RE, (_m, text) => text ? `==${text}==` : "").replace(SPACED_YELLOW_RE, (_m, text) => text ? `==${text}==` : "");
+    return { content, metadata: input.metadata };
+  }
+};
+
+// src/converter/post-processors/table-alignment-restorer.ts
+var TableAlignmentRestorer = class {
+  name = "TableAlignmentRestorer";
+  order = 35;
+  process(input) {
+    if (input.context.direction !== "pull") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const lines = input.content.split("\n");
+    for (let i = 1; i < lines.length - 1; i++) {
+      const delim = parseDelimiterRow(lines[i]);
+      if (!delim || lines[i].includes(":")) continue;
+      const phantom = parseDelimiterRow(lines[i + 1]);
+      if (!phantom || !lines[i + 1].includes(":") || phantom.length !== delim.length) continue;
+      if (!lines[i - 1].includes("|")) continue;
+      lines[i] = alignmentsToDelimiter(phantom.map(cellAlignment));
+      lines.splice(i + 1, 1);
+    }
+    const markers = input.metadata.preserveMarkers ?? [];
+    const remaining = [];
+    for (const marker of markers) {
+      if (marker.type !== "table-align" || !marker.params.align || !marker.params.__anchor) {
+        remaining.push(marker);
+        continue;
+      }
+      const anchor = marker.params.__anchor;
+      const idx = lines.findIndex(
+        (line, i) => i < lines.length - 1 && line.trim().startsWith(anchor) && parseDelimiterRow(lines[i + 1]) !== null
+      );
+      if (idx === -1) continue;
+      const delimCells = parseDelimiterRow(lines[idx + 1]);
+      if (lines[idx + 1].includes(":")) continue;
+      const originalLine = marker.params.__line;
+      if (originalLine && parseDelimiterRow(originalLine)?.length === delimCells.length) {
+        lines[idx + 1] = originalLine;
+        continue;
+      }
+      const alignments = marker.params.align.split(",");
+      while (alignments.length < delimCells.length) alignments.push("none");
+      lines[idx + 1] = alignmentsToDelimiter(alignments.slice(0, delimCells.length));
+    }
+    return {
+      content: lines.join("\n"),
+      metadata: { ...input.metadata, preserveMarkers: remaining }
+    };
+  }
+};
+
 // src/converter/post-processors/preserve-marker-injector.ts
 var PreserveMarkerInjector = class {
   name = "PreserveMarkerInjector";
@@ -2633,23 +3046,90 @@ var PreserveMarkerInjector = class {
       return { content: input.content, metadata: input.metadata };
     }
     let content = input.content;
-    const missingMarkers = markers.filter((m) => !content.includes(this.formatMarker(m)));
-    if (missingMarkers.length === 0) {
+    const missing = markers.filter((m) => {
+      const rendered = this.renderMarker(m);
+      if (rendered === null) return false;
+      if (content.includes(rendered)) return false;
+      return !this.isSemanticallyRestored(m, content);
+    });
+    if (missing.length === 0) {
       return { content, metadata: input.metadata };
     }
-    const sorted = [...missingMarkers].sort((a, b) => a.startIndex - b.startIndex);
-    for (const m of sorted) {
-      const markerText = this.formatMarker(m);
-      const at = Math.max(0, Math.min(m.startIndex, content.length));
-      content = content.slice(0, at) + markerText + content.slice(at);
+    const sorted = [...missing].sort((a, b) => a.startIndex - b.startIndex);
+    for (const marker of sorted) {
+      const rendered = this.renderMarker(marker);
+      if (marker.params?.__anchor === void 0) {
+        const at2 = Math.max(frontmatterEnd(content), Math.min(marker.startIndex, content.length));
+        content = content.slice(0, at2) + rendered + content.slice(at2);
+        continue;
+      }
+      const at = this.findInsertionPoint(marker, content);
+      const before = content.slice(0, at);
+      const needsNewline = before.length > 0 && !before.endsWith("\n");
+      content = before + (needsNewline ? "\n" : "") + rendered + "\n" + content.slice(at);
     }
     return { content, metadata: input.metadata };
   }
-  formatMarker(marker) {
-    const params = Object.entries(marker.params).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
-    return spacedMarker(`${marker.type}:${params}`);
+  /** 마커의 본문 표현. 복원 불가능한(빈) 마커는 null — 삽입하지 않고 폐기한다. */
+  renderMarker(marker) {
+    const params = marker.params ?? {};
+    if (marker.type === "comment") {
+      if (!params.text) return null;
+      return params.style === "html" ? `<!--${params.text}-->` : `%%${params.text}%%`;
+    }
+    if (params.__raw !== void 0) {
+      return spacedMarker(`${marker.type}:${params.__raw}`);
+    }
+    const entries = Object.entries(params).filter(([key]) => !key.startsWith("__"));
+    if (entries.length === 0) return null;
+    const body = entries.map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+    return spacedMarker(`${marker.type}:${body}`);
+  }
+  /** 마커가 이미 원래 문법으로 복원돼 있으면 재삽입은 중복·오염이다. */
+  isSemanticallyRestored(marker, content) {
+    const params = marker.params ?? {};
+    switch (marker.type) {
+      case "wikilink": {
+        const text = params.text;
+        if (!text) return false;
+        return content.includes(`[[${text}]]`) || content.includes(`[[${text}|`);
+      }
+      case "local-image":
+      case "local-file": {
+        const target = params.__raw ?? params.path;
+        return target ? content.includes(`![[${target}]]`) : false;
+      }
+      case "table-align":
+        return true;
+      default:
+        return false;
+    }
+  }
+  /** 삽입 위치: 앵커 → startIndex(줄 경계 보정) 순. 항상 프론트매터 뒤. */
+  findInsertionPoint(marker, content) {
+    const fmEnd = frontmatterEnd(content);
+    const anchor = marker.params?.__anchor;
+    if (anchor && anchor.trim().length >= 4) {
+      const idx = content.indexOf(anchor, fmEnd);
+      if (idx !== -1) {
+        return nextLineStart(content, idx + anchor.length);
+      }
+    }
+    const clamped = Math.max(fmEnd, Math.min(marker.startIndex, content.length));
+    return nextLineStart(content, clamped);
   }
 };
+function frontmatterEnd(content) {
+  if (!content.startsWith("---\n")) return 0;
+  const close = content.indexOf("\n---", 3);
+  if (close === -1) return 0;
+  const lineEnd = content.indexOf("\n", close + 4);
+  return lineEnd === -1 ? content.length : lineEnd + 1;
+}
+function nextLineStart(content, pos) {
+  const nl = content.indexOf("\n", pos);
+  return nl === -1 ? content.length : nl + 1;
+}
 
 // src/converter/post-processors/callout-restorer.ts
 var EMOJI_TYPE_MAP = {
@@ -2785,7 +3265,7 @@ function normalizeDate(dateStr) {
 
 // src/converter/post-processors/local-image-restorer.ts
 var LOCAL_IMAGE_MARKER_REGEX = new RegExp(
-  `>\\s*\u{1F4CE}\\s*[^\\n]*\\n>\\s*%%\\s*${MARKER_BRAND_RE}:local-image:([^\\s]+)\\s*%%`,
+  `>\\s*\u{1F4CE}\\s*[^\\n]*\\n>\\s*%%\\s*${MARKER_BRAND_RE}:local-(?:image|file):([^\\s]+)\\s*%%`,
   "g"
 );
 var LocalImageRestorer = class {
@@ -2897,25 +3377,178 @@ function stripQuotes(s) {
   return s;
 }
 
+// src/converter/post-processors/block-spacer.ts
+var BlockSpacer = class {
+  name = "BlockSpacer";
+  order = 110;
+  process(input) {
+    if (input.context.direction !== "pull") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    return {
+      content: respace(input.content, input.metadata.notionExportCompact),
+      metadata: input.metadata
+    };
+  }
+};
+var LIST_ITEM_RE = /^[ \t]*(?:[-*+]|\d+[.)])\s/;
+var QUOTE_RE = /^[ \t]*>/;
+var CALLOUT_START_RE = /^[ \t]*>\s*\[![^\]]*\]/;
+var TABLE_ROW_RE = /^[ \t]*\|/;
+var FOOTNOTE_DEF_RE = /^\[\^[^\]]+\]:/;
+var FENCE_RE = /^[ \t]*(```+|~~~+)/;
+var MATH_FENCE_RE = /^[ \t]*\$\$\s*$/;
+var BRAND_MARKER_LINE_RE = new RegExp(`^[ \\t]*%%\\s*${MARKER_BRAND}:`);
+var INDENTED_CONTINUATION_RE = /^(?:\t| {2,})\S/;
+function respace(content, sourceCompact) {
+  if (sourceCompact === false) return content;
+  const lines = content.split("\n");
+  const head = [];
+  let start = 0;
+  if (lines[0]?.trim() === "---") {
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i].trim() === "---") {
+        for (let j = 0; j <= i; j++) head.push(lines[j]);
+        start = i + 1;
+        break;
+      }
+    }
+  }
+  if (sourceCompact === void 0 && hasBlankOutsideFences(lines, start)) return content;
+  const blocks = [];
+  let fence = null;
+  let fenceToken = "";
+  let boundary = false;
+  const push = (kind, line) => {
+    blocks.push({ kind, lines: [line] });
+  };
+  const appendToLast = (line) => {
+    blocks[blocks.length - 1].lines.push(line);
+  };
+  const last = () => blocks[blocks.length - 1];
+  for (let i = start; i < lines.length; i++) {
+    const raw = lines[i];
+    if (fence !== null) {
+      appendToLast(raw);
+      const closed = fence === "code" ? FENCE_RE.test(raw) && raw.trim().startsWith(fenceToken) : MATH_FENCE_RE.test(raw);
+      if (closed) fence = null;
+      continue;
+    }
+    if (raw.trim() === "") {
+      boundary = true;
+      continue;
+    }
+    const atBoundary = boundary;
+    boundary = false;
+    const fenceMatch = raw.match(FENCE_RE);
+    if (fenceMatch) {
+      push("fence", raw);
+      fence = "code";
+      fenceToken = fenceMatch[1][0].repeat(3);
+      continue;
+    }
+    if (MATH_FENCE_RE.test(raw)) {
+      push("math", raw);
+      fence = "math";
+      continue;
+    }
+    const line = LIST_ITEM_RE.test(raw) || INDENTED_CONTINUATION_RE.test(raw) ? raw.replace(/^\t+/, (t) => "    ".repeat(t.length)) : raw;
+    if (BRAND_MARKER_LINE_RE.test(line) && blocks.length > 0) {
+      appendToLast(line);
+      continue;
+    }
+    if (LIST_ITEM_RE.test(line)) {
+      if (last()?.kind === "list" && !atBoundary) appendToLast(line);
+      else push("list", line);
+      continue;
+    }
+    if (last()?.kind === "list" && INDENTED_CONTINUATION_RE.test(line)) {
+      appendToLast(line);
+      continue;
+    }
+    if (QUOTE_RE.test(line)) {
+      if (last()?.kind === "quote" && !CALLOUT_START_RE.test(line) && !atBoundary) {
+        appendToLast(line);
+      } else {
+        push("quote", line);
+      }
+      continue;
+    }
+    if (TABLE_ROW_RE.test(line)) {
+      if (last()?.kind === "table" && !atBoundary) appendToLast(line);
+      else push("table", line);
+      continue;
+    }
+    if (FOOTNOTE_DEF_RE.test(line)) {
+      if (last()?.kind === "footnote" && !atBoundary) appendToLast(line);
+      else push("footnote", line);
+      continue;
+    }
+    push("other", line);
+  }
+  const body = blocks.map((b) => b.lines.join("\n")).join("\n\n");
+  const tail = content.endsWith("\n") ? "\n" : "";
+  if (head.length === 0) return body + tail;
+  return `${head.join("\n")}
+
+${body}${tail}`;
+}
+function isCompactExport(rawMarkdown) {
+  return !hasBlankOutsideFences(rawMarkdown.split("\n"), 0);
+}
+function hasBlankOutsideFences(lines, start) {
+  let end = lines.length - 1;
+  while (end >= start && lines[end].trim() === "") end--;
+  let fence = null;
+  let fenceToken = "";
+  for (let i = start; i <= end; i++) {
+    const raw = lines[i];
+    if (fence !== null) {
+      const closed = fence === "code" ? FENCE_RE.test(raw) && raw.trim().startsWith(fenceToken) : MATH_FENCE_RE.test(raw);
+      if (closed) fence = null;
+      continue;
+    }
+    const fenceMatch = raw.match(FENCE_RE);
+    if (fenceMatch) {
+      fence = "code";
+      fenceToken = fenceMatch[1][0].repeat(3);
+      continue;
+    }
+    if (MATH_FENCE_RE.test(raw)) {
+      fence = "math";
+      continue;
+    }
+    if (raw.trim() === "") return true;
+  }
+  return false;
+}
+
 // src/converter/pipeline-factory.ts
 function createDefaultPipeline(options) {
   const pipeline = new ConversionPipeline();
   pipeline.registerPreProcessor(new InlineAnnotationPreserver());
   pipeline.registerPreProcessor(new UnsupportedBlockStripper());
+  pipeline.registerPreProcessor(new CommentStripper());
   pipeline.registerPreProcessor(new FrontmatterExtractor());
+  pipeline.registerPreProcessor(new FootnoteGuard());
   pipeline.registerPreProcessor(new PropertiesTableInjector());
   pipeline.registerPreProcessor(new WikilinkResolver(options?.wikilinkResolver));
   pipeline.registerPreProcessor(new CalloutTransformer());
+  pipeline.registerPreProcessor(new TableAlignmentGuard());
   pipeline.registerPreProcessor(new MathNormalizer());
   pipeline.registerPreProcessor(new EmbedResolver());
   pipeline.registerPreProcessor(new PreserveMarkerCollector());
+  pipeline.registerPostProcessor(new EscapeNormalizer());
   pipeline.registerPostProcessor(new PropertiesTableRestorer());
   pipeline.registerPostProcessor(new LocalImageRestorer());
+  pipeline.registerPostProcessor(new HighlightRestorer());
+  pipeline.registerPostProcessor(new TableAlignmentRestorer());
   pipeline.registerPostProcessor(new PreserveMarkerInjector());
   pipeline.registerPostProcessor(new MentionToWikilink());
   pipeline.registerPostProcessor(new CalloutRestorer());
   pipeline.registerPostProcessor(new ColorAnnotator());
   pipeline.registerPostProcessor(new FrontmatterGenerator());
+  pipeline.registerPostProcessor(new BlockSpacer());
   return pipeline;
 }
 
@@ -3728,6 +4361,87 @@ var EXTENSION_TO_MIME = {
   ".ico": "image/x-icon",
   ".tiff": "image/tiff"
 };
+function scanMarkdownLinks(markdown) {
+  const spans = [];
+  let i = 0;
+  while (i < markdown.length) {
+    const open = markdown.indexOf("[", i);
+    if (open === -1) break;
+    if (markdown[open - 1] === "\\") {
+      i = open + 1;
+      continue;
+    }
+    const isEmbed = markdown[open - 1] === "!" && markdown[open - 2] !== "\\";
+    let depth = 1;
+    let j = open + 1;
+    let broken = false;
+    while (j < markdown.length && depth > 0) {
+      const ch = markdown[j];
+      if (ch === "\\") {
+        j += 2;
+        continue;
+      }
+      if (ch === "\n" && markdown[j + 1] === "\n") {
+        broken = true;
+        break;
+      }
+      if (ch === "[") depth++;
+      else if (ch === "]") depth--;
+      j++;
+    }
+    if (broken || depth !== 0 || markdown[j] !== "(") {
+      i = open + 1;
+      continue;
+    }
+    const label = markdown.slice(open + 1, j - 1);
+    let parenDepth = 1;
+    let k = j + 1;
+    while (k < markdown.length && parenDepth > 0) {
+      const ch = markdown[k];
+      if (ch === "\\") {
+        k += 2;
+        continue;
+      }
+      if (ch === "\n") {
+        broken = true;
+        break;
+      }
+      if (ch === "(") parenDepth++;
+      else if (ch === ")") parenDepth--;
+      k++;
+    }
+    if (broken || parenDepth !== 0) {
+      i = open + 1;
+      continue;
+    }
+    const start = isEmbed ? open - 1 : open;
+    spans.push({
+      full: markdown.slice(start, k),
+      label,
+      url: markdown.slice(j + 1, k - 1),
+      isEmbed
+    });
+    i = k;
+  }
+  return spans;
+}
+function toWikilinkAlias(label) {
+  return label.replace(/!?\[([^\]]*)\]\(([^)]*)\)/g, "$1").replace(/\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g, (_m, t, d) => d ?? t).replace(/[\r\n]+/g, " ").replace(/\]\]/g, ")").replace(/\|/g, "-").trim();
+}
+var INTERNAL_FILE_URL_RE = /^file:\/\/%7B.*%7D%7D$/;
+var FILE_LABEL_PREFIX_RE = /^(?:📎|🎬|🎞|📄|🔊)\s*/u;
+var LOCAL_MARKER_RE = new RegExp(`${MARKER_BRAND_RE}:local-(?:image|file):([^\\s%]+)`, "g");
+function collectLocalMarkerBasenames(markdown) {
+  const names = /* @__PURE__ */ new Set();
+  const unescaped = markdown.replace(/\\/g, "");
+  for (const m of unescaped.matchAll(LOCAL_MARKER_RE)) {
+    names.add(baseName(m[1]));
+  }
+  return names;
+}
+function baseName(path) {
+  return path.split("/").pop() ?? path;
+}
 var ImageHandler = class {
   constructor(vaultFs, attachmentFolder = "attachments", notionClient, customFetch, options, stateDb) {
     this.vaultFs = vaultFs;
@@ -3753,6 +4467,9 @@ var ImageHandler = class {
     return this.customFetch ?? globalThis.fetch;
   }
   async downloadImage(url, pageTitle) {
+    return this.persistImage(await this.fetchImage(url, pageTitle));
+  }
+  async fetchImage(url, pageTitle) {
     const maxRetries = this.maxRetries;
     let lastError = null;
     for (let attempt = 0; attempt < maxRetries; attempt++) {
@@ -3770,38 +4487,67 @@ var ImageHandler = class {
         const contentType = response.headers.get("content-type") ?? "image/png";
         const extension = IMAGE_EXTENSIONS[contentType] ?? this.guessExtension(url) ?? ".png";
         const buffer = Buffer.from(await response.arrayBuffer());
-        const hash = createHash("sha256").update(buffer).digest("hex").slice(0, 12);
+        const fullHash = createHash("sha256").update(buffer).digest("hex");
+        const hash = fullHash.slice(0, 12);
         const safeName = pageTitle.replace(/[^a-zA-Z0-9가-힣\s-]/g, "").replace(/\s+/g, "-").slice(0, 50);
         const fileName = `${safeName}-${hash}${extension}`;
         const localPath = `${this.attachmentFolder}/${fileName}`;
-        await this.vaultFs.ensureFolder(this.attachmentFolder);
-        await this.vaultFs.writeBinary(localPath, buffer);
-        return { originalUrl: url, localPath, hash, size: buffer.length };
+        return { originalUrl: url, localPath, hash, fullHash, buffer };
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
       }
     }
     throw lastError;
   }
-  async downloadAllImages(markdown, pageTitle) {
-    const imageRegex = /!\[([^\]]*)\]\((https?:\/\/[^)]+)\)/g;
-    const matches = [...markdown.matchAll(imageRegex)];
-    const notionMatches = matches.filter((m) => m[2] && this.isNotionImageUrl(m[2]));
-    const internalImageRegex = /!\[([^\]]*)\]\((file:\/\/%7B.*?%7D%7D)\)/g;
-    const internalMatches = [...markdown.matchAll(internalImageRegex)];
+  async persistImage(fetched) {
+    await this.vaultFs.ensureFolder(this.attachmentFolder);
+    await this.vaultFs.writeBinary(fetched.localPath, fetched.buffer);
+    return {
+      originalUrl: fetched.originalUrl,
+      localPath: fetched.localPath,
+      hash: fetched.hash,
+      size: fetched.buffer.length
+    };
+  }
+  async downloadAllImages(markdown, pageTitle, pageId) {
+    const embeds = scanMarkdownLinks(markdown).filter((s) => s.isEmbed);
+    const notionMatches = embeds.filter(
+      (s) => /^https?:\/\//.test(s.url) && this.isNotionImageUrl(s.url)
+    );
+    const internalMatches = embeds.filter((s) => INTERNAL_FILE_URL_RE.test(s.url));
+    for (const span of embeds) {
+      if (isNotionAttachmentUri(span.url)) {
+        getLogger().warn(
+          `[Im-Nobsidian] \uC811\uADFC \uBD88\uAC00 \uCCA8\uBD80(attachment:) \uAC10\uC9C0 \u2014 Notion \uD1B5\uD569\uC5D0 \uACF5\uC720\uB418\uC9C0 \uC54A\uC740 \uC6D0\uBCF8\uC758 \uD30C\uC77C\uC774\uB77C \uB2E4\uC6B4\uB85C\uB4DC\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uC6D0\uBB38\uC744 \uBCF4\uC874\uD569\uB2C8\uB2E4: ${pageTitle}`
+        );
+      }
+    }
     if (notionMatches.length === 0 && internalMatches.length === 0) {
       return { content: markdown, downloads: [] };
     }
+    const registryByHash = /* @__PURE__ */ new Map();
+    if (pageId && this.stateDb) {
+      for (const entry of this.stateDb.getFilesByPageId(pageId)) {
+        const list = registryByHash.get(entry.fileHash) ?? [];
+        list.push(entry.localPath);
+        registryByHash.set(entry.fileHash, list);
+      }
+    }
+    const markerBasenames = collectLocalMarkerBasenames(markdown);
+    const isAppendedCopy = (fetched) => {
+      const paths = registryByHash.get(fetched.fullHash);
+      return paths !== void 0 && paths.some((p) => markerBasenames.has(baseName(p)));
+    };
     const sema = new Sema(this.concurrency);
     const downloads = [];
     let result = markdown;
     const httpResults = await Promise.allSettled(
-      notionMatches.map(async (match) => {
+      notionMatches.map(async (span) => {
         await sema.acquire();
         try {
           return {
-            match,
-            download: await this.downloadImage(match[2], pageTitle)
+            span,
+            fetched: await this.fetchImage(span.url, pageTitle)
           };
         } finally {
           sema.release();
@@ -3810,26 +4556,37 @@ var ImageHandler = class {
     );
     for (const settled of httpResults) {
       if (settled.status !== "fulfilled") continue;
-      const { match, download } = settled.value;
+      const { span, fetched } = settled.value;
+      if (isAppendedCopy(fetched)) {
+        result = result.replace(span.full, "");
+        continue;
+      }
+      const download = await this.persistImage(fetched);
       downloads.push(download);
-      const obsidianEmbed = `![[${download.localPath}${match[1] ? `|${match[1]}` : ""}]]`;
-      result = result.replace(match[0], obsidianEmbed);
+      const alias = toWikilinkAlias(span.label);
+      const obsidianEmbed = `![[${download.localPath}${alias ? `|${alias}` : ""}]]`;
+      result = result.replace(span.full, obsidianEmbed);
     }
-    for (const match of internalMatches) {
+    for (const span of internalMatches) {
       await sema.acquire();
       try {
-        const fileUrl = match[2];
-        const parsed = this.parseNotionFileUrl(fileUrl);
+        const parsed = this.parseNotionFileUrl(span.url);
         if (!parsed || !this.notionClient) continue;
         const realUrl = await this.notionClient.getFileBlockUrl(parsed.blockId);
         if (!realUrl) {
           getLogger().warn(`[Im-Nobsidian] \uC774\uBBF8\uC9C0 Block URL \uC870\uD68C \uC2E4\uD328: ${parsed.fileName}`);
           continue;
         }
-        const download = await this.downloadImage(realUrl, pageTitle);
+        const fetched = await this.fetchImage(realUrl, pageTitle);
+        if (isAppendedCopy(fetched)) {
+          result = result.replace(span.full, "");
+          continue;
+        }
+        const download = await this.persistImage(fetched);
         downloads.push(download);
-        const obsidianEmbed = `![[${download.localPath}${match[1] ? `|${match[1]}` : ""}]]`;
-        result = result.replace(match[0], obsidianEmbed);
+        const alias = toWikilinkAlias(span.label);
+        const obsidianEmbed = `![[${download.localPath}${alias ? `|${alias}` : ""}]]`;
+        result = result.replace(span.full, obsidianEmbed);
       } catch (error) {
         getLogger().warn(`\uB0B4\uBD80 \uC774\uBBF8\uC9C0 \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: ${error}`);
       } finally {
@@ -3838,27 +4595,28 @@ var ImageHandler = class {
     }
     return { content: result, downloads };
   }
-  async uploadLocalImage(localPath) {
+  async uploadLocalImage(localPath, noteFolder) {
     if (!this.notionClient) {
       throw new Error("NotionClient required for image upload");
     }
-    const buffer = await this.readImageFromVault(localPath);
+    const { buffer, resolvedPath } = await this.readImageFromVault(localPath, noteFolder);
     const filename = localPath.split("/").pop() ?? "image.png";
     const contentType = this.getContentTypeFromPath(filename);
     const blob = new Blob([buffer], { type: contentType });
     const fileUploadId = await this.notionClient.uploadFile(blob, filename, contentType);
     const fileHash = createHash("sha256").update(buffer).digest("hex");
-    return { localPath, fileUploadId, fileHash, fileSize: buffer.length };
+    return { localPath: resolvedPath, fileUploadId, fileHash, fileSize: buffer.length };
   }
-  async uploadAndAppendImages(pageId, images) {
+  async uploadAndAppendImages(pageId, images, notePath) {
     if (!this.notionClient) return [];
     const localImages = images.filter((img) => !img.isExternal && img.localPath);
     if (localImages.length === 0) return [];
+    const noteFolder = notePath?.includes("/") ? notePath.slice(0, notePath.lastIndexOf("/")) : void 0;
     const results = [];
     const imageBlocks = [];
     for (const img of localImages) {
       try {
-        const result = await this.uploadLocalImage(img.localPath);
+        const result = await this.uploadLocalImage(img.localPath, noteFolder);
         results.push(result);
         imageBlocks.push({
           type: "image",
@@ -3868,7 +4626,11 @@ var ImageHandler = class {
           }
         });
       } catch (error) {
-        getLogger().warn(`\uC774\uBBF8\uC9C0 \uC5C5\uB85C\uB4DC \uC2E4\uD328 (${img.localPath}):`, error);
+        if (error?.code === "ENOENT") {
+          getLogger().warn(`\uC774\uBBF8\uC9C0 \uC5C5\uB85C\uB4DC \uAC74\uB108\uB700 \u2014 \uBCFC\uD2B8\uC5D0\uC11C \uD30C\uC77C\uC744 \uCC3E\uC9C0 \uBABB\uD568: ${img.localPath}`);
+        } else {
+          getLogger().warn(`\uC774\uBBF8\uC9C0 \uC5C5\uB85C\uB4DC \uC2E4\uD328 (${img.localPath}):`, error);
+        }
       }
     }
     if (imageBlocks.length > 0) {
@@ -3892,23 +4654,39 @@ var ImageHandler = class {
     }
     return results;
   }
-  async readImageFromVault(localPath) {
-    try {
-      return await this.vaultFs.readBinary(localPath);
-    } catch {
-      return await this.vaultFs.readBinary(`${this.attachmentFolder}/${localPath}`);
+  /**
+   * 임베드 경로를 볼트 실제 파일로 해석한다(F23). Obsidian 위키링크 임베드는 노트 옆
+   * 파일을 파일명만으로 참조하는 게 관례라, 노트 폴더 → 볼트 루트 → attachments/ 순으로
+   * 시도한다. 폴백은 조용히 진행하고, 전부 실패했을 때만 마지막 오류를 던진다.
+   */
+  async readImageFromVault(localPath, noteFolder) {
+    const candidates = [];
+    if (noteFolder && !localPath.includes("/")) {
+      candidates.push(`${noteFolder}/${localPath}`);
+    }
+    candidates.push(localPath, `${this.attachmentFolder}/${localPath}`);
+    let lastError;
+    for (const candidate of candidates) {
+      try {
+        return { buffer: await this.vaultFs.readBinary(candidate), resolvedPath: candidate };
+      } catch (error) {
+        lastError = error;
+      }
     }
+    throw lastError;
   }
   getContentTypeFromPath(filename) {
     const ext = filename.match(/\.[^.]+$/)?.[0]?.toLowerCase();
     return (ext && EXTENSION_TO_MIME[ext]) ?? "application/octet-stream";
   }
   async downloadAllFiles(markdown, pageTitle) {
-    const mdLinkRegex = /\[(?:📎|🎬|🎞|📄|🔊)\s*([^\]]*)\]\((https?:\/\/[^)]+)\)/g;
-    const mdHttpMatches = [...markdown.matchAll(mdLinkRegex)];
-    const notionHttpMatches = mdHttpMatches.filter((m) => m[2] && this.isNotionFileUrl(m[2]));
-    const mdInternalRegex = /\[(?:📎|🎬|🎞|📄|🔊)\s*([^\]]*)\]\((file:\/\/%7B.*?%7D%7D)\)/g;
-    const mdInternalMatches = [...markdown.matchAll(mdInternalRegex)];
+    const fileLinks = scanMarkdownLinks(markdown).filter(
+      (s) => !s.isEmbed && FILE_LABEL_PREFIX_RE.test(s.label)
+    );
+    const notionHttpMatches = fileLinks.filter(
+      (s) => /^https?:\/\//.test(s.url) && this.isNotionFileUrl(s.url)
+    );
+    const mdInternalMatches = fileLinks.filter((s) => INTERNAL_FILE_URL_RE.test(s.url));
     const xmlHttpRegex = /<(?:file|video|audio|pdf)\s+src="(https?:\/\/[^"]+)">([\s\S]*?)<\/(?:file|video|audio|pdf)>/g;
     const xmlHttpMatches = [...markdown.matchAll(xmlHttpRegex)];
     const notionXmlHttpMatches = xmlHttpMatches.filter((m) => m[1] && this.isNotionFileUrl(m[1]));
@@ -3921,38 +4699,36 @@ var ImageHandler = class {
     const sema = new Sema(this.concurrency);
     const downloads = [];
     let result = markdown;
-    for (const match of notionHttpMatches) {
+    for (const span of notionHttpMatches) {
       await sema.acquire();
       try {
-        const url = match[2];
-        const caption = match[1]?.trim() || "file";
-        const download = await this.downloadFile(url, pageTitle, caption);
+        const caption = toWikilinkAlias(span.label.replace(FILE_LABEL_PREFIX_RE, "")) || "file";
+        const download = await this.downloadFile(span.url, pageTitle, caption);
         if (!download.localPath) continue;
         downloads.push(download);
-        const obsidianLink = `[[${download.localPath}|${caption}]]`;
-        result = result.replace(match[0], obsidianLink);
+        const obsidianLink = `![[${download.localPath}|${caption}]]`;
+        result = result.replace(span.full, obsidianLink);
       } catch (error) {
         getLogger().warn(`\uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: ${error}`);
       } finally {
         sema.release();
       }
     }
-    for (const match of mdInternalMatches) {
+    for (const span of mdInternalMatches) {
       await sema.acquire();
       try {
-        const fileUrl = match[2];
-        const parsed = this.parseNotionFileUrl(fileUrl);
+        const parsed = this.parseNotionFileUrl(span.url);
         if (!parsed || !this.notionClient) continue;
         const blockId = parsed.blockId;
         const fileName = parsed.fileName;
         const realUrl = await this.notionClient.getFileBlockUrl(blockId);
         if (!realUrl) continue;
-        const caption = fileName || match[1]?.trim() || "file";
+        const caption = fileName || toWikilinkAlias(span.label.replace(FILE_LABEL_PREFIX_RE, "")) || "file";
         const download = await this.downloadFile(realUrl, pageTitle, caption);
         if (!download.localPath) continue;
         downloads.push(download);
-        const obsidianLink = `[[${download.localPath}|${caption}]]`;
-        result = result.replace(match[0], obsidianLink);
+        const obsidianLink = `![[${download.localPath}|${caption}]]`;
+        result = result.replace(span.full, obsidianLink);
       } catch (error) {
         getLogger().warn(`\uB0B4\uBD80 \uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: ${error}`);
       } finally {
@@ -3963,11 +4739,11 @@ var ImageHandler = class {
       await sema.acquire();
       try {
         const url = match[1];
-        const caption = match[2]?.trim() || "file";
+        const caption = toWikilinkAlias(match[2] ?? "") || "file";
         const download = await this.downloadFile(url, pageTitle, caption);
         if (!download.localPath) continue;
         downloads.push(download);
-        const obsidianLink = `[[${download.localPath}|${caption}]]`;
+        const obsidianLink = `![[${download.localPath}|${caption}]]`;
         result = result.replace(match[0], obsidianLink);
       } catch (error) {
         getLogger().warn(`\uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: ${error}`);
@@ -3985,11 +4761,11 @@ var ImageHandler = class {
         const fileName = parsed.fileName;
         const realUrl = await this.notionClient.getFileBlockUrl(blockId);
         if (!realUrl) continue;
-        const caption = fileName || match[2]?.trim() || "file";
+        const caption = fileName || toWikilinkAlias(match[2] ?? "") || "file";
         const download = await this.downloadFile(realUrl, pageTitle, caption);
         if (!download.localPath) continue;
         downloads.push(download);
-        const obsidianLink = `[[${download.localPath}|${caption}]]`;
+        const obsidianLink = `![[${download.localPath}|${caption}]]`;
         result = result.replace(match[0], obsidianLink);
       } catch (error) {
         getLogger().warn(`\uB0B4\uBD80 \uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: ${error}`);
@@ -4031,7 +4807,9 @@ var ImageHandler = class {
         const MAX_FILE_SIZE = this.maxFileSizeBytes;
         if (contentLength && parseInt(contentLength, 10) > MAX_FILE_SIZE) {
           const sizeMB = Math.round(parseInt(contentLength, 10) / 1024 / 1024);
-          getLogger().debug(`[Im-Nobsidian] \uD30C\uC77C \uC2A4\uD0B5 \u2014 \uB108\uBB34 \uD07C (${sizeMB}MB): ${caption}`);
+          getLogger().info(
+            `[Im-Nobsidian] \uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uAC74\uB108\uB700 \u2014 \uD06C\uAE30 \uC0C1\uD55C \uCD08\uACFC (${sizeMB}MB > ${Math.round(MAX_FILE_SIZE / 1024 / 1024)}MB), Notion \uC6D0\uBCF8 \uB9C1\uD06C \uC720\uC9C0: ${caption}`
+          );
           return { originalUrl: url, localPath: "", hash: "", size: 0 };
         }
         const buffer = Buffer.from(await response.arrayBuffer());
@@ -4053,7 +4831,26 @@ var ImageHandler = class {
     return this.isNotionFileUrl(url);
   }
   isNotionFileUrl(url) {
-    return url.includes("secure.notion-static.com") || url.includes("prod-files-secure") || url.includes("s3.us-west-2.amazonaws.com/secure.notion-static.com");
+    return isNotionHostedFileUrl(url);
+  }
+  /**
+   * notion-hosted 파일 URL 하나를 로컬 첨부로 로컬라이즈한다(P3-A).
+   * DB 행의 `files` 속성처럼 본문 밖에 있는 서명 URL 용 — 서명 URL 은 약 1시간 뒤
+   * 만료되어 frontmatter 에 남으면 깨진 링크가 되고, push 로 되밀면 Notion 원본이
+   * external(만료 URL)로 오염된다(실측). notion-hosted 가 아닌 URL(사용자가 넣은
+   * 진짜 외부 링크)은 다운로드 대상이 아니므로 null 을 반환한다.
+   *
+   * @returns 로컬 첨부 경로(`attachments/...`), 다운로드 대상이 아니거나 실패 시 null
+   */
+  async localizeNotionFileUrl(url, caption) {
+    if (!/^https?:\/\//.test(url) || !this.isNotionFileUrl(url)) return null;
+    try {
+      const download = await this.downloadFile(url, caption, caption);
+      return download.localPath || null;
+    } catch (error) {
+      getLogger().warn(`[Im-Nobsidian] \uC18D\uC131 \uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328 (${caption}): ${error}`);
+      return null;
+    }
   }
   guessExtension(url) {
     const pathname = new URL(url).pathname;
@@ -4080,6 +4877,28 @@ var ImageHandler = class {
     return "";
   }
 };
+
+// src/sync/stale-db-artifacts.ts
+var ARTIFACT_SUFFIXES = [".base", ".notion.json"];
+function isDbArtifactPath(path) {
+  return ARTIFACT_SUFFIXES.some((suffix) => path.endsWith(suffix));
+}
+function selectStaleDbArtifacts(files, localFolder, keepPaths) {
+  const prefix = `${localFolder}/`;
+  const stale = [];
+  for (const file of files) {
+    const path = file.path;
+    if (!path.startsWith(prefix)) continue;
+    const rel = path.slice(prefix.length);
+    if (rel.includes("/")) continue;
+    if (!ARTIFACT_SUFFIXES.some((suffix) => rel.endsWith(suffix))) continue;
+    if (keepPaths.has(path)) continue;
+    stale.push(path);
+  }
+  return stale;
+}
+
+// src/sync/file-handler.ts
 var EXTENSION_TO_BLOCK_TYPE = {
   ".png": "image",
   ".jpg": "image",
@@ -4188,7 +5007,7 @@ var FileHandler = class {
   stateDb;
   sema;
   async pushFilesForFolder(folderPageId, folderPath) {
-    const allFiles = await this.vaultFs.listNonMarkdownFiles();
+    const allFiles = await this.listUploadableFiles();
     const folderFiles = allFiles.filter((f) => getFolderPath(f.path) === folderPath);
     if (folderFiles.length === 0) return [];
     const results = [];
@@ -4212,8 +5031,18 @@ var FileHandler = class {
     }
     return results;
   }
-  async pushAllFiles() {
+  /**
+   * 업로드 후보 목록 — 도구 내부 산출물(`.base`/`.notion.json`)은 제외한다.
+   * node 측 VaultFS 는 과거 `.base` 를 워커에서 빼는 식으로 우회했지만, Obsidian
+   * 어댑터는 모든 파일을 반환하므로 플러그인 push 가 사이드카를 Notion 첨부로
+   * 오염시켰다. 소비자인 여기서 일괄 차단해 구현체 간 동작을 통일한다.
+   */
+  async listUploadableFiles() {
     const allFiles = await this.vaultFs.listNonMarkdownFiles();
+    return allFiles.filter((f) => !isDbArtifactPath(f.path));
+  }
+  async pushAllFiles() {
+    const allFiles = await this.listUploadableFiles();
     if (allFiles.length === 0) return [];
     const filesByFolder = /* @__PURE__ */ new Map();
     for (const file of allFiles) {
@@ -4442,6 +5271,44 @@ function resolveDbRowPath(localFolder, safeName, pageId, lookupByPath) {
   return `${localFolder}/${safeName} (${raw}).md`;
 }
 
+// src/utils/db-folder-path.ts
+function resolveDbFolderPath(folder, dbId, ownerOf) {
+  const usable = (candidate) => {
+    const owner = ownerOf(candidate);
+    return owner === null || notionIdsEqual(owner, dbId);
+  };
+  if (usable(folder)) return folder;
+  const raw = dbId.replace(/-/g, "");
+  for (const len of [8, 16, 32]) {
+    const candidate = `${folder} (${raw.slice(0, len)})`;
+    if (usable(candidate)) return candidate;
+  }
+  return `${folder} (${raw})`;
+}
+function repairDbFolderCollisions(configs, takenFolders) {
+  const owner = new Map(takenFolders ?? []);
+  let repaired = 0;
+  for (const config of configs) {
+    const resolved = resolveDbFolderPath(
+      config.localFolder,
+      config.databaseId,
+      (f) => owner.get(f) ?? null
+    );
+    if (resolved !== config.localFolder) {
+      config.localFolder = resolved;
+      repaired++;
+    }
+    owner.set(resolved, config.databaseId);
+  }
+  return repaired;
+}
+function isDirectDbRowPath(localFolder, path) {
+  const prefix = localFolder.endsWith("/") ? localFolder : `${localFolder}/`;
+  if (!path.startsWith(prefix)) return false;
+  const rel = path.slice(prefix.length);
+  return rel.length > 0 && !rel.includes("/");
+}
+
 // src/utils/wikilink-title.ts
 function wikilinkTitleFromPath(obsidianPath) {
   return obsidianPath.replace(/\.md$/i, "").split("/").pop() ?? "";
@@ -4781,23 +5648,6 @@ function sortKeys(value) {
   return value;
 }
 
-// src/sync/stale-db-artifacts.ts
-var ARTIFACT_SUFFIXES = [".base", ".notion.json"];
-function selectStaleDbArtifacts(files, localFolder, keepPaths) {
-  const prefix = `${localFolder}/`;
-  const stale = [];
-  for (const file of files) {
-    const path = file.path;
-    if (!path.startsWith(prefix)) continue;
-    const rel = path.slice(prefix.length);
-    if (rel.includes("/")) continue;
-    if (!ARTIFACT_SUFFIXES.some((suffix) => rel.endsWith(suffix))) continue;
-    if (keepPaths.has(path)) continue;
-    stale.push(path);
-  }
-  return stale;
-}
-
 // src/converter/enhanced-md-converter.ts
 var NOTION_CALLOUT_RE = /^::: callout\n([\s\S]*?)\n:::/gm;
 var NOTION_PAGE_MENTION_RE = /<mention-page id="([^"]+)">([\s\S]*?)<\/mention-page>/g;
@@ -4827,12 +5677,13 @@ function notionEnhancedToObsidian(enhanced) {
   result = convertNotionTables(result);
   result = convertSpans(result);
   result = convertDatabaseBlocks(result);
-  result = cleanInlineColorAttrs(result);
+  result = convertBlockColorAttrs(result);
   result = removeEmptyBlocks(result);
   result = unescapePipes(result);
   result = unescapeNotionChars(result);
   result = unescapeWikilinkBrackets(result);
   result = ensureCalloutContinuity(result);
+  result = separateAdjacentCallouts(result);
   return result;
 }
 function unescapeWikilinkBrackets(content) {
@@ -4846,9 +5697,12 @@ function obsidianToNotionEnhanced(obsidian) {
   result = restoreMediaTags(result);
   result = restoreUnknownBlocks(result);
   result = restoreColorSpans(result);
+  result = restoreBlockColorMarkers(result);
   result = restoreUnderlineSpans(result);
   result = convertMentionPageIdToUrl(result);
   result = restoreWikilinkPreserveLinks(result);
+  result = restoreSyncedBlocks(result);
+  result = reassembleColumns(result);
   return result;
 }
 var MENTION_PAGE_ID_RE = /<mention-page id="([^"]+)">[\s\S]*?<\/mention-page>/g;
@@ -4941,29 +5795,36 @@ ${fence}
     }
   );
 }
-var NO_CONTAINER_BODY = "(?:(?!<details>|<callout|<columns>)[\\s\\S])*?";
-var SUMMARY_TITLE = "((?:(?!<\\/summary>|<details>|<summary>)[\\s\\S])*?)";
+var NO_CONTAINER_BODY = "(?:(?!<details|<callout|<columns)[\\s\\S])*?";
+var SUMMARY_TITLE = "((?:(?!<\\/summary>|<details|<summary>)[\\s\\S])*?)";
 var INNERMOST_DETAILS_RE = new RegExp(
-  `([\\t ]*)<details>\\s*<summary>${SUMMARY_TITLE}<\\/summary>(${NO_CONTAINER_BODY})<\\/details>`,
+  `([\\t ]*)<details([^>]*)>[ \\t]*\\n?(?:\\s*<summary>${SUMMARY_TITLE}<\\/summary>)?(${NO_CONTAINER_BODY})<\\/details>`,
   "g"
 );
 var INNERMOST_CALLOUT_RE = new RegExp(
-  `([\\t ]*)<callout[^>]*>\\n?(${NO_CONTAINER_BODY})<\\/callout>`,
+  `([\\t ]*)<callout([^>]*)>\\n?(${NO_CONTAINER_BODY})<\\/callout>`,
   "g"
 );
 var INNERMOST_COLUMNS_RE = new RegExp(
-  `([\\t ]*)<columns>\\n?(${NO_CONTAINER_BODY})<\\/columns>`,
+  `([\\t ]*)<columns[^>]*>\\n?(${NO_CONTAINER_BODY})<\\/columns>`,
   "g"
 );
-var COLUMN_WRAP_RE = /[\t ]*<column>\n?([\s\S]*?)[\t ]*<\/column>\n?/g;
+var COLUMN_WRAP_RE = /[\t ]*<column(?!s)[^>]*>\n?([\s\S]*?)[\t ]*<\/column>\n?/g;
 function reindentLines(text, indent) {
   if (!indent) return text;
   return text.split("\n").map((line) => line === "" ? line : indent + line).join("\n");
 }
-function toggleToCallout(title, rawBody) {
+function parseDesignAttrs(attrs) {
+  const icon = /\bicon="([^"]*)"/.exec(attrs)?.[1];
+  const color = /\bcolor="([^"]*)"/.exec(attrs)?.[1];
+  return { icon: icon || void 0, color: color || void 0 };
+}
+function toggleToCallout(title, rawBody, color) {
   const body = dedentContainerBody(rawBody);
+  const head = ["> [!toggle]-", title.trim(), color ? toggleColorMarker(color) : ""].filter((part) => part !== "").join(" ");
+  if (body.trim() === "") return head;
   const calloutBody = body.split("\n").map((line) => line.trim() ? `> ${line}` : ">").join("\n");
-  return `> [!toggle]- ${title.trim()}
+  return `${head}
 ${calloutBody}`;
 }
 function flattenColumns(body) {
@@ -4977,20 +5838,22 @@ function flattenColumns(body) {
     if (col.trim() !== "") cols.push(col);
   }
   if (!matched) return dedentContainerBody(body);
-  return cols.join("\n\n");
+  if (cols.length === 0) return "";
+  return [COLUMN_LIST_START, ...cols.map((c) => `${COLUMN_SEP}
+${c}`), COLUMN_LIST_END].join("\n");
 }
 function convertContainers(content) {
   let result = content;
   let safety = 0;
-  while (safety++ < 2e3 && (result.includes("<details>") || result.includes("<callout") || result.includes("<columns>"))) {
+  while (safety++ < 2e3 && (result.includes("<details") || result.includes("<callout") || result.includes("<columns"))) {
     const before = result;
     result = result.replace(
       INNERMOST_DETAILS_RE,
-      (_m, indent, title, body) => reindentLines(toggleToCallout(title, body), indent)
+      (_m, indent, attrs, title, body) => reindentLines(toggleToCallout(title ?? "", body, parseDesignAttrs(attrs).color), indent)
     );
     result = result.replace(
       INNERMOST_CALLOUT_RE,
-      (_m, indent, body) => reindentLines(calloutBodyToObsidian(body), indent)
+      (_m, indent, attrs, body) => reindentLines(calloutBodyToObsidian(body, parseDesignAttrs(attrs)), indent)
     );
     result = result.replace(
       INNERMOST_COLUMNS_RE,
@@ -4998,16 +5861,38 @@ function convertContainers(content) {
     );
     if (result === before) break;
   }
-  return result;
+  return stripQuotedColumnMarkers(result);
+}
+var QUOTED_COLUMN_EDGE_RE = new RegExp(
+  `^(?:>[ \\t]?)+[ \\t]*%%${MARKER_BRAND_RE}:column-list:(?:start|end)%%[ \\t]*\\n?`,
+  "gm"
+);
+var QUOTED_COLUMN_SEP_RE = new RegExp(
+  `^((?:>[ \\t]?)+)[ \\t]*%%${MARKER_BRAND_RE}:column%%[ \\t]*$`,
+  "gm"
+);
+var QUOTED_COLUMN_INLINE_RE = new RegExp(
+  `[ \\t]*%%${MARKER_BRAND_RE}:column(?:-list:(?:start|end))?%%`,
+  "g"
+);
+function stripQuotedColumnMarkers(content) {
+  return content.replace(QUOTED_COLUMN_EDGE_RE, "").replace(QUOTED_COLUMN_SEP_RE, (_m, prefix) => prefix.trimEnd()).replace(
+    /^(?:>[ \t]?).*%%.*$/gm,
+    (line) => line.replace(QUOTED_COLUMN_INLINE_RE, "").trimEnd()
+  );
 }
-function calloutBodyToObsidian(body) {
+function calloutBodyToObsidian(body, style) {
   const lines = dedentContainerBody(body).split("\n").filter((l, i, arr) => !(i === 0 && l === "") && !(i === arr.length - 1 && l === ""));
   const firstLine = lines[0] ?? "";
-  const emojiMatch = /^([\p{Emoji}️‍]+)\s*(.*)/u.exec(firstLine);
-  const type = emojiMatch ? emojiToCalloutType(emojiMatch[1]) : "note";
+  const emojiMatch = style?.icon || style?.color ? null : /^([\p{Emoji}️‍]+)\s*(.*)/u.exec(firstLine);
+  const rawIcon = style?.icon ?? (emojiMatch ? emojiMatch[1] : void 0);
+  const icon = rawIcon !== void 0 && /^https?:\/\//i.test(rawIcon) ? void 0 : rawIcon;
+  const type = icon ? emojiToCalloutType(icon) : "note";
   const title = emojiMatch ? emojiMatch[2] : firstLine;
   const rest = lines.slice(1).join("\n").trim();
-  const calloutTitle = title ? `> [!${type}] ${title}` : `> [!${type}]`;
+  const needsMarker = Boolean(style?.color) || icon !== void 0 && calloutTypeToEmoji(type) !== icon;
+  const styleTail = needsMarker ? ` ${calloutStyleMarker({ icon, color: style?.color })}` : "";
+  const calloutTitle = title ? `> [!${type}] ${title}${styleTail}` : `> [!${type}]${styleTail}`;
   const calloutBody = rest ? "\n" + rest.split("\n").map((line) => line.trim() ? `> ${line}` : ">").join("\n") : "";
   return calloutTitle + calloutBody;
 }
@@ -5020,7 +5905,7 @@ function convertPageMentions(content) {
     return `[[${cleaned}]]`;
   });
   result = result.replace(
-    /<mention-page\s+url="https?:\/\/(?:www\.)?notion\.so\/([a-f0-9]{32})"[^>]*?(?:\/>|>[\s\S]*?<\/mention-page>)/g,
+    /<mention-page\s+url="https?:\/\/(?:[a-z]+\.)?notion\.(?:so|com)\/(?:p\/)?([a-f0-9]{32})"[^>]*?(?:\/>|>[\s\S]*?<\/mention-page>)/g,
     (_match, id) => `[[notion:${id}]]`
   );
   return result;
@@ -5050,19 +5935,52 @@ function preserveUnknownBlocks(content) {
   return result;
 }
 function convertSyncedBlockRef(content) {
+  const unwrap = (match, openRe, closeRe) => match.replace(openRe, "").replace(closeRe, "").split("\n").map((l) => l.replace(/^\t/, "")).join("\n").trim();
   let result = content.replace(
-    /<synced_block_reference[^>]*>[\s\S]*?<\/synced_block_reference>/g,
-    (match) => {
-      const inner = match.replace(/<synced_block_reference[^>]*>\n?/, "").replace(/<\/synced_block_reference>/, "").split("\n").map((l) => l.replace(/^\t/, "")).join("\n").trim();
-      return inner;
+    /<synced_block_reference([^>]*)>[\s\S]*?<\/synced_block_reference>/g,
+    (match, attrs) => {
+      const inner = unwrap(match, /<synced_block_reference[^>]*>\n?/, /<\/synced_block_reference>/);
+      const url = /url="([^"]*)"/.exec(attrs)?.[1];
+      if (!url) return inner;
+      return `${syncedStartMarker("ref", url)}
+${inner}
+${SYNCED_END}`;
     }
   );
   result = result.replace(
-    /<synced_block[^>]*>\n?([\s\S]*?)<\/synced_block>/g,
-    (_match, inner) => inner.trim()
+    /<synced_block([^>]*)>[\s\S]*?<\/synced_block>/g,
+    (match, attrs) => {
+      const inner = unwrap(match, /<synced_block[^>]*>\n?/, /<\/synced_block>/);
+      const url = /url="([^"]*)"/.exec(attrs)?.[1];
+      if (!url) return inner;
+      return `${syncedStartMarker("orig", url)}
+${inner}
+${SYNCED_END}`;
+    }
   );
   return result;
 }
+var SYNCED_MARKER_PAIR_RE = new RegExp(
+  `%%${MARKER_BRAND_RE}:synced:start:(.*?)%%\\n?([\\s\\S]*?)%%${MARKER_BRAND_RE}:synced:end%%`,
+  "g"
+);
+function restoreSyncedBlocks(content) {
+  return content.replace(SYNCED_MARKER_PAIR_RE, (_match, params, body) => {
+    const kind = /kind=(ref|orig)/.exec(params)?.[1] ?? "orig";
+    const encoded = /url=([^&]*)/.exec(params)?.[1] ?? "";
+    let url = encoded;
+    try {
+      url = decodeURIComponent(encoded);
+    } catch {
+    }
+    if (!url) return body.trim();
+    const tag = kind === "ref" ? "synced_block_reference" : "synced_block";
+    const indented = body.trim().split("\n").map((l) => l.length > 0 ? `	${l}` : l).join("\n");
+    return `<${tag} url="${url}">
+${indented}
+</${tag}>`;
+  });
+}
 function convertMediaTags(content) {
   let result = content;
   result = result.replace(NOTION_AUDIO_RE, (_match, src, caption) => {
@@ -5105,17 +6023,21 @@ function convertSpans(content) {
   }
   return result;
 }
+var TOGGLE_COLOR_MARKER_RE = new RegExp(`\\s*%%${MARKER_BRAND_RE}:toggle-color:([a-z_]+)%%`);
 function convertTogglesToHtml(content) {
-  const calloutToggleRe = /^> \[!toggle\]-\s*(.+)\n((?:>.*\n?)*)/gm;
+  const calloutToggleRe = /^> \[!toggle\]-[ \t]*(.*)\n?((?:>.*\n?)*)/gm;
   let result = content;
   let prev = "";
   let safety = 0;
   while (result !== prev && safety++ < 100) {
     prev = result;
     result = result.replace(calloutToggleRe, (_match, title, body) => {
+      const colorMatch = TOGGLE_COLOR_MARKER_RE.exec(title);
+      const cleanTitle = colorMatch ? title.replace(TOGGLE_COLOR_MARKER_RE, "") : title;
+      const attrs = colorMatch ? ` color="${colorMatch[1]}"` : "";
       const bodyText = body.split("\n").map((line) => line.replace(/^>\s?/, "")).join("\n").trim();
-      return `<details>
-<summary>${title.trim()}</summary>
+      return `<details${attrs}>
+<summary>${cleanTitle.trim()}</summary>
 
 ${bodyText}
 
@@ -5142,6 +6064,7 @@ ${body}
     result = result.slice(0, startIdx) + html + result.slice(endIdx + TOGGLE_END.length);
   }
   result = result.replace(startRe, "").replace(endRe, "");
+  result = result.replace(/^(<\/details>)(?!\n|$)/gm, "$1\n");
   return result;
 }
 function findMatchingEnd(content, startFrom) {
@@ -5162,29 +6085,53 @@ function findMatchingEnd(content, startFrom) {
   }
   return -1;
 }
+var CALLOUT_STYLE_MARKER_RE = new RegExp(`\\s*%%${MARKER_BRAND_RE}:callout-style:(.*?)%%`);
+function parseCalloutStyleParams(params) {
+  const style = {};
+  for (const kv of params.split("&")) {
+    const eq = kv.indexOf("=");
+    if (eq <= 0) continue;
+    const key = kv.slice(0, eq);
+    const value = decodeURIComponent(kv.slice(eq + 1));
+    if (key === "icon") style.icon = value;
+    else if (key === "color") style.color = value;
+  }
+  return style;
+}
 function convertObsidianCallouts(content) {
   const lines = content.split("\n");
   const result = [];
   let i = 0;
   while (i < lines.length) {
-    const headerMatch = /^> \[!(\w+)\]([-+])?\s*(.*)/.exec(lines[i]);
-    if (headerMatch) {
-      const type = headerMatch[1];
-      const title = headerMatch[3];
-      const emoji = calloutTypeToEmoji(type) ?? "\u{1F4A1}";
-      const calloutTitle = title ? `${emoji} ${title}` : emoji;
+    const headerMatch = /^> \[!(\w+)\]([-+])?[ \t]*(.*)$/.exec(lines[i]);
+    const type = headerMatch?.[1]?.toLowerCase();
+    if (headerMatch && type !== "toggle" && type !== "tab") {
+      let title = headerMatch[3];
+      let style = {};
+      const styleMatch = CALLOUT_STYLE_MARKER_RE.exec(title);
+      if (styleMatch) {
+        style = parseCalloutStyleParams(styleMatch[1]);
+        title = title.replace(CALLOUT_STYLE_MARKER_RE, "");
+      } else {
+        style.icon = calloutTypeToEmoji(type);
+      }
       const bodyLines = [];
       i++;
-      while (i < lines.length && lines[i].startsWith("> ")) {
-        bodyLines.push(lines[i].slice(2));
+      while (i < lines.length && (lines[i] === ">" || lines[i].startsWith("> "))) {
+        bodyLines.push(lines[i] === ">" ? "" : lines[i].slice(2));
         i++;
       }
-      result.push("::: callout");
-      result.push(calloutTitle);
-      if (bodyLines.length > 0) {
-        result.push(...bodyLines);
+      const innerConverted = convertObsidianCallouts(convertTogglesToHtml(bodyLines.join("\n")));
+      const attrs = `${style.icon ? ` icon="${style.icon}"` : ""}${style.color ? ` color="${style.color}"` : ""}`;
+      result.push(`<callout${attrs}>`);
+      const cleanTitle = title.trim();
+      if (cleanTitle) result.push(`	${cleanTitle}`);
+      if (innerConverted.trim() !== "") {
+        for (const line of innerConverted.split("\n")) {
+          result.push(line === "" ? "" : `	${line}`);
+        }
       }
-      result.push(":::");
+      result.push("</callout>");
     } else {
       result.push(lines[i]);
       i++;
@@ -5228,12 +6175,38 @@ function convertPageLinks(content) {
 }
 function convertDatabaseBlocks(content) {
   return content.replace(
-    /<database[^>]*>([\s\S]*?)<\/database>/g,
-    (_match, title) => `**${title.trim()}** *(Notion DB)*`
+    /<database\b([^>]*)>([\s\S]*?)<\/database>/g,
+    (_match, attrs, title) => {
+      const clean = title.trim();
+      const placeholder = `**${clean}** *(Notion DB)*`;
+      const idMatch = /\burl="[^"]*?([a-f0-9]{32})[^"]*"/.exec(attrs);
+      if (!idMatch?.[1]) return placeholder;
+      return `${placeholder}${compactMarker(
+        `child-database:id=${idMatch[1]}&title=${encodeURIComponent(clean)}`
+      )}`;
+    }
   );
 }
-function cleanInlineColorAttrs(content) {
-  return content.replace(/\s*\{color="[^"]*"\}/g, "");
+var TRAILING_BLOCK_COLOR_RE = /[ \t]*\{color="([a-z_]+)"\}(?=[ \t]*$)/gm;
+function convertBlockColorAttrs(content) {
+  return content.replace(TRAILING_BLOCK_COLOR_RE, (_m, color) => ` ${blockColorMarker(color)}`).replace(/\s*\{color="[^"]*"\}/g, "");
+}
+var CALLOUT_HEAD_RE = /^((?:> )*)> \[!\w+\][-+]?/;
+function separateAdjacentCallouts(content) {
+  const lines = content.split("\n");
+  const out = [];
+  for (const line of lines) {
+    const head = CALLOUT_HEAD_RE.exec(line);
+    if (head && out.length > 0) {
+      const parentPrefix = head[1];
+      const prev = out[out.length - 1];
+      if (prev.startsWith(`${parentPrefix}>`)) {
+        out.push(parentPrefix.trimEnd());
+      }
+    }
+    out.push(line);
+  }
+  return out.join("\n");
 }
 function removeEmptyBlocks(content) {
   return content.replace(NOTION_EMPTY_BLOCK_RE, "\n");
@@ -5257,7 +6230,7 @@ function unescapeNotionChars(content) {
   return content.replace(/\\~/g, "~").replace(/\\\^/g, "^");
 }
 var NOTION_TABLE_RE = /<table[^>]*>([\s\S]*?)<\/table>/g;
-var TABLE_ROW_RE = /<tr>([\s\S]*?)<\/tr>/g;
+var TABLE_ROW_RE2 = /<tr>([\s\S]*?)<\/tr>/g;
 var TABLE_CELL_RE = /<t[dh][^>]*>([\s\S]*?)<\/t[dh]>/g;
 function isAlignmentRow(cells) {
   return cells.every((c) => /^:?-{2,}:?$/.test(c.trim()));
@@ -5266,7 +6239,7 @@ function convertNotionTables(content) {
   return content.replace(NOTION_TABLE_RE, (_match, tableBody) => {
     const rows = [];
     let rowMatch;
-    const rowRe = new RegExp(TABLE_ROW_RE.source, TABLE_ROW_RE.flags);
+    const rowRe = new RegExp(TABLE_ROW_RE2.source, TABLE_ROW_RE2.flags);
     while ((rowMatch = rowRe.exec(tableBody)) !== null) {
       const cells = [];
       let cellMatch;
@@ -5298,26 +6271,23 @@ var OBSIDIAN_MEDIA_PDF_RE = /\[📄\s*([^\]]*)\]\(([^)]+)\)/g;
 var OBSIDIAN_MEDIA_FILE_RE = /\[📎\s*([^\]]*)\]\(([^)]+)\)/g;
 function restoreMediaTags(content) {
   let result = content;
-  result = result.replace(OBSIDIAN_MEDIA_AUDIO_RE, (_match, caption, src) => {
-    return `<audio src="${src}">${caption}</audio>`;
-  });
-  result = result.replace(OBSIDIAN_MEDIA_VIDEO_RE, (_match, caption, src) => {
-    return `<video src="${src}">${caption}</video>`;
-  });
-  result = result.replace(OBSIDIAN_MEDIA_PDF_RE, (_match, caption, src) => {
-    return `<pdf src="${src}">${caption}</pdf>`;
-  });
-  result = result.replace(OBSIDIAN_MEDIA_FILE_RE, (_match, caption, src) => {
-    return `<file src="${src}">${caption}</file>`;
-  });
+  const restore = (tag) => (_match, caption, src) => {
+    const cap = caption.trim() === tag ? "" : caption;
+    return `<${tag} src="${src}">${cap}</${tag}>`;
+  };
+  result = result.replace(OBSIDIAN_MEDIA_AUDIO_RE, restore("audio"));
+  result = result.replace(OBSIDIAN_MEDIA_VIDEO_RE, restore("video"));
+  result = result.replace(OBSIDIAN_MEDIA_PDF_RE, restore("pdf"));
+  result = result.replace(OBSIDIAN_MEDIA_FILE_RE, restore("file"));
   return result;
 }
 var OBSIDIAN_TAB_RE = /^> \[!tab\]\s*(.+)\n((?:> .*\n?)*)/gm;
 function restoreTabBlocks(content) {
-  return content.replace(OBSIDIAN_TAB_RE, (_match, title, body) => {
+  const result = content.replace(OBSIDIAN_TAB_RE, (_match, title, body) => {
     const unquoted = body.split("\n").map((line) => line.replace(/^> /, "")).join("\n").trim();
     return `<tab title="${title}">${unquoted}</tab>`;
   });
+  return result.replace(/(<\/tab>)(?!\n|$)/g, "$1\n");
 }
 var OBSIDIAN_UNKNOWN_RE = new RegExp(
   `(?:\\[[^\\]]*\\]\\([^)]*\\))?%%${MARKER_BRAND_RE}:unknown:id=([^&]+)&type=([^%]+)%%`,
@@ -5350,6 +6320,42 @@ function restoreUnderlineSpans(content) {
     return `<span underline="true">${text}</span>`;
   });
 }
+var OBSIDIAN_BLOCK_COLOR_RE = new RegExp(
+  `[ \\t]*%%${MARKER_BRAND_RE}:block-color:([a-z_]+)%%`,
+  "g"
+);
+function restoreBlockColorMarkers(content) {
+  return content.replace(OBSIDIAN_BLOCK_COLOR_RE, (_m, color) => ` {color="${color}"}`);
+}
+var COLUMN_REGION_RE = new RegExp(
+  `^${escapeRegex3(COLUMN_LIST_START)}[ \\t]*\\n([\\s\\S]*?)\\n?^${escapeRegex3(COLUMN_LIST_END)}[ \\t]*$\\n?`,
+  "gm"
+);
+function indentColumnLines(text) {
+  return text.split("\n").map((line) => line === "" ? "" : `	${line}`).join("\n");
+}
+function reassembleColumns(content) {
+  const sepRe = new RegExp(`^${escapeRegex3(COLUMN_SEP)}[ \\t]*$`, "m");
+  let result = content.replace(COLUMN_REGION_RE, (_m, inner) => {
+    const cols = inner.split(new RegExp(sepRe.source, "gm")).map((c) => c.replace(/^\n/, "").replace(/\n$/, "")).filter((c) => c.trim() !== "");
+    if (cols.length === 0) return "";
+    const parts = cols.map((c) => `<column>
+${indentColumnLines(c)}
+</column>`).join("\n");
+    return `<columns>
+${indentColumnLines(parts)}
+</columns>
+`;
+  });
+  result = result.replace(
+    new RegExp(
+      `^[>\\t ]*%%${MARKER_BRAND_RE}:(?:column-list:start|column-list:end|column)%%[ \\t]*\\n?`,
+      "gm"
+    ),
+    ""
+  );
+  return result;
+}
 function unescapePipes(content) {
   const lines = content.split("\n");
   const result = [];
@@ -5413,6 +6419,14 @@ var DatabaseSyncer = class {
   propertyMapper = new PropertyMapper();
   baseFileGenerator = new BaseFileGenerator();
   sidecarGenerator = new SidecarGenerator();
+  /**
+   * 이번 프로세스가 실제로 기록한 .base 경로/DB 제목 (databaseId nohyph → info).
+   * placeholder 임베드 재작성(F22)의 SSOT — 폴더명(하이픈 새니타이즈)과 .base 파일명
+   * (sanitizeFileName: 공백·점 보존)은 규칙이 달라 localFolder 로 추측한 경로는 깨진
+   * 임베드가 된다. generateBaseFile 은 매 pull 모든 DB 에 대해 실행되므로 pull 종료
+   * 시점에는 성공한 DB 전체가 채워져 있다.
+   */
+  baseFileInfo = /* @__PURE__ */ new Map();
   async pullAll() {
     const databases = this.config.notion.databases;
     if (!databases || databases.length === 0) {
@@ -5467,16 +6481,33 @@ var DatabaseSyncer = class {
     }
     return { created, updated, conflicts: [], failed, writtenPaths: [] };
   }
-  async pullDatabase(dbConfig) {
+  async pullDatabase(dbConfig, opts) {
+    const pages = await this.notionClient.queryAllDatabasePages(
+      dbConfig.databaseId,
+      dbConfig.pullFilter
+    );
+    const parent = pages[0]?.parent;
+    const ownerDbId = parent?.database_id;
+    if (ownerDbId && !notionIdsEqual(ownerDbId, dbConfig.databaseId)) {
+      const ownerFolder = opts?.resolveDbFolder?.(ownerDbId) ?? null;
+      if (ownerFolder !== null) {
+        const viewsConfig2 = await this.pullDatabaseViews(dbConfig);
+        await this.generateBaseFile(dbConfig, viewsConfig2, ownerFolder);
+        return {
+          created: 0,
+          updated: 0,
+          conflicts: [],
+          failed: [],
+          writtenPaths: [],
+          linkedOriginalDbId: ownerDbId
+        };
+      }
+    }
     const schema = await this.notionClient.getDatabaseSchema(dbConfig.databaseId);
     this.propertyMapper.loadSchema(schema);
     await this.vaultFs.ensureFolder(dbConfig.localFolder);
     const viewsConfig = await this.pullDatabaseViews(dbConfig);
     await this.generateBaseFile(dbConfig, viewsConfig);
-    const pages = await this.notionClient.queryAllDatabasePages(
-      dbConfig.databaseId,
-      dbConfig.pullFilter
-    );
     let created = 0;
     let updated = 0;
     const conflicts = [];
@@ -5486,7 +6517,8 @@ var DatabaseSyncer = class {
       try {
         const record = this.stateDb.getByNotionId(page.id);
         if (record) {
-          if (page.last_edited_time === record.notionLastEdited) continue;
+          const misplaced = !isDirectDbRowPath(dbConfig.localFolder, record.obsidianPath);
+          if (page.last_edited_time === record.notionLastEdited && !misplaced) continue;
           const outcome = await this.pullDatabasePage(page, dbConfig);
           if (outcome.action === "written") {
             updated++;
@@ -5544,7 +6576,7 @@ var DatabaseSyncer = class {
       return null;
     }
   }
-  async generateBaseFile(dbConfig, viewsConfig) {
+  async generateBaseFile(dbConfig, viewsConfig, rowsFolder) {
     try {
       const schemaFull = await this.notionClient.getDatabaseSchemaFull(dbConfig.databaseId);
       const dbName = viewsConfig?.databaseName || await this.notionClient.getDatabaseTitle(dbConfig.databaseId) || dbConfig.localFolder.split("/").pop() || "Database";
@@ -5559,11 +6591,12 @@ var DatabaseSyncer = class {
         databaseName: dbName,
         schema: schemaFull,
         viewsConfig: resolvedViews,
-        folderPath: dbConfig.localFolder
+        folderPath: rowsFolder ?? dbConfig.localFolder
       });
       const safeName = sanitizeFileName(dbName);
       const basePath = `${dbConfig.localFolder}/${safeName}.base`;
       await this.vaultFs.writeFile(basePath, baseContent);
+      this.baseFileInfo.set(dbConfig.databaseId.replace(/-/g, ""), { basePath, title: dbName });
       getLogger().debug(`[DB Sync] .base \uD30C\uC77C \uC0DD\uC131: ${basePath}`);
       await this.generateSidecar(dbConfig, dbName, safeName, schemaFull, resolvedViews);
       await this.cleanupStaleDbArtifacts(dbConfig.localFolder, safeName);
@@ -5606,7 +6639,10 @@ var DatabaseSyncer = class {
         viewsConfig: resolvedViews
       });
       const sidecarPath = `${dbConfig.localFolder}/${safeName}.notion.json`;
-      await this.vaultFs.writeFile(sidecarPath, this.sidecarGenerator.serialize(sidecar));
+      const serialized = this.sidecarGenerator.serialize(sidecar);
+      const existing = await this.vaultFs.readFile(sidecarPath).catch(() => null);
+      if (existing === serialized) return;
+      await this.vaultFs.writeFile(sidecarPath, serialized);
       if (sidecar.degraded.length > 0) {
         const unrep = sidecar.degraded.filter((d) => d.kind === "view-unrepresentable").length;
         const dropped = sidecar.degraded.length - unrep;
@@ -5618,6 +6654,42 @@ var DatabaseSyncer = class {
       getLogger().warn(`[DB Sync] \uC0AC\uC774\uB4DC\uCE74 \uC0DD\uC131 \uC2E4\uD328 (\uACC4\uC18D \uC9C4\uD589):`, error);
     }
   }
+  /**
+   * DB 행 `files` 속성의 notion-hosted 서명 URL 을 로컬 첨부로 로컬라이즈한다(P3-A).
+   * 서명 URL 은 약 1시간 뒤 만료되어 frontmatter 에 남으면 깨진 링크가 되고, push 로
+   * 되밀면 Notion 원본이 만료 URL 의 external 파일로 오염된다(실측). 다운로드 성공분은
+   * `[[attachments/..]]` 위키링크로 대체한다 — Bases 카드 `image:` 는 위키링크 스칼라를
+   * 렌더하므로 갤러리 커버도 유지된다. 원본 파일명은 raw 속성의 `name` 에서 취한다
+   * (extractValue 는 URL 만 남긴다). 사용자가 넣은 진짜 외부 URL 은 그대로 둔다.
+   */
+  async localizeFileProperties(rawProps, properties, safeName) {
+    for (const [key, rawProp] of Object.entries(rawProps)) {
+      const prop = rawProp;
+      if (prop?.type !== "files" || !Array.isArray(prop.files) || prop.files.length === 0) {
+        continue;
+      }
+      const localized = [];
+      let changed = false;
+      for (const f of prop.files) {
+        const url = f.type === "file" ? f.file?.url : f.external?.url;
+        if (!url) continue;
+        const caption = f.name?.trim() || `${safeName}-${key}`;
+        try {
+          const localPath = await this.imageHandler.localizeNotionFileUrl(url, caption);
+          if (localPath) {
+            localized.push(`[[${localPath}]]`);
+            changed = true;
+          } else {
+            localized.push(url);
+          }
+        } catch {
+          localized.push(url);
+        }
+      }
+      if (!changed || localized.length === 0) continue;
+      properties[key] = localized.length === 1 ? localized[0] : localized;
+    }
+  }
   async pullDatabasePage(page, dbConfig) {
     const title = this.notionClient.extractTitle(page);
     const safeName = sanitizeFileName(title);
@@ -5625,30 +6697,25 @@ var DatabaseSyncer = class {
       page.properties
     );
     properties.title = title;
+    await this.localizeFileProperties(
+      page.properties,
+      properties,
+      safeName
+    );
     const cover = this.notionClient.extractCover(page);
     const icon = this.notionClient.extractIcon(page);
     if (cover) {
-      try {
-        const coverResult = await this.imageHandler.downloadAllImages(
-          `![cover](${cover.url})`,
-          `${safeName}-cover`
-        );
-        const resolved = coverResult.content.match(/!\[cover\]\((.+?)\)/)?.[1];
-        if (resolved && !/^https?:\/\//i.test(resolved)) {
-          properties.cover = `[[${resolved}]]`;
-        } else {
-          properties.cover = cover.url;
-        }
-      } catch {
-        properties.cover = cover.url;
-      }
+      const local = await this.imageHandler.localizeNotionFileUrl(cover.url, `${safeName}-cover`);
+      properties.cover = local ? `[[${local}]]` : cover.url;
     }
     if (icon) {
       properties.icon = icon.value;
     }
     let markdown = "";
+    let exportCompact = false;
     try {
       const mdResult = await this.notionClient.getPageMarkdown(page.id);
+      exportCompact = isCompactExport(mdResult.markdown);
       markdown = notionEnhancedToObsidian(mdResult.markdown);
     } catch {
     }
@@ -5669,9 +6736,10 @@ var DatabaseSyncer = class {
       }
     }
     const existingRecord = this.stateDb.getByNotionId(page.id);
+    const recordPath = existingRecord?.obsidianPath;
     let filePath;
-    if (existingRecord?.obsidianPath) {
-      filePath = existingRecord.obsidianPath;
+    if (recordPath && isDirectDbRowPath(dbConfig.localFolder, recordPath)) {
+      filePath = recordPath;
     } else {
       filePath = resolveDbRowPath(
         dbConfig.localFolder,
@@ -5688,12 +6756,12 @@ var DatabaseSyncer = class {
         filePath,
         parentMode: "database"
       },
-      { properties }
+      { properties, notionExportCompact: exportCompact }
     );
     if (existingRecord) {
       let localContent = "";
       try {
-        localContent = await this.vaultFs.readFile(filePath);
+        localContent = await this.vaultFs.readFile(recordPath ?? filePath);
       } catch {
         localContent = "";
       }
@@ -5710,17 +6778,26 @@ var DatabaseSyncer = class {
         strategy: this.config.sync.conflictStrategy
       });
       if (resolution.action === "skip") {
-        return { action: "skipped", path: filePath };
+        return { action: "skipped", path: recordPath ?? filePath };
       }
       if (resolution.action === "conflict") {
         this.stateDb.updateStatus(existingRecord.id, "conflict");
-        return { action: "conflict", path: filePath, conflict: resolution.conflict };
+        return {
+          action: "conflict",
+          path: recordPath ?? filePath,
+          conflict: resolution.conflict
+        };
       }
     }
     await this.vaultFs.ensureFolder(dbConfig.localFolder);
     await this.vaultFs.writeFile(filePath, finalContent);
+    const rehomed = existingRecord && recordPath && recordPath !== filePath;
     const hash = computeHash(finalContent);
     this.stateDb.transaction(() => {
+      if (rehomed) {
+        this.stateDb.updatePath(existingRecord.id, filePath);
+        this.stateDb.deleteWikilink(recordPath);
+      }
       this.stateDb.upsert({
         obsidianPath: filePath,
         notionPageId: page.id,
@@ -5740,6 +6817,12 @@ var DatabaseSyncer = class {
         aliases: extractAliases(properties)
       });
     });
+    if (rehomed) {
+      try {
+        await this.vaultFs.deleteFile(recordPath);
+      } catch {
+      }
+    }
     return { action: "written", path: filePath };
   }
   async pushDatabase(dbConfig) {
@@ -6089,8 +7172,8 @@ var ConflictResolver = class {
   async resolveDuplicate(conflict) {
     const originalPath = conflict.syncRecord.obsidianPath;
     const ext = originalPath.endsWith(".md") ? ".md" : "";
-    const baseName = originalPath.replace(/\.md$/, "");
-    const conflictPath = `${baseName}.conflict${ext}`;
+    const baseName2 = originalPath.replace(/\.md$/, "");
+    const conflictPath = `${baseName2}.conflict${ext}`;
     await this.vaultFs.writeFile(conflictPath, conflict.remoteContent);
     const localHash = computeHash(conflict.localContent);
     this.stateDb.updateHash(
@@ -6177,8 +7260,77 @@ function resolveFrontmatterRelations(content, idToTitle) {
   return { content: stringifyFrontmatter(parsed.content, resolved), count };
 }
 
+// src/utils/inline-db-refs.ts
+function extractInlineDbIds(markdown) {
+  const ids = /* @__PURE__ */ new Set();
+  const tagRe = /<database\b[^>]*\burl="[^"]*?([a-f0-9]{32})[^"]*"[^>]*>/g;
+  let m;
+  while ((m = tagRe.exec(markdown)) !== null) {
+    if (m[1]) ids.add(m[1]);
+  }
+  const markerRe = new RegExp(`${MARKER_BRAND_RE}:child-database:id=([a-f0-9-]{32,36})`, "g");
+  while ((m = markerRe.exec(markdown)) !== null) {
+    if (m[1]) ids.add(m[1].replace(/-/g, ""));
+  }
+  return [...ids];
+}
+
+// src/sync/db-placeholder-rewriter.ts
+var ID32 = "[a-f0-9]{32}";
+var IDUUID = "[a-f0-9-]{32,36}";
+var ENC_TITLE = "(?:&title=(.*?))?";
+var INLINE_PLACEHOLDER_RE = new RegExp(
+  `\\*\\*([^\\n*]*)\\*\\*\\s*\\*\\(Notion DB\\)\\*\\s*%%\\s*${MARKER_BRAND_RE}:child-database:id=(${ID32})${ENC_TITLE}\\s*%%`,
+  "g"
+);
+var CALLOUT_PLACEHOLDER_RE = new RegExp(
+  `^((?:[ \\t]*>)+[ \\t]*)\\[!database\\][ \\t]*([^\\n]*)\\n(?:[ \\t]*>)+[ \\t]*%%\\s*${MARKER_BRAND_RE}:child-database:id=(${IDUUID})${ENC_TITLE}\\s*%%[ \\t]*$`,
+  "gm"
+);
+function decodeTitle(encoded) {
+  if (!encoded) return "";
+  try {
+    return decodeURIComponent(encoded);
+  } catch {
+    return encoded;
+  }
+}
+function toAlias(...candidates) {
+  for (const c of candidates) {
+    const cleaned = (c ?? "").replace(/[|[\]\n]/g, "").trim();
+    if (cleaned) return cleaned;
+  }
+  return "";
+}
+function rewriteDbPlaceholders(content, resolve) {
+  let rewrites = 0;
+  let result = content.replace(
+    INLINE_PLACEHOLDER_RE,
+    (match, inlineTitle, id, encTitle) => {
+      const target = resolve(id);
+      if (!target) return match;
+      const alias = toAlias(decodeTitle(encTitle), inlineTitle, target.title, "Database");
+      rewrites++;
+      return `![[${target.basePath}|${alias}]]`;
+    }
+  );
+  result = result.replace(
+    CALLOUT_PLACEHOLDER_RE,
+    (match, prefix, calloutTitle, id, encTitle) => {
+      const target = resolve(id.replace(/-/g, ""));
+      if (!target) return match;
+      const alias = toAlias(decodeTitle(encTitle), calloutTitle, target.title, "Database");
+      rewrites++;
+      return `${prefix}![[${target.basePath}|${alias}]]`;
+    }
+  );
+  return { content: result, rewrites };
+}
+
 // src/sync/orchestrator.ts
 var INACCESSIBLE_DBS_META_KEY = "inaccessible_dbs";
+var LINKED_DBS_META_KEY = "linked_dbs";
+var INCREMENTAL_SAFETY_WINDOW_MS = 15 * 6e4;
 function strategyToChoice(strategy) {
   switch (strategy) {
     case "local-first":
@@ -6479,7 +7631,12 @@ var SyncOrchestrator = class _SyncOrchestrator {
       return record && options.paths.some((p) => record.obsidianPath.startsWith(p));
     }) : remoteChanges;
     if (filtered.length === 0 && (this.config.notion.databases?.length ?? 0) === 0) {
-      const dbDiscovery = await this.pullDiscoveredDatabases(writtenPaths, failed, conflicts);
+      const dbDiscovery = await this.pullDiscoveredDatabases(
+        writtenPaths,
+        failed,
+        conflicts,
+        options?.force === true
+      );
       return finalize(dbDiscovery.created, dbDiscovery.updated, 0);
     }
     if (filtered.length === 0) {
@@ -6606,7 +7763,12 @@ var SyncOrchestrator = class _SyncOrchestrator {
       }
     }
     {
-      const dbDiscovery = await this.pullDiscoveredDatabases(writtenPaths, failed, conflicts);
+      const dbDiscovery = await this.pullDiscoveredDatabases(
+        writtenPaths,
+        failed,
+        conflicts,
+        options?.force === true
+      );
       counts.created += dbDiscovery.created;
       counts.updated += dbDiscovery.updated;
     }
@@ -6698,7 +7860,7 @@ var SyncOrchestrator = class _SyncOrchestrator {
       let remoteContent = "";
       if (record.notionPageId) {
         try {
-          remoteContent = await this.fetchPageMarkdown(record.notionPageId);
+          remoteContent = (await this.fetchPageMarkdown(record.notionPageId)).content;
         } catch {
         }
       }
@@ -6745,7 +7907,20 @@ var SyncOrchestrator = class _SyncOrchestrator {
     let dbTitle;
     try {
       const info = await this.notionClient.getDatabaseSyncability(dbId);
+      if (info.linkedOriginalDbId) {
+        getLogger().info(
+          `[Im-Nobsidian] DB ${dbId}: linked view \uCEE8\uD14C\uC774\uB108(\uC6D0\uBCF8 ${info.linkedOriginalDbId}) \u2192 \uC6D0\uBCF8\uC73C\uB85C \uD574\uC18C(F25)`
+        );
+        return { kind: "linked", originalDbId: info.linkedOriginalDbId };
+      }
       if (!info.queryable) {
+        const linked = await this.notionClient.resolveLinkedDatabase(dbId);
+        if (linked) {
+          getLogger().info(
+            `[Im-Nobsidian] DB ${dbId}: linked view("${linked.viewName}") \u2192 \uC6D0\uBCF8 ${linked.originalDbId} \uB85C \uD574\uC18C`
+          );
+          return { kind: "linked", originalDbId: linked.originalDbId };
+        }
         return { kind: "inaccessible" };
       }
       dbTitle = info.title;
@@ -6760,8 +7935,9 @@ var SyncOrchestrator = class _SyncOrchestrator {
       const obsPath = parentEntry.obsidianPath;
       if (obsPath.endsWith(".md")) {
         const parts = obsPath.split("/");
-        parts.pop();
-        parentFolder = parts.length > 0 ? parts.join("/") : obsPath.replace(/\.md$/, "");
+        const fileBase = (parts.pop() ?? "").replace(/\.md$/, "");
+        const dirName = parts[parts.length - 1] ?? "";
+        parentFolder = fileBase === dirName ? parts.join("/") : [...parts, fileBase].filter(Boolean).join("/");
       } else {
         parentFolder = obsPath;
       }
@@ -6795,7 +7971,20 @@ var SyncOrchestrator = class _SyncOrchestrator {
       return /* @__PURE__ */ new Set();
     }
   }
-  async pullDiscoveredDatabases(writtenPaths, failed, conflicts) {
+  /** linked view 컨테이너 → 원본 DB 매핑을 상태 메타에서 로드한다(nohyph → nohyph). */
+  loadLinkedDbMap() {
+    const raw = this.stateDb.getMeta(LINKED_DBS_META_KEY);
+    if (!raw) return /* @__PURE__ */ new Map();
+    try {
+      const obj = JSON.parse(raw);
+      return new Map(
+        Object.entries(obj).map(([k, v]) => [k.replace(/-/g, ""), v.replace(/-/g, "")])
+      );
+    } catch {
+      return /* @__PURE__ */ new Map();
+    }
+  }
+  async pullDiscoveredDatabases(writtenPaths, failed, conflicts, forceRediscovery = false) {
     if (this.isDatabaseMode) return { created: 0, updated: 0 };
     let created = 0;
     let updated = 0;
@@ -6817,6 +8006,23 @@ var SyncOrchestrator = class _SyncOrchestrator {
         ...dbConfigs.map((c) => c.databaseId.replace(/-/g, ""))
       ]);
       let changed = false;
+      const folderOwner = new Map(
+        (this.config.notion.databases ?? []).map((d) => [d.localFolder, d.databaseId])
+      );
+      const repairedCount = repairDbFolderCollisions(dbConfigs, folderOwner);
+      for (const c of dbConfigs) folderOwner.set(c.localFolder, c.databaseId);
+      if (repairedCount > 0) {
+        changed = true;
+        getLogger().info(`[Im-Nobsidian] \uB3D9\uBA85 DB \uD3F4\uB354 \uCDA9\uB3CC ${repairedCount}\uAC74 \uBD84\uB9AC(F24)`);
+      }
+      const claimFolder = (config) => {
+        config.localFolder = resolveDbFolderPath(
+          config.localFolder,
+          config.databaseId,
+          (f) => folderOwner.get(f) ?? null
+        );
+        folderOwner.set(config.localFolder, config.databaseId);
+      };
       const inaccessibleIds = this.loadInaccessibleDbIds();
       let inaccessibleChanged = false;
       const degrade = (rawId) => {
@@ -6829,52 +8035,119 @@ var SyncOrchestrator = class _SyncOrchestrator {
           `[Im-Nobsidian] DB ${rawId}: \uC811\uADFC \uAC00\uB2A5\uD55C data source \uC5C6\uC74C(\uB9C1\uD06C\uB4DC/\uBBF8\uACF5\uC720/\uC0AD\uC81C \uCD94\uC815) \u2014 \uB3D9\uAE30\uD654 \uB300\uC0C1\uC5D0\uC11C \uC81C\uC678(\uC81C\uBAA9\uC740 \uBD80\uBAA8 \uD398\uC774\uC9C0\uC5D0 \uBCF4\uC874)`
         );
       };
-      if (dbConfigs.length === 0) {
-        const discovered = await this.discoverChildDatabases();
-        for (const { dbId, parentPageId } of discovered) {
-          const nohyph = dbId.replace(/-/g, "");
-          if (knownIds.has(nohyph) || inaccessibleIds.has(nohyph)) continue;
-          const outcome = await this.buildDiscoveredDbConfig(dbId, parentPageId);
-          knownIds.add(nohyph);
-          if (outcome.kind === "ok") {
-            dbConfigs.push(outcome.config);
+      if (forceRediscovery && inaccessibleIds.size > 0) {
+        getLogger().info(
+          `[Im-Nobsidian] --force: \uC811\uADFC \uBD88\uAC00 DB ${inaccessibleIds.size}\uAC1C denylist \uC7AC\uAC80\uC99D`
+        );
+        inaccessibleIds.clear();
+        inaccessibleChanged = true;
+      }
+      const linkedMap = this.loadLinkedDbMap();
+      let linkedChanged = false;
+      const register = async (dbId, parentPageId) => {
+        const nohyph = dbId.replace(/-/g, "");
+        if (knownIds.has(nohyph) || inaccessibleIds.has(nohyph)) return;
+        const registerOriginal = async (origNohyph) => {
+          if (knownIds.has(origNohyph) || inaccessibleIds.has(origNohyph)) return;
+          const origId = normalizeNotionId(origNohyph);
+          const outcome2 = await this.buildDiscoveredDbConfig(origId, parentPageId);
+          knownIds.add(origNohyph);
+          if (outcome2.kind === "ok") {
+            claimFolder(outcome2.config);
+            dbConfigs.push(outcome2.config);
             changed = true;
-          } else if (outcome.kind === "inaccessible") {
-            degrade(dbId);
+          } else if (outcome2.kind !== "error") {
+            degrade(origId);
           }
+        };
+        const knownOriginal = linkedMap.get(nohyph);
+        if (knownOriginal) {
+          await registerOriginal(knownOriginal);
+          return;
         }
-      }
-      for (const [nohyph, parentPageId] of this._inlineDbRefs) {
-        if (knownIds.has(nohyph) || inaccessibleIds.has(nohyph)) continue;
-        const dbId = normalizeNotionId(nohyph);
         const outcome = await this.buildDiscoveredDbConfig(dbId, parentPageId);
         knownIds.add(nohyph);
         if (outcome.kind === "ok") {
+          claimFolder(outcome.config);
           dbConfigs.push(outcome.config);
           changed = true;
+        } else if (outcome.kind === "linked") {
+          const origNohyph = outcome.originalDbId.replace(/-/g, "");
+          linkedMap.set(nohyph, origNohyph);
+          linkedChanged = true;
+          await registerOriginal(origNohyph);
         } else if (outcome.kind === "inaccessible") {
           degrade(dbId);
         }
+      };
+      if (dbConfigs.length === 0 || forceRediscovery) {
+        const discovered = await this.discoverChildDatabases();
+        for (const { dbId, parentPageId } of discovered) {
+          await register(dbId, parentPageId);
+        }
+      }
+      for (const [nohyph, parentPageId] of this._inlineDbRefs) {
+        await register(normalizeNotionId(nohyph), parentPageId);
       }
       const stillSyncable = [];
-      for (const dbConfig of dbConfigs) {
-        if (inaccessibleIds.has(dbConfig.databaseId.replace(/-/g, ""))) continue;
-        try {
-          const dbResult = await this.databaseSyncer.pullDatabase(dbConfig);
-          created += dbResult.created;
-          updated += dbResult.updated;
-          conflicts.push(...dbResult.conflicts);
-          failed.push(...dbResult.failed);
-          writtenPaths.push(...dbResult.writtenPaths);
-          stillSyncable.push(dbConfig);
-        } catch (error) {
-          if (isNotionObjectNotFound(error)) {
-            degrade(dbConfig.databaseId);
-          } else {
-            getLogger().warn(`[Im-Nobsidian] DB ${dbConfig.databaseId} \uB3D9\uAE30\uD654 \uC2E4\uD328:`, error);
+      let queue = [...dbConfigs];
+      const MAX_DISCOVERY_ROUNDS = 4;
+      const resolveDbFolder = (dbId) => {
+        const key = dbId.replace(/-/g, "");
+        const hit = dbConfigs.find((c) => c.databaseId.replace(/-/g, "") === key) ?? (this.config.notion.databases ?? []).find((c) => c.databaseId.replace(/-/g, "") === key);
+        return hit?.localFolder ?? null;
+      };
+      for (let round = 1; queue.length > 0; round++) {
+        const roundRowPaths = [];
+        for (const dbConfig of queue) {
+          if (inaccessibleIds.has(dbConfig.databaseId.replace(/-/g, ""))) continue;
+          try {
+            const dbResult = await this.databaseSyncer.pullDatabase(dbConfig, { resolveDbFolder });
+            if (dbResult.linkedOriginalDbId) {
+              linkedMap.set(
+                dbConfig.databaseId.replace(/-/g, ""),
+                dbResult.linkedOriginalDbId.replace(/-/g, "")
+              );
+              linkedChanged = true;
+              changed = true;
+              getLogger().info(
+                `[Im-Nobsidian] DB ${dbConfig.databaseId}: linked view \uCEE8\uD14C\uC774\uB108 \uAC10\uC9C0 \u2192 \uD589\uC740 \uC6D0\uBCF8 ${dbResult.linkedOriginalDbId} \uD3F4\uB354\uAC00 \uB2E8\uC77C \uC18C\uC720(F25)`
+              );
+              continue;
+            }
+            created += dbResult.created;
+            updated += dbResult.updated;
+            conflicts.push(...dbResult.conflicts);
+            failed.push(...dbResult.failed);
+            writtenPaths.push(...dbResult.writtenPaths);
+            roundRowPaths.push(...dbResult.writtenPaths);
             stillSyncable.push(dbConfig);
+          } catch (error) {
+            if (isNotionObjectNotFound(error)) {
+              degrade(dbConfig.databaseId);
+            } else {
+              getLogger().warn(`[Im-Nobsidian] DB ${dbConfig.databaseId} \uB3D9\uAE30\uD654 \uC2E4\uD328:`, error);
+              stillSyncable.push(dbConfig);
+            }
           }
         }
+        const before = dbConfigs.length;
+        for (const ref of await this.collectRowInlineRefs(roundRowPaths)) {
+          await register(ref.dbId, ref.parentPageId);
+        }
+        queue = dbConfigs.slice(before);
+        if (queue.length > 0 && round >= MAX_DISCOVERY_ROUNDS) {
+          getLogger().warn(
+            `[Im-Nobsidian] \uC911\uCCA9 DB \uBC1C\uACAC \uB77C\uC6B4\uB4DC \uD55C\uB3C4(${MAX_DISCOVERY_ROUNDS}) \uB3C4\uB2EC \u2014 ${queue.length}\uAC1C\uB294 \uB2E4\uC74C pull \uC5D0\uC11C \uB3D9\uAE30\uD654`
+          );
+          stillSyncable.push(...queue);
+          break;
+        }
+        if (queue.length > 0) {
+          getLogger().info(
+            `[Im-Nobsidian] DB row \uBCF8\uBB38\uC5D0\uC11C \uC911\uCCA9 DB ${queue.length}\uAC1C \uCD94\uAC00 \uBC1C\uACAC(\uB77C\uC6B4\uB4DC ${round + 1})`
+          );
+        }
       }
       if (changed || inaccessibleChanged || stillSyncable.length !== dbConfigs.length) {
         this.stateDb.setMeta("discovered_dbs", JSON.stringify(stillSyncable));
@@ -6882,11 +8155,68 @@ var SyncOrchestrator = class _SyncOrchestrator {
       if (inaccessibleChanged) {
         this.stateDb.setMeta(INACCESSIBLE_DBS_META_KEY, JSON.stringify([...inaccessibleIds]));
       }
+      if (linkedChanged) {
+        this.stateDb.setMeta(LINKED_DBS_META_KEY, JSON.stringify(Object.fromEntries(linkedMap)));
+      }
+      await this.rewriteDbPlaceholderEmbeds(writtenPaths, stillSyncable, linkedMap);
     } catch (error) {
       getLogger().warn("[Im-Nobsidian] child_database \uC790\uB3D9 \uBC1C\uACAC \uC2E4\uD328:", error);
     }
     return { created, updated };
   }
+  /**
+   * pull 산출 md 의 인라인 DB placeholder(`**제목** *(Notion DB)*` + 보존 마커)를
+   * `![[<실제 .base 경로>|제목]]` 임베드로 재작성한다(F22) — folder note 본문에서
+   * DB 가 텍스트 한 줄이 아니라 실제 Bases 뷰로 보이게 하는 마지막 조각. linked view
+   * 컨테이너는 linkedMap 을 거쳐 원본 DB 의 .base 로 향한다. .base 경로는 DatabaseSyncer
+   * 가 실제 기록한 경로(baseFileInfo)가 SSOT — 폴더명과 .base 파일명은 새니타이즈 규칙이
+   * 달라(공백→하이픈 vs 공백 보존) localFolder 로 추측하면 깨진 임베드가 된다(E2E 실측
+   * 91/158건). 최종적으로 .base 실존까지 확인해, 없으면 placeholder 를 마커째 보존한다.
+   */
+  async rewriteDbPlaceholderEmbeds(paths, dbConfigs, linkedMap) {
+    const targets = /* @__PURE__ */ new Map();
+    const addTarget = (databaseId, localFolder) => {
+      const nohyph = databaseId.replace(/-/g, "");
+      if (targets.has(nohyph)) return;
+      const info = this.databaseSyncer.baseFileInfo.get(nohyph);
+      if (info) {
+        targets.set(nohyph, { basePath: info.basePath, title: info.title });
+        return;
+      }
+      const safeName = localFolder.split("/").pop() ?? localFolder;
+      targets.set(nohyph, { basePath: `${localFolder}/${safeName}.base`, title: safeName });
+    };
+    for (const cfg of dbConfigs) addTarget(cfg.databaseId, cfg.localFolder);
+    for (const d of this.config.notion.databases ?? []) addTarget(d.databaseId, d.localFolder);
+    for (const [key, t] of [...targets]) {
+      if (!await this.vaultFs.exists(t.basePath)) targets.delete(key);
+    }
+    if (targets.size === 0) return;
+    const resolve = (nohyph) => targets.get(nohyph) ?? targets.get(linkedMap.get(nohyph) ?? "") ?? null;
+    let total = 0;
+    for (const filePath of paths) {
+      if (!filePath.endsWith(".md")) continue;
+      try {
+        const content = await this.vaultFs.readFile(filePath);
+        const { content: next, rewrites } = rewriteDbPlaceholders(content, resolve);
+        if (rewrites === 0) continue;
+        await this.vaultFs.writeFile(filePath, next);
+        total += rewrites;
+        const record = this.stateDb.getByPath(filePath);
+        if (record) {
+          const stat2 = await this.vaultFs.getFileStat(filePath);
+          this.stateDb.transaction(() => {
+            this.stateDb.updateHash(record.id, computeHash(next), Buffer.from(next, "utf-8"));
+            if (stat2) this.stateDb.updateStatCache(record.id, stat2.mtime, stat2.size);
+          });
+        }
+      } catch {
+      }
+    }
+    if (total > 0) {
+      getLogger().info(`[Im-Nobsidian] \uC778\uB77C\uC778 DB \uC784\uBCA0\uB4DC \uC7AC\uC791\uC131: ${total}\uAC74`);
+    }
+  }
   async resolveNotionLinks(paths) {
     let totalResolved = 0;
     const allRecords = this.stateDb.getAll();
@@ -7035,7 +8365,7 @@ var SyncOrchestrator = class _SyncOrchestrator {
       localMtime: null,
       localFileSize: null
     });
-    await this.imageHandler.uploadAndAppendImages(page.id, conversionResult.images);
+    await this.imageHandler.uploadAndAppendImages(page.id, conversionResult.images, path);
     const hash = computeHash(content);
     const fileStat = await this.vaultFs.getFileStat(path);
     this.stateDb.transaction(() => {
@@ -7081,7 +8411,11 @@ var SyncOrchestrator = class _SyncOrchestrator {
       parentMode: this.config.notion.parentMode
     });
     await this.pushUpdatePage(record.notionPageId, conversionResult.content, record.baseSnapshot);
-    await this.imageHandler.uploadAndAppendImages(record.notionPageId, conversionResult.images);
+    await this.imageHandler.uploadAndAppendImages(
+      record.notionPageId,
+      conversionResult.images,
+      path
+    );
     let propsToUpdate;
     if (this.isDatabaseMode && conversionResult.properties && Object.keys(conversionResult.properties).length > 0) {
       await this.ensureDbSchema();
@@ -7305,7 +8639,9 @@ var SyncOrchestrator = class _SyncOrchestrator {
   async detectRemoteChangesIncremental(since) {
     const changes = [];
     this._childParentIds.clear();
-    const recentPages = await this.notionClient.searchRecentPages(since);
+    const sinceMs = Date.parse(since);
+    const safeSince = Number.isFinite(sinceMs) ? new Date(sinceMs - INCREMENTAL_SAFETY_WINDOW_MS).toISOString() : since;
+    const recentPages = await this.notionClient.searchRecentPages(safeSince);
     for (const page of recentPages) {
       const record = this.stateDb.getByNotionId(page.id);
       if (!record) {
@@ -7346,7 +8682,7 @@ var SyncOrchestrator = class _SyncOrchestrator {
     const safeName = sanitizeFileName(title);
     const parentPath = await this.resolveParentPath(page);
     const hasChildPages = await this.pageHasChildContainers(pageId);
-    const markdown = await this.fetchPageMarkdown(pageId);
+    const { content: markdown, compact: exportCompact } = await this.fetchPageMarkdown(pageId);
     const hasContent = markdown.trim().length > 0;
     let filePath;
     let fileType;
@@ -7374,10 +8710,12 @@ var SyncOrchestrator = class _SyncOrchestrator {
     } else {
       properties = this.notionClient.extractProperties(page);
     }
-    properties.title = title;
+    if (this.isDatabaseMode || extractTitle(filePath) !== title) {
+      properties.title = title;
+    }
     let processedMarkdown = markdown;
     if (this.config.conversion.imageDownload === "immediate") {
-      const imageResult = await this.imageHandler.downloadAllImages(markdown, title);
+      const imageResult = await this.imageHandler.downloadAllImages(markdown, title, pageId);
       processedMarkdown = imageResult.content;
       this._pullImageCount += imageResult.downloads.length;
     }
@@ -7392,7 +8730,7 @@ var SyncOrchestrator = class _SyncOrchestrator {
         filePath,
         parentMode: this.config.notion.parentMode
       },
-      { properties }
+      { properties, notionExportCompact: exportCompact }
     );
     const resolvedParentId = await this.extractParentId(page);
     await this.vaultFs.writeFile(filePath, finalContent);
@@ -7449,7 +8787,8 @@ var SyncOrchestrator = class _SyncOrchestrator {
     const record = this.stateDb.getByNotionId(change.pageId);
     if (!record) return {};
     const page = await this.notionClient.getPage(change.pageId);
-    let markdown = await this.fetchPageMarkdown(change.pageId);
+    const fetched = await this.fetchPageMarkdown(change.pageId);
+    let markdown = fetched.content;
     const title = this.notionClient.extractTitle(page);
     let properties;
     if (this.isDatabaseMode) {
@@ -7460,9 +8799,11 @@ var SyncOrchestrator = class _SyncOrchestrator {
     } else {
       properties = this.notionClient.extractProperties(page);
     }
-    properties.title = title;
+    if (this.isDatabaseMode || extractTitle(record.obsidianPath) !== title) {
+      properties.title = title;
+    }
     if (this.config.conversion.imageDownload === "immediate") {
-      const imageResult = await this.imageHandler.downloadAllImages(markdown, title);
+      const imageResult = await this.imageHandler.downloadAllImages(markdown, title, change.pageId);
       markdown = imageResult.content;
       this._pullImageCount += imageResult.downloads.length;
     }
@@ -7478,7 +8819,11 @@ var SyncOrchestrator = class _SyncOrchestrator {
         filePath: record.obsidianPath,
         parentMode: this.config.notion.parentMode
       },
-      { properties, preserveMarkers: savedMarkers.length > 0 ? savedMarkers : void 0 }
+      {
+        properties,
+        preserveMarkers: savedMarkers.length > 0 ? savedMarkers : void 0,
+        notionExportCompact: fetched.compact
+      }
     );
     let localContent;
     try {
@@ -7739,24 +9084,51 @@ var SyncOrchestrator = class _SyncOrchestrator {
       try {
         const result = await this.notionClient.getPageMarkdown(pageId);
         this.collectInlineDbRefs(pageId, result.markdown);
-        return this.resolveNotionIdWikilinks(notionEnhancedToObsidian(result.markdown));
+        return {
+          content: this.resolveNotionIdWikilinks(notionEnhancedToObsidian(result.markdown)),
+          // 압축형 판정은 반드시 원시 export 기준 — enhanced 변환이 <empty-block/> 을
+          // 빈 줄로 바꾼 뒤에는 BlockSpacer 가 저작형과 구분할 수 없다(D1).
+          compact: isCompactExport(result.markdown)
+        };
       } catch {
       }
     }
-    return this.blockConverter.notionBlocksToMarkdown(pageId);
+    const fallback = await this.blockConverter.notionBlocksToMarkdown(pageId);
+    this.collectInlineDbRefs(pageId, fallback);
+    return { content: fallback, compact: false };
   }
-  // Markdown API는 인라인 데이터베이스를 다음처럼 렌더한다(컬럼/synced_block 내부 포함):
-  //   <database url="https://www.notion.so/<id-nohyph>" inline="true"
-  //             data-source-url="collection://<ds-id>">Title</database>
-  // url 안의 32자리 hex 가 databaseId 이므로, 별도 블록 트리 재귀 없이 이 태그만 파싱해
-  // 깊이 중첩된 child_database 까지 폴더+.base 동기화 대상으로 등록한다.
+  // Markdown API는 인라인 데이터베이스를 <database url="..." ...>Title</database> 로 렌더한다
+  // (컬럼/콜아웃/synced_block 내부 포함). url 의 32자리 hex 가 databaseId 이므로 블록 트리
+  // 재귀 없이 이 신호만으로 깊이 중첩된 child_database 를 발견한다. url 호스트는
+  // www.notion.so / app.notion.com/p 두 형태가 실측돼 고정하지 않는다 — 규칙은
+  // extractInlineDbIds(blocks-API 폴백 마커 겸용) 참조.
   collectInlineDbRefs(parentPageId, rawMarkdown) {
-    const re = /<database\b[^>]*\burl="https:\/\/www\.notion\.so\/([a-f0-9]{32})"[^>]*>/g;
-    let m;
-    while ((m = re.exec(rawMarkdown)) !== null) {
-      const dbId = m[1];
-      if (dbId) this._inlineDbRefs.set(dbId, parentPageId);
+    for (const dbId of extractInlineDbIds(rawMarkdown)) {
+      this._inlineDbRefs.set(dbId, parentPageId);
+    }
+  }
+  /**
+   * 이번 라운드에 기록된 DB row md 를 읽어 본문의 인라인 DB 참조를 수집한다.
+   * row 페이지는 DatabaseSyncer 자체 파이프라인으로 변환돼 fetchPageMarkdown 의
+   * _inlineDbRefs 수집을 타지 않는다 — 디스크에 남은 보존 마커가 유일한 발견 신호다.
+   * 부모 Notion 페이지 id 는 state DB 역조회(getByPath)로 얻는다(row upsert 직후라 항상 존재).
+   */
+  async collectRowInlineRefs(rowPaths) {
+    const refs = [];
+    for (const path of rowPaths) {
+      if (!path.endsWith(".md")) continue;
+      try {
+        const ids = extractInlineDbIds(await this.vaultFs.readFile(path));
+        if (ids.length === 0) continue;
+        const record = this.stateDb.getByPath(path);
+        if (!record?.notionPageId) continue;
+        for (const id of ids) {
+          refs.push({ dbId: normalizeNotionId(id), parentPageId: record.notionPageId });
+        }
+      } catch {
+      }
     }
+    return refs;
   }
   // pull 시 url 기반 page mention 은 `[[notion:<id>]]` 로 1차 변환된다(notionEnhancedToObsidian).
   // 이를 state DB 역조회로 원래 `[[제목]]` 위키링크로 복원해 push↔pull 라운드트립을 수렴시킨다.
@@ -8039,7 +9411,7 @@ var NodeVaultFS = class {
       if (this.isExcluded(relativePath)) continue;
       if (entry.isDirectory()) {
         await this.walkDirNonMd(fullPath, result);
-      } else if (entry.isFile() && !entry.name.endsWith(".md") && !entry.name.endsWith(".base")) {
+      } else if (entry.isFile() && !entry.name.endsWith(".md")) {
         const fileStat = await stat(fullPath);
         result.push({
           path: relativePath,