@im-nobsidian/core 0.1.4 → 0.1.6

package/dist/index.js

@@ -5,7 +5,7 @@ import Database from 'better-sqlite3';
 import { randomUUID, createHash } from 'crypto';
 import { Client } from '@notionhq/client';
 import { Sema } from 'async-sema';
-import matter from 'gray-matter';
+import matter7 from 'gray-matter';
 import { markdownToBlocks } from '@tryfabric/martian';
 import { NotionToMarkdown } from 'notion-to-md';
 import { readFileSync } from 'fs';
@@ -783,15 +783,17 @@ var PropertyMapper = class {
 };
 
 // src/notion/client.ts
-var NotionClient = class {
+var NotionClient = class _NotionClient {
   client;
   sema;
+  token;
   propertyMapper = new PropertyMapper();
   constructor(options) {
     this.client = new Client({
       auth: options.token,
       timeoutMs: options.timeoutMs ?? 3e4
     });
+    this.token = options.token;
     this.sema = new Sema(options.concurrency ?? 3);
   }
   getInternalClient() {
@@ -880,11 +882,31 @@ var NotionClient = class {
     );
   }
   // ─── Database / DataSource ───
+  async fetchDatabaseLegacy(databaseId) {
+    const cleanId = databaseId.replace(/-/g, "");
+    const formatted = `${cleanId.slice(0, 8)}-${cleanId.slice(8, 12)}-${cleanId.slice(12, 16)}-${cleanId.slice(16, 20)}-${cleanId.slice(20)}`;
+    const resp = await this.withRateLimit(async () => {
+      const r = await fetch(`https://api.notion.com/v1/databases/${formatted}`, {
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Notion-Version": "2022-06-28",
+          "Content-Type": "application/json"
+        }
+      });
+      if (!r.ok) throw new Error(`Database fetch failed: ${r.status}`);
+      return await r.json();
+    });
+    return resp;
+  }
+  async getDatabaseTitle(databaseId) {
+    const db = await this.fetchDatabaseLegacy(databaseId);
+    const titleArr = db.title;
+    return titleArr?.[0]?.plain_text ?? "";
+  }
   async getDatabaseSchema(databaseId) {
-    const db = await this.withRateLimit(
-      () => this.client.databases.retrieve({ database_id: databaseId })
-    );
+    const db = await this.fetchDatabaseLegacy(databaseId);
     const properties = db.properties;
+    if (!properties) return {};
     const schema = {};
     for (const [name, prop] of Object.entries(properties)) {
       schema[name] = { id: prop.id, type: prop.type };
@@ -892,9 +914,10 @@ var NotionClient = class {
     return schema;
   }
   async queryDatabase(databaseId, options) {
+    const dsId = await this.getDataSourceId(databaseId);
     const response = await this.withRateLimit(
       () => this.client.dataSources.query({
-        data_source_id: databaseId,
+        data_source_id: dsId,
         start_cursor: options?.startCursor,
         page_size: options?.pageSize ?? 100,
         filter: options?.filter
@@ -929,6 +952,23 @@ var NotionClient = class {
   async archivePage(pageId) {
     await this.withRateLimit(() => this.client.pages.update({ page_id: pageId, archived: true }));
   }
+  async getFileBlockUrl(blockId) {
+    try {
+      const block = await this.withRateLimit(
+        () => this.client.blocks.retrieve({ block_id: blockId })
+      );
+      const b = block;
+      const media = b.file ?? b.pdf ?? b.video ?? b.audio ?? b.image;
+      return media?.file?.url ?? media?.external?.url ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async getBlock(blockId) {
+    return this.withRateLimit(
+      () => this.client.blocks.retrieve({ block_id: blockId })
+    );
+  }
   // ─── Block CRUD ───
   async listChildren(blockId, options) {
     const response = await this.withRateLimit(
@@ -953,6 +993,35 @@ var NotionClient = class {
     } while (cursor);
     return blocks;
   }
+  static CONTAINER_BLOCK_TYPES = /* @__PURE__ */ new Set([
+    "column_list",
+    "column",
+    "callout",
+    "toggle",
+    "quote"
+  ]);
+  async fetchAllChildrenDeep(blockId) {
+    const directChildren = await this.fetchAllChildren(blockId);
+    const allBlocks = [...directChildren];
+    const toExpand = directChildren.filter((b) => {
+      if (!b.has_children) return false;
+      if (b.type === "child_page" || b.type === "child_database") return false;
+      if (_NotionClient.CONTAINER_BLOCK_TYPES.has(b.type)) return true;
+      if (b.type === "synced_block") {
+        const sb = b;
+        return sb.synced_block?.synced_from === null;
+      }
+      return true;
+    });
+    for (const container of toExpand) {
+      try {
+        const nested = await this.fetchAllChildrenDeep(container.id);
+        allBlocks.push(...nested);
+      } catch {
+      }
+    }
+    return allBlocks;
+  }
   async appendChildren(blockId, children) {
     const BATCH_SIZE = 100;
     for (let i = 0; i < children.length; i += BATCH_SIZE) {
@@ -1004,19 +1073,23 @@ var NotionClient = class {
     };
   }
   async getChildPages(parentId) {
-    const blocks = await this.fetchAllChildren(parentId);
+    const blocks = await this.fetchAllChildrenDeep(parentId);
     const childPageBlocks = blocks.filter((b) => b.type === "child_page");
     if (childPageBlocks.length === 0) return [];
     const pages = await Promise.all(childPageBlocks.map((b) => this.getPage(b.id)));
     return pages;
   }
+  async getChildDatabaseIds(parentId) {
+    const blocks = await this.fetchAllChildrenDeep(parentId);
+    return blocks.filter((b) => b.type === "child_database").map((b) => b.id);
+  }
   async getChildPagesRecursive(parentId) {
     const all = [];
     let currentLevel = [parentId];
     while (currentLevel.length > 0) {
-      const childArrays = await Promise.all(currentLevel.map((id) => this.getChildPages(id)));
       const nextLevel = [];
-      for (const children of childArrays) {
+      for (const id of currentLevel) {
+        const children = await this.getChildPages(id);
         for (const child of children) {
           all.push(child);
           nextLevel.push(child.id);
@@ -1026,6 +1099,76 @@ var NotionClient = class {
     }
     return all;
   }
+  // ─── Views API ───
+  async listDatabaseViews(databaseId) {
+    const allViews = [];
+    let cursor;
+    do {
+      const response = await this.withRateLimit(
+        () => this.client.views.list({
+          database_id: databaseId,
+          start_cursor: cursor,
+          page_size: 100
+        })
+      );
+      const viewRefs = response.results;
+      for (const ref of viewRefs) {
+        try {
+          const detail = await this.getView(ref.id);
+          if (detail) allViews.push(detail);
+        } catch {
+        }
+      }
+      cursor = response.next_cursor;
+    } while (cursor);
+    return allViews;
+  }
+  async getView(viewId) {
+    const view = await this.withRateLimit(() => this.client.views.retrieve({ view_id: viewId }));
+    const v = view;
+    if (!v.type) return null;
+    return parseViewResponse(v);
+  }
+  async getDatabaseViewsConfig(databaseId) {
+    const views = await this.listDatabaseViews(databaseId);
+    return {
+      databaseId,
+      lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
+      views
+    };
+  }
+  // ─── Cover / Icon Extraction ───
+  extractCover(page) {
+    const raw = page;
+    if (!raw.cover) return null;
+    if (raw.cover.type === "file" && raw.cover.file) {
+      return {
+        type: "file",
+        url: raw.cover.file.url,
+        expiryTime: raw.cover.file.expiry_time
+      };
+    }
+    if (raw.cover.type === "external" && raw.cover.external) {
+      return { type: "external", url: raw.cover.external.url };
+    }
+    return null;
+  }
+  extractIcon(page) {
+    const raw = page;
+    if (!raw.icon) return null;
+    switch (raw.icon.type) {
+      case "emoji":
+        return { type: "emoji", value: raw.icon.emoji };
+      case "external":
+        return { type: "external", value: raw.icon.external.url };
+      case "file":
+        return { type: "file", value: raw.icon.file.url };
+      case "icon":
+        return { type: "icon", value: raw.icon.icon.name, color: raw.icon.icon.color };
+      default:
+        return null;
+    }
+  }
   // ─── Property Extraction ───
   extractTitle(page) {
     const props = page.properties;
@@ -1041,9 +1184,17 @@ var NotionClient = class {
     return this.propertyMapper.fromNotionProperties(page.properties);
   }
   // ─── Internal ───
+  lastRequestTime = 0;
+  minRequestInterval = 350;
   async withRateLimit(fn) {
     await this.sema.acquire();
     try {
+      const now = Date.now();
+      const elapsed = now - this.lastRequestTime;
+      if (elapsed < this.minRequestInterval) {
+        await sleep(this.minRequestInterval - elapsed);
+      }
+      this.lastRequestTime = Date.now();
       return await this.executeWithRetry(fn);
     } finally {
       this.sema.release();
@@ -1084,6 +1235,60 @@ function extractRetryAfter(error) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function parseViewResponse(v) {
+  const config = {
+    id: v.id,
+    name: v.name,
+    type: v.type,
+    dataSourceId: v.data_source_id,
+    filter: v.filter,
+    sorts: v.sorts?.map((s) => {
+      if ("property" in s) {
+        return { property: s.property, direction: s.direction };
+      }
+      return { timestamp: s.timestamp, direction: s.direction };
+    }),
+    ...extractViewTypeConfig(v.configuration)
+  };
+  return config;
+}
+function extractViewTypeConfig(cfg) {
+  if (!cfg) return {};
+  const result = {};
+  if ("properties" in cfg && cfg.properties) {
+    result.properties = cfg.properties.map((p) => ({
+      propertyId: p.property_id,
+      propertyName: p.property_name,
+      visible: p.visible,
+      width: p.width,
+      wrap: p.wrap
+    }));
+  }
+  if ("group_by" in cfg && cfg.group_by) {
+    const gb = cfg.group_by;
+    result.groupBy = {
+      type: gb.type,
+      propertyId: gb.property_id,
+      propertyName: "property_name" in gb ? gb.property_name : void 0,
+      sort: "sort" in gb && gb.sort ? gb.sort.type : void 0,
+      hideEmptyGroups: "hide_empty_groups" in gb ? gb.hide_empty_groups : void 0
+    };
+  }
+  if ("cover" in cfg && cfg.cover) {
+    result.cover = {
+      type: cfg.cover.type,
+      propertyId: cfg.cover.property_id
+    };
+  }
+  if ("cover_size" in cfg) result.coverSize = cfg.cover_size;
+  if ("cover_aspect" in cfg) result.coverAspect = cfg.cover_aspect;
+  if ("date_property_id" in cfg) {
+    result.datePropertyId = cfg.date_property_id;
+    result.datePropertyName = cfg.date_property_name;
+  }
+  if ("view_range" in cfg) result.viewRange = cfg.view_range;
+  return result;
+}
 
 // src/notion/block-builder.ts
 var VALID_COLORS = /* @__PURE__ */ new Set([
@@ -1589,7 +1794,7 @@ var FrontmatterExtractor = class {
   name = "FrontmatterExtractor";
   order = 10;
   process(input) {
-    const { data, content } = matter(input.content);
+    const { data, content } = matter7(input.content);
     return {
       content: content.trim(),
       metadata: {
@@ -1830,7 +2035,7 @@ var PropertiesTableInjector = class {
     if (Object.keys(filteredProps).length === 0) {
       return { content: input.content, metadata: input.metadata };
     }
-    const yamlStr = matter.stringify("", filteredProps).trim();
+    const yamlStr = matter7.stringify("", filteredProps).trim();
     const yamlBody = yamlStr.slice(4, -3).trim();
     const codeBlock = "```yaml\n# im-nobsidian:properties\n" + yamlBody + "\n```";
     const content = codeBlock + "\n\n---\n\n" + input.content;
@@ -1988,7 +2193,7 @@ var FrontmatterGenerator = class {
       return { content: input.content, metadata: input.metadata };
     }
     const normalized = normalizeProperties(properties);
-    const content = matter.stringify(input.content, normalized);
+    const content = matter7.stringify(input.content, normalized);
     return {
       content,
       metadata: input.metadata
@@ -2006,6 +2211,9 @@ function normalizeProperties(props) {
   return result;
 }
 function normalizeValue(value) {
+  if (value instanceof Date) {
+    return normalizeDate(value.toISOString());
+  }
   if (typeof value === "string") {
     return normalizeDate(value);
   }
@@ -2073,7 +2281,7 @@ ${yamlContent}---
 `;
     let parsed;
     try {
-      const result = matter(fakeDocument);
+      const result = matter7(fakeDocument);
       parsed = result.data;
     } catch {
       return { content: input.content, metadata: input.metadata };
@@ -2282,7 +2490,7 @@ var BlockConverter = class {
       const title = richTextToMarkdown(b.toggle?.rich_text);
       const children = b.has_children ? await n2m.pageToMarkdown(b.id) : [];
       const childMd = (Array.isArray(children) ? n2m.toMarkdownString(children).parent : "") ?? "";
-      const indented = childMd.split("\n").map((line) => line ? `  ${line}` : "").join("\n").trimEnd();
+      const indented = childMd.split("\n").map((line) => line.trim() ? `  ${line}` : "  ").join("\n").trimEnd();
       return `${TOGGLE_START}
 - ${title}
 ${indented}
@@ -2487,7 +2695,7 @@ ${COLUMN_LIST_END}`;
       const calloutType = EMOJI_TO_TYPE[emoji] ?? "note";
       let result = `> [!${calloutType}] ${text}`;
       if (childMd?.trim()) {
-        const lines = childMd.trim().split("\n").map((l) => `> ${l}`);
+        const lines = childMd.trim().split("\n").map((l) => l.trim() ? `> ${l}` : ">");
         result += "\n" + lines.join("\n");
       }
       return result;
@@ -2850,35 +3058,49 @@ var ImageHandler = class {
   attachmentFolder;
   notionClient;
   async downloadImage(url, pageTitle) {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`\uC774\uBBF8\uC9C0 \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: ${response.status} ${response.statusText}`);
+    const maxRetries = 3;
+    let lastError = null;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        if (attempt > 0) {
+          await new Promise((r) => setTimeout(r, 1e3 * attempt));
+          getLogger().info(
+            `[Im-Nobsidian] \uC774\uBBF8\uC9C0 \uB2E4\uC6B4\uB85C\uB4DC \uC7AC\uC2DC\uB3C4 (${attempt + 1}/${maxRetries}): ${pageTitle}`
+          );
+        }
+        const response = await fetch(url);
+        if (!response.ok) {
+          throw new Error(`\uC774\uBBF8\uC9C0 \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: ${response.status} ${response.statusText}`);
+        }
+        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 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 };
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+      }
     }
-    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 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
-    };
+    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]));
-    if (notionMatches.length === 0) {
+    const internalImageRegex = /!\[([^\]]*)\]\((file:\/\/%7B.*?%7D%7D)\)/g;
+    const internalMatches = [...markdown.matchAll(internalImageRegex)];
+    if (notionMatches.length === 0 && internalMatches.length === 0) {
       return { content: markdown, downloads: [] };
     }
     const sema = new Sema(3);
-    const results = await Promise.allSettled(
+    const downloads = [];
+    let result = markdown;
+    const httpResults = await Promise.allSettled(
       notionMatches.map(async (match) => {
         await sema.acquire();
         try {
@@ -2891,15 +3113,34 @@ var ImageHandler = class {
         }
       })
     );
-    const downloads = [];
-    let result = markdown;
-    for (const settled of results) {
+    for (const settled of httpResults) {
       if (settled.status !== "fulfilled") continue;
       const { match, download } = settled.value;
       downloads.push(download);
       const obsidianEmbed = `![[${download.localPath}${match[1] ? `|${match[1]}` : ""}]]`;
       result = result.replace(match[0], obsidianEmbed);
     }
+    for (const match of internalMatches) {
+      await sema.acquire();
+      try {
+        const fileUrl = match[2];
+        const parsed = this.parseNotionFileUrl(fileUrl);
+        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);
+        downloads.push(download);
+        const obsidianEmbed = `![[${download.localPath}${match[1] ? `|${match[1]}` : ""}]]`;
+        result = result.replace(match[0], obsidianEmbed);
+      } catch (error) {
+        getLogger().warn(`\uB0B4\uBD80 \uC774\uBBF8\uC9C0 \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: ${error}`);
+      } finally {
+        sema.release();
+      }
+    }
     return { content: result, downloads };
   }
   async uploadLocalImage(localPath) {
@@ -2950,7 +3191,145 @@ var ImageHandler = class {
     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 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]));
+    const xmlInternalRegex = /<(?:file|video|audio|pdf)\s+src="(file:\/\/%7B.*?%7D%7D)">([\s\S]*?)<\/(?:file|video|audio|pdf)>/g;
+    const xmlInternalMatches = [...markdown.matchAll(xmlInternalRegex)];
+    const totalMatches = notionHttpMatches.length + mdInternalMatches.length + notionXmlHttpMatches.length + xmlInternalMatches.length;
+    if (totalMatches === 0) {
+      return { content: markdown, downloads: [] };
+    }
+    const sema = new Sema(3);
+    const downloads = [];
+    let result = markdown;
+    for (const match of notionHttpMatches) {
+      await sema.acquire();
+      try {
+        const url = match[2];
+        const caption = match[1]?.trim() || "file";
+        const download = await this.downloadFile(url, pageTitle, caption);
+        downloads.push(download);
+        const obsidianLink = `[[${download.localPath}|${caption}]]`;
+        result = result.replace(match[0], obsidianLink);
+      } catch (error) {
+        getLogger().warn(`\uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: ${error}`);
+      } finally {
+        sema.release();
+      }
+    }
+    for (const match of mdInternalMatches) {
+      await sema.acquire();
+      try {
+        const fileUrl = match[2];
+        const parsed = this.parseNotionFileUrl(fileUrl);
+        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 download = await this.downloadFile(realUrl, pageTitle, caption);
+        downloads.push(download);
+        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}`);
+      } finally {
+        sema.release();
+      }
+    }
+    for (const match of notionXmlHttpMatches) {
+      await sema.acquire();
+      try {
+        const url = match[1];
+        const caption = match[2]?.trim() || "file";
+        const download = await this.downloadFile(url, pageTitle, caption);
+        downloads.push(download);
+        const obsidianLink = `[[${download.localPath}|${caption}]]`;
+        result = result.replace(match[0], obsidianLink);
+      } catch (error) {
+        getLogger().warn(`\uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: ${error}`);
+      } finally {
+        sema.release();
+      }
+    }
+    for (const match of xmlInternalMatches) {
+      await sema.acquire();
+      try {
+        const fileUrl = match[1];
+        const parsed = this.parseNotionFileUrl(fileUrl);
+        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[2]?.trim() || "file";
+        const download = await this.downloadFile(realUrl, pageTitle, caption);
+        downloads.push(download);
+        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}`);
+      } finally {
+        sema.release();
+      }
+    }
+    return { content: result, downloads };
+  }
+  parseNotionFileUrl(fileUrl) {
+    try {
+      const decoded = decodeURIComponent(fileUrl.replace("file://", ""));
+      const json = JSON.parse(decoded);
+      const blockId = json.permissionRecord?.id ?? "";
+      const source = json.source ?? "";
+      const fileNameMatch = source.match(/attachment:[^:]+:(.+)$/);
+      const fileName = fileNameMatch ? decodeURIComponent(fileNameMatch[1]) : "";
+      return blockId ? { blockId, fileName } : null;
+    } catch {
+      return null;
+    }
+  }
+  async downloadFile(url, _pageTitle, caption) {
+    const maxRetries = 3;
+    let lastError = null;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        if (attempt > 0) {
+          await new Promise((r) => setTimeout(r, 1e3 * attempt));
+          getLogger().info(
+            `[Im-Nobsidian] \uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC7AC\uC2DC\uB3C4 (${attempt + 1}/${maxRetries}): ${caption}`
+          );
+        }
+        const response = await fetch(url);
+        if (!response.ok) {
+          throw new Error(`\uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: ${response.status} ${response.statusText}`);
+        }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        const hash = createHash("sha256").update(buffer).digest("hex").slice(0, 12);
+        const extension = this.guessFileExtension(url, response.headers.get("content-type"));
+        const safeName = caption.replace(/[^a-zA-Z0-9가-힣\s._-]/g, "").replace(/\s+/g, "-").slice(0, 80);
+        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 };
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+      }
+    }
+    throw lastError;
+  }
   isNotionImageUrl(url) {
+    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");
   }
   guessExtension(url) {
@@ -2958,6 +3337,25 @@ var ImageHandler = class {
     const ext = pathname.match(/\.(png|jpg|jpeg|gif|webp|svg|bmp|tiff)(\?|$)/i);
     return ext ? `.${ext[1].toLowerCase()}` : null;
   }
+  guessFileExtension(url, contentType) {
+    try {
+      const pathname = new URL(url).pathname;
+      const extMatch = pathname.match(/\.([a-zA-Z0-9]{1,10})(?:\?|$)/);
+      if (extMatch) return `.${extMatch[1].toLowerCase()}`;
+    } catch {
+    }
+    const mimeMap = {
+      "application/pdf": ".pdf",
+      "application/zip": ".zip",
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+      "application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+      "application/x-hwp": ".hwp",
+      "application/gzip": ".gz"
+    };
+    if (contentType && mimeMap[contentType]) return mimeMap[contentType];
+    return "";
+  }
 };
 var EXTENSION_TO_BLOCK_TYPE = {
   ".png": "image",
@@ -3259,21 +3657,24 @@ function sanitizeFileName(name) {
 
 // src/converter/enhanced-md-converter.ts
 var NOTION_CALLOUT_RE = /^::: callout\n([\s\S]*?)\n:::/gm;
-var NOTION_TOGGLE_RE = /<details>\s*<summary>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/gs;
+var NOTION_CALLOUT_TAG_RE = /<callout[^>]*>\n?([\s\S]*?)<\/callout>/g;
+var NOTION_TOGGLE_RE = /[\t ]*<details>\s*<summary>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/gs;
 var NOTION_PAGE_MENTION_RE = /<mention-page id="([^"]+)">([\s\S]*?)<\/mention-page>/g;
 var NOTION_USER_MENTION_RE = /<mention-user id="[^"]*">([^<]*)<\/mention-user>/g;
 var NOTION_DATE_MENTION_RE = /<mention-date start="([^"]*)"(?: end="([^"]*)")?[^>]*\/>/g;
 var NOTION_UNKNOWN_RE = /<unknown id="([^"]*)"([^>]*)\/>/g;
-var NOTION_AUDIO_RE = /<audio src="([^"]*)">([\s\S]*?)<\/audio>/g;
-var NOTION_VIDEO_RE = /<video src="([^"]*)">([\s\S]*?)<\/video>/g;
-var NOTION_PDF_RE = /<pdf src="([^"]*)">([\s\S]*?)<\/pdf>/g;
-var NOTION_FILE_RE = /<file src="([^"]*)">([\s\S]*?)<\/file>/g;
+var NOTION_AUDIO_RE = /[\t ]*<audio src="([^"]*)">([\s\S]*?)<\/audio>/g;
+var NOTION_VIDEO_RE = /[\t ]*<video src="([^"]*)">([\s\S]*?)<\/video>/g;
+var NOTION_PDF_RE = /[\t ]*<pdf src="([^"]*)">([\s\S]*?)<\/pdf>/g;
+var NOTION_FILE_RE = /[\t ]*<file src="([^"]*)">([\s\S]*?)<\/file>/g;
 var NOTION_TAB_RE = /<tab title="([^"]*)">([\s\S]*?)<\/tab>/g;
 var NOTION_UNDERLINE_RE = /<span underline="true">([\s\S]*?)<\/span>/g;
 var TOGGLE_START2 = "%%im-nobsidian:toggle:start%%";
 var TOGGLE_END2 = "%%im-nobsidian:toggle:end%%";
 function notionEnhancedToObsidian(enhanced) {
   let result = enhanced;
+  result = convertSyncedBlockRef(result);
+  result = normalizeCodeBlockToggles(result);
   result = convertToggles(result);
   result = convertCallouts(result);
   result = convertPageMentions(result);
@@ -3287,8 +3688,13 @@ function notionEnhancedToObsidian(enhanced) {
   result = convertNotionTables(result);
   result = convertColorSpans(result);
   result = convertUnderlineSpans(result);
+  result = convertColumnBlocks(result);
+  result = convertDatabaseBlocks(result);
+  result = cleanInlineColorAttrs(result);
   result = removeEmptyBlocks(result);
   result = unescapePipes(result);
+  result = unescapeNotionChars(result);
+  result = ensureCalloutContinuity(result);
   return result;
 }
 function obsidianToNotionEnhanced(obsidian) {
@@ -3302,39 +3708,62 @@ function obsidianToNotionEnhanced(obsidian) {
   result = restoreUnderlineSpans(result);
   return result;
 }
+function normalizeCodeBlockToggles(content) {
+  return content.replace(
+    /^- (.+)\n\t```(\w*)\n([\s\S]*?)\n\t```$/gm,
+    (_match, title, lang, body) => {
+      const langTag = lang ? lang : "";
+      return `<details>
+<summary>${title.trim()}</summary>
+\`\`\`${langTag}
+${body}
+\`\`\`
+</details>`;
+    }
+  );
+}
 function convertToggles(content) {
   function replaceToggle(match) {
-    const m = /<details>\s*<summary>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/s.exec(match);
+    const m = /[\t ]*<details>\s*<summary>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/s.exec(match);
     if (!m) return match;
     const title = m[1].trim();
     let body = m[2].trim();
     body = convertToggles(body);
-    const indented = body.split("\n").map((line) => line ? `  ${line}` : "").join("\n").trimEnd();
-    return `${TOGGLE_START2}
-- ${title}
-${indented}
-${TOGGLE_END2}`;
+    const calloutBody = body.split("\n").map((line) => line ? `> ${line}` : ">").join("\n");
+    return `> [!toggle]- ${title}
+${calloutBody}`;
   }
   return content.replace(NOTION_TOGGLE_RE, replaceToggle);
 }
+function calloutBodyToObsidian(body) {
+  const lines = body.split("\n").map((l) => l.replace(/^\t/, "")).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 title = emojiMatch ? emojiMatch[2] : firstLine;
+  const rest = lines.slice(1).join("\n").trim();
+  const calloutTitle = title ? `> [!${type}] ${title}` : `> [!${type}]`;
+  const calloutBody = rest ? "\n" + rest.split("\n").map((line) => line.trim() ? `> ${line}` : ">").join("\n") : "";
+  return calloutTitle + calloutBody;
+}
 function convertCallouts(content) {
-  return content.replace(NOTION_CALLOUT_RE, (_match, body) => {
-    const lines = body.trim().split("\n");
-    const firstLine = lines[0] ?? "";
-    const emojiMatch = /^([\p{Emoji}️‍]+)\s*(.*)/u.exec(firstLine);
-    const type = emojiMatch ? emojiToCalloutType(emojiMatch[1]) : "note";
-    const title = emojiMatch ? emojiMatch[2] : firstLine;
-    const rest = lines.slice(1).join("\n").trim();
-    const calloutTitle = title ? `> [!${type}] ${title}` : `> [!${type}]`;
-    const calloutBody = rest ? "\n" + rest.split("\n").map((line) => `> ${line}`).join("\n") : "";
-    return calloutTitle + calloutBody;
-  });
+  let result = content.replace(
+    NOTION_CALLOUT_TAG_RE,
+    (_match, body) => calloutBodyToObsidian(body)
+  );
+  result = result.replace(NOTION_CALLOUT_RE, (_match, body) => calloutBodyToObsidian(body));
+  return result;
 }
 function convertPageMentions(content) {
-  return content.replace(NOTION_PAGE_MENTION_RE, (_match, _id, text) => {
+  let result = content.replace(NOTION_PAGE_MENTION_RE, (_match, _id, text) => {
     const cleaned = text.trim();
     return `[[${cleaned}]]`;
   });
+  result = result.replace(
+    /<mention-page\s+url="https?:\/\/(?:www\.)?notion\.so\/([a-f0-9]{32})"[^>]*\/>/g,
+    (_match, id) => `[[notion:${id}]]`
+  );
+  return result;
 }
 function convertUserMentions(content) {
   return content.replace(NOTION_USER_MENTION_RE, (_match, name) => `@${name}`);
@@ -3352,6 +3781,20 @@ function preserveUnknownBlocks(content) {
     return `%%im-nobsidian:unknown:id=${id}&type=${blockType}%%`;
   });
 }
+function convertSyncedBlockRef(content) {
+  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;
+    }
+  );
+  result = result.replace(
+    /<synced_block[^>]*>\n?([\s\S]*?)<\/synced_block>/g,
+    (_match, inner) => inner.trim()
+  );
+  return result;
+}
 function convertMediaTags(content) {
   let result = content;
   result = result.replace(NOTION_AUDIO_RE, (_match, src, caption) => {
@@ -3386,10 +3829,25 @@ function convertUnderlineSpans(content) {
   });
 }
 function convertTogglesToHtml(content) {
-  const startRe = new RegExp(escapeRegex3(TOGGLE_START2), "g");
-  const endRe = new RegExp(escapeRegex3(TOGGLE_END2), "g");
+  const calloutToggleRe = /^> \[!toggle\]-\s*(.+)\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 bodyText = body.split("\n").map((line) => line.replace(/^>\s?/, "")).join("\n").trim();
+      return `<details>
+<summary>${title.trim()}</summary>
+
+${bodyText}
+
+</details>`;
+    });
+  }
+  const startRe = new RegExp(escapeRegex3(TOGGLE_START2), "g");
+  const endRe = new RegExp(escapeRegex3(TOGGLE_END2), "g");
+  safety = 0;
   while (result.includes(TOGGLE_START2) && safety++ < 100) {
     const startIdx = result.indexOf(TOGGLE_START2);
     const endIdx = findMatchingEnd(result, startIdx + TOGGLE_START2.length);
@@ -3485,7 +3943,7 @@ function escapeRegex3(str) {
 }
 var NOTION_PAGE_LINK_RE = /<page url="[^"]*">([\s\S]*?)<\/page>/g;
 var NOTION_COLOR_SPAN_RE = /<span color="([^"]+)">([\s\S]*?)<\/span>/g;
-var NOTION_EMPTY_BLOCK_RE = /^<empty-block\/>\n?/gm;
+var NOTION_EMPTY_BLOCK_RE = /^(?:>[\t ]*)*[\t ]*<empty-block\/>\n?/gm;
 function convertPageLinks(content) {
   return content.replace(NOTION_PAGE_LINK_RE, (_match, text) => {
     const cleaned = text.replace(/\*\*/g, "").trim();
@@ -3498,6 +3956,20 @@ function convertColorSpans(content) {
     (_match, color, text) => `%%im-nobsidian:color:${color}%%${text}%%/color%%`
   );
 }
+function convertDatabaseBlocks(content) {
+  return content.replace(
+    /<database[^>]*>([\s\S]*?)<\/database>/g,
+    (_match, title) => `**${title.trim()}** *(Notion DB)*`
+  );
+}
+function cleanInlineColorAttrs(content) {
+  return content.replace(/\s*\{color="[^"]*"\}/g, "");
+}
+function convertColumnBlocks(content) {
+  return content.replace(/<columns>\n?([\s\S]*?)<\/columns>/g, (_match, inner) => {
+    return inner.replace(/\t?<column>\n?/g, "").replace(/\t?<\/column>\n?/g, "").trim();
+  });
+}
 function removeEmptyBlocks(content) {
   return content.replace(NOTION_EMPTY_BLOCK_RE, "\n");
 }
@@ -3510,11 +3982,21 @@ ${eq.trim()}
 $$`;
   });
   result = result.replace(NOTION_INLINE_MATH_RE, (_match, eq) => `$${eq}$`);
+  result = result.replace(/\\\$([^$]+?)\\\$/g, (_match, inner) => {
+    const unescaped = inner.replace(/\\\^/g, "^").replace(/\\~/g, "~");
+    return `$${unescaped}$`;
+  });
   return result;
 }
+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_CELL_RE = /<t[dh][^>]*>([\s\S]*?)<\/t[dh]>/g;
+function isAlignmentRow(cells) {
+  return cells.every((c) => /^:?-{2,}:?$/.test(c.trim()));
+}
 function convertNotionTables(content) {
   return content.replace(NOTION_TABLE_RE, (_match, tableBody) => {
     const rows = [];
@@ -3527,7 +4009,9 @@ function convertNotionTables(content) {
       while ((cellMatch = cellRe.exec(rowMatch[1])) !== null) {
         cells.push(cellMatch[1].trim());
       }
-      rows.push(cells);
+      if (!isAlignmentRow(cells)) {
+        rows.push(cells);
+      }
     }
     if (rows.length === 0) return _match;
     const colCount = Math.max(...rows.map((r) => r.length));
@@ -3607,6 +4091,23 @@ function unescapePipes(content) {
   }
   return result.join("\n");
 }
+function ensureCalloutContinuity(content) {
+  const lines = content.split("\n");
+  const result = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "" && i > 0 && i < lines.length - 1) {
+      const prev = result[result.length - 1] ?? "";
+      const next = lines[i + 1] ?? "";
+      if (/^>/.test(prev) && /^>/.test(next) && !/^> \[!/.test(next)) {
+        result.push(">");
+        continue;
+      }
+    }
+    result.push(line);
+  }
+  return result.join("\n");
+}
 var DatabaseSyncer = class {
   constructor(config, stateDb, notionClient, vaultFs, pipeline, imageHandler) {
     this.config = config;
@@ -3681,6 +4182,7 @@ var DatabaseSyncer = class {
     const schema = await this.notionClient.getDatabaseSchema(dbConfig.databaseId);
     this.propertyMapper.loadSchema(schema);
     await this.vaultFs.ensureFolder(dbConfig.localFolder);
+    await this.pullDatabaseViews(dbConfig);
     const pages = await this.notionClient.queryAllDatabasePages(
       dbConfig.databaseId,
       dbConfig.pullFilter
@@ -3710,6 +4212,26 @@ var DatabaseSyncer = class {
     getLogger().info(`[DB Sync] ${dbConfig.localFolder}: ${created} \uC0DD\uC131, ${updated} \uC5C5\uB370\uC774\uD2B8`);
     return { created, updated, failed };
   }
+  async pullDatabaseViews(dbConfig) {
+    try {
+      const viewsConfig = await this.notionClient.getDatabaseViewsConfig(dbConfig.databaseId);
+      const configPath = ".im-nobsidian/db-views.json";
+      await this.vaultFs.ensureFolder(".im-nobsidian");
+      let allViewsConfigs = {};
+      try {
+        const existing = await this.vaultFs.readFile(configPath);
+        allViewsConfigs = JSON.parse(existing);
+      } catch {
+      }
+      allViewsConfigs[dbConfig.databaseId] = viewsConfig;
+      await this.vaultFs.writeFile(configPath, JSON.stringify(allViewsConfigs, null, 2));
+      getLogger().info(
+        `[DB Sync] \uBDF0 \uC124\uC815 ${viewsConfig.views.length}\uAC1C \uC800\uC7A5: ${dbConfig.databaseId}`
+      );
+    } catch (error) {
+      getLogger().warn(`[DB Sync] \uBDF0 \uC124\uC815 Pull \uC2E4\uD328 (\uACC4\uC18D \uC9C4\uD589):`, error);
+    }
+  }
   async pullDatabasePage(page, dbConfig) {
     const title = this.notionClient.extractTitle(page);
     const safeName = sanitizeFileName(title);
@@ -3717,6 +4239,27 @@ var DatabaseSyncer = class {
       page.properties
     );
     properties.title = title;
+    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 localUrlMatch = coverResult.content.match(/!\[cover\]\((.+?)\)/);
+        if (localUrlMatch?.[1]) {
+          properties.cover = localUrlMatch[1];
+        } else {
+          properties.cover = cover.url;
+        }
+      } catch {
+        properties.cover = cover.url;
+      }
+    }
+    if (icon) {
+      properties.icon = icon.value;
+    }
     let markdown = "";
     try {
       const mdResult = await this.notionClient.getPageMarkdown(page.id);
@@ -3727,6 +4270,10 @@ var DatabaseSyncer = class {
       const imageResult = await this.imageHandler.downloadAllImages(markdown, title);
       markdown = imageResult.content;
     }
+    if (markdown) {
+      const fileResult = await this.imageHandler.downloadAllFiles(markdown, title);
+      markdown = fileResult.content;
+    }
     const existingRecord = this.stateDb.getByNotionId(page.id);
     const filePath = existingRecord?.obsidianPath ?? `${dbConfig.localFolder}/${safeName}.md`;
     const finalContent = this.pipeline.convertToMarkdown(
@@ -3779,7 +4326,7 @@ var DatabaseSyncer = class {
         const hash = computeHash(content);
         const record = this.stateDb.getByPath(file.path);
         if (record?.contentHash === hash) continue;
-        const parsed = matter(content);
+        const parsed = matter7(content);
         const frontmatter = parsed.data;
         const body = parsed.content;
         const title = frontmatter.title ?? extractTitleFromPath(file.path);
@@ -3906,8 +4453,13 @@ var SyncOrchestrator = class {
     const changes = this.changeDetector.detectLocalChanges(files);
     const conflictPaths = new Set(this.stateDb.getByStatus("conflict").map((r) => r.obsidianPath));
     const eligible = options?.force ? changes : changes.filter((c) => !conflictPaths.has(c.path));
-    const filtered = options?.paths ? eligible.filter((c) => options.paths.some((p) => c.path.startsWith(p))) : eligible;
-    if (filtered.length === 0) {
+    const dbFolders = (this.config.notion.databases ?? []).map(
+      (d) => d.localFolder.endsWith("/") ? d.localFolder : d.localFolder + "/"
+    );
+    const isDbPath = (path) => dbFolders.some((prefix) => path.startsWith(prefix));
+    const filtered = (options?.paths ? eligible.filter((c) => options.paths.some((p) => c.path.startsWith(p))) : eligible).filter((c) => !isDbPath(c.path));
+    const hasDbConfigs = (this.config.notion.databases?.length ?? 0) > 0;
+    if (filtered.length === 0 && !hasDbConfigs) {
       return { created: 0, updated: 0, deleted: 0, failed: [], duration: Date.now() - startTime };
     }
     if (options?.dryRun) {
@@ -3978,6 +4530,46 @@ var SyncOrchestrator = class {
       }
     });
     await Promise.all(tasks.map((t) => t()));
+    if (failed.length > 0) {
+      const retryTargets = failed.splice(0, failed.length);
+      getLogger().info(`[Im-Nobsidian] Push ${retryTargets.length}\uAC74 \uC7AC\uC2DC\uB3C4 (2\uCD08 \uD6C4)`);
+      await new Promise((r) => setTimeout(r, 2e3));
+      for (const target of retryTargets) {
+        const change = filtered.find((c) => c.path === target.path);
+        if (!change) {
+          failed.push(target);
+          continue;
+        }
+        try {
+          switch (change.type) {
+            case "created":
+              await this.pushCreate(change.path);
+              created++;
+              break;
+            case "modified":
+              await this.pushUpdate(change.path);
+              updated++;
+              break;
+            case "moved":
+              await this.pushMove(change.path);
+              updated++;
+              break;
+            case "deleted":
+              await this.pushDelete(change.path);
+              deleted++;
+              break;
+          }
+          getLogger().info(`[Im-Nobsidian] \uC7AC\uC2DC\uB3C4 \uC131\uACF5: ${change.path}`);
+        } catch (error) {
+          failed.push({
+            path: change.path,
+            operation: target.operation,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          getLogger().warn(`[Im-Nobsidian] \uC7AC\uC2DC\uB3C4 \uC2E4\uD328: ${change.path}`);
+        }
+      }
+    }
     if (this.config.sync.syncFiles !== false) {
       try {
         const fileResults = await this.fileHandler.pushAllFiles();
@@ -4091,6 +4683,54 @@ var SyncOrchestrator = class {
       }
     });
     await Promise.all(tasks.map((t) => t()));
+    if (failed.length > 0) {
+      const retryTargets = failed.splice(0, failed.length);
+      getLogger().info(`[Im-Nobsidian] Pull ${retryTargets.length}\uAC74 \uC7AC\uC2DC\uB3C4 (2\uCD08 \uD6C4)`);
+      await new Promise((r) => setTimeout(r, 2e3));
+      for (const target of retryTargets) {
+        const change = filtered.find((c) => {
+          const record = this.stateDb.getByNotionId(c.pageId);
+          return (record?.obsidianPath ?? c.pageId) === target.path;
+        });
+        if (!change) {
+          failed.push(target);
+          continue;
+        }
+        try {
+          switch (change.type) {
+            case "created": {
+              const path = await this.pullCreate(change.pageId);
+              writtenPaths.push(path);
+              created++;
+              break;
+            }
+            case "modified": {
+              const result = await this.pullUpdate(change);
+              if (result.conflict) {
+                conflicts.push(result.conflict);
+              } else if (result.path) {
+                writtenPaths.push(result.path);
+                updated++;
+              }
+              break;
+            }
+            case "deleted": {
+              const path = await this.pullDelete(change.pageId);
+              if (path) deleted++;
+              break;
+            }
+          }
+          getLogger().info(`[Im-Nobsidian] \uC7AC\uC2DC\uB3C4 \uC131\uACF5: ${target.path}`);
+        } catch (error) {
+          failed.push({
+            path: target.path,
+            operation: target.operation,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          getLogger().warn(`[Im-Nobsidian] \uC7AC\uC2DC\uB3C4 \uC2E4\uD328: ${target.path}`);
+        }
+      }
+    }
     if ((this.config.notion.databases?.length ?? 0) > 0) {
       try {
         const dbResult = await this.databaseSyncer.pullAll();
@@ -4105,6 +4745,44 @@ var SyncOrchestrator = class {
         getLogger().warn("[Im-Nobsidian] DB Pull \uC911 \uC624\uB958:", error);
       }
     }
+    if (!this.isDatabaseMode) {
+      try {
+        const discoveredDbs = await this.discoverChildDatabases();
+        const configuredIds = new Set(
+          (this.config.notion.databases ?? []).map((d) => d.databaseId.replace(/-/g, ""))
+        );
+        const newDbs = discoveredDbs.filter((db) => !configuredIds.has(db.dbId.replace(/-/g, "")));
+        for (const { dbId, parentPageId } of newDbs) {
+          try {
+            const dbTitle = await this.notionClient.getDatabaseTitle(dbId);
+            const safeName = (dbTitle || dbId.slice(0, 8)).replace(/[^a-zA-Z0-9가-힣\s_-]/g, "").replace(/\s+/g, "-");
+            const parentEntry = parentPageId ? this.stateDb.getByNotionId(parentPageId) : null;
+            let parentFolder = "databases";
+            if (parentEntry?.obsidianPath) {
+              const parts = parentEntry.obsidianPath.split("/");
+              parts.pop();
+              parentFolder = parts.length > 0 ? parts.join("/") : "databases";
+            }
+            const folderName = `${parentFolder}/${safeName}`;
+            const dbConfig = {
+              databaseId: dbId,
+              localFolder: folderName,
+              titleProperty: "Name"
+            };
+            const dbResult = await this.databaseSyncer.pullDatabase(dbConfig);
+            created += dbResult.created;
+            updated += dbResult.updated;
+            failed.push(...dbResult.failed);
+          } catch (error) {
+            getLogger().warn(`[Im-Nobsidian] \uC790\uB3D9 \uBC1C\uACAC DB ${dbId} \uB3D9\uAE30\uD654 \uC2E4\uD328:`, error);
+          }
+        }
+      } catch (error) {
+        getLogger().warn("[Im-Nobsidian] child_database \uC790\uB3D9 \uBC1C\uACAC \uC2E4\uD328:", error);
+      }
+    }
+    const allSyncedMdPaths = this.stateDb.getAll().filter((r) => r.obsidianPath?.endsWith(".md")).map((r) => r.obsidianPath);
+    await this.resolveNotionLinks(allSyncedMdPaths);
     this.stateDb.setMeta("last_pull_at", (/* @__PURE__ */ new Date()).toISOString());
     this.stateDb.setMeta("last_sync_at", (/* @__PURE__ */ new Date()).toISOString());
     this.stateDb.setMeta("pull_in_progress", "");
@@ -4193,6 +4871,72 @@ var SyncOrchestrator = class {
   get isDatabaseMode() {
     return this.config.notion.parentMode === "database" && !!this.config.notion.databaseId;
   }
+  async discoverChildDatabases() {
+    const rootId = this.config.notion.rootPageId;
+    const allDbs = [];
+    let currentLevel = [rootId];
+    while (currentLevel.length > 0) {
+      const nextLevel = [];
+      for (const parentId of currentLevel) {
+        try {
+          const dbIds = await this.notionClient.getChildDatabaseIds(parentId);
+          for (const dbId of dbIds) {
+            allDbs.push({ dbId, parentPageId: parentId });
+          }
+          const childPages = await this.notionClient.getChildPages(parentId);
+          nextLevel.push(...childPages.map((p) => p.id));
+        } catch {
+        }
+      }
+      currentLevel = nextLevel;
+    }
+    return allDbs;
+  }
+  async resolveNotionLinks(paths) {
+    const allRecords = this.stateDb.getAll();
+    const idToTitle = /* @__PURE__ */ new Map();
+    for (const r of allRecords) {
+      if (r.notionPageId && r.obsidianPath) {
+        const title = r.obsidianPath.replace(/\.md$/, "").split("/").pop() ?? "";
+        const cleanId = r.notionPageId.replace(/-/g, "");
+        idToTitle.set(cleanId, title);
+        idToTitle.set(r.notionPageId, title);
+      }
+    }
+    if (idToTitle.size === 0) return;
+    for (const filePath of paths) {
+      if (!filePath.endsWith(".md")) continue;
+      try {
+        let content = await this.vaultFs.readFile(filePath);
+        let changed = false;
+        const resolved = content.replace(/\[\[notion:([a-f0-9-]+)\]\]/g, (_match, id) => {
+          const title = idToTitle.get(id.replace(/-/g, ""));
+          if (title) {
+            changed = true;
+            return `[[${title}]]`;
+          }
+          return _match;
+        });
+        content = resolved;
+        const resolved2 = content.replace(
+          /\[([^\]]+)\]\(\/([a-f0-9]{32})\?pvs=\d+\)/g,
+          (_match, text, id) => {
+            const title = idToTitle.get(id);
+            if (title) {
+              changed = true;
+              return `[[${title}|${text}]]`;
+            }
+            return _match;
+          }
+        );
+        content = resolved2;
+        if (changed) {
+          await this.vaultFs.writeFile(filePath, content);
+        }
+      } catch {
+      }
+    }
+  }
   async ensureDbSchema() {
     if (this.dbSchemaLoaded || !this.isDatabaseMode) return;
     const schema = await this.notionClient.getDatabaseSchema(this.config.notion.databaseId);
@@ -4392,7 +5136,7 @@ var SyncOrchestrator = class {
     const title = this.notionClient.extractTitle(page);
     const safeName = sanitizeFileName(title);
     const parentPath = await this.resolveParentPath(page);
-    const allChildren = await this.notionClient.fetchAllChildren(pageId);
+    const allChildren = await this.notionClient.fetchAllChildrenDeep(pageId);
     const hasChildPages = allChildren.some((b) => "type" in b && b.type === "child_page");
     const markdown = await this.fetchPageMarkdown(pageId);
     const hasContent = markdown.trim().length > 0;
@@ -4428,6 +5172,8 @@ var SyncOrchestrator = class {
       const imageResult = await this.imageHandler.downloadAllImages(markdown, title);
       processedMarkdown = imageResult.content;
     }
+    const fileResult = await this.imageHandler.downloadAllFiles(processedMarkdown, title);
+    processedMarkdown = fileResult.content;
     const finalContent = this.pipeline.convertToMarkdown(
       processedMarkdown,
       {
@@ -4440,11 +5186,12 @@ var SyncOrchestrator = class {
     );
     await this.vaultFs.writeFile(filePath, finalContent);
     const hash = computeHash(finalContent);
+    const resolvedParentId = await this.extractParentId(page);
     this.stateDb.transaction(() => {
       this.stateDb.upsert({
         obsidianPath: filePath,
         notionPageId: pageId,
-        notionParentId: this.extractParentId(page),
+        notionParentId: resolvedParentId,
         contentHash: hash,
         notionLastEdited: page.last_edited_time,
         localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4483,6 +5230,8 @@ var SyncOrchestrator = class {
       const imageResult = await this.imageHandler.downloadAllImages(markdown, title);
       markdown = imageResult.content;
     }
+    const fileResult = await this.imageHandler.downloadAllFiles(markdown, title);
+    markdown = fileResult.content;
     const savedMarkers = this.stateDb.getPreserveMarkers(record.obsidianPath);
     const remoteContent = this.pipeline.convertToMarkdown(
       markdown,
@@ -4614,7 +5363,7 @@ var SyncOrchestrator = class {
     return fileName === folderName;
   }
   async resolveParentPath(page) {
-    const parentId = this.extractParentId(page);
+    const parentId = await this.extractParentId(page);
     if (!parentId || notionIdsEqual(parentId, this.config.notion.rootPageId)) return "";
     const parentRecord = this.stateDb.getByNotionId(parentId);
     if (parentRecord) {
@@ -4758,10 +5507,30 @@ var SyncOrchestrator = class {
     }
     return this.blockConverter.notionBlocksToMarkdown(pageId);
   }
-  extractParentId(page) {
+  async extractParentId(page) {
     const parent = page.parent;
     if (parent.type === "page_id") return parent.page_id ?? null;
     if (parent.type === "database_id") return parent.database_id ?? null;
+    if (parent.type === "block_id" && parent.block_id) {
+      return this.resolveBlockToPageId(parent.block_id);
+    }
+    return null;
+  }
+  async resolveBlockToPageId(blockId) {
+    for (let i = 0; i < 10; i++) {
+      try {
+        const block = await this.notionClient.getBlock(blockId);
+        const bp = block.parent;
+        if (bp.type === "page_id") return bp.page_id ?? null;
+        if (bp.type === "block_id" && bp.block_id) {
+          blockId = bp.block_id;
+          continue;
+        }
+        return null;
+      } catch {
+        return null;
+      }
+    }
     return null;
   }
   cleanupInterruptedSync() {
@@ -5391,6 +6160,325 @@ var WatchSyncService = class {
   }
 };
 
-export { BlockConverter, CalloutRestorer, CalloutTransformer, ChangeDetector, ColorAnnotator, ConfigManager, ConfigSchema, ConflictResolver, ConversionPipeline, DEFAULT_CONFIG, DatabaseSyncer, EmbedResolver, FileHandler, FileWatcher, FrontmatterExtractor, FrontmatterGenerator, HtmlAnnotationStripper, ImageHandler, InlineDBParser, LocalImageRestorer, MathNormalizer, MentionToWikilink, NodeVaultFS, NotionBlockBuilder, NotionClient, PreserveMarkerCollector, PreserveMarkerInjector, PropertiesTableInjector, PropertiesTableRestorer, PropertyMapper, StateDB, SyncOrchestrator, TreeMapper, UnsupportedBlockStripper, WatchSyncService, WikilinkResolver, computeBufferHash, computeHash, createDefaultPipeline, generateId, getLogger, normalizeNotionId, notionIdsEqual, sanitizeFileName, setLogger, threeWayMerge };
+// src/view/filter-engine.ts
+function sortEntries(entries, sorts) {
+  if (sorts.length === 0) return entries;
+  return [...entries].sort((a, b) => {
+    for (const sort of sorts) {
+      const key = sort.property ?? sort.timestamp;
+      if (!key) continue;
+      const aVal = a.properties[key] ?? null;
+      const bVal = b.properties[key] ?? null;
+      const cmp = compareValues(aVal, bVal);
+      if (cmp !== 0) return sort.direction === "ascending" ? cmp : -cmp;
+    }
+    return 0;
+  });
+}
+function groupEntries(entries, groupByProperty, options) {
+  const groups = /* @__PURE__ */ new Map();
+  const ungrouped = [];
+  for (const entry of entries) {
+    const val = entry.properties[groupByProperty] ?? null;
+    const groupName = extractGroupName(val);
+    if (groupName === null) {
+      ungrouped.push(entry);
+    } else {
+      const existing = groups.get(groupName);
+      if (existing) {
+        existing.push(entry);
+      } else {
+        groups.set(groupName, [entry]);
+      }
+    }
+  }
+  let result = Array.from(groups.entries()).map(([name, items]) => ({
+    groupName: name,
+    entries: items
+  }));
+  if (options?.sort === "ascending") {
+    result.sort((a, b) => a.groupName.localeCompare(b.groupName));
+  } else if (options?.sort === "descending") {
+    result.sort((a, b) => b.groupName.localeCompare(a.groupName));
+  }
+  if (ungrouped.length > 0) {
+    result.push({ groupName: "\uADF8\uB8F9 \uC5C6\uC74C", entries: ungrouped });
+  }
+  if (options?.hideEmptyGroups) {
+    result = result.filter((g) => g.entries.length > 0);
+  }
+  return result;
+}
+function extractCalendarEntries(entries, dateProperty) {
+  const result = [];
+  for (const entry of entries) {
+    const val = entry.properties[dateProperty];
+    if (!val) continue;
+    if (typeof val === "string") {
+      const date = parseDate(val);
+      if (date) result.push({ entry, date });
+    } else if (typeof val === "object" && val !== null && !Array.isArray(val) && "start" in val) {
+      const date = parseDate(val.start);
+      if (date) {
+        result.push({
+          entry,
+          date,
+          endDate: val.end ? parseDate(val.end) ?? void 0 : void 0
+        });
+      }
+    }
+  }
+  return result;
+}
+function filterByMonth(calendarEntries, year, month) {
+  const monthStr = `${year}-${String(month).padStart(2, "0")}`;
+  return calendarEntries.filter((ce) => ce.date.startsWith(monthStr));
+}
+function getVisibleProperties(viewConfig) {
+  if (!viewConfig.properties) return [];
+  return viewConfig.properties.filter((p) => p.visible !== false).map((p) => ({
+    id: p.propertyId,
+    name: p.propertyName ?? p.propertyId,
+    width: p.width
+  }));
+}
+function compareValues(a, b) {
+  if (a === null && b === null) return 0;
+  if (a === null) return 1;
+  if (b === null) return -1;
+  if (typeof a === "string" && typeof b === "string") return a.localeCompare(b);
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "boolean" && typeof b === "boolean") return (a ? 1 : 0) - (b ? 1 : 0);
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.join(",").localeCompare(b.join(","));
+  }
+  if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {
+    if ("start" in a && "start" in b) {
+      return (a.start ?? "").localeCompare(b.start ?? "");
+    }
+  }
+  return String(a).localeCompare(String(b));
+}
+function extractGroupName(val) {
+  if (val === null || val === void 0) return null;
+  if (typeof val === "string") return val || null;
+  if (typeof val === "boolean") return val ? "true" : "false";
+  if (typeof val === "number") return String(val);
+  if (Array.isArray(val)) return val.length > 0 ? val.join(", ") : null;
+  if (typeof val === "object" && "start" in val) return val.start;
+  return null;
+}
+function parseDate(value) {
+  const match = /^(\d{4}-\d{2}-\d{2})/.exec(value);
+  return match?.[1] ?? null;
+}
+var DB_VIEWS_PATH = ".im-nobsidian/db-views.json";
+var ViewDataProvider = class {
+  constructor(vaultFs) {
+    this.vaultFs = vaultFs;
+  }
+  vaultFs;
+  async loadAllViewConfigs() {
+    try {
+      const raw = await this.vaultFs.readFile(DB_VIEWS_PATH);
+      return JSON.parse(raw);
+    } catch {
+      return {};
+    }
+  }
+  async getViewConfigs(databaseId) {
+    const all = await this.loadAllViewConfigs();
+    return all[databaseId] ?? null;
+  }
+  async collectEntries(folderPath) {
+    const allFiles = await this.vaultFs.listMarkdownFiles();
+    const prefix = folderPath.endsWith("/") ? folderPath : folderPath + "/";
+    const dbFiles = allFiles.filter((f) => f.path.startsWith(prefix));
+    const entries = [];
+    for (const file of dbFiles) {
+      try {
+        const content = await this.vaultFs.readFile(file.path);
+        const entry = parseEntry(file.path, content);
+        if (entry) entries.push(entry);
+      } catch {
+      }
+    }
+    return entries;
+  }
+  async buildViewData(databaseId, viewId, folderPath, schema) {
+    const dbConfig = await this.getViewConfigs(databaseId);
+    if (!dbConfig) return null;
+    const viewConfig = dbConfig.views.find((v) => v.id === viewId);
+    if (!viewConfig) return null;
+    const entries = await this.collectEntries(folderPath);
+    return this.processViewData(entries, viewConfig, databaseId, dbConfig.databaseName, schema);
+  }
+  async buildDefaultViewData(databaseId, folderPath, schema) {
+    const dbConfig = await this.getViewConfigs(databaseId);
+    if (!dbConfig || dbConfig.views.length === 0) return null;
+    const viewConfig = dbConfig.views[0];
+    const entries = await this.collectEntries(folderPath);
+    return this.processViewData(entries, viewConfig, databaseId, dbConfig.databaseName, schema);
+  }
+  processViewData(entries, viewConfig, databaseId, databaseName, schema) {
+    let processed = entries;
+    if (viewConfig.sorts && viewConfig.sorts.length > 0) {
+      processed = sortEntries(processed, viewConfig.sorts);
+    }
+    const visibleProps = getVisibleProperties(viewConfig);
+    const propertyNames = visibleProps.length > 0 ? visibleProps.map((p) => p.name) : collectPropertyNames(processed);
+    const data = {
+      databaseId,
+      databaseName,
+      viewConfig,
+      entries: processed,
+      propertyNames,
+      schema
+    };
+    if (viewConfig.type === "board" && viewConfig.groupBy) {
+      const grouped = groupEntries(
+        processed,
+        viewConfig.groupBy.propertyName ?? viewConfig.groupBy.propertyId,
+        {
+          sort: viewConfig.groupBy.sort === "manual" ? void 0 : viewConfig.groupBy.sort,
+          hideEmptyGroups: viewConfig.groupBy.hideEmptyGroups
+        }
+      );
+      return { ...data, grouped };
+    }
+    if (viewConfig.type === "calendar" && viewConfig.datePropertyName) {
+      const calendarEntries = extractCalendarEntries(processed, viewConfig.datePropertyName);
+      return { ...data, calendarEntries };
+    }
+    return data;
+  }
+};
+function parseEntry(path, content) {
+  try {
+    const parsed = matter7(content);
+    const fm = parsed.data;
+    const title = fm.title ?? extractTitleFromPath2(path);
+    const icon = fm.icon;
+    const cover = fm.cover;
+    const properties = {};
+    for (const [key, value] of Object.entries(fm)) {
+      if (key === "title" || key === "icon" || key === "cover") continue;
+      properties[key] = normalizePropertyValue(value);
+    }
+    return { path, title, icon, cover, properties };
+  } catch {
+    return null;
+  }
+}
+function normalizePropertyValue(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return value;
+  if (typeof value === "boolean") return value;
+  if (value instanceof Date) {
+    return value.toISOString().split("T")[0];
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => String(v));
+  }
+  if (typeof value === "object" && value !== null) {
+    const obj = value;
+    if ("start" in obj) {
+      return {
+        start: String(obj.start),
+        end: obj.end ? String(obj.end) : void 0
+      };
+    }
+  }
+  return String(value);
+}
+function extractTitleFromPath2(filePath) {
+  const parts = filePath.split("/");
+  const filename = parts[parts.length - 1] ?? "";
+  return filename.replace(/\.md$/, "");
+}
+function collectPropertyNames(entries) {
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    for (const key of Object.keys(entry.properties)) {
+      names.add(key);
+    }
+  }
+  return Array.from(names);
+}
+var EntryEditor = class {
+  constructor(vaultFs) {
+    this.vaultFs = vaultFs;
+  }
+  vaultFs;
+  async updateProperty(entryPath, propertyName, newValue) {
+    const content = await this.vaultFs.readFile(entryPath);
+    const parsed = matter7(content);
+    parsed.data[propertyName] = newValue;
+    const updated = matter7.stringify(parsed.content, parsed.data);
+    await this.vaultFs.writeFile(entryPath, updated);
+  }
+  async createEntry(folderPath, title, properties) {
+    const safeName = title.replace(/[\\/:*?"<>|]/g, "_").trim() || "Untitled";
+    const filePath = `${folderPath}/${safeName}.md`;
+    const frontmatter = { title, ...properties };
+    const content = matter7.stringify("", frontmatter);
+    await this.vaultFs.ensureFolder(folderPath);
+    await this.vaultFs.writeFile(filePath, content);
+    return filePath;
+  }
+  async moveEntryToGroup(entry, groupProperty, newGroupValue) {
+    await this.updateProperty(entry.path, groupProperty, newGroupValue);
+  }
+  async updateDate(entryPath, dateProperty, newDate) {
+    await this.updateProperty(entryPath, dateProperty, newDate);
+  }
+};
+
+// src/view/color-map.ts
+var NOTION_COLORS = {
+  default: "#37352F",
+  gray: "#787774",
+  brown: "#9F6B53",
+  orange: "#D9730D",
+  yellow: "#CB912F",
+  green: "#448361",
+  blue: "#337EA9",
+  purple: "#9065B0",
+  pink: "#C14C8A",
+  red: "#D44C47"
+};
+var NOTION_BG_COLORS = {
+  default: "#F1F1EF",
+  gray: "#F1F1EF",
+  brown: "#F4EEEE",
+  orange: "#FBECDD",
+  yellow: "#FBF3DB",
+  green: "#EDF3EC",
+  blue: "#E7F3F8",
+  purple: "#F4F0F7",
+  pink: "#F9F0F5",
+  red: "#FDEBEC"
+};
+function getNotionColor(color) {
+  return NOTION_COLORS[color] ?? NOTION_COLORS.default;
+}
+function getNotionBgColor(color) {
+  return NOTION_BG_COLORS[color] ?? NOTION_BG_COLORS.default;
+}
+function generateColorCSS() {
+  const lines = [];
+  for (const [name, hex] of Object.entries(NOTION_COLORS)) {
+    lines.push(`  --notion-color-${name}: ${hex};`);
+  }
+  for (const [name, hex] of Object.entries(NOTION_BG_COLORS)) {
+    lines.push(`  --notion-bg-${name}: ${hex};`);
+  }
+  return `:root {
+${lines.join("\n")}
+}`;
+}
+
+export { BlockConverter, CalloutRestorer, CalloutTransformer, ChangeDetector, ColorAnnotator, ConfigManager, ConfigSchema, ConflictResolver, ConversionPipeline, DEFAULT_CONFIG, DatabaseSyncer, EmbedResolver, EntryEditor, FileHandler, FileWatcher, FrontmatterExtractor, FrontmatterGenerator, HtmlAnnotationStripper, ImageHandler, InlineDBParser, LocalImageRestorer, MathNormalizer, MentionToWikilink, NodeVaultFS, NotionBlockBuilder, NotionClient, PreserveMarkerCollector, PreserveMarkerInjector, PropertiesTableInjector, PropertiesTableRestorer, PropertyMapper, StateDB, SyncOrchestrator, TreeMapper, UnsupportedBlockStripper, ViewDataProvider, WatchSyncService, WikilinkResolver, computeBufferHash, computeHash, createDefaultPipeline, extractCalendarEntries, filterByMonth, generateColorCSS, generateId, getLogger, getNotionBgColor, getNotionColor, getVisibleProperties, groupEntries, normalizeNotionId, notionIdsEqual, sanitizeFileName, setLogger, sortEntries, threeWayMerge };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map