@im-nobsidian/core 0.1.2 → 0.1.4

package/dist/index.js

@@ -12,6 +12,13 @@ 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 {
@@ -371,6 +407,11 @@ var StateDB = class _StateDB {
       "UPDATE sync_state SET notion_last_edited = ?, updated_at = datetime('now') WHERE id = ?"
     ).run(lastEdited, id);
   }
+  setNotionParentId(id, parentId) {
+    this.db.prepare(
+      "UPDATE sync_state SET notion_parent_id = ?, updated_at = datetime('now') WHERE id = ?"
+    ).run(parentId, id);
+  }
   delete(id) {
     this.db.prepare("DELETE FROM sync_state WHERE id = ?").run(id);
   }
@@ -401,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) {
@@ -568,6 +652,15 @@ var PropertyMapper = class {
         });
         return { files: filesArr };
       }
+      case "created_time":
+      case "last_edited_time":
+      case "created_by":
+      case "last_edited_by":
+      case "formula":
+      case "rollup":
+      case "unique_id":
+      case "verification":
+        return null;
       default:
         return { rich_text: [{ text: { content: String(value) } }] };
     }
@@ -760,6 +853,32 @@ var NotionClient = class {
       })
     );
   }
+  async updatePageMarkdownPartial(pageId, patches) {
+    return this.withRateLimit(
+      () => this.client.pages.updateMarkdown({
+        page_id: pageId,
+        type: "update_content",
+        update_content: {
+          content_updates: patches.map((p) => ({
+            old_str: p.oldStr,
+            new_str: p.newStr,
+            replace_all_matches: p.replaceAll ?? false
+          })),
+          allow_deleting_content: true
+        }
+      })
+    );
+  }
+  // ─── Page Move ───
+  async movePage(pageId, newParentId, newParentType) {
+    const parent = newParentType === "database" ? { database_id: newParentId } : { page_id: newParentId };
+    return this.withRateLimit(
+      () => this.client.pages.update({
+        page_id: pageId,
+        parent
+      })
+    );
+  }
   // ─── Database / DataSource ───
   async getDatabaseSchema(databaseId) {
     const db = await this.withRateLimit(
@@ -777,7 +896,8 @@ var NotionClient = class {
       () => this.client.dataSources.query({
         data_source_id: databaseId,
         start_cursor: options?.startCursor,
-        page_size: options?.pageSize ?? 100
+        page_size: options?.pageSize ?? 100,
+        filter: options?.filter
       })
     );
     return {
@@ -785,6 +905,27 @@ 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 }));
   }
@@ -833,15 +974,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 ───
@@ -1854,7 +1998,10 @@ var FrontmatterGenerator = class {
 function normalizeProperties(props) {
   const result = {};
   for (const [key, value] of Object.entries(props)) {
-    result[key] = normalizeValue(value);
+    const normalized = normalizeValue(value);
+    if (normalized !== void 0) {
+      result[key] = normalized;
+    }
   }
   return result;
 }
@@ -1862,6 +2009,10 @@ function normalizeValue(value) {
   if (typeof value === "string") {
     return normalizeDate(value);
   }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return void 0;
+    return value;
+  }
   if (typeof value === "object" && value !== null && "start" in value) {
     const dateObj = value;
     const normalized = {
@@ -1872,12 +2023,10 @@ function normalizeValue(value) {
   }
   return value;
 }
+var MIDNIGHT_RE = /T00:00:00(?:\.\d{3})?(?:Z|[+-]\d{2}:\d{2})/;
 function normalizeDate(dateStr) {
   if (typeof dateStr !== "string") return dateStr;
-  if (dateStr.match(/T00:00:00\.000[Z+]/)) {
-    return dateStr.split("T")[0] ?? dateStr;
-  }
-  if (dateStr.match(/T00:00:00[Z+]/)) {
+  if (MIDNIGHT_RE.test(dateStr)) {
     return dateStr.split("T")[0] ?? dateStr;
   }
   return dateStr;
@@ -2810,6 +2959,265 @@ var ImageHandler = class {
     return ext ? `.${ext[1].toLowerCase()}` : null;
   }
 };
+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;
+  }
+  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;
+  }
+  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;
@@ -2855,7 +3263,13 @@ var NOTION_TOGGLE_RE = /<details>\s*<summary>([\s\S]*?)<\/summary>([\s\S]*?)<\/d
 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_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_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) {
@@ -2866,10 +3280,13 @@ function notionEnhancedToObsidian(enhanced) {
   result = convertPageLinks(result);
   result = convertUserMentions(result);
   result = convertDateMentions(result);
-  result = removeUnknownBlocks(result);
+  result = convertMediaTags(result);
+  result = convertTabBlocks(result);
+  result = preserveUnknownBlocks(result);
   result = convertNotionMath(result);
   result = convertNotionTables(result);
   result = convertColorSpans(result);
+  result = convertUnderlineSpans(result);
   result = removeEmptyBlocks(result);
   result = unescapePipes(result);
   return result;
@@ -2877,7 +3294,12 @@ function notionEnhancedToObsidian(enhanced) {
 function obsidianToNotionEnhanced(obsidian) {
   let result = obsidian;
   result = convertTogglesToHtml(result);
+  result = restoreTabBlocks(result);
   result = convertObsidianCallouts(result);
+  result = restoreMediaTags(result);
+  result = restoreUnknownBlocks(result);
+  result = restoreColorSpans(result);
+  result = restoreUnderlineSpans(result);
   return result;
 }
 function convertToggles(content) {
@@ -2922,8 +3344,46 @@ function convertDateMentions(content) {
     return end ? `${start} \u2192 ${end}` : start;
   });
 }
-function removeUnknownBlocks(content) {
-  return content.replace(NOTION_UNKNOWN_RE, "");
+function preserveUnknownBlocks(content) {
+  return content.replace(NOTION_UNKNOWN_RE, (_match, id, attrs) => {
+    const typeMatch = /type="([^"]*)"/.exec(attrs);
+    const altMatch = /alt="([^"]*)"/.exec(attrs);
+    const blockType = altMatch?.[1] ?? typeMatch?.[1] ?? "unknown";
+    return `%%im-nobsidian:unknown:id=${id}&type=${blockType}%%`;
+  });
+}
+function convertMediaTags(content) {
+  let result = content;
+  result = result.replace(NOTION_AUDIO_RE, (_match, src, caption) => {
+    const cap = caption.trim();
+    return cap ? `[\u{1F50A} ${cap}](${src})` : `[\u{1F50A} audio](${src})`;
+  });
+  result = result.replace(NOTION_VIDEO_RE, (_match, src, caption) => {
+    const cap = caption.trim();
+    return cap ? `[\u{1F3AC} ${cap}](${src})` : `[\u{1F3AC} video](${src})`;
+  });
+  result = result.replace(NOTION_PDF_RE, (_match, src, caption) => {
+    const cap = caption.trim();
+    return cap ? `[\u{1F4C4} ${cap}](${src})` : `[\u{1F4C4} pdf](${src})`;
+  });
+  result = result.replace(NOTION_FILE_RE, (_match, src, caption) => {
+    const cap = caption.trim();
+    return cap ? `[\u{1F4CE} ${cap}](${src})` : `[\u{1F4CE} file](${src})`;
+  });
+  return result;
+}
+function convertTabBlocks(content) {
+  return content.replace(NOTION_TAB_RE, (_match, title, body) => {
+    const trimmed = body.trim();
+    const indented = trimmed.split("\n").map((line) => `> ${line}`).join("\n");
+    return `> [!tab] ${title}
+${indented}`;
+  });
+}
+function convertUnderlineSpans(content) {
+  return content.replace(NOTION_UNDERLINE_RE, (_match, text) => {
+    return `%%im-nobsidian:underline%%${text}%%/underline%%`;
+  });
 }
 function convertTogglesToHtml(content) {
   const startRe = new RegExp(escapeRegex3(TOGGLE_START2), "g");
@@ -3033,7 +3493,10 @@ function convertPageLinks(content) {
   });
 }
 function convertColorSpans(content) {
-  return content.replace(NOTION_COLOR_SPAN_RE, (_match, _color, text) => text);
+  return content.replace(
+    NOTION_COLOR_SPAN_RE,
+    (_match, color, text) => `%%im-nobsidian:color:${color}%%${text}%%/color%%`
+  );
 }
 function removeEmptyBlocks(content) {
   return content.replace(NOTION_EMPTY_BLOCK_RE, "\n");
@@ -3080,6 +3543,51 @@ function convertNotionTables(content) {
     return lines.join("\n");
   });
 }
+var OBSIDIAN_MEDIA_AUDIO_RE = /\[🔊\s*([^\]]*)\]\(([^)]+)\)/g;
+var OBSIDIAN_MEDIA_VIDEO_RE = /\[🎬\s*([^\]]*)\]\(([^)]+)\)/g;
+var OBSIDIAN_MEDIA_PDF_RE = /\[📄\s*([^\]]*)\]\(([^)]+)\)/g;
+var OBSIDIAN_MEDIA_FILE_RE = /\[📎\s*([^\]]*)\]\(([^)]+)\)/g;
+function restoreMediaTags(content) {
+  let result = content;
+  result = result.replace(OBSIDIAN_MEDIA_AUDIO_RE, (_match, caption, src) => {
+    return `<audio src="${src}">${caption}</audio>`;
+  });
+  result = result.replace(OBSIDIAN_MEDIA_VIDEO_RE, (_match, caption, src) => {
+    return `<video src="${src}">${caption}</video>`;
+  });
+  result = result.replace(OBSIDIAN_MEDIA_PDF_RE, (_match, caption, src) => {
+    return `<pdf src="${src}">${caption}</pdf>`;
+  });
+  result = result.replace(OBSIDIAN_MEDIA_FILE_RE, (_match, caption, src) => {
+    return `<file src="${src}">${caption}</file>`;
+  });
+  return result;
+}
+var OBSIDIAN_TAB_RE = /^> \[!tab\]\s*(.+)\n((?:> .*\n?)*)/gm;
+function restoreTabBlocks(content) {
+  return content.replace(OBSIDIAN_TAB_RE, (_match, title, body) => {
+    const unquoted = body.split("\n").map((line) => line.replace(/^> /, "")).join("\n").trim();
+    return `<tab title="${title}">${unquoted}</tab>`;
+  });
+}
+var OBSIDIAN_UNKNOWN_RE = /%%im-nobsidian:unknown:id=([^&]+)&type=([^%]+)%%/g;
+function restoreUnknownBlocks(content) {
+  return content.replace(OBSIDIAN_UNKNOWN_RE, (_match, id, type) => {
+    return `<unknown id="${id}" type="${type}"/>`;
+  });
+}
+var OBSIDIAN_COLOR_RE = /%%im-nobsidian:color:([^%]+)%%([\s\S]*?)%%\/color%%/g;
+function restoreColorSpans(content) {
+  return content.replace(OBSIDIAN_COLOR_RE, (_match, color, text) => {
+    return `<span color="${color}">${text}</span>`;
+  });
+}
+var OBSIDIAN_UNDERLINE_RE = /%%im-nobsidian:underline%%([\s\S]*?)%%\/underline%%/g;
+function restoreUnderlineSpans(content) {
+  return content.replace(OBSIDIAN_UNDERLINE_RE, (_match, text) => {
+    return `<span underline="true">${text}</span>`;
+  });
+}
 function unescapePipes(content) {
   const lines = content.split("\n");
   const result = [];
@@ -3099,6 +3607,253 @@ function unescapePipes(content) {
   }
   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);
+    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 pullDatabasePage(page, dbConfig) {
+    const title = this.notionClient.extractTitle(page);
+    const safeName = sanitizeFileName(title);
+    const properties = this.propertyMapper.fromNotionProperties(
+      page.properties
+    );
+    properties.title = title;
+    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;
+    }
+    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 = matter(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 {
@@ -3113,7 +3868,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
@@ -3128,6 +3892,8 @@ var SyncOrchestrator = class {
   pipeline;
   blockConverter;
   imageHandler;
+  fileHandler;
+  databaseSyncer;
   propertyMapper;
   dbSchemaLoaded = false;
   async push(options) {
@@ -3189,10 +3955,13 @@ var SyncOrchestrator = class {
             created++;
             break;
           case "modified":
-          case "moved":
             await this.pushUpdate(change.path);
             updated++;
             break;
+          case "moved":
+            await this.pushMove(change.path);
+            updated++;
+            break;
           case "deleted":
             await this.pushDelete(change.path);
             deleted++;
@@ -3209,6 +3978,26 @@ var SyncOrchestrator = class {
       }
     });
     await Promise.all(tasks.map((t) => t()));
+    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", "");
@@ -3302,6 +4091,20 @@ var SyncOrchestrator = class {
       }
     });
     await Promise.all(tasks.map((t) => t()));
+    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);
+      }
+    }
     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", "");
@@ -3369,13 +4172,20 @@ var SyncOrchestrator = class {
         localContent = await this.vaultFs.readFile(record.obsidianPath);
       } catch {
       }
+      let remoteContent = "";
+      if (record.notionPageId) {
+        try {
+          remoteContent = await this.fetchPageMarkdown(record.notionPageId);
+        } catch {
+        }
+      }
       conflicts.push({
         syncRecord: record,
         localChange,
         remoteChange,
         baseContent: record.baseSnapshot?.toString("utf-8") ?? null,
         localContent,
-        remoteContent: ""
+        remoteContent
       });
     }
     return conflicts;
@@ -3439,7 +4249,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,
@@ -3465,7 +4275,7 @@ var SyncOrchestrator = class {
       filePath: path,
       parentMode: this.config.notion.parentMode
     });
-    await this.pushUpdatePage(record.notionPageId, conversionResult.content);
+    await this.pushUpdatePage(record.notionPageId, conversionResult.content, record.baseSnapshot);
     await this.imageHandler.uploadAndAppendImages(record.notionPageId, conversionResult.images);
     let propsToUpdate = conversionResult.properties;
     if (this.isDatabaseMode && propsToUpdate && Object.keys(propsToUpdate).length > 0) {
@@ -3479,7 +4289,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");
@@ -3503,6 +4313,22 @@ var SyncOrchestrator = class {
       this.stateDb.updateStatus(record.id, "pending");
     }
   }
+  async pushMove(path) {
+    const record = this.stateDb.getByPath(path);
+    if (!record?.notionPageId) return;
+    const newParentId = await this.resolveNotionParent(path);
+    const currentParentId = record.notionParentId;
+    if (currentParentId && !notionIdsEqual(newParentId, currentParentId)) {
+      try {
+        const parentType = this.isDatabaseMode ? "database" : "page";
+        await this.notionClient.movePage(record.notionPageId, newParentId, parentType);
+        this.stateDb.setNotionParentId(record.id, newParentId);
+      } catch {
+        getLogger().warn(`[Im-Nobsidian] Move API \uC2E4\uD328 \u2014 "${path}" \uB0B4\uC6A9\uB9CC \uC5C5\uB370\uC774\uD2B8\uD569\uB2C8\uB2E4`);
+      }
+    }
+    await this.pushUpdate(path);
+  }
   async detectRemoteChanges() {
     const changes = [];
     const lastPull = this.stateDb.getMeta("last_pull_at");
@@ -3627,7 +4453,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,
@@ -3838,10 +4664,23 @@ var SyncOrchestrator = class {
     }
     return page;
   }
-  async pushUpdatePage(pageId, markdownContent) {
+  async pushUpdatePage(pageId, markdownContent, baseSnapshot) {
     if (this.config.conversion.preferMarkdownApi !== false) {
       try {
         const enhanced = obsidianToNotionEnhanced(markdownContent);
+        if (baseSnapshot) {
+          const baseEnhanced = obsidianToNotionEnhanced(baseSnapshot.toString("utf-8"));
+          const patches = this.computePatches(baseEnhanced, enhanced);
+          if (patches.length > 0 && patches.length <= 20) {
+            try {
+              await this.notionClient.updatePageMarkdownPartial(pageId, patches);
+              return;
+            } catch {
+              await this.notionClient.replacePageMarkdown(pageId, enhanced);
+              return;
+            }
+          }
+        }
         await this.notionClient.replacePageMarkdown(pageId, enhanced);
         return;
       } catch {
@@ -3864,6 +4703,51 @@ var SyncOrchestrator = class {
       })
     );
   }
+  computePatches(oldContent, newContent) {
+    const oldLines = oldContent.split("\n");
+    const newLines = newContent.split("\n");
+    const patches = [];
+    let i = 0;
+    let j = 0;
+    while (i < oldLines.length && j < newLines.length) {
+      if (oldLines[i] === newLines[j]) {
+        i++;
+        j++;
+        continue;
+      }
+      let oldEnd = i + 1;
+      let newEnd = j + 1;
+      const lookahead = Math.min(10, oldLines.length - i, newLines.length - j);
+      for (let k = 1; k <= lookahead; k++) {
+        if (i + k < oldLines.length && newLines[j] === oldLines[i + k]) {
+          oldEnd = i + k;
+          newEnd = j;
+          break;
+        }
+        if (j + k < newLines.length && oldLines[i] === newLines[j + k]) {
+          oldEnd = i;
+          newEnd = j + k;
+          break;
+        }
+        oldEnd = i + k;
+        newEnd = j + k;
+      }
+      const oldChunk = oldLines.slice(i, oldEnd).join("\n");
+      const newChunk = newLines.slice(j, newEnd).join("\n");
+      if (oldChunk || newChunk) {
+        patches.push({ oldStr: oldChunk, newStr: newChunk });
+      }
+      i = oldEnd;
+      j = newEnd;
+    }
+    if (i < oldLines.length || j < newLines.length) {
+      patches.push({
+        oldStr: oldLines.slice(i).join("\n"),
+        newStr: newLines.slice(j).join("\n")
+      });
+    }
+    return patches;
+  }
   async fetchPageMarkdown(pageId) {
     if (this.config.conversion.preferMarkdownApi !== false) {
       try {
@@ -3909,7 +4793,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");
@@ -3981,6 +4865,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("/**")) {
@@ -4003,6 +4892,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) {
@@ -4483,6 +5391,6 @@ 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 };
+export { BlockConverter, CalloutRestorer, CalloutTransformer, ChangeDetector, ColorAnnotator, ConfigManager, ConfigSchema, ConflictResolver, ConversionPipeline, DEFAULT_CONFIG, DatabaseSyncer, EmbedResolver, FileHandler, FileWatcher, FrontmatterExtractor, FrontmatterGenerator, HtmlAnnotationStripper, ImageHandler, InlineDBParser, LocalImageRestorer, MathNormalizer, MentionToWikilink, NodeVaultFS, NotionBlockBuilder, NotionClient, PreserveMarkerCollector, PreserveMarkerInjector, PropertiesTableInjector, PropertiesTableRestorer, PropertyMapper, StateDB, SyncOrchestrator, TreeMapper, UnsupportedBlockStripper, WatchSyncService, WikilinkResolver, computeBufferHash, computeHash, createDefaultPipeline, generateId, getLogger, normalizeNotionId, notionIdsEqual, sanitizeFileName, setLogger, threeWayMerge };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map