@im-nobsidian/core 0.1.3 → 0.1.6

package/dist/index.js

@@ -5,13 +5,20 @@ 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';
 import { watch } from 'chokidar';
 
 // src/types/config.ts
+var DatabaseSyncSchema = z.object({
+  databaseId: z.string(),
+  localFolder: z.string(),
+  propertyMapping: z.record(z.string()).optional(),
+  pullFilter: z.unknown().optional(),
+  titleProperty: z.string().default("Name")
+});
 var ConfigSchema = z.object({
   version: z.literal(1),
   notion: z.object({
@@ -19,14 +26,16 @@ var ConfigSchema = z.object({
     rootPageId: z.string(),
     workspaceId: z.string().optional(),
     parentMode: z.enum(["page", "database"]).default("page"),
-    databaseId: z.string().optional()
+    databaseId: z.string().optional(),
+    databases: z.array(DatabaseSyncSchema).default([])
   }),
   sync: z.object({
     direction: z.enum(["push", "pull", "both"]).default("both"),
     conflictStrategy: z.enum(["local-first", "remote-first", "manual", "duplicate"]).default("manual"),
     autoSync: z.boolean().default(false),
     autoSyncInterval: z.number().min(30).max(3600).default(300),
-    deleteSync: z.boolean().default(false)
+    deleteSync: z.boolean().default(false),
+    syncFiles: z.boolean().default(true)
   }),
   paths: z.object({
     include: z.array(z.string()).default(["**/*"]),
@@ -51,14 +60,16 @@ var DEFAULT_CONFIG = {
   notion: {
     token: "",
     rootPageId: "",
-    parentMode: "page"
+    parentMode: "page",
+    databases: []
   },
   sync: {
     direction: "both",
     conflictStrategy: "manual",
     autoSync: false,
     autoSyncInterval: 300,
-    deleteSync: false
+    deleteSync: false,
+    syncFiles: true
   },
   paths: {
     include: ["**/*"],
@@ -257,6 +268,28 @@ CREATE TABLE IF NOT EXISTS sync_metadata (
 INSERT OR IGNORE INTO sync_metadata (key, value) VALUES ('schema_version', '1');
 `;
 
+// src/state/migrations/002-file-registry.ts
+var FILE_REGISTRY_MIGRATION = `
+CREATE TABLE IF NOT EXISTS file_registry (
+    id              TEXT PRIMARY KEY,
+    local_path      TEXT NOT NULL,
+    notion_page_id  TEXT NOT NULL,
+    file_upload_id  TEXT NOT NULL,
+    file_type       TEXT NOT NULL DEFAULT 'file',
+    file_hash       TEXT NOT NULL,
+    file_size       INTEGER NOT NULL DEFAULT 0,
+    created_at      TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at      TEXT NOT NULL DEFAULT (datetime('now')),
+
+    CONSTRAINT chk_file_type CHECK (file_type IN ('image', 'pdf', 'video', 'audio', 'file'))
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_file_registry_path ON file_registry(local_path);
+CREATE INDEX IF NOT EXISTS idx_file_registry_page ON file_registry(notion_page_id);
+
+UPDATE sync_metadata SET value = '2' WHERE key = 'schema_version';
+`;
+
 // src/state/state-db.ts
 var StateDB = class _StateDB {
   db;
@@ -276,6 +309,9 @@ var StateDB = class _StateDB {
     if (version < 1) {
       this.db.exec(INITIAL_MIGRATION);
     }
+    if (version < 2) {
+      this.db.exec(FILE_REGISTRY_MIGRATION);
+    }
   }
   getSchemaVersion() {
     try {
@@ -406,6 +442,49 @@ var StateDB = class _StateDB {
   setMeta(key, value) {
     this.db.prepare("INSERT OR REPLACE INTO sync_metadata (key, value) VALUES (?, ?)").run(key, value);
   }
+  // --- file_registry ---
+  isFileRegistered(localPath) {
+    const row = this.db.prepare("SELECT 1 FROM file_registry WHERE local_path = ?").get(localPath);
+    return !!row;
+  }
+  getFileRegistry(localPath) {
+    const row = this.db.prepare("SELECT * FROM file_registry WHERE local_path = ?").get(localPath);
+    return row ? this.mapFileRegistryRow(row) : null;
+  }
+  getFilesByPageId(notionPageId) {
+    const rows = this.db.prepare("SELECT * FROM file_registry WHERE notion_page_id = ?").all(notionPageId);
+    return rows.map((r) => this.mapFileRegistryRow(r));
+  }
+  registerFile(entry) {
+    const id = generateId();
+    this.db.prepare(
+      `INSERT OR REPLACE INTO file_registry
+          (id, local_path, notion_page_id, file_upload_id, file_type, file_hash, file_size)
+        VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      entry.localPath,
+      entry.notionPageId,
+      entry.fileUploadId,
+      entry.fileType,
+      entry.fileHash,
+      entry.fileSize
+    );
+  }
+  deleteFileRegistry(localPath) {
+    this.db.prepare("DELETE FROM file_registry WHERE local_path = ?").run(localPath);
+  }
+  mapFileRegistryRow(row) {
+    return {
+      id: row.id,
+      localPath: row.local_path,
+      notionPageId: row.notion_page_id,
+      fileUploadId: row.file_upload_id,
+      fileType: row.file_type,
+      fileHash: row.file_hash,
+      fileSize: row.file_size
+    };
+  }
   // --- preserve markers ---
   storePreserveMarkers(path, markers) {
     if (markers.length === 0) {
@@ -704,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() {
@@ -801,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 };
@@ -813,11 +914,13 @@ 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
+        page_size: options?.pageSize ?? 100,
+        filter: options?.filter
       })
     );
     return {
@@ -825,9 +928,47 @@ var NotionClient = class {
       nextCursor: response.next_cursor
     };
   }
+  async queryAllDatabasePages(databaseId, filter) {
+    const all = [];
+    let cursor;
+    do {
+      const response = await this.queryDatabase(databaseId, {
+        startCursor: cursor,
+        pageSize: 100,
+        filter
+      });
+      all.push(...response.results);
+      cursor = response.nextCursor ?? void 0;
+    } while (cursor);
+    return all;
+  }
+  async getDataSourceId(databaseId) {
+    const db = await this.withRateLimit(
+      () => this.client.databases.retrieve({ database_id: databaseId })
+    );
+    const dataSources = db.data_sources;
+    return dataSources?.[0]?.id ?? databaseId;
+  }
   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(
@@ -852,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) {
@@ -873,15 +1043,18 @@ var NotionClient = class {
       () => this.client.fileUploads.create({ filename, content_type: contentType })
     );
     const fileUploadId = upload.id;
-    await this.withRateLimit(
+    const sendResult = await this.withRateLimit(
       () => this.client.fileUploads.send({
         file_upload_id: fileUploadId,
         file: { data: fileData, filename }
       })
     );
-    await this.withRateLimit(
-      () => this.client.fileUploads.complete({ file_upload_id: fileUploadId })
-    );
+    const status = sendResult.status;
+    if (status === "pending") {
+      await this.withRateLimit(
+        () => this.client.fileUploads.complete({ file_upload_id: fileUploadId })
+      );
+    }
     return fileUploadId;
   }
   // ─── Search & Navigation ───
@@ -900,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);
@@ -922,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;
@@ -937,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();
@@ -980,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([
@@ -1485,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: {
@@ -1726,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;
@@ -1884,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
@@ -1902,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);
   }
@@ -1969,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 };
@@ -2178,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}
@@ -2383,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;
@@ -2746,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 {
@@ -2787,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) {
@@ -2846,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) {
@@ -2854,63 +3337,344 @@ 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 "";
+  }
 };
-
-// src/utils/sanitize.ts
-var INVALID_CHARS = /[<>:"/\\|?*\x00-\x1f]/g;
-var TRAILING_DOTS = /\.+$/;
-var RESERVED_NAMES = /* @__PURE__ */ new Set([
-  "CON",
-  "PRN",
-  "AUX",
-  "NUL",
-  "COM1",
-  "COM2",
-  "COM3",
-  "COM4",
-  "COM5",
-  "COM6",
-  "COM7",
-  "COM8",
-  "COM9",
-  "LPT1",
-  "LPT2",
-  "LPT3",
-  "LPT4",
-  "LPT5",
-  "LPT6",
-  "LPT7",
-  "LPT8",
-  "LPT9"
-]);
-function sanitizeFileName(name) {
-  let sanitized = name.replace(INVALID_CHARS, "_").replace(TRAILING_DOTS, "").trim().slice(0, 200);
-  if (RESERVED_NAMES.has(sanitized.toUpperCase())) {
-    sanitized = `_${sanitized}`;
+var EXTENSION_TO_BLOCK_TYPE = {
+  ".png": "image",
+  ".jpg": "image",
+  ".jpeg": "image",
+  ".gif": "image",
+  ".svg": "image",
+  ".webp": "image",
+  ".ico": "image",
+  ".bmp": "image",
+  ".tiff": "image",
+  ".tif": "image",
+  ".avif": "image",
+  ".apng": "image",
+  ".heic": "image",
+  ".pdf": "pdf",
+  ".mp4": "video",
+  ".mov": "video",
+  ".webm": "video",
+  ".avi": "video",
+  ".mkv": "video",
+  ".flv": "video",
+  ".wmv": "video",
+  ".m4v": "video",
+  ".mpeg": "video",
+  ".ogv": "video",
+  ".3gp": "video",
+  ".mp3": "audio",
+  ".wav": "audio",
+  ".ogg": "audio",
+  ".m4a": "audio",
+  ".flac": "audio",
+  ".aac": "audio",
+  ".wma": "audio",
+  ".opus": "audio",
+  ".weba": "audio"
+};
+var EXTENSION_TO_MIME2 = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".tiff": "image/tiff",
+  ".tif": "image/tiff",
+  ".avif": "image/avif",
+  ".heic": "image/heic",
+  ".pdf": "application/pdf",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".avi": "video/x-msvideo",
+  ".mkv": "video/x-matroska",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".m4a": "audio/mp4",
+  ".flac": "audio/flac",
+  ".aac": "audio/aac",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".zip": "application/zip",
+  ".gz": "application/gzip",
+  ".tar": "application/x-tar",
+  ".rar": "application/vnd.rar",
+  ".7z": "application/x-7z-compressed",
+  ".py": "text/x-python",
+  ".js": "text/javascript",
+  ".ts": "text/typescript",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".txt": "text/plain",
+  ".html": "text/html",
+  ".xml": "application/xml",
+  ".hwp": "application/x-hwp",
+  ".xls": "application/vnd.ms-excel",
+  ".doc": "application/msword",
+  ".ppt": "application/vnd.ms-powerpoint"
+};
+function getBlockType(filename) {
+  const ext = filename.match(/\.[^.]+$/)?.[0]?.toLowerCase();
+  if (!ext) return "file";
+  return EXTENSION_TO_BLOCK_TYPE[ext] ?? "file";
+}
+function getMimeType(filename) {
+  const ext = filename.match(/\.[^.]+$/)?.[0]?.toLowerCase();
+  if (!ext) return "application/octet-stream";
+  return EXTENSION_TO_MIME2[ext] ?? "application/octet-stream";
+}
+function getFolderPath(filePath) {
+  const parts = filePath.split("/");
+  return parts.length > 1 ? parts.slice(0, -1).join("/") : "";
+}
+var FileHandler = class {
+  constructor(vaultFs, notionClient, stateDb) {
+    this.vaultFs = vaultFs;
+    this.notionClient = notionClient;
+    this.stateDb = stateDb;
   }
-  if (sanitized.length === 0) {
-    sanitized = "_untitled";
+  vaultFs;
+  notionClient;
+  stateDb;
+  sema = new Sema(2);
+  async pushFilesForFolder(folderPageId, folderPath) {
+    const allFiles = await this.vaultFs.listNonMarkdownFiles();
+    const folderFiles = allFiles.filter((f) => getFolderPath(f.path) === folderPath);
+    if (folderFiles.length === 0) return [];
+    const results = [];
+    for (const file of folderFiles) {
+      if (this.stateDb.isFileRegistered(file.path)) {
+        const existing = this.stateDb.getFileRegistry(file.path);
+        if (existing) {
+          const buffer = await this.vaultFs.readBinary(file.path);
+          const currentHash = createHash("sha256").update(buffer).digest("hex");
+          if (existing.fileHash === currentHash) continue;
+        }
+      }
+      await this.sema.acquire();
+      try {
+        const result = await this.uploadFile(file, folderPageId);
+        if (result) results.push(result);
+      } catch (error) {
+        getLogger().warn(`\uD30C\uC77C \uC5C5\uB85C\uB4DC \uC2E4\uD328 (${file.path}):`, error);
+      } finally {
+        this.sema.release();
+      }
+    }
+    return results;
   }
-  return sanitized;
-}
-
-// 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;
+  async pushAllFiles() {
+    const allFiles = await this.vaultFs.listNonMarkdownFiles();
+    if (allFiles.length === 0) return [];
+    const filesByFolder = /* @__PURE__ */ new Map();
+    for (const file of allFiles) {
+      const folder = getFolderPath(file.path);
+      const list = filesByFolder.get(folder) ?? [];
+      list.push(file);
+      filesByFolder.set(folder, list);
+    }
+    const results = [];
+    for (const [folderPath, files] of filesByFolder) {
+      const folderRecord = folderPath ? this.stateDb.getByPath(folderPath) : this.stateDb.getByPath("__root__");
+      const folderPageId = folderRecord?.notionPageId;
+      if (!folderPageId) {
+        getLogger().warn(
+          `\uD3F4\uB354 \uD398\uC774\uC9C0 \uC5C6\uC74C, \uD30C\uC77C \uC2A4\uD0B5: ${folderPath || "(\uB8E8\uD2B8)"} (${files.length}\uAC1C)`
+        );
+        continue;
+      }
+      for (const file of files) {
+        if (this.stateDb.isFileRegistered(file.path)) {
+          const existing = this.stateDb.getFileRegistry(file.path);
+          if (existing) {
+            const buffer = await this.vaultFs.readBinary(file.path);
+            const currentHash = createHash("sha256").update(buffer).digest("hex");
+            if (existing.fileHash === currentHash) continue;
+          }
+        }
+        await this.sema.acquire();
+        try {
+          const result = await this.uploadFile(file, folderPageId);
+          if (result) results.push(result);
+        } catch (error) {
+          getLogger().warn(`\uD30C\uC77C \uC5C5\uB85C\uB4DC \uC2E4\uD328 (${file.path}):`, error);
+        } finally {
+          this.sema.release();
+        }
+      }
+    }
+    return results;
+  }
+  async downloadFileBlock(url, filename, targetFolder) {
+    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");
+    const localPath = targetFolder ? `${targetFolder}/${filename}` : filename;
+    await this.vaultFs.ensureFolder(targetFolder || ".");
+    await this.vaultFs.writeBinary(localPath, buffer);
+    return { url, localPath, hash, size: buffer.length };
+  }
+  async downloadFileBlocks(blocks, targetFolder) {
+    const results = [];
+    for (const block of blocks) {
+      const filename = this.extractFilename(block.url, block.caption);
+      if (this.stateDb.isFileRegistered(`${targetFolder}/${filename}`)) continue;
+      await this.sema.acquire();
+      try {
+        const result = await this.downloadFileBlock(block.url, filename, targetFolder);
+        results.push(result);
+      } catch (error) {
+        getLogger().warn(`\uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328 (${block.url}):`, error);
+      } finally {
+        this.sema.release();
+      }
+    }
+    return results;
+  }
+  async uploadFile(file, parentPageId) {
+    const buffer = await this.vaultFs.readBinary(file.path);
+    const filename = file.path.split("/").pop() ?? "file";
+    const contentType = getMimeType(filename);
+    const blockType = getBlockType(filename);
+    const hash = createHash("sha256").update(buffer).digest("hex");
+    const blob = new Blob([buffer], { type: contentType });
+    const fileUploadId = await this.notionClient.uploadFile(blob, filename, contentType);
+    const block = this.createFileBlock(blockType, fileUploadId);
+    await this.notionClient.appendChildren(parentPageId, [block]);
+    this.stateDb.registerFile({
+      localPath: file.path,
+      notionPageId: parentPageId,
+      fileUploadId,
+      fileType: blockType,
+      fileHash: hash,
+      fileSize: file.size
+    });
+    getLogger().info(`\uD30C\uC77C \uC5C5\uB85C\uB4DC \uC644\uB8CC: ${file.path} \u2192 ${blockType} \uBE14\uB85D`);
+    return { localPath: file.path, fileUploadId, blockType };
+  }
+  createFileBlock(blockType, fileUploadId) {
+    const fileRef = {
+      type: "file_upload",
+      file_upload: { id: fileUploadId }
+    };
+    switch (blockType) {
+      case "image":
+        return { type: "image", image: fileRef };
+      case "pdf":
+        return { type: "pdf", pdf: fileRef };
+      case "video":
+        return { type: "video", video: fileRef };
+      case "audio":
+        return { type: "audio", audio: fileRef };
+      case "file":
+      default:
+        return { type: "file", file: fileRef };
+    }
+  }
+  extractFilename(url, caption) {
+    if (caption) {
+      const safe = caption.replace(/[^a-zA-Z0-9가-힣._\s-]/g, "").trim();
+      if (safe) return safe;
+    }
+    try {
+      const pathname = new URL(url).pathname;
+      const segments = pathname.split("/");
+      const last = segments[segments.length - 1];
+      if (last && last.includes(".")) return decodeURIComponent(last);
+    } catch {
+    }
+    const ext = url.match(/\.(png|jpg|jpeg|gif|pdf|mp4|mp3|docx|xlsx|zip|webp)(\?|$)/i);
+    return `file-${Date.now()}${ext ? `.${ext[1]}` : ""}`;
+  }
+};
+
+// src/utils/sanitize.ts
+var INVALID_CHARS = /[<>:"/\\|?*\x00-\x1f]/g;
+var TRAILING_DOTS = /\.+$/;
+var RESERVED_NAMES = /* @__PURE__ */ new Set([
+  "CON",
+  "PRN",
+  "AUX",
+  "NUL",
+  "COM1",
+  "COM2",
+  "COM3",
+  "COM4",
+  "COM5",
+  "COM6",
+  "COM7",
+  "COM8",
+  "COM9",
+  "LPT1",
+  "LPT2",
+  "LPT3",
+  "LPT4",
+  "LPT5",
+  "LPT6",
+  "LPT7",
+  "LPT8",
+  "LPT9"
+]);
+function sanitizeFileName(name) {
+  let sanitized = name.replace(INVALID_CHARS, "_").replace(TRAILING_DOTS, "").trim().slice(0, 200);
+  if (RESERVED_NAMES.has(sanitized.toUpperCase())) {
+    sanitized = `_${sanitized}`;
+  }
+  if (sanitized.length === 0) {
+    sanitized = "_untitled";
+  }
+  return sanitized;
+}
+
+// src/converter/enhanced-md-converter.ts
+var NOTION_CALLOUT_RE = /^::: callout\n([\s\S]*?)\n:::/gm;
+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);
@@ -2924,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) {
@@ -2939,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}`);
@@ -2989,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) => {
@@ -3023,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);
@@ -3122,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();
@@ -3135,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");
 }
@@ -3147,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 = [];
@@ -3164,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));
@@ -3244,6 +4091,316 @@ 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;
+    this.stateDb = stateDb;
+    this.notionClient = notionClient;
+    this.vaultFs = vaultFs;
+    this.pipeline = pipeline;
+    this.imageHandler = imageHandler;
+    this.propertyMapper.setWikilinkResolver({
+      resolve: (title) => stateDb.resolveWikilink(title)?.notionPageId ?? null,
+      resolvePageId: (pageId) => stateDb.resolvePageId(pageId)?.title ?? null
+    });
+  }
+  config;
+  stateDb;
+  notionClient;
+  vaultFs;
+  pipeline;
+  imageHandler;
+  propertyMapper = new PropertyMapper();
+  async pullAll() {
+    const databases = this.config.notion.databases;
+    if (!databases || databases.length === 0) {
+      return { created: 0, updated: 0, failed: [] };
+    }
+    let created = 0;
+    let updated = 0;
+    const failed = [];
+    for (const dbConfig of databases) {
+      try {
+        const result = await this.pullDatabase(dbConfig);
+        created += result.created;
+        updated += result.updated;
+        failed.push(...result.failed);
+      } catch (error) {
+        getLogger().warn(`[DB Sync] DB ${dbConfig.databaseId} pull \uC2E4\uD328:`, error);
+        failed.push({
+          path: dbConfig.localFolder,
+          operation: "create",
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return { created, updated, failed };
+  }
+  async pushAll() {
+    const databases = this.config.notion.databases;
+    if (!databases || databases.length === 0) {
+      return { created: 0, updated: 0, failed: [] };
+    }
+    let created = 0;
+    let updated = 0;
+    const failed = [];
+    for (const dbConfig of databases) {
+      try {
+        const result = await this.pushDatabase(dbConfig);
+        created += result.created;
+        updated += result.updated;
+        failed.push(...result.failed);
+      } catch (error) {
+        getLogger().warn(`[DB Sync] DB ${dbConfig.databaseId} push \uC2E4\uD328:`, error);
+        failed.push({
+          path: dbConfig.localFolder,
+          operation: "create",
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return { created, updated, failed };
+  }
+  async pullDatabase(dbConfig) {
+    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
+    );
+    let created = 0;
+    let updated = 0;
+    const failed = [];
+    for (const page of pages) {
+      try {
+        const record = this.stateDb.getByNotionId(page.id);
+        if (record) {
+          if (page.last_edited_time === record.notionLastEdited) continue;
+          await this.pullDatabasePage(page, dbConfig);
+          updated++;
+        } else {
+          await this.pullDatabasePage(page, dbConfig);
+          created++;
+        }
+      } catch (error) {
+        failed.push({
+          path: `${dbConfig.localFolder}/${page.id}`,
+          operation: "create",
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    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);
+    const properties = this.propertyMapper.fromNotionProperties(
+      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);
+      markdown = notionEnhancedToObsidian(mdResult.markdown);
+    } catch {
+    }
+    if (this.config.conversion.imageDownload === "immediate" && markdown) {
+      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(
+      markdown,
+      {
+        direction: "pull",
+        path: "markdown-api",
+        filePath,
+        parentMode: "database"
+      },
+      { properties }
+    );
+    await this.vaultFs.ensureFolder(dbConfig.localFolder);
+    await this.vaultFs.writeFile(filePath, finalContent);
+    const hash = computeHash(finalContent);
+    this.stateDb.transaction(() => {
+      this.stateDb.upsert({
+        obsidianPath: filePath,
+        notionPageId: page.id,
+        notionParentId: dbConfig.databaseId,
+        contentHash: hash,
+        notionLastEdited: page.last_edited_time,
+        localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
+        syncDirection: "both",
+        fileType: "db-row",
+        status: "synced",
+        baseSnapshot: Buffer.from(finalContent, "utf-8")
+      });
+      this.stateDb.upsertWikilink({
+        obsidianPath: filePath,
+        notionPageId: page.id,
+        title,
+        aliases: extractAliases(properties)
+      });
+    });
+    return filePath;
+  }
+  async pushDatabase(dbConfig) {
+    const schema = await this.notionClient.getDatabaseSchema(dbConfig.databaseId);
+    this.propertyMapper.loadSchema(schema);
+    const allFiles = await this.vaultFs.listMarkdownFiles();
+    const prefix = dbConfig.localFolder.endsWith("/") ? dbConfig.localFolder : dbConfig.localFolder + "/";
+    const dbFiles = allFiles.filter((f) => f.path.startsWith(prefix));
+    let created = 0;
+    let updated = 0;
+    const failed = [];
+    for (const file of dbFiles) {
+      try {
+        const content = await this.vaultFs.readFile(file.path);
+        const hash = computeHash(content);
+        const record = this.stateDb.getByPath(file.path);
+        if (record?.contentHash === hash) continue;
+        const parsed = matter7(content);
+        const frontmatter = parsed.data;
+        const body = parsed.content;
+        const title = frontmatter.title ?? extractTitleFromPath(file.path);
+        delete frontmatter.title;
+        const notionProps = this.propertyMapper.toNotionProperties(frontmatter, title);
+        const enhanced = obsidianToNotionEnhanced(body.trim());
+        if (record?.notionPageId) {
+          await this.notionClient.updatePageProperties(record.notionPageId, notionProps);
+          try {
+            await this.notionClient.replacePageMarkdown(record.notionPageId, enhanced);
+          } catch {
+          }
+          const updatedPage = await this.notionClient.getPage(record.notionPageId);
+          this.stateDb.transaction(() => {
+            this.stateDb.updateHash(record.id, hash, Buffer.from(content, "utf-8"));
+            this.stateDb.updateStatus(record.id, "synced");
+            this.stateDb.setNotionLastEdited(record.id, updatedPage.last_edited_time);
+          });
+          updated++;
+        } else {
+          const page = await this.notionClient.createPageWithMarkdown({
+            parentId: dbConfig.databaseId,
+            parentType: "database",
+            title,
+            markdown: enhanced,
+            properties: notionProps
+          });
+          this.stateDb.transaction(() => {
+            this.stateDb.upsert({
+              obsidianPath: file.path,
+              notionPageId: page.id,
+              notionParentId: dbConfig.databaseId,
+              contentHash: hash,
+              notionLastEdited: page.last_edited_time,
+              localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
+              syncDirection: "both",
+              fileType: "db-row",
+              status: "synced",
+              baseSnapshot: Buffer.from(content, "utf-8")
+            });
+            this.stateDb.upsertWikilink({
+              obsidianPath: file.path,
+              notionPageId: page.id,
+              title,
+              aliases: extractAliases(frontmatter)
+            });
+          });
+          created++;
+        }
+      } catch (error) {
+        failed.push({
+          path: file.path,
+          operation: "create",
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    getLogger().info(`[DB Sync] ${dbConfig.localFolder}: ${created} \uC0DD\uC131, ${updated} \uC5C5\uB370\uC774\uD2B8`);
+    return { created, updated, failed };
+  }
+};
+function extractAliases(properties) {
+  const raw = properties.aliases ?? properties.alias;
+  if (!raw) return [];
+  if (Array.isArray(raw)) return raw.filter((a) => typeof a === "string");
+  if (typeof raw === "string")
+    return raw.split(",").map((s) => s.trim()).filter(Boolean);
+  return [];
+}
+function extractTitleFromPath(filePath) {
+  const parts = filePath.split("/");
+  const filename = parts[parts.length - 1] ?? "";
+  return filename.replace(/\.md$/, "");
+}
 
 // src/sync/orchestrator.ts
 var SyncOrchestrator = class {
@@ -3258,7 +4415,16 @@ var SyncOrchestrator = class {
     });
     this.blockConverter = new BlockConverter();
     this.imageHandler = new ImageHandler(vaultFs, config.paths.attachments, notionClient);
+    this.fileHandler = new FileHandler(vaultFs, notionClient, stateDb);
     this.propertyMapper = new PropertyMapper();
+    this.databaseSyncer = new DatabaseSyncer(
+      config,
+      stateDb,
+      notionClient,
+      vaultFs,
+      this.pipeline,
+      this.imageHandler
+    );
     this.propertyMapper.setWikilinkResolver({
       resolve: (title) => stateDb.resolveWikilink(title)?.notionPageId ?? null,
       resolvePageId: (pageId) => stateDb.resolvePageId(pageId)?.title ?? null
@@ -3273,6 +4439,8 @@ var SyncOrchestrator = class {
   pipeline;
   blockConverter;
   imageHandler;
+  fileHandler;
+  databaseSyncer;
   propertyMapper;
   dbSchemaLoaded = false;
   async push(options) {
@@ -3285,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) {
@@ -3357,6 +4530,66 @@ 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();
+        if (fileResults.length > 0) {
+          getLogger().info(`[Im-Nobsidian] ${fileResults.length}\uAC1C \uD30C\uC77C \uC5C5\uB85C\uB4DC \uC644\uB8CC`);
+        }
+      } catch (error) {
+        getLogger().warn("[Im-Nobsidian] \uD30C\uC77C \uC5C5\uB85C\uB4DC \uC911 \uC624\uB958:", error);
+      }
+    }
+    if ((this.config.notion.databases?.length ?? 0) > 0) {
+      try {
+        const dbResult = await this.databaseSyncer.pushAll();
+        created += dbResult.created;
+        updated += dbResult.updated;
+        failed.push(...dbResult.failed);
+      } catch (error) {
+        getLogger().warn("[Im-Nobsidian] DB Push \uC911 \uC624\uB958:", error);
+      }
+    }
     this.stateDb.setMeta("last_push_at", (/* @__PURE__ */ new Date()).toISOString());
     this.stateDb.setMeta("last_sync_at", (/* @__PURE__ */ new Date()).toISOString());
     this.stateDb.setMeta("push_in_progress", "");
@@ -3450,6 +4683,106 @@ 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();
+        created += dbResult.created;
+        updated += dbResult.updated;
+        failed.push(...dbResult.failed);
+        if (dbResult.created + dbResult.updated > 0) {
+          const dbPaths = this.stateDb.getByStatus("synced").filter((r) => r.fileType === "db-row").map((r) => r.obsidianPath);
+          writtenPaths.push(...dbPaths.slice(-dbResult.created - dbResult.updated));
+        }
+      } catch (error) {
+        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", "");
@@ -3538,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);
@@ -3594,7 +4993,7 @@ var SyncOrchestrator = class {
         status: "synced",
         baseSnapshot: Buffer.from(content, "utf-8")
       });
-      const aliases = extractAliases(conversionResult.properties);
+      const aliases = extractAliases2(conversionResult.properties);
       this.stateDb.upsertWikilink({
         obsidianPath: path,
         notionPageId: page.id,
@@ -3634,7 +5033,7 @@ var SyncOrchestrator = class {
     const updatedPage = await this.notionClient.getPage(record.notionPageId);
     const hash = computeHash(content);
     const title = extractTitle(path);
-    const aliases = extractAliases(conversionResult.properties);
+    const aliases = extractAliases2(conversionResult.properties);
     this.stateDb.transaction(() => {
       this.stateDb.updateHash(record.id, hash, Buffer.from(content, "utf-8"));
       this.stateDb.updateStatus(record.id, "synced");
@@ -3737,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;
@@ -3773,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,
       {
@@ -3785,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(),
@@ -3798,7 +5200,7 @@ var SyncOrchestrator = class {
         status: "synced",
         baseSnapshot: Buffer.from(finalContent, "utf-8")
       });
-      const aliases = extractAliases(properties);
+      const aliases = extractAliases2(properties);
       this.stateDb.upsertWikilink({
         obsidianPath: filePath,
         notionPageId: pageId,
@@ -3828,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,
@@ -3959,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) {
@@ -4017,8 +5421,13 @@ var SyncOrchestrator = class {
           const baseEnhanced = obsidianToNotionEnhanced(baseSnapshot.toString("utf-8"));
           const patches = this.computePatches(baseEnhanced, enhanced);
           if (patches.length > 0 && patches.length <= 20) {
-            await this.notionClient.updatePageMarkdownPartial(pageId, patches);
-            return;
+            try {
+              await this.notionClient.updatePageMarkdownPartial(pageId, patches);
+              return;
+            } catch {
+              await this.notionClient.replacePageMarkdown(pageId, enhanced);
+              return;
+            }
           }
         }
         await this.notionClient.replacePageMarkdown(pageId, enhanced);
@@ -4098,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() {
@@ -4133,7 +5562,7 @@ function extractTitle(filePath) {
   const filename = parts[parts.length - 1] ?? "";
   return filename.replace(/\.md$/, "");
 }
-function extractAliases(properties) {
+function extractAliases2(properties) {
   const raw = properties.aliases ?? properties.alias;
   if (!raw) return [];
   if (Array.isArray(raw)) return raw.filter((a) => typeof a === "string");
@@ -4205,6 +5634,11 @@ var NodeVaultFS = class {
     await this.walkDir(this.rootPath, files);
     return files;
   }
+  async listNonMarkdownFiles() {
+    const files = [];
+    await this.walkDirNonMd(this.rootPath, files);
+    return files;
+  }
   matchesPattern(relativePath, pattern) {
     if (pattern === "**/*" || pattern === "**") return true;
     if (pattern.endsWith("/**")) {
@@ -4227,6 +5661,25 @@ var NodeVaultFS = class {
     }
     return this.excludePatterns.some((p) => this.matchesPattern(relativePath, p));
   }
+  async walkDirNonMd(dir, result) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.name.startsWith(".")) continue;
+      const relativePath = relative(this.rootPath, fullPath);
+      if (this.isExcluded(relativePath)) continue;
+      if (entry.isDirectory()) {
+        await this.walkDirNonMd(fullPath, result);
+      } else if (entry.isFile() && !entry.name.endsWith(".md")) {
+        const fileStat = await stat(fullPath);
+        result.push({
+          path: relativePath,
+          size: fileStat.size,
+          mtime: fileStat.mtime.toISOString()
+        });
+      }
+    }
+  }
   async walkDir(dir, result) {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
@@ -4707,6 +6160,325 @@ var WatchSyncService = class {
   }
 };
 
-export { BlockConverter, CalloutRestorer, CalloutTransformer, ChangeDetector, ColorAnnotator, ConfigManager, ConfigSchema, ConflictResolver, ConversionPipeline, DEFAULT_CONFIG, EmbedResolver, 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