@im-nobsidian/core 0.1.0

package/dist/index.js

@@ -0,0 +1,3683 @@
+import { z } from 'zod';
+import { readFile, mkdir, writeFile, unlink, rename, stat, readdir } from 'fs/promises';
+import { join, dirname, relative } from 'path';
+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 { markdownToBlocks } from '@tryfabric/martian';
+import { NotionToMarkdown } from 'notion-to-md';
+import { readFileSync } from 'fs';
+import { watch } from 'chokidar';
+
+// src/types/config.ts
+var ConfigSchema = z.object({
+  version: z.literal(1),
+  notion: z.object({
+    token: z.string().startsWith("ntn_"),
+    rootPageId: z.string(),
+    workspaceId: z.string().optional(),
+    parentMode: z.enum(["page", "database"]).default("page"),
+    databaseId: z.string().optional()
+  }),
+  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)
+  }),
+  paths: z.object({
+    include: z.array(z.string()).default(["**/*"]),
+    exclude: z.array(z.string()).default([]),
+    attachments: z.string().default("attachments")
+  }),
+  conversion: z.object({
+    preferMarkdownApi: z.boolean().default(true),
+    preserveMarkers: z.boolean().default(true),
+    frontmatterMapping: z.boolean().default(true),
+    imageDownload: z.enum(["immediate", "lazy", "skip"]).default("immediate")
+  }),
+  advanced: z.object({
+    concurrency: z.number().min(1).max(10).default(3),
+    maxRetries: z.number().min(0).max(10).default(5),
+    timeoutMs: z.number().min(5e3).max(6e4).default(3e4),
+    batchSize: z.number().min(1).max(100).default(50)
+  })
+});
+var DEFAULT_CONFIG = {
+  version: 1,
+  notion: {
+    token: "",
+    rootPageId: "",
+    parentMode: "page"
+  },
+  sync: {
+    direction: "both",
+    conflictStrategy: "manual",
+    autoSync: false,
+    autoSyncInterval: 300,
+    deleteSync: false
+  },
+  paths: {
+    include: ["**/*"],
+    exclude: [],
+    attachments: "attachments"
+  },
+  conversion: {
+    preferMarkdownApi: true,
+    preserveMarkers: true,
+    frontmatterMapping: true,
+    imageDownload: "immediate"
+  },
+  advanced: {
+    concurrency: 3,
+    maxRetries: 5,
+    timeoutMs: 3e4,
+    batchSize: 50
+  }
+};
+var CONFIG_FILE = "config.json";
+var IM_NOBSIDIAN_DIR = ".im-nobsidian";
+var ConfigManager = class {
+  constructor(vaultRoot) {
+    this.vaultRoot = vaultRoot;
+  }
+  vaultRoot;
+  config = null;
+  get configDir() {
+    return join(this.vaultRoot, IM_NOBSIDIAN_DIR);
+  }
+  get configPath() {
+    return join(this.configDir, CONFIG_FILE);
+  }
+  get dbPath() {
+    return join(this.configDir, "sync.db");
+  }
+  async load() {
+    try {
+      const raw = await readFile(this.configPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      this.config = ConfigSchema.parse(parsed);
+      return this.config;
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new Error(`\uC124\uC815 \uD30C\uC77C\uC758 JSON \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4: ${this.configPath}`);
+      }
+      if (error instanceof Error && error.name === "ZodError") {
+        throw new Error(`\uC124\uC815 \uD30C\uC77C \uAC80\uC99D \uC2E4\uD328: ${error.message}`);
+      }
+      throw new Error(
+        `\uC124\uC815 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${this.configPath}
+'im-nobsidian init'\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.`
+      );
+    }
+  }
+  async save(config) {
+    await mkdir(this.configDir, { recursive: true });
+    const content = JSON.stringify(config, null, 2);
+    await writeFile(this.configPath, content, "utf-8");
+    this.config = config;
+  }
+  async init(params) {
+    const config = {
+      ...DEFAULT_CONFIG,
+      notion: {
+        ...DEFAULT_CONFIG.notion,
+        token: params.token,
+        rootPageId: params.rootPageId
+      }
+    };
+    await this.save(config);
+    await this.ensureGitignore();
+    return config;
+  }
+  getConfig() {
+    if (!this.config) {
+      throw new Error("\uC124\uC815\uC774 \uB85C\uB4DC\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. load()\uB97C \uBA3C\uC800 \uD638\uCD9C\uD558\uC138\uC694.");
+    }
+    return this.config;
+  }
+  async ensureGitignore() {
+    const gitignorePath = join(this.vaultRoot, ".gitignore");
+    const entry = ".im-nobsidian/";
+    try {
+      const content = await readFile(gitignorePath, "utf-8");
+      if (!content.includes(entry)) {
+        await writeFile(gitignorePath, `${content.trimEnd()}
+${entry}
+`, "utf-8");
+      }
+    } catch {
+      await writeFile(gitignorePath, `${entry}
+`, "utf-8");
+    }
+  }
+  async isInitialized() {
+    try {
+      const { stat: stat2 } = await import('fs/promises');
+      await stat2(this.configPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function generateId() {
+  return randomUUID();
+}
+function normalizeNotionId(id) {
+  const raw = id.replace(/-/g, "");
+  if (raw.length !== 32) return id;
+  return `${raw.slice(0, 8)}-${raw.slice(8, 12)}-${raw.slice(12, 16)}-${raw.slice(16, 20)}-${raw.slice(20)}`;
+}
+function notionIdsEqual(a, b) {
+  return a.replace(/-/g, "") === b.replace(/-/g, "");
+}
+
+// src/state/migrations/001-initial.ts
+var INITIAL_MIGRATION = `
+CREATE TABLE IF NOT EXISTS sync_state (
+    id              TEXT PRIMARY KEY,
+    obsidian_path   TEXT NOT NULL,
+    notion_page_id  TEXT,
+    notion_parent_id TEXT,
+    content_hash    TEXT NOT NULL,
+    notion_last_edited TEXT,
+    local_last_modified TEXT NOT NULL,
+    sync_direction  TEXT NOT NULL DEFAULT 'both',
+    file_type       TEXT NOT NULL DEFAULT 'file',
+    status          TEXT NOT NULL DEFAULT 'pending',
+    base_snapshot   BLOB,
+    version         INTEGER NOT NULL DEFAULT 1,
+    created_at      TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at      TEXT NOT NULL DEFAULT (datetime('now')),
+
+    CONSTRAINT chk_sync_direction CHECK (sync_direction IN ('push', 'pull', 'both')),
+    CONSTRAINT chk_file_type CHECK (file_type IN ('file', 'folder-note', 'folder-only', 'db-row')),
+    CONSTRAINT chk_status CHECK (status IN ('synced', 'pending', 'conflict', 'error'))
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_sync_state_path ON sync_state(obsidian_path);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_sync_state_notion ON sync_state(notion_page_id) WHERE notion_page_id IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_sync_state_status ON sync_state(status);
+CREATE INDEX IF NOT EXISTS idx_sync_state_parent ON sync_state(notion_parent_id);
+
+CREATE TABLE IF NOT EXISTS wikilink_map (
+    obsidian_path   TEXT PRIMARY KEY,
+    notion_page_id  TEXT NOT NULL UNIQUE,
+    title           TEXT NOT NULL,
+    aliases         TEXT DEFAULT '[]',
+    updated_at      TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_wikilink_title ON wikilink_map(title);
+CREATE INDEX IF NOT EXISTS idx_wikilink_notion ON wikilink_map(notion_page_id);
+
+CREATE TABLE IF NOT EXISTS pending_operations (
+    id              TEXT PRIMARY KEY,
+    sync_state_id   TEXT NOT NULL REFERENCES sync_state(id) ON DELETE CASCADE,
+    operation       TEXT NOT NULL,
+    direction       TEXT NOT NULL,
+    payload         TEXT,
+    retry_count     INTEGER NOT NULL DEFAULT 0,
+    error_message   TEXT,
+    status          TEXT NOT NULL DEFAULT 'pending',
+    created_at      TEXT NOT NULL DEFAULT (datetime('now')),
+    completed_at    TEXT,
+
+    CONSTRAINT chk_operation CHECK (operation IN ('create', 'update', 'delete', 'move')),
+    CONSTRAINT chk_direction CHECK (direction IN ('push', 'pull')),
+    CONSTRAINT chk_op_status CHECK (status IN ('pending', 'processing', 'completed', 'failed'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_pending_status ON pending_operations(status, created_at);
+
+CREATE TABLE IF NOT EXISTS image_registry (
+    id              TEXT PRIMARY KEY,
+    sync_state_id   TEXT NOT NULL REFERENCES sync_state(id) ON DELETE CASCADE,
+    notion_file_url TEXT NOT NULL,
+    local_path      TEXT NOT NULL,
+    content_hash    TEXT NOT NULL,
+    file_size       INTEGER NOT NULL,
+    mime_type       TEXT NOT NULL,
+    expires_at      TEXT,
+    downloaded_at   TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_image_hash ON image_registry(content_hash);
+CREATE INDEX IF NOT EXISTS idx_image_sync ON image_registry(sync_state_id);
+
+CREATE TABLE IF NOT EXISTS sync_metadata (
+    key     TEXT PRIMARY KEY,
+    value   TEXT NOT NULL
+);
+
+INSERT OR IGNORE INTO sync_metadata (key, value) VALUES ('schema_version', '1');
+`;
+
+// src/state/state-db.ts
+var StateDB = class _StateDB {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+  }
+  static open(dbPath) {
+    const db = new Database(dbPath);
+    const stateDb = new _StateDB(db);
+    stateDb.migrate();
+    return stateDb;
+  }
+  migrate() {
+    const version = this.getSchemaVersion();
+    if (version < 1) {
+      this.db.exec(INITIAL_MIGRATION);
+    }
+  }
+  getSchemaVersion() {
+    try {
+      const row = this.db.prepare("SELECT value FROM sync_metadata WHERE key = 'schema_version'").get();
+      return row ? Number(row.value) : 0;
+    } catch {
+      return 0;
+    }
+  }
+  close() {
+    this.db.close();
+  }
+  // --- sync_state ---
+  getByPath(path) {
+    const row = this.db.prepare("SELECT * FROM sync_state WHERE obsidian_path = ?").get(path);
+    return row ? this.mapRow(row) : null;
+  }
+  getByNotionId(pageId) {
+    const row = this.db.prepare("SELECT * FROM sync_state WHERE notion_page_id = ?").get(pageId);
+    return row ? this.mapRow(row) : null;
+  }
+  getByStatus(status) {
+    const rows = this.db.prepare("SELECT * FROM sync_state WHERE status = ?").all(status);
+    return rows.map((r) => this.mapRow(r));
+  }
+  getAll() {
+    const rows = this.db.prepare("SELECT * FROM sync_state").all();
+    return rows.map((r) => this.mapRow(r));
+  }
+  upsert(record) {
+    const existing = this.getByPath(record.obsidianPath);
+    if (existing) {
+      this.db.prepare(
+        `UPDATE sync_state SET
+            notion_page_id = ?, notion_parent_id = ?, content_hash = ?,
+            notion_last_edited = ?, local_last_modified = ?,
+            sync_direction = ?, file_type = ?, status = ?,
+            base_snapshot = ?, version = version + 1,
+            updated_at = datetime('now')
+          WHERE id = ?`
+      ).run(
+        record.notionPageId ?? null,
+        record.notionParentId ?? null,
+        record.contentHash,
+        record.notionLastEdited ?? null,
+        record.localLastModified,
+        record.syncDirection,
+        record.fileType,
+        record.status,
+        record.baseSnapshot ?? null,
+        existing.id
+      );
+      return this.getByPath(record.obsidianPath);
+    }
+    const id = generateId();
+    this.db.prepare(
+      `INSERT INTO sync_state
+          (id, obsidian_path, notion_page_id, notion_parent_id, content_hash,
+           notion_last_edited, local_last_modified, sync_direction, file_type,
+           status, base_snapshot, version)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)`
+    ).run(
+      id,
+      record.obsidianPath,
+      record.notionPageId ?? null,
+      record.notionParentId ?? null,
+      record.contentHash,
+      record.notionLastEdited ?? null,
+      record.localLastModified,
+      record.syncDirection,
+      record.fileType,
+      record.status,
+      record.baseSnapshot ?? null
+    );
+    return this.getByPath(record.obsidianPath);
+  }
+  updateStatus(id, status) {
+    this.db.prepare("UPDATE sync_state SET status = ?, updated_at = datetime('now') WHERE id = ?").run(status, id);
+  }
+  updateHash(id, hash, snapshot) {
+    if (snapshot !== void 0) {
+      this.db.prepare(
+        "UPDATE sync_state SET content_hash = ?, base_snapshot = ?, updated_at = datetime('now') WHERE id = ?"
+      ).run(hash, snapshot, id);
+    } else {
+      this.db.prepare(
+        "UPDATE sync_state SET content_hash = ?, updated_at = datetime('now') WHERE id = ?"
+      ).run(hash, id);
+    }
+  }
+  delete(id) {
+    this.db.prepare("DELETE FROM sync_state WHERE id = ?").run(id);
+  }
+  // --- wikilink_map ---
+  resolveWikilink(text) {
+    const byTitle = this.db.prepare("SELECT * FROM wikilink_map WHERE title = ?").get(text);
+    if (byTitle) return this.mapWikilinkRow(byTitle);
+    const byAlias = this.db.prepare("SELECT * FROM wikilink_map WHERE aliases LIKE ?").get(`%"${text}"%`);
+    if (byAlias) return this.mapWikilinkRow(byAlias);
+    const byFilename = this.db.prepare("SELECT * FROM wikilink_map WHERE obsidian_path LIKE ?").get(`%/${text}.md`);
+    return byFilename ? this.mapWikilinkRow(byFilename) : null;
+  }
+  resolvePageId(pageId) {
+    const row = this.db.prepare("SELECT * FROM wikilink_map WHERE notion_page_id = ?").get(pageId);
+    return row ? this.mapWikilinkRow(row) : null;
+  }
+  upsertWikilink(entry) {
+    this.db.prepare(
+      `INSERT OR REPLACE INTO wikilink_map (obsidian_path, notion_page_id, title, aliases, updated_at)
+        VALUES (?, ?, ?, ?, datetime('now'))`
+    ).run(entry.obsidianPath, entry.notionPageId, entry.title, JSON.stringify(entry.aliases));
+  }
+  // --- sync_metadata ---
+  getMeta(key) {
+    const row = this.db.prepare("SELECT value FROM sync_metadata WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  setMeta(key, value) {
+    this.db.prepare("INSERT OR REPLACE INTO sync_metadata (key, value) VALUES (?, ?)").run(key, value);
+  }
+  // --- preserve markers ---
+  storePreserveMarkers(path, markers) {
+    if (markers.length === 0) {
+      this.db.prepare("DELETE FROM sync_metadata WHERE key = ?").run(`preserve_markers:${path}`);
+      return;
+    }
+    this.setMeta(`preserve_markers:${path}`, JSON.stringify(markers));
+  }
+  getPreserveMarkers(path) {
+    const value = this.getMeta(`preserve_markers:${path}`);
+    if (!value) return [];
+    try {
+      return JSON.parse(value);
+    } catch {
+      return [];
+    }
+  }
+  // --- transaction ---
+  transaction(fn) {
+    return this.db.transaction(fn)();
+  }
+  // --- private ---
+  mapRow(row) {
+    return {
+      id: row.id,
+      obsidianPath: row.obsidian_path,
+      notionPageId: row.notion_page_id,
+      notionParentId: row.notion_parent_id,
+      contentHash: row.content_hash,
+      notionLastEdited: row.notion_last_edited,
+      localLastModified: row.local_last_modified,
+      syncDirection: row.sync_direction,
+      fileType: row.file_type,
+      status: row.status,
+      baseSnapshot: row.base_snapshot,
+      version: row.version,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  mapWikilinkRow(row) {
+    return {
+      obsidianPath: row.obsidian_path,
+      notionPageId: row.notion_page_id,
+      title: row.title,
+      aliases: JSON.parse(row.aliases || "[]")
+    };
+  }
+};
+
+// src/notion/property-mapper.ts
+var DATE_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2})?/;
+var PropertyMapper = class {
+  schema = /* @__PURE__ */ new Map();
+  loadSchema(properties) {
+    this.schema.clear();
+    for (const [name, prop] of Object.entries(properties)) {
+      this.schema.set(name, { id: prop.id, type: prop.type, name });
+    }
+  }
+  toNotionProperties(frontmatter, title) {
+    const result = {
+      title: { title: [{ text: { content: title } }] }
+    };
+    for (const [key, value] of Object.entries(frontmatter)) {
+      if (key === "title") continue;
+      if (value === null || value === void 0) continue;
+      const schemaProp = this.schema.get(key);
+      if (schemaProp) {
+        const converted = this.convertBySchema(schemaProp.type, value);
+        if (converted) result[key] = converted;
+      } else {
+        const inferred = this.inferAndConvert(value);
+        if (inferred) result[key] = inferred;
+      }
+    }
+    return result;
+  }
+  fromNotionProperties(notionProps) {
+    const result = {};
+    for (const [key, rawProp] of Object.entries(notionProps)) {
+      const prop = rawProp;
+      if (prop.type === "title") continue;
+      const value = this.extractValue(prop);
+      if (value !== void 0) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  convertBySchema(type, value) {
+    switch (type) {
+      case "rich_text":
+        return { rich_text: [{ text: { content: String(value) } }] };
+      case "number":
+        return { number: typeof value === "number" ? value : Number(value) };
+      case "select":
+        return { select: { name: String(value) } };
+      case "multi_select": {
+        const items = Array.isArray(value) ? value : String(value).split(",").map((s) => s.trim());
+        return { multi_select: items.map((name) => ({ name: String(name) })) };
+      }
+      case "checkbox":
+        return { checkbox: Boolean(value) };
+      case "date": {
+        const dateStr = String(value);
+        if (DATE_REGEX.test(dateStr)) {
+          return { date: { start: dateStr } };
+        }
+        return null;
+      }
+      case "url":
+        return { url: String(value) };
+      case "email":
+        return { email: String(value) };
+      case "phone_number":
+        return { phone_number: String(value) };
+      case "status":
+        return { status: { name: String(value) } };
+      default:
+        return { rich_text: [{ text: { content: String(value) } }] };
+    }
+  }
+  inferAndConvert(value) {
+    if (typeof value === "boolean") {
+      return { checkbox: value };
+    }
+    if (typeof value === "number") {
+      return { number: value };
+    }
+    if (Array.isArray(value)) {
+      return {
+        multi_select: value.map((v) => ({ name: String(v) }))
+      };
+    }
+    if (typeof value === "string") {
+      if (DATE_REGEX.test(value)) {
+        return { date: { start: value } };
+      }
+      if (value.startsWith("http://") || value.startsWith("https://")) {
+        return { url: value };
+      }
+      return { rich_text: [{ text: { content: value } }] };
+    }
+    return null;
+  }
+  extractValue(prop) {
+    switch (prop.type) {
+      case "rich_text": {
+        const arr = prop.rich_text;
+        return arr?.map((t) => t.plain_text).join("") || null;
+      }
+      case "number":
+        return prop.number;
+      case "select": {
+        const sel = prop.select;
+        return sel?.name ?? null;
+      }
+      case "multi_select": {
+        const items = prop.multi_select;
+        return items?.map((s) => s.name) ?? [];
+      }
+      case "checkbox":
+        return prop.checkbox;
+      case "date":
+        return prop.date ?? null;
+      case "url":
+        return prop.url;
+      case "email":
+        return prop.email;
+      case "phone_number":
+        return prop.phone_number;
+      case "status": {
+        const status = prop.status;
+        return status?.name ?? null;
+      }
+      case "created_time":
+        return prop.created_time;
+      case "last_edited_time":
+        return prop.last_edited_time;
+      case "people": {
+        const people = prop.people;
+        return people?.map((p) => p.name ?? p.id) ?? [];
+      }
+      case "files": {
+        const files = prop.files;
+        return files?.map((f) => ({
+          name: f.name,
+          url: f.type === "file" ? f.file?.url : f.external?.url
+        })) ?? [];
+      }
+      case "formula": {
+        const formula = prop.formula;
+        if (!formula) return null;
+        return formula[formula.type];
+      }
+      case "relation": {
+        const rel = prop.relation;
+        return rel?.map((r) => r.id) ?? [];
+      }
+      case "rollup": {
+        const rollup = prop.rollup;
+        if (!rollup) return null;
+        if (rollup.type === "array") {
+          const arr = rollup.array;
+          return arr.map((item) => this.extractValue(item));
+        }
+        return rollup[rollup.type] ?? null;
+      }
+      case "unique_id": {
+        const uid = prop.unique_id;
+        if (!uid) return null;
+        return uid.prefix ? `${uid.prefix}-${uid.number}` : String(uid.number);
+      }
+      case "created_by":
+      case "last_edited_by": {
+        const user = prop[prop.type];
+        return user?.name ?? user?.id ?? null;
+      }
+      case "verification": {
+        const v = prop.verification;
+        return v?.state ?? null;
+      }
+      default:
+        return null;
+    }
+  }
+};
+
+// src/notion/client.ts
+var NotionClient = class {
+  client;
+  sema;
+  propertyMapper = new PropertyMapper();
+  constructor(options) {
+    this.client = new Client({
+      auth: options.token,
+      timeoutMs: options.timeoutMs ?? 3e4
+    });
+    this.sema = new Sema(options.concurrency ?? 3);
+  }
+  getInternalClient() {
+    return this.client;
+  }
+  async getPage(pageId) {
+    return this.withRateLimit(
+      () => this.client.pages.retrieve({ page_id: pageId })
+    );
+  }
+  async createPage(params) {
+    const parent = params.parentType === "database" ? { database_id: params.parentId } : { page_id: params.parentId };
+    const properties = params.parentType === "page" ? { title: { title: [{ text: { content: params.title } }] } } : params.properties ?? {
+      title: { title: [{ text: { content: params.title } }] }
+    };
+    return this.withRateLimit(
+      () => this.client.pages.create({
+        parent,
+        properties,
+        children: params.children
+      })
+    );
+  }
+  async updatePageProperties(pageId, properties) {
+    return this.withRateLimit(
+      () => this.client.pages.update({
+        page_id: pageId,
+        properties
+      })
+    );
+  }
+  async getDatabaseSchema(databaseId) {
+    const db = await this.withRateLimit(
+      () => this.client.databases.retrieve({ database_id: databaseId })
+    );
+    const properties = db.properties;
+    const schema = {};
+    for (const [name, prop] of Object.entries(properties)) {
+      schema[name] = { id: prop.id, type: prop.type };
+    }
+    return schema;
+  }
+  async queryDatabase(databaseId, options) {
+    const response = await this.withRateLimit(
+      () => this.client.databases.query({
+        database_id: databaseId,
+        start_cursor: options?.startCursor,
+        page_size: options?.pageSize ?? 100
+      })
+    );
+    return {
+      results: response.results,
+      nextCursor: response.next_cursor
+    };
+  }
+  async archivePage(pageId) {
+    await this.withRateLimit(() => this.client.pages.update({ page_id: pageId, archived: true }));
+  }
+  async listChildren(blockId, options) {
+    const response = await this.withRateLimit(
+      () => this.client.blocks.children.list({
+        block_id: blockId,
+        start_cursor: options?.startCursor,
+        page_size: options?.pageSize ?? 100
+      })
+    );
+    return {
+      results: response.results,
+      nextCursor: response.next_cursor
+    };
+  }
+  async fetchAllChildren(blockId) {
+    const blocks = [];
+    let cursor;
+    do {
+      const response = await this.listChildren(blockId, { startCursor: cursor });
+      blocks.push(...response.results.filter((b) => "type" in b));
+      cursor = response.nextCursor ?? void 0;
+    } while (cursor);
+    return blocks;
+  }
+  async appendChildren(blockId, children) {
+    const BATCH_SIZE = 100;
+    for (let i = 0; i < children.length; i += BATCH_SIZE) {
+      const batch = children.slice(i, i + BATCH_SIZE);
+      await this.withRateLimit(
+        () => this.client.blocks.children.append({
+          block_id: blockId,
+          children: batch
+        })
+      );
+    }
+  }
+  async deleteBlock(blockId) {
+    await this.withRateLimit(() => this.client.blocks.delete({ block_id: blockId }));
+  }
+  async search(params) {
+    const response = await this.withRateLimit(
+      () => this.client.search({
+        query: params.query,
+        filter: params.filter,
+        start_cursor: params.startCursor,
+        page_size: params.pageSize ?? 100
+      })
+    );
+    return {
+      results: response.results,
+      nextCursor: response.next_cursor
+    };
+  }
+  async getChildPages(parentId) {
+    const blocks = await this.fetchAllChildren(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 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 child of children) {
+          all.push(child);
+          nextLevel.push(child.id);
+        }
+      }
+      currentLevel = nextLevel;
+    }
+    return all;
+  }
+  extractTitle(page) {
+    for (const prop of Object.values(page.properties)) {
+      if (prop.type === "title" && "title" in prop) {
+        const titleArr = prop.title;
+        if (titleArr[0]?.plain_text) return titleArr[0].plain_text;
+      }
+    }
+    return "\uC81C\uBAA9 \uC5C6\uC74C";
+  }
+  extractProperties(page) {
+    return this.propertyMapper.fromNotionProperties(page.properties);
+  }
+  async withRateLimit(fn) {
+    await this.sema.acquire();
+    try {
+      return await this.executeWithRetry(fn);
+    } finally {
+      this.sema.release();
+    }
+  }
+  async executeWithRetry(fn, attempt = 0) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (isRateLimited(error) && attempt < 5) {
+        const baseDelay = extractRetryAfter(error) ?? 1e3 * Math.pow(2, attempt);
+        const jitter = baseDelay * (0.5 + Math.random() * 0.5);
+        await sleep(jitter);
+        return this.executeWithRetry(fn, attempt + 1);
+      }
+      throw error;
+    }
+  }
+};
+function isRateLimited(error) {
+  return typeof error === "object" && error !== null && "status" in error && error.status === 429;
+}
+function extractRetryAfter(error) {
+  if (typeof error === "object" && error !== null && "headers" in error) {
+    const headers = error.headers;
+    const retryAfter = headers["retry-after"];
+    if (retryAfter) return Number(retryAfter) * 1e3;
+  }
+  return null;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/notion/block-builder.ts
+var VALID_COLORS = /* @__PURE__ */ new Set([
+  "default",
+  "gray",
+  "brown",
+  "orange",
+  "yellow",
+  "green",
+  "blue",
+  "purple",
+  "pink",
+  "red",
+  "gray_background",
+  "brown_background",
+  "orange_background",
+  "yellow_background",
+  "green_background",
+  "blue_background",
+  "purple_background",
+  "pink_background",
+  "red_background"
+]);
+function safeColor(color) {
+  return VALID_COLORS.has(color) ? color : "default";
+}
+var NotionBlockBuilder = class _NotionBlockBuilder {
+  // ─── Rich Text ──────────────────────────────────────────
+  static richText(content, options) {
+    const textObj = { content };
+    if (options?.link) {
+      textObj.link = { url: options.link };
+    }
+    return [
+      {
+        type: "text",
+        text: textObj,
+        annotations: {
+          bold: options?.bold ?? false,
+          italic: options?.italic ?? false,
+          underline: options?.underline ?? false,
+          strikethrough: options?.strikethrough ?? false,
+          code: options?.code ?? false,
+          color: safeColor(options?.color ?? "default")
+        }
+      }
+    ];
+  }
+  static richTextArray(segments) {
+    return segments.map((seg) => {
+      const textObj = {
+        content: seg.content
+      };
+      if (seg.link) {
+        textObj.link = { url: seg.link };
+      }
+      return {
+        type: "text",
+        text: textObj,
+        annotations: {
+          bold: seg.bold ?? false,
+          italic: seg.italic ?? false,
+          underline: seg.underline ?? false,
+          strikethrough: seg.strikethrough ?? false,
+          code: seg.code ?? false,
+          color: safeColor(seg.color ?? "default")
+        }
+      };
+    });
+  }
+  static richTextEquation(expression) {
+    return [{ type: "equation", equation: { expression } }];
+  }
+  static richTextMentionPage(pageId) {
+    return [{ type: "mention", mention: { type: "page", page: { id: pageId } } }];
+  }
+  static richTextMentionDate(start, end) {
+    const date = { start };
+    if (end) date.end = end;
+    return [{ type: "mention", mention: { type: "date", date } }];
+  }
+  // ─── Basic Blocks ───────────────────────────────────────
+  static paragraph(richText, color) {
+    return {
+      object: "block",
+      type: "paragraph",
+      paragraph: { rich_text: richText, color: safeColor(color ?? "default") }
+    };
+  }
+  static heading(level, richText, options) {
+    const key = `heading_${level}`;
+    const data = {
+      rich_text: richText,
+      color: safeColor(options?.color ?? "default"),
+      is_toggleable: options?.isToggleable ?? false
+    };
+    if (options?.isToggleable && options?.children) {
+      data.children = options.children;
+    }
+    return { object: "block", type: key, [key]: data };
+  }
+  static callout(richText, icon, options) {
+    const data = {
+      rich_text: richText,
+      icon: { type: "emoji", emoji: icon ?? "\u{1F4CC}" },
+      color: safeColor(options?.color ?? "default")
+    };
+    if (options?.children) {
+      data.children = options.children;
+    }
+    return { object: "block", type: "callout", callout: data };
+  }
+  static toggle(richText, children, color) {
+    const data = {
+      rich_text: richText,
+      color: safeColor(color ?? "default")
+    };
+    if (children) {
+      data.children = children;
+    }
+    return { object: "block", type: "toggle", toggle: data };
+  }
+  static bulletedListItem(richText, children, color) {
+    const data = {
+      rich_text: richText,
+      color: safeColor(color ?? "default")
+    };
+    if (children) {
+      data.children = children;
+    }
+    return {
+      object: "block",
+      type: "bulleted_list_item",
+      bulleted_list_item: data
+    };
+  }
+  static numberedListItem(richText, children, color) {
+    const data = {
+      rich_text: richText,
+      color: safeColor(color ?? "default")
+    };
+    if (children) {
+      data.children = children;
+    }
+    return {
+      object: "block",
+      type: "numbered_list_item",
+      numbered_list_item: data
+    };
+  }
+  static toDo(richText, checked, color) {
+    return {
+      object: "block",
+      type: "to_do",
+      to_do: {
+        rich_text: richText,
+        checked: checked ?? false,
+        color: safeColor(color ?? "default")
+      }
+    };
+  }
+  static quote(richText, children, color) {
+    const data = {
+      rich_text: richText,
+      color: safeColor(color ?? "default")
+    };
+    if (children) {
+      data.children = children;
+    }
+    return { object: "block", type: "quote", quote: data };
+  }
+  static divider() {
+    return { object: "block", type: "divider", divider: {} };
+  }
+  static code(code, language, caption) {
+    const data = {
+      rich_text: _NotionBlockBuilder.richText(code),
+      language: language ?? "plain text"
+    };
+    if (caption) {
+      data.caption = _NotionBlockBuilder.richText(caption);
+    }
+    return { object: "block", type: "code", code: data };
+  }
+  static equationBlock(expression) {
+    return {
+      object: "block",
+      type: "equation",
+      equation: { expression }
+    };
+  }
+  // ─── Media Blocks ───────────────────────────────────────
+  static image(url, caption) {
+    const data = {
+      type: "external",
+      external: { url }
+    };
+    if (caption) {
+      data.caption = _NotionBlockBuilder.richText(caption);
+    }
+    return { object: "block", type: "image", image: data };
+  }
+  static bookmark(url, caption) {
+    const data = { url };
+    if (caption) {
+      data.caption = _NotionBlockBuilder.richText(caption);
+    }
+    return { object: "block", type: "bookmark", bookmark: data };
+  }
+  static video(url, caption) {
+    const data = {
+      type: "external",
+      external: { url }
+    };
+    if (caption) {
+      data.caption = _NotionBlockBuilder.richText(caption);
+    }
+    return { object: "block", type: "video", video: data };
+  }
+  static audio(url, caption) {
+    const data = {
+      type: "external",
+      external: { url }
+    };
+    if (caption) {
+      data.caption = _NotionBlockBuilder.richText(caption);
+    }
+    return { object: "block", type: "audio", audio: data };
+  }
+  static fileBlock(url, name, caption) {
+    const data = {
+      type: "external",
+      external: { url }
+    };
+    if (name) data.name = name;
+    if (caption) {
+      data.caption = _NotionBlockBuilder.richText(caption);
+    }
+    return { object: "block", type: "file", file: data };
+  }
+  static pdf(url, caption) {
+    const data = {
+      type: "external",
+      external: { url }
+    };
+    if (caption) {
+      data.caption = _NotionBlockBuilder.richText(caption);
+    }
+    return { object: "block", type: "pdf", pdf: data };
+  }
+  static embed(url, caption) {
+    const data = { url };
+    if (caption) {
+      data.caption = _NotionBlockBuilder.richText(caption);
+    }
+    return { object: "block", type: "embed", embed: data };
+  }
+  // ─── Advanced Blocks ────────────────────────────────────
+  static tableOfContents(color) {
+    return {
+      object: "block",
+      type: "table_of_contents",
+      table_of_contents: { color: safeColor(color ?? "default") }
+    };
+  }
+  static breadcrumb() {
+    return { object: "block", type: "breadcrumb", breadcrumb: {} };
+  }
+  static columnList(columns) {
+    const children = columns.map((colBlocks) => ({
+      object: "block",
+      type: "column",
+      column: { children: colBlocks }
+    }));
+    return {
+      object: "block",
+      type: "column_list",
+      column_list: { children }
+    };
+  }
+  static syncedBlockOriginal(children) {
+    return {
+      object: "block",
+      type: "synced_block",
+      synced_block: { synced_from: null, children }
+    };
+  }
+  static syncedBlockDuplicate(originalBlockId) {
+    return {
+      object: "block",
+      type: "synced_block",
+      synced_block: { synced_from: { block_id: originalBlockId } }
+    };
+  }
+  static linkToPage(pageId) {
+    return {
+      object: "block",
+      type: "link_to_page",
+      link_to_page: { type: "page_id", page_id: pageId }
+    };
+  }
+  static table(rows, hasColumnHeader, hasRowHeader) {
+    if (rows.length === 0) rows = [["", ""]];
+    const width = rows[0].length;
+    const tableRows = rows.map((row) => {
+      const cells = row.map((cell) => _NotionBlockBuilder.richText(cell));
+      while (cells.length < width) {
+        cells.push(_NotionBlockBuilder.richText(""));
+      }
+      return {
+        object: "block",
+        type: "table_row",
+        table_row: { cells }
+      };
+    });
+    return {
+      object: "block",
+      type: "table",
+      table: {
+        table_width: width,
+        has_column_header: hasColumnHeader ?? true,
+        has_row_header: hasRowHeader ?? false,
+        children: tableRows
+      }
+    };
+  }
+};
+function computeHash(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function computeBufferHash(buffer) {
+  return createHash("sha256").update(buffer).digest("hex");
+}
+
+// src/sync/change-detector.ts
+var ChangeDetector = class {
+  constructor(stateDb) {
+    this.stateDb = stateDb;
+  }
+  stateDb;
+  detectLocalChanges(currentFiles) {
+    const changes = [];
+    const existingPaths = /* @__PURE__ */ new Set();
+    for (const file of currentFiles) {
+      existingPaths.add(file.path);
+      const record = this.stateDb.getByPath(file.path);
+      if (!record) {
+        changes.push({
+          path: file.path,
+          type: "created",
+          currentHash: computeHash(file.content),
+          previousHash: null
+        });
+        continue;
+      }
+      if (record.localLastModified && file.mtime === record.localLastModified) {
+        continue;
+      }
+      const currentHash = computeHash(file.content);
+      if (record.contentHash !== currentHash) {
+        changes.push({
+          path: file.path,
+          type: "modified",
+          currentHash,
+          previousHash: record.contentHash
+        });
+      }
+    }
+    const syncedRecords = this.stateDb.getByStatus("synced");
+    for (const record of syncedRecords) {
+      if (!existingPaths.has(record.obsidianPath)) {
+        changes.push({
+          path: record.obsidianPath,
+          type: "deleted",
+          currentHash: "",
+          previousHash: record.contentHash
+        });
+      }
+    }
+    return this.detectMoves(changes);
+  }
+  detectMoves(changes) {
+    const result = [];
+    const created = changes.filter((c) => c.type === "created");
+    const deleted = changes.filter((c) => c.type === "deleted");
+    const others = changes.filter((c) => c.type !== "created" && c.type !== "deleted");
+    const matchedCreated = /* @__PURE__ */ new Set();
+    const matchedDeleted = /* @__PURE__ */ new Set();
+    for (const del of deleted) {
+      const match = created.find(
+        (c) => c.currentHash === del.previousHash && !matchedCreated.has(c.path)
+      );
+      if (match) {
+        matchedCreated.add(match.path);
+        matchedDeleted.add(del.path);
+        result.push({
+          path: match.path,
+          type: "moved",
+          currentHash: match.currentHash,
+          previousHash: del.previousHash,
+          movedFrom: del.path
+        });
+      }
+    }
+    for (const c of created) {
+      if (!matchedCreated.has(c.path)) result.push(c);
+    }
+    for (const d of deleted) {
+      if (!matchedDeleted.has(d.path)) result.push(d);
+    }
+    result.push(...others);
+    return result;
+  }
+};
+
+// src/utils/logger.ts
+var consoleLogger = {
+  warn: (msg, ...args) => console.warn(msg, ...args),
+  error: (msg, ...args) => console.error(msg, ...args),
+  info: (msg, ...args) => console.info(msg, ...args),
+  debug: () => {
+  }
+};
+var currentLogger = consoleLogger;
+function setLogger(logger) {
+  currentLogger = logger;
+}
+function getLogger() {
+  return currentLogger;
+}
+
+// src/converter/pipeline.ts
+var ConversionPipeline = class {
+  preProcessors = [];
+  postProcessors = [];
+  registerPreProcessor(processor) {
+    this.preProcessors.push(processor);
+    this.preProcessors.sort((a, b) => a.order - b.order);
+  }
+  registerPostProcessor(processor) {
+    this.postProcessors.push(processor);
+    this.postProcessors.sort((a, b) => a.order - b.order);
+  }
+  selectPath(content) {
+    const hasInlineDb = /%% im-nobsidian:inline-db/.test(content);
+    const hasColumnLayout = />\s*\[!col\]/.test(content);
+    const hasToggleHeading = /%% im-nobsidian:toggle-heading/.test(content);
+    if (hasInlineDb || hasColumnLayout || hasToggleHeading) {
+      return "block-api";
+    }
+    return "markdown-api";
+  }
+  convertToNotion(markdown, context) {
+    let input = {
+      content: markdown,
+      metadata: {},
+      context
+    };
+    for (const processor of this.preProcessors) {
+      try {
+        const output = processor.process(input);
+        input = {
+          content: output.content,
+          metadata: output.metadata,
+          context
+        };
+      } catch (error) {
+        getLogger().warn(`[${processor.name}] Pre-processor failed:`, error);
+      }
+    }
+    return {
+      content: input.content,
+      properties: input.metadata.properties ?? {},
+      images: input.metadata.images ?? [],
+      preserveMarkers: input.metadata.preserveMarkers ?? []
+    };
+  }
+  convertToMarkdown(content, context, metadata) {
+    let input = {
+      content,
+      metadata: metadata ?? {},
+      context
+    };
+    for (const processor of this.postProcessors) {
+      try {
+        const output = processor.process(input);
+        input = {
+          content: output.content,
+          metadata: output.metadata,
+          context
+        };
+      } catch (error) {
+        getLogger().warn(`[${processor.name}] Post-processor failed:`, error);
+      }
+    }
+    return input.content;
+  }
+};
+var FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---/;
+var WIKILINK_IN_YAML = /\[\[([^\]]+)\]\]/g;
+var FrontmatterExtractor = class {
+  name = "FrontmatterExtractor";
+  order = 10;
+  process(input) {
+    const sanitized = input.content.replace(FRONTMATTER_REGEX, (match, yaml) => {
+      const fixed = yaml.replace(WIKILINK_IN_YAML, "$1");
+      return match.replace(yaml, fixed);
+    });
+    const { data, content } = matter(sanitized);
+    return {
+      content: content.trim(),
+      metadata: {
+        ...input.metadata,
+        properties: data
+      }
+    };
+  }
+};
+
+// src/converter/pre-processors/wikilink.ts
+var WIKILINK_REGEX = /\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
+var WikilinkResolver = class {
+  name = "WikilinkResolver";
+  order = 20;
+  process(input) {
+    const resolved = input.content.replace(
+      WIKILINK_REGEX,
+      (_match, target, display) => {
+        const label = display ?? target;
+        return `**${label}**`;
+      }
+    );
+    return {
+      content: resolved,
+      metadata: input.metadata
+    };
+  }
+};
+
+// src/converter/pre-processors/callout.ts
+var CALLOUT_REGEX = /^> \[!(\w+)\]([+-])?\s*(.*)?$/gm;
+var CALLOUT_EMOJI_MAP = {
+  note: "\u{1F4DD}",
+  abstract: "\u{1F4CB}",
+  summary: "\u{1F4CB}",
+  info: "\u2139\uFE0F",
+  tip: "\u{1F4A1}",
+  hint: "\u{1F4A1}",
+  success: "\u2705",
+  check: "\u2705",
+  question: "\u2753",
+  faq: "\u2753",
+  warning: "\u26A0\uFE0F",
+  caution: "\u26A0\uFE0F",
+  failure: "\u274C",
+  fail: "\u274C",
+  danger: "\u{1F525}",
+  error: "\u{1F525}",
+  bug: "\u{1F41B}",
+  example: "\u{1F4CC}",
+  quote: "\u{1F4AC}",
+  cite: "\u{1F4AC}"
+};
+var CalloutTransformer = class {
+  name = "CalloutTransformer";
+  order = 30;
+  process(input) {
+    const content = input.content.replace(
+      CALLOUT_REGEX,
+      (_match, type, foldable, title) => {
+        const emoji = CALLOUT_EMOJI_MAP[type.toLowerCase()] ?? "\u{1F4DD}";
+        const titleText = title?.trim() || type;
+        const foldMeta = foldable ? `
+%% im-nobsidian:callout:type=${type}&foldable=${foldable === "+" ? "open" : "closed"} %%` : "";
+        return `> ${emoji} **${titleText}**${foldMeta}`;
+      }
+    );
+    return {
+      content,
+      metadata: input.metadata
+    };
+  }
+};
+
+// src/converter/pre-processors/math.ts
+var BLOCK_MATH_REGEX = /\$\$([\s\S]+?)\$\$/g;
+var INLINE_MATH_REGEX = /(?<![\\$])\$([^\n$]+?)\$(?!\$)/g;
+var MathNormalizer = class {
+  name = "MathNormalizer";
+  order = 50;
+  process(input) {
+    let content = input.content;
+    content = content.replace(BLOCK_MATH_REGEX, (_match, equation) => {
+      return `$$
+${equation.trim()}
+$$`;
+    });
+    content = content.replace(INLINE_MATH_REGEX, (_match, equation) => {
+      return `$${equation.trim()}$`;
+    });
+    return {
+      content,
+      metadata: input.metadata
+    };
+  }
+};
+
+// src/converter/pre-processors/embed.ts
+var OBSIDIAN_EMBED_REGEX = /!\[\[([^\]]+)\]\]/g;
+var MARKDOWN_IMAGE_REGEX = /!\[([^\]]*)\]\(([^)]+)\)/g;
+var VIDEO_HOSTS = ["youtube.com", "youtu.be", "vimeo.com"];
+var EmbedResolver = class {
+  name = "EmbedResolver";
+  order = 60;
+  process(input) {
+    const images = input.metadata.images ? [...input.metadata.images] : [];
+    const isPush = input.context.direction === "push";
+    let content = input.content.replace(OBSIDIAN_EMBED_REGEX, (_match, target) => {
+      if (isImageFile(target)) {
+        images.push({ url: target, localPath: target, isExternal: false });
+        if (isPush && !isExternalUrl(target)) {
+          const fileName = target.split("/").pop() ?? target;
+          return `> \u{1F4CE} ${fileName} (\uB85C\uCEEC \uC774\uBBF8\uC9C0 \u2014 Notion API \uC81C\uD55C\uC73C\uB85C \uC5C5\uB85C\uB4DC \uBD88\uAC00)
+> %% im-nobsidian:local-image:${target} %%`;
+        }
+        return `![${target}](${encodeURI(target)})`;
+      }
+      return `[${target}](${encodeURI(target)})`;
+    });
+    content = content.replace(MARKDOWN_IMAGE_REGEX, (_match, alt, url) => {
+      if (isVideoUrl(url)) {
+        return `%% im-nobsidian:embed:type=video&url=${encodeURIComponent(url)} %%
+[${alt || "Video"}](${url})`;
+      }
+      if (isExternalUrl(url)) {
+        images.push({ url, isExternal: true });
+      }
+      return `![${alt}](${url})`;
+    });
+    return {
+      content,
+      metadata: { ...input.metadata, images }
+    };
+  }
+};
+function isImageFile(path) {
+  return /\.(png|jpg|jpeg|gif|svg|webp|bmp|ico)$/i.test(path);
+}
+function isVideoUrl(url) {
+  return VIDEO_HOSTS.some((host) => url.includes(host));
+}
+function isExternalUrl(url) {
+  return url.startsWith("http://") || url.startsWith("https://");
+}
+
+// src/converter/pre-processors/preserve-marker.ts
+var MARKER_REGEX = /%% im-nobsidian:(\w[\w-]*):([^\s]+?) %%/g;
+var PreserveMarkerCollector = class {
+  name = "PreserveMarkerCollector";
+  order = 70;
+  process(input) {
+    const markers = input.metadata.preserveMarkers ? [...input.metadata.preserveMarkers] : [];
+    const matches = [...input.content.matchAll(MARKER_REGEX)];
+    for (const match of matches) {
+      markers.push({
+        type: match[1],
+        params: parseMarkerParams(match[2]),
+        startIndex: match.index
+      });
+    }
+    return {
+      content: input.content,
+      metadata: { ...input.metadata, preserveMarkers: markers }
+    };
+  }
+};
+function parseMarkerParams(paramString) {
+  const params = {};
+  for (const pair of paramString.split("&")) {
+    const eqIdx = pair.indexOf("=");
+    if (eqIdx > 0) {
+      params[pair.slice(0, eqIdx)] = decodeURIComponent(pair.slice(eqIdx + 1));
+    }
+  }
+  return params;
+}
+
+// src/converter/pre-processors/unsupported-block-stripper.ts
+var UNSUPPORTED_CALLOUT_REGEX = /> \[!im-nobsidian-unsupported\][^\n]*\n(?:>[^\n]*\n)*/g;
+var UnsupportedBlockStripper = class {
+  name = "UnsupportedBlockStripper";
+  order = 5;
+  process(input) {
+    if (input.context.direction !== "push") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const content = input.content.replace(UNSUPPORTED_CALLOUT_REGEX, "");
+    return {
+      content: content.replace(/\n{3,}/g, "\n\n"),
+      metadata: input.metadata
+    };
+  }
+};
+
+// src/converter/pre-processors/properties-table.ts
+var PropertiesTableInjector = class {
+  name = "PropertiesTableInjector";
+  order = 15;
+  process(input) {
+    if (input.context.direction !== "push") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    if (input.context.parentMode === "database") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const properties = input.metadata.properties;
+    if (!properties || Object.keys(properties).length === 0) {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const filteredEntries = Object.entries(properties).filter(([key]) => key !== "title");
+    if (filteredEntries.length === 0) {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const rows = filteredEntries.map(([key, value]) => {
+      const display = formatValue(value);
+      return `| ${key} | ${display} |`;
+    });
+    const table = ["| Property | Value |", "| --- | --- |", ...rows].join("\n");
+    const content = table + "\n\n---\n\n" + input.content;
+    return { content, metadata: input.metadata };
+  }
+};
+function formatValue(value) {
+  if (value === null || value === void 0) return "";
+  if (value instanceof Date) {
+    return value.toISOString().replace(/T00:00:00(?:\.000)?Z$/, "");
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => formatValue(v)).join(", ");
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
+// src/converter/pre-processors/html-annotation.ts
+var UNDERLINE_REGEX = /<u>([\s\S]*?)<\/u>/g;
+var COLOR_SPAN_REGEX = /<span class="notion-(\w+?)(?:-bg)?">([\s\S]*?)<\/span>/g;
+var IM_NOBSIDIAN_COLOR_REGEX = /%% im-nobsidian:color:(\w+(?:_background)?) %%([\s\S]*?)%% im-nobsidian:end %%/g;
+var HtmlAnnotationStripper = class {
+  name = "HtmlAnnotationStripper";
+  order = 5;
+  process(input) {
+    if (input.context.direction !== "push") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    let content = input.content;
+    content = content.replace(IM_NOBSIDIAN_COLOR_REGEX, (_m, _color, text) => text);
+    content = content.replace(UNDERLINE_REGEX, (_m, text) => text);
+    content = content.replace(COLOR_SPAN_REGEX, (_m, _color, text) => text);
+    return { content, metadata: input.metadata };
+  }
+};
+
+// src/converter/post-processors/mention-to-wikilink.ts
+var NOTION_LINK_REGEX = /\[([^\]]+)\]\((?:https:\/\/www\.notion\.so\/|notion:\/\/)([a-f0-9-]+)\)/g;
+var MentionToWikilink = class {
+  name = "MentionToWikilink";
+  order = 10;
+  process(input) {
+    const content = input.content.replace(
+      NOTION_LINK_REGEX,
+      (_match, display, _pageId) => {
+        return `[[${display}]]`;
+      }
+    );
+    return {
+      content,
+      metadata: input.metadata
+    };
+  }
+};
+
+// src/converter/post-processors/preserve-marker-injector.ts
+var PreserveMarkerInjector = class {
+  name = "PreserveMarkerInjector";
+  order = 100;
+  process(input) {
+    if (input.context.direction !== "pull") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const markers = input.metadata.preserveMarkers;
+    if (!markers || markers.length === 0) {
+      return { content: input.content, metadata: input.metadata };
+    }
+    let content = input.content;
+    const missingMarkers = markers.filter((m) => !content.includes(this.formatMarker(m)));
+    if (missingMarkers.length === 0) {
+      return { content, metadata: input.metadata };
+    }
+    const markerLines = missingMarkers.map((m) => this.formatMarker(m));
+    const suffix = "\n\n" + markerLines.join("\n");
+    content = content.trimEnd() + suffix + "\n";
+    return { content, metadata: input.metadata };
+  }
+  formatMarker(marker) {
+    const params = Object.entries(marker.params).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+    return `%% im-nobsidian:${marker.type}:${params} %%`;
+  }
+};
+
+// src/converter/post-processors/callout-restorer.ts
+var EMOJI_TYPE_MAP = {
+  "\u{1F4DD}": "note",
+  "\u{1F4CB}": "abstract",
+  "\u2139\uFE0F": "info",
+  "\u{1F4A1}": "tip",
+  "\u2705": "success",
+  "\u2753": "question",
+  "\u26A0\uFE0F": "warning",
+  "\u274C": "failure",
+  "\u{1F525}": "danger",
+  "\u{1F41B}": "bug",
+  "\u{1F4CC}": "example",
+  "\u{1F4AC}": "quote"
+};
+var CALLOUT_PRESERVE_REGEX = /%% im-nobsidian:callout:type=(\w+)&foldable=(open|closed) %%/g;
+var CalloutRestorer = class {
+  name = "CalloutRestorer";
+  order = 20;
+  process(input) {
+    let content = input.content;
+    content = content.replace(CALLOUT_PRESERVE_REGEX, (_match, type, foldable) => {
+      const foldChar = foldable === "open" ? "+" : "-";
+      return `[!${type}]${foldChar}`;
+    });
+    for (const [emoji, type] of Object.entries(EMOJI_TYPE_MAP)) {
+      const pattern = new RegExp(`> ${escapeRegex(emoji)} \\*\\*(.+?)\\*\\*`, "g");
+      content = content.replace(pattern, (_match, title) => {
+        if (title.toLowerCase() === type) {
+          return `> [!${type}]`;
+        }
+        return `> [!${type}] ${title}`;
+      });
+    }
+    return {
+      content,
+      metadata: input.metadata
+    };
+  }
+};
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/converter/post-processors/color-annotator.ts
+var COLOR_MARKER_REGEX = /%% im-nobsidian:color:(\w+(?:_background)?) %%([\s\S]*?)%% im-nobsidian:end %%/g;
+var ColorAnnotator = class {
+  name = "ColorAnnotator";
+  order = 30;
+  process(input) {
+    const content = input.content.replace(
+      COLOR_MARKER_REGEX,
+      (_match, color, text) => {
+        const cssClass = color.endsWith("_background") ? `notion-${color.replace("_background", "-bg")}` : `notion-${color}`;
+        return `<span class="${cssClass}">${text}</span>`;
+      }
+    );
+    return {
+      content,
+      metadata: input.metadata
+    };
+  }
+};
+var FrontmatterGenerator = class {
+  name = "FrontmatterGenerator";
+  order = 90;
+  process(input) {
+    const properties = input.metadata.properties;
+    if (!properties || Object.keys(properties).length === 0) {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const content = matter.stringify(input.content, properties);
+    return {
+      content,
+      metadata: input.metadata
+    };
+  }
+};
+
+// src/converter/post-processors/local-image-restorer.ts
+var LOCAL_IMAGE_MARKER_REGEX = />\s*📎\s*[^\n]*\n>\s*%%\s*im-nobsidian:local-image:([^\s]+)\s*%%/g;
+var LocalImageRestorer = class {
+  name = "LocalImageRestorer";
+  order = 15;
+  process(input) {
+    if (input.context.direction !== "pull") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const content = input.content.replace(LOCAL_IMAGE_MARKER_REGEX, (_match, target) => {
+      return `![[${target}]]`;
+    });
+    return { content, metadata: input.metadata };
+  }
+};
+
+// src/converter/post-processors/properties-table-restorer.ts
+var PROPERTIES_TABLE_REGEX = /^\s*\| Property\s*\| Value\s*\|\n\s*\|\s*-{3,}\s*\|\s*-{3,}\s*\|\n((?:\|[^\n]+\|\n?)+)\n*---\n*/;
+var PropertiesTableRestorer = class {
+  name = "PropertiesTableRestorer";
+  order = 5;
+  process(input) {
+    if (input.context.direction !== "pull") {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const match = input.content.match(PROPERTIES_TABLE_REGEX);
+    if (!match) {
+      return { content: input.content, metadata: input.metadata };
+    }
+    const rows = match[1].trim().split("\n");
+    const properties = {
+      ...input.metadata.properties
+    };
+    for (const row of rows) {
+      const cells = row.split("|").map((c) => c.trim()).filter(Boolean);
+      if (cells.length >= 2) {
+        const key = cells[0];
+        const rawValue = cells[1];
+        properties[key] = parseValue(rawValue);
+      }
+    }
+    const content = input.content.replace(PROPERTIES_TABLE_REGEX, "").trimStart();
+    return {
+      content,
+      metadata: { ...input.metadata, properties }
+    };
+  }
+};
+function stripQuotes(s) {
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?$/;
+function parseValue(raw) {
+  if (raw === "" || raw === "null") return null;
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  const unquoted = stripQuotes(raw);
+  if (ISO_DATE_REGEX.test(unquoted)) {
+    return unquoted.replace(/T00:00:00(?:\.000)?Z?$/, "");
+  }
+  const num = Number(unquoted);
+  if (!isNaN(num) && unquoted.trim() !== "") return num;
+  if (unquoted.includes(", ")) {
+    const parts = unquoted.split(", ");
+    const looksLikeArray = parts.every((p) => p.split(/\s+/).length <= 3);
+    if (looksLikeArray) {
+      return parts.map((v) => {
+        const n = Number(v);
+        return !isNaN(n) && v.trim() !== "" ? n : v;
+      });
+    }
+  }
+  if (unquoted.startsWith("{") || unquoted.startsWith("[")) {
+    try {
+      return JSON.parse(unquoted);
+    } catch {
+      return unquoted;
+    }
+  }
+  return unquoted;
+}
+
+// src/converter/pipeline-factory.ts
+function createDefaultPipeline() {
+  const pipeline = new ConversionPipeline();
+  pipeline.registerPreProcessor(new HtmlAnnotationStripper());
+  pipeline.registerPreProcessor(new UnsupportedBlockStripper());
+  pipeline.registerPreProcessor(new FrontmatterExtractor());
+  pipeline.registerPreProcessor(new PropertiesTableInjector());
+  pipeline.registerPreProcessor(new WikilinkResolver());
+  pipeline.registerPreProcessor(new CalloutTransformer());
+  pipeline.registerPreProcessor(new MathNormalizer());
+  pipeline.registerPreProcessor(new EmbedResolver());
+  pipeline.registerPreProcessor(new PreserveMarkerCollector());
+  pipeline.registerPostProcessor(new PropertiesTableRestorer());
+  pipeline.registerPostProcessor(new LocalImageRestorer());
+  pipeline.registerPostProcessor(new PreserveMarkerInjector());
+  pipeline.registerPostProcessor(new MentionToWikilink());
+  pipeline.registerPostProcessor(new CalloutRestorer());
+  pipeline.registerPostProcessor(new ColorAnnotator());
+  pipeline.registerPostProcessor(new FrontmatterGenerator());
+  return pipeline;
+}
+var TRULY_UNSUPPORTED_BLOCK_TYPES = ["unsupported", "template"];
+var DIVIDER_PLACEHOLDER = "\u200B%%IM-NOBSIDIAN_DIVIDER%%\u200B";
+var TOGGLE_START = "%%im-nobsidian:toggle:start%%";
+var TOGGLE_END = "%%im-nobsidian:toggle:end%%";
+var COLUMN_LIST_START = "%%im-nobsidian:column-list:start%%";
+var COLUMN_SEP = "%%im-nobsidian:column%%";
+var COLUMN_LIST_END = "%%im-nobsidian:column-list:end%%";
+var VIDEO_URL_PATTERNS = [
+  /^https?:\/\/(www\.)?youtube\.com\/watch/,
+  /^https?:\/\/youtu\.be\//,
+  /^https?:\/\/(www\.)?vimeo\.com\//,
+  /^https?:\/\/(www\.)?dailymotion\.com\//,
+  /^https?:\/\/(www\.)?loom\.com\/share\//
+];
+var EMBED_URL_PATTERNS = [
+  /^https?:\/\/(www\.)?figma\.com\//,
+  /^https?:\/\/docs\.google\.com\//,
+  /^https?:\/\/drive\.google\.com\//,
+  /^https?:\/\/(www\.)?miro\.com\//,
+  /^https?:\/\/(www\.)?twitter\.com\//,
+  /^https?:\/\/(www\.)?x\.com\//,
+  /^https?:\/\/codepen\.io\//,
+  /^https?:\/\/gist\.github\.com\//,
+  /^https?:\/\/(www\.)?spotify\.com\//,
+  /^https?:\/\/(www\.)?soundcloud\.com\//
+];
+function escapeRegex2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function richTextToPlain(richText) {
+  if (!richText) return "";
+  return richText.map((t) => t.plain_text).join("");
+}
+function richTextToMarkdown(richText) {
+  if (!richText) return "";
+  return richText.map((t) => {
+    if (t.type === "equation" && t.equation) {
+      return `$${t.equation.expression}$`;
+    }
+    if (t.type === "mention" && t.mention) {
+      return formatMention(t.mention);
+    }
+    let text = t.plain_text;
+    const a = t.annotations;
+    if (a?.code) text = `\`${text}\``;
+    if (a?.bold) text = `**${text}**`;
+    if (a?.italic) text = `*${text}*`;
+    if (a?.strikethrough) text = `~~${text}~~`;
+    if (a?.underline) text = `<u>${text}</u>`;
+    if (t.href) text = `[${text}](${t.href})`;
+    const color = a?.color;
+    if (color && color !== "default") {
+      text = `%% im-nobsidian:color:${color} %%${text}%% im-nobsidian:end %%`;
+    }
+    return text;
+  }).join("");
+}
+function formatMention(mention) {
+  switch (mention.type) {
+    case "page":
+      return mention.page ? `[[${mention.page.id}]]` : "";
+    case "date": {
+      if (!mention.date) return "";
+      const start = mention.date.start;
+      return mention.date.end ? `${start} \u2192 ${mention.date.end}` : start;
+    }
+    case "user":
+      return mention.user?.name ? `@${mention.user.name}` : "@user";
+    case "database":
+      return mention.database ? `[[${mention.database.id}]]` : "";
+    default:
+      return "";
+  }
+}
+var BlockConverter = class {
+  n2m = null;
+  client = null;
+  initNotionToMd(client) {
+    this.client = client;
+    this.n2m = new NotionToMarkdown({ notionClient: client });
+    this.registerCustomTransformers();
+  }
+  registerCustomTransformers() {
+    if (!this.n2m) return;
+    for (const blockType of TRULY_UNSUPPORTED_BLOCK_TYPES) {
+      this.n2m.setCustomTransformer(blockType, (block) => {
+        const id = block.id ?? "unknown";
+        return Promise.resolve(
+          `> [!im-nobsidian-unsupported] Notion \uC804\uC6A9 \uBE14\uB85D
+> type: ${blockType}, id: ${id}
+> %%im-nobsidian:unsupported:type=${blockType}&id=${id}%%`
+        );
+      });
+    }
+    this.registerToggleTransformer();
+    this.registerColumnTransformer();
+    this.registerSyncedBlockTransformer();
+    this.registerBookmarkTransformer();
+    this.registerVideoTransformer();
+    this.registerAudioTransformer();
+    this.registerFileTransformer();
+    this.registerChildPageTransformer();
+    this.registerChildDatabaseTransformer();
+    this.registerLinkToPageTransformer();
+    this.registerTocTransformer();
+    this.registerBreadcrumbTransformer();
+    this.registerLinkPreviewTransformer();
+    this.registerCalloutTransformer();
+    this.registerToggleHeadingTransformers();
+  }
+  registerToggleTransformer() {
+    if (!this.n2m) return;
+    const n2m = this.n2m;
+    this.n2m.setCustomTransformer("toggle", async (block) => {
+      const b = block;
+      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();
+      return `${TOGGLE_START}
+- ${title}
+${indented}
+${TOGGLE_END}`;
+    });
+  }
+  registerToggleHeadingTransformers() {
+    if (!this.n2m) return;
+    const n2m = this.n2m;
+    for (const level of [1, 2, 3]) {
+      const headingKey = `heading_${level}`;
+      this.n2m.setCustomTransformer(headingKey, async (block) => {
+        const b = block;
+        const headingData = b[headingKey];
+        const text = richTextToMarkdown(headingData?.rich_text);
+        const prefix = "#".repeat(level);
+        if (headingData?.is_toggleable && b.has_children) {
+          const children = await n2m.pageToMarkdown(b.id);
+          const childMd = (Array.isArray(children) ? n2m.toMarkdownString(children).parent : "") ?? "";
+          return `${prefix} ${text}
+
+${childMd.trimEnd()}`;
+        }
+        return `${prefix} ${text}`;
+      });
+    }
+  }
+  registerColumnTransformer() {
+    if (!this.n2m) return;
+    const n2m = this.n2m;
+    const client = this.client;
+    this.n2m.setCustomTransformer("column_list", async (block) => {
+      const b = block;
+      const response = await client.blocks.children.list({ block_id: b.id });
+      const columns = response.results;
+      const parts = [];
+      for (let i = 0; i < columns.length; i++) {
+        const col = columns[i];
+        const children = await n2m.pageToMarkdown(col.id);
+        const childMd = (Array.isArray(children) ? n2m.toMarkdownString(children).parent : "") ?? "";
+        parts.push(`${COLUMN_SEP}
+${childMd.trimEnd()}`);
+      }
+      return `${COLUMN_LIST_START}
+${parts.join("\n")}
+${COLUMN_LIST_END}`;
+    });
+    this.n2m.setCustomTransformer("column", async () => "");
+  }
+  registerSyncedBlockTransformer() {
+    if (!this.n2m) return;
+    const n2m = this.n2m;
+    const client = this.client;
+    this.n2m.setCustomTransformer("synced_block", async (block) => {
+      const b = block;
+      const sourceId = b.synced_block?.synced_from?.block_id ?? b.id;
+      const response = await client.blocks.children.list({ block_id: sourceId });
+      const mdBlocks = [];
+      for (const child of response.results) {
+        const result = await n2m.blockToMarkdown(child);
+        if (result) mdBlocks.push(result);
+      }
+      const childMd = n2m.toMarkdownString(mdBlocks).parent ?? "";
+      return childMd.trimEnd();
+    });
+  }
+  registerBookmarkTransformer() {
+    if (!this.n2m) return;
+    this.n2m.setCustomTransformer("bookmark", async (block) => {
+      const b = block;
+      const url = b.bookmark?.url ?? "";
+      const caption = richTextToPlain(b.bookmark?.caption);
+      if (caption) {
+        return `[${caption}](${url})`;
+      }
+      return `[${url}](${url})`;
+    });
+  }
+  registerVideoTransformer() {
+    if (!this.n2m) return;
+    this.n2m.setCustomTransformer("video", async (block) => {
+      const b = block;
+      const url = b.video?.type === "external" ? b.video.external?.url : b.video?.file?.url;
+      const caption = richTextToPlain(b.video?.caption);
+      return `![${caption || "video"}](${url ?? ""})`;
+    });
+  }
+  registerAudioTransformer() {
+    if (!this.n2m) return;
+    this.n2m.setCustomTransformer("audio", async (block) => {
+      const b = block;
+      const url = b.audio?.type === "external" ? b.audio.external?.url : b.audio?.file?.url;
+      const caption = richTextToPlain(b.audio?.caption);
+      return `![${caption || "audio"}](${url ?? ""})`;
+    });
+  }
+  registerFileTransformer() {
+    if (!this.n2m) return;
+    this.n2m.setCustomTransformer("file", async (block) => {
+      const b = block;
+      const url = b.file?.type === "external" ? b.file.external?.url : b.file?.file?.url;
+      const name = b.file?.name ?? richTextToPlain(b.file?.caption) ?? "file";
+      return `[${name}](${url ?? ""})`;
+    });
+  }
+  registerChildPageTransformer() {
+    if (!this.n2m) return;
+    this.n2m.setCustomTransformer("child_page", async (block) => {
+      const b = block;
+      const title = b.child_page?.title ?? "Untitled";
+      return `[[${title}]]`;
+    });
+  }
+  registerChildDatabaseTransformer() {
+    if (!this.n2m) return;
+    this.n2m.setCustomTransformer("child_database", async (block) => {
+      const b = block;
+      const title = b.child_database?.title ?? "Database";
+      return `> [!database] ${title}
+> %%im-nobsidian:child-database:id=${b.id}&title=${encodeURIComponent(title)}%%`;
+    });
+  }
+  registerLinkToPageTransformer() {
+    if (!this.n2m) return;
+    const client = this.client;
+    this.n2m.setCustomTransformer("link_to_page", async (block) => {
+      const b = block;
+      const pageId = b.link_to_page?.page_id ?? b.link_to_page?.database_id;
+      if (!pageId) return "";
+      try {
+        const page = await client.pages.retrieve({ page_id: pageId });
+        const p = page;
+        for (const prop of Object.values(p.properties)) {
+          if (prop.type === "title" && prop.title?.[0]?.plain_text) {
+            return `[[${prop.title[0].plain_text}]]`;
+          }
+        }
+      } catch {
+      }
+      return `[[${pageId}]]`;
+    });
+  }
+  registerTocTransformer() {
+    if (!this.n2m) return;
+    this.n2m.setCustomTransformer("table_of_contents", async () => {
+      return `%%im-nobsidian:toc%%`;
+    });
+  }
+  registerBreadcrumbTransformer() {
+    if (!this.n2m) return;
+    this.n2m.setCustomTransformer("breadcrumb", async () => "");
+  }
+  registerLinkPreviewTransformer() {
+    if (!this.n2m) return;
+    this.n2m.setCustomTransformer("link_preview", async (block) => {
+      const b = block;
+      const url = b.link_preview?.url ?? "";
+      return `[${url}](${url})`;
+    });
+  }
+  registerCalloutTransformer() {
+    if (!this.n2m) return;
+    const n2m = this.n2m;
+    this.n2m.setCustomTransformer("callout", async (block) => {
+      const b = block;
+      const text = richTextToMarkdown(b.callout?.rich_text);
+      const emoji = b.callout?.icon?.emoji ?? "";
+      const children = b.has_children ? await n2m.pageToMarkdown(b.id) : [];
+      const childMd = (Array.isArray(children) ? n2m.toMarkdownString(children).parent : "") ?? "";
+      const EMOJI_TO_TYPE = {
+        "\u{1F4DD}": "note",
+        "\u{1F4CB}": "abstract",
+        "\u2139\uFE0F": "info",
+        "\u{1F4A1}": "tip",
+        "\u2705": "success",
+        "\u2753": "question",
+        "\u26A0\uFE0F": "warning",
+        "\u274C": "failure",
+        "\u{1F525}": "danger",
+        "\u{1F41B}": "bug",
+        "\u{1F4CC}": "example",
+        "\u{1F4AC}": "quote"
+      };
+      const calloutType = EMOJI_TO_TYPE[emoji] ?? "note";
+      let result = `> [!${calloutType}] ${text}`;
+      if (childMd?.trim()) {
+        const lines = childMd.trim().split("\n").map((l) => `> ${l}`);
+        result += "\n" + lines.join("\n");
+      }
+      return result;
+    });
+  }
+  markdownToNotionBlocks(markdown) {
+    const preprocessed = this.preProcessMarkdown(markdown);
+    const blocks = markdownToBlocks(preprocessed);
+    return this.postProcessBlocks(blocks);
+  }
+  toggleContents = /* @__PURE__ */ new Map();
+  columnContents = /* @__PURE__ */ new Map();
+  toggleCounter = 0;
+  columnCounter = 0;
+  preProcessMarkdown(markdown) {
+    this.toggleContents.clear();
+    this.columnContents.clear();
+    this.toggleCounter = 0;
+    this.columnCounter = 0;
+    let processed = this.extractToggleBlocks(markdown);
+    processed = this.extractColumnBlocks(processed);
+    processed = this.replaceDividers(processed);
+    return processed;
+  }
+  replaceDividers(markdown) {
+    const lines = markdown.split("\n");
+    const result = [];
+    let inCodeBlock = false;
+    for (const line of lines) {
+      if (line.trimStart().startsWith("```")) {
+        inCodeBlock = !inCodeBlock;
+      }
+      if (!inCodeBlock && /^---\s*$/.test(line.trim())) {
+        result.push(DIVIDER_PLACEHOLDER);
+      } else {
+        result.push(line);
+      }
+    }
+    return result.join("\n");
+  }
+  extractToggleBlocks(markdown) {
+    const startRe = new RegExp(`^${escapeRegex2(TOGGLE_START)}$`, "gm");
+    const endRe = new RegExp(`^${escapeRegex2(TOGGLE_END)}$`, "gm");
+    let result = markdown;
+    let match;
+    while ((match = startRe.exec(result)) !== null) {
+      endRe.lastIndex = match.index;
+      const endMatch = endRe.exec(result);
+      if (!endMatch) break;
+      const content = result.slice(match.index + match[0].length + 1, endMatch.index).trimEnd();
+      const id = this.toggleCounter++;
+      this.toggleContents.set(id, content);
+      const placeholder = `%%IM-NOBSIDIAN_TOGGLE_${id}%%`;
+      result = result.slice(0, match.index) + placeholder + result.slice(endMatch.index + endMatch[0].length);
+      startRe.lastIndex = match.index + placeholder.length;
+    }
+    return result;
+  }
+  extractColumnBlocks(markdown) {
+    const startRe = new RegExp(`^${escapeRegex2(COLUMN_LIST_START)}$`, "gm");
+    const endRe = new RegExp(`^${escapeRegex2(COLUMN_LIST_END)}$`, "gm");
+    let result = markdown;
+    let match;
+    while ((match = startRe.exec(result)) !== null) {
+      endRe.lastIndex = match.index;
+      const endMatch = endRe.exec(result);
+      if (!endMatch) break;
+      const inner = result.slice(match.index + match[0].length + 1, endMatch.index);
+      const columns = inner.split(new RegExp(`^${escapeRegex2(COLUMN_SEP)}$`, "m")).map((c) => c.trim()).filter(Boolean);
+      const id = this.columnCounter++;
+      this.columnContents.set(id, columns);
+      const placeholder = `%%IM-NOBSIDIAN_COLLIST_${id}%%`;
+      result = result.slice(0, match.index) + placeholder + result.slice(endMatch.index + endMatch[0].length);
+      startRe.lastIndex = match.index + placeholder.length;
+    }
+    return result;
+  }
+  postProcessBlocks(blocks) {
+    const result = [];
+    for (const block of blocks) {
+      const toggleConverted = this.convertTogglePlaceholder(block);
+      if (toggleConverted) {
+        result.push(toggleConverted);
+        continue;
+      }
+      const columnConverted = this.convertColumnPlaceholder(block);
+      if (columnConverted) {
+        result.push(columnConverted);
+        continue;
+      }
+      const dividerConverted = this.convertDividerPlaceholder(block);
+      if (dividerConverted) {
+        result.push(dividerConverted);
+        continue;
+      }
+      const videoConverted = this.convertImageToVideoOrEmbed(block);
+      if (videoConverted) {
+        result.push(videoConverted);
+        continue;
+      }
+      const calloutConverted = this.convertQuoteToCallout(block);
+      result.push(calloutConverted);
+    }
+    return result;
+  }
+  convertTogglePlaceholder(block) {
+    if (block.type !== "paragraph") return null;
+    const para = block.paragraph;
+    const text = para?.rich_text?.[0]?.text?.content ?? "";
+    const toggleMatch = text.match(/%%IM-NOBSIDIAN_TOGGLE_(\d+)%%/);
+    if (!toggleMatch) return null;
+    const id = parseInt(toggleMatch[1], 10);
+    const content = this.toggleContents.get(id);
+    if (content === void 0) return null;
+    const titleMatch = content.match(/^- (.+)$/m);
+    const title = titleMatch?.[1] ?? "Toggle";
+    const childLines = content.split("\n").slice(1);
+    const childMd = childLines.map((l) => l.startsWith("  ") ? l.slice(2) : l).join("\n").trim();
+    const children = childMd ? markdownToBlocks(childMd) : [];
+    return NotionBlockBuilder.toggle(
+      NotionBlockBuilder.richText(title),
+      children.length > 0 ? children : void 0
+    );
+  }
+  convertColumnPlaceholder(block) {
+    if (block.type !== "paragraph") return null;
+    const para = block.paragraph;
+    const text = para?.rich_text?.[0]?.text?.content ?? "";
+    const colMatch = text.match(/%%IM-NOBSIDIAN_COLLIST_(\d+)%%/);
+    if (!colMatch) return null;
+    const id = parseInt(colMatch[1], 10);
+    const columns = this.columnContents.get(id);
+    if (!columns) return null;
+    const columnBlocks = columns.map((colMd) => {
+      const blocks = markdownToBlocks(colMd);
+      return this.postProcessBlocks(blocks);
+    });
+    return NotionBlockBuilder.columnList(columnBlocks);
+  }
+  convertDividerPlaceholder(block) {
+    if (block.type !== "paragraph") return null;
+    const para = block.paragraph;
+    const text = para?.rich_text?.[0]?.text?.content ?? "";
+    if (text.includes("%%IM-NOBSIDIAN_DIVIDER%%")) {
+      return NotionBlockBuilder.divider();
+    }
+    return null;
+  }
+  convertImageToVideoOrEmbed(block) {
+    let url = "";
+    let caption;
+    if (block.type === "image") {
+      const img = block.image;
+      url = img?.external?.url ?? "";
+      caption = img?.caption?.[0]?.text?.content;
+    } else if (block.type === "paragraph") {
+      const para = block.paragraph;
+      const texts = para?.rich_text ?? [];
+      if (texts.length === 1) {
+        const content = texts[0]?.text?.content ?? "";
+        if (/^https?:\/\//.test(content)) {
+          url = content;
+        }
+      }
+    }
+    if (!url) return null;
+    if (VIDEO_URL_PATTERNS.some((p) => p.test(url))) {
+      return NotionBlockBuilder.video(url, caption);
+    }
+    if (EMBED_URL_PATTERNS.some((p) => p.test(url))) {
+      return NotionBlockBuilder.embed(url, caption);
+    }
+    return null;
+  }
+  convertQuoteToCallout(block) {
+    if (block.type !== "quote") return block;
+    const quote = block.quote;
+    if (!quote?.rich_text?.[0]) return block;
+    const firstText = quote.rich_text[0]?.text?.content ?? "";
+    const KNOWN_CALLOUT_EMOJIS = [
+      "\u{1F4DD}",
+      "\u{1F4CB}",
+      "\u2139\uFE0F",
+      "\u{1F4A1}",
+      "\u2705",
+      "\u2753",
+      "\u26A0\uFE0F",
+      "\u274C",
+      "\u{1F525}",
+      "\u{1F41B}",
+      "\u{1F4CC}",
+      "\u{1F4AC}"
+    ];
+    const matchedEmoji = KNOWN_CALLOUT_EMOJIS.find((e) => firstText.startsWith(e));
+    if (!matchedEmoji) return block;
+    const emoji = matchedEmoji;
+    const remainingText = firstText.slice(emoji.length).replace(/^\s+/, "");
+    const newRichText = [...quote.rich_text];
+    if (remainingText) {
+      newRichText[0] = {
+        ...newRichText[0],
+        text: { content: remainingText, link: null }
+      };
+    } else {
+      newRichText.shift();
+    }
+    return {
+      type: "callout",
+      callout: {
+        rich_text: newRichText,
+        icon: { type: "emoji", emoji },
+        children: quote.children ?? []
+      }
+    };
+  }
+  async notionBlocksToMarkdown(pageId) {
+    if (!this.n2m) {
+      throw new Error(
+        "NotionToMarkdown\uC774 \uCD08\uAE30\uD654\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. initNotionToMd()\uB97C \uBA3C\uC800 \uD638\uCD9C\uD558\uC138\uC694."
+      );
+    }
+    const mdBlocks = await this.n2m.pageToMarkdown(pageId);
+    const result = this.n2m.toMarkdownString(mdBlocks);
+    return result.parent ?? "";
+  }
+};
+var IMAGE_EXTENSIONS = {
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/gif": ".gif",
+  "image/webp": ".webp",
+  "image/svg+xml": ".svg",
+  "image/bmp": ".bmp",
+  "image/tiff": ".tiff"
+};
+var ImageHandler = class {
+  constructor(vaultFs, attachmentFolder = "attachments") {
+    this.vaultFs = vaultFs;
+    this.attachmentFolder = attachmentFolder;
+  }
+  vaultFs;
+  attachmentFolder;
+  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 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
+    };
+  }
+  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) {
+      return { content: markdown, downloads: [] };
+    }
+    const sema = new Sema(3);
+    const results = await Promise.allSettled(
+      notionMatches.map(async (match) => {
+        await sema.acquire();
+        try {
+          return {
+            match,
+            download: await this.downloadImage(match[2], pageTitle)
+          };
+        } finally {
+          sema.release();
+        }
+      })
+    );
+    const downloads = [];
+    let result = markdown;
+    for (const settled of results) {
+      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);
+    }
+    return { content: result, downloads };
+  }
+  isNotionImageUrl(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) {
+    const pathname = new URL(url).pathname;
+    const ext = pathname.match(/\.(png|jpg|jpeg|gif|webp|svg|bmp|tiff)(\?|$)/i);
+    return ext ? `.${ext[1].toLowerCase()}` : null;
+  }
+};
+
+// 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/sync/orchestrator.ts
+var SyncOrchestrator = class {
+  constructor(config, stateDb, notionClient, vaultFs) {
+    this.config = config;
+    this.stateDb = stateDb;
+    this.notionClient = notionClient;
+    this.vaultFs = vaultFs;
+    this.changeDetector = new ChangeDetector(stateDb);
+    this.pipeline = createDefaultPipeline();
+    this.blockConverter = new BlockConverter();
+    this.imageHandler = new ImageHandler(vaultFs, config.paths.attachments);
+    this.propertyMapper = new PropertyMapper();
+    this.blockConverter.initNotionToMd(this.notionClient.getInternalClient());
+  }
+  config;
+  stateDb;
+  notionClient;
+  vaultFs;
+  changeDetector;
+  pipeline;
+  blockConverter;
+  imageHandler;
+  propertyMapper;
+  dbSchemaLoaded = false;
+  async push(options) {
+    const startTime = Date.now();
+    const files = await this.vaultFs.listMarkdownFiles();
+    const changes = this.changeDetector.detectLocalChanges(files);
+    const conflictPaths = new Set(this.stateDb.getByStatus("conflict").map((r) => r.obsidianPath));
+    const nonConflict = changes.filter((c) => !conflictPaths.has(c.path));
+    const filtered = options?.paths ? nonConflict.filter((c) => options.paths.some((p) => c.path.startsWith(p))) : nonConflict;
+    if (filtered.length === 0) {
+      return { created: 0, updated: 0, deleted: 0, failed: [], duration: Date.now() - startTime };
+    }
+    if (options?.dryRun) {
+      return { created: 0, updated: 0, deleted: 0, failed: [], duration: Date.now() - startTime };
+    }
+    this.stateDb.setMeta("push_in_progress", "true");
+    const folderPaths = /* @__PURE__ */ new Set();
+    for (const change of filtered) {
+      const parts = change.path.split("/");
+      if (parts.length > 1) {
+        for (let i = 1; i < parts.length; i++) {
+          folderPaths.add(parts.slice(0, i).join("/"));
+        }
+      }
+    }
+    const sortedFolders = [...folderPaths].sort(
+      (a, b) => a.split("/").length - b.split("/").length
+    );
+    for (const folderPath of sortedFolders) {
+      await this.ensureFolderPage(folderPath);
+    }
+    const sema = new Sema(this.config.advanced.concurrency);
+    let created = 0;
+    let updated = 0;
+    let deleted = 0;
+    const failed = [];
+    let completed = 0;
+    const total = filtered.length;
+    const tasks = filtered.map((change) => async () => {
+      await sema.acquire();
+      try {
+        options?.onProgress?.(++completed, total, change.path);
+        switch (change.type) {
+          case "created":
+            await this.pushCreate(change.path);
+            created++;
+            break;
+          case "modified":
+          case "moved":
+            await this.pushUpdate(change.path);
+            updated++;
+            break;
+          case "deleted":
+            await this.pushDelete(change.path);
+            deleted++;
+            break;
+        }
+      } catch (error) {
+        failed.push({
+          path: change.path,
+          operation: change.type === "created" ? "create" : change.type === "deleted" ? "delete" : "update",
+          error: error instanceof Error ? error.message : String(error)
+        });
+      } finally {
+        sema.release();
+      }
+    });
+    await Promise.all(tasks.map((t) => t()));
+    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", "");
+    return { created, updated, deleted, failed, duration: Date.now() - startTime };
+  }
+  async pull(options) {
+    const startTime = Date.now();
+    let created = 0;
+    let updated = 0;
+    let deleted = 0;
+    const conflicts = [];
+    const writtenPaths = [];
+    const failed = [];
+    const remoteChanges = await this.detectRemoteChanges();
+    const filtered = options?.paths ? remoteChanges.filter((c) => {
+      const record = this.stateDb.getByNotionId(c.pageId);
+      return record && options.paths.some((p) => record.obsidianPath.startsWith(p));
+    }) : remoteChanges;
+    if (options?.dryRun || filtered.length === 0) {
+      return {
+        created: 0,
+        updated: 0,
+        deleted: 0,
+        conflicts: [],
+        writtenPaths: [],
+        failed: [],
+        duration: Date.now() - startTime
+      };
+    }
+    this.stateDb.setMeta("pull_in_progress", "true");
+    const sema = new Sema(this.config.advanced.concurrency);
+    let pullCompleted = 0;
+    const pullTotal = filtered.length;
+    const tasks = filtered.map((change) => async () => {
+      await sema.acquire();
+      try {
+        options?.onProgress?.(++pullCompleted, pullTotal, change.pageId);
+        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;
+          }
+        }
+      } catch (error) {
+        const record = this.stateDb.getByNotionId(change.pageId);
+        failed.push({
+          path: record?.obsidianPath ?? change.pageId,
+          operation: change.type === "created" ? "create" : change.type === "deleted" ? "delete" : "update",
+          error: error instanceof Error ? error.message : String(error)
+        });
+      } finally {
+        sema.release();
+      }
+    });
+    await Promise.all(tasks.map((t) => t()));
+    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", "");
+    return {
+      created,
+      updated,
+      deleted,
+      conflicts,
+      writtenPaths,
+      failed,
+      duration: Date.now() - startTime
+    };
+  }
+  async sync(options) {
+    const startTime = Date.now();
+    const pullResult = await this.pull(options);
+    const pushResult = await this.push({
+      ...options,
+      paths: options?.paths
+    });
+    return {
+      pull: pullResult,
+      push: pushResult,
+      conflicts: pullResult.conflicts,
+      duration: Date.now() - startTime
+    };
+  }
+  async status() {
+    const files = await this.vaultFs.listMarkdownFiles();
+    const localChanges = this.changeDetector.detectLocalChanges(files);
+    const remoteChanges = await this.detectRemoteChanges();
+    const conflictRecords = this.stateDb.getByStatus("conflict");
+    const lastSyncAt = this.stateDb.getMeta("last_sync_at");
+    const conflicts = await this.buildConflictsFromRecords(
+      conflictRecords,
+      localChanges,
+      remoteChanges
+    );
+    return {
+      localChanges,
+      remoteChanges,
+      conflicts,
+      conflictRecords,
+      pendingOperations: conflictRecords.length,
+      lastSyncAt
+    };
+  }
+  async buildConflictsFromRecords(records, localChanges, remoteChanges) {
+    const conflicts = [];
+    for (const record of records) {
+      const localChange = localChanges.find((c) => c.path === record.obsidianPath) ?? {
+        path: record.obsidianPath,
+        type: "modified",
+        currentHash: record.contentHash,
+        previousHash: record.contentHash
+      };
+      const remoteChange = remoteChanges.find((c) => c.pageId === record.notionPageId) ?? {
+        pageId: record.notionPageId ?? "",
+        type: "modified",
+        lastEdited: record.notionLastEdited ?? "",
+        previousEdited: null
+      };
+      let localContent = "";
+      try {
+        localContent = await this.vaultFs.readFile(record.obsidianPath);
+      } catch {
+      }
+      conflicts.push({
+        syncRecord: record,
+        localChange,
+        remoteChange,
+        baseContent: record.baseSnapshot?.toString("utf-8") ?? null,
+        localContent,
+        remoteContent: ""
+      });
+    }
+    return conflicts;
+  }
+  get isDatabaseMode() {
+    return this.config.notion.parentMode === "database" && !!this.config.notion.databaseId;
+  }
+  async ensureDbSchema() {
+    if (this.dbSchemaLoaded || !this.isDatabaseMode) return;
+    const schema = await this.notionClient.getDatabaseSchema(this.config.notion.databaseId);
+    this.propertyMapper.loadSchema(schema);
+    this.dbSchemaLoaded = true;
+  }
+  async pushCreate(path) {
+    const content = await this.vaultFs.readFile(path);
+    const title = extractTitle(path);
+    const parentId = await this.resolveNotionParent(path);
+    const selectedPath = this.pipeline.selectPath(content);
+    if (selectedPath === "block-api") {
+      getLogger().warn(
+        `[Im-Nobsidian] "${path}" contains block-api features (inline-db/column/toggle) \u2014 converted with reduced fidelity in v0.1.0`
+      );
+    }
+    const conversionResult = this.pipeline.convertToNotion(content, {
+      direction: "push",
+      path: selectedPath,
+      filePath: path,
+      parentMode: this.config.notion.parentMode
+    });
+    const blocks = this.blockConverter.markdownToNotionBlocks(conversionResult.content);
+    let effectiveParentId = parentId;
+    let effectiveParentType = "page";
+    let effectiveProperties = conversionResult.properties;
+    if (this.isDatabaseMode) {
+      await this.ensureDbSchema();
+      effectiveParentId = this.config.notion.databaseId;
+      effectiveParentType = "database";
+      effectiveProperties = this.propertyMapper.toNotionProperties(
+        conversionResult.properties,
+        title
+      );
+    }
+    const page = await this.notionClient.createPage({
+      parentId: effectiveParentId,
+      parentType: effectiveParentType,
+      title,
+      properties: effectiveProperties
+    });
+    if (blocks.length > 0) {
+      await this.notionClient.appendChildren(page.id, blocks);
+    }
+    const hash = computeHash(content);
+    this.stateDb.transaction(() => {
+      this.stateDb.upsert({
+        obsidianPath: path,
+        notionPageId: page.id,
+        notionParentId: parentId,
+        contentHash: hash,
+        notionLastEdited: page.last_edited_time,
+        localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
+        syncDirection: "both",
+        fileType: this.isFolderNote(path) ? "folder-note" : "file",
+        status: "synced",
+        baseSnapshot: Buffer.from(content, "utf-8")
+      });
+      this.stateDb.upsertWikilink({
+        obsidianPath: path,
+        notionPageId: page.id,
+        title,
+        aliases: []
+      });
+      this.stateDb.storePreserveMarkers(path, conversionResult.preserveMarkers);
+    });
+  }
+  async pushUpdate(path) {
+    const content = await this.vaultFs.readFile(path);
+    const record = this.stateDb.getByPath(path);
+    if (!record?.notionPageId) return;
+    const updatePath = this.pipeline.selectPath(content);
+    if (updatePath === "block-api") {
+      getLogger().warn(
+        `[Im-Nobsidian] "${path}" contains block-api features (inline-db/column/toggle) \u2014 converted with reduced fidelity in v0.1.0`
+      );
+    }
+    const conversionResult = this.pipeline.convertToNotion(content, {
+      direction: "push",
+      path: updatePath,
+      filePath: path,
+      parentMode: this.config.notion.parentMode
+    });
+    const blocks = this.blockConverter.markdownToNotionBlocks(conversionResult.content);
+    const existingBlocks = await this.notionClient.fetchAllChildren(record.notionPageId);
+    if (blocks.length > 0) {
+      await this.notionClient.appendChildren(record.notionPageId, blocks);
+    }
+    for (const block of existingBlocks) {
+      await this.notionClient.deleteBlock(block.id);
+    }
+    let propsToUpdate = conversionResult.properties;
+    if (this.isDatabaseMode && propsToUpdate && Object.keys(propsToUpdate).length > 0) {
+      await this.ensureDbSchema();
+      const title = extractTitle(path);
+      propsToUpdate = this.propertyMapper.toNotionProperties(propsToUpdate, title);
+    }
+    if (propsToUpdate && Object.keys(propsToUpdate).length > 0) {
+      await this.notionClient.updatePageProperties(record.notionPageId, propsToUpdate);
+    }
+    const hash = computeHash(content);
+    this.stateDb.transaction(() => {
+      this.stateDb.updateHash(record.id, hash, Buffer.from(content, "utf-8"));
+      this.stateDb.updateStatus(record.id, "synced");
+      this.stateDb.storePreserveMarkers(path, conversionResult.preserveMarkers);
+    });
+  }
+  async pushDelete(path) {
+    const record = this.stateDb.getByPath(path);
+    if (!record?.notionPageId) return;
+    if (this.config.sync.deleteSync) {
+      await this.notionClient.archivePage(record.notionPageId);
+    }
+    this.stateDb.delete(record.id);
+  }
+  async detectRemoteChanges() {
+    const changes = [];
+    const lastPull = this.stateDb.getMeta("last_pull_at");
+    const syncedRecords = this.stateDb.getAll();
+    const trackedPageIds = new Set(
+      syncedRecords.filter((r) => r.notionPageId).map((r) => r.notionPageId)
+    );
+    let remotePages;
+    if (this.isDatabaseMode) {
+      const allPages = [];
+      let cursor;
+      do {
+        const result = await this.notionClient.queryDatabase(this.config.notion.databaseId, {
+          startCursor: cursor
+        });
+        allPages.push(
+          ...result.results.map((p) => ({ id: p.id, last_edited_time: p.last_edited_time }))
+        );
+        cursor = result.nextCursor ?? void 0;
+      } while (cursor);
+      remotePages = allPages;
+    } else {
+      remotePages = await this.notionClient.getChildPagesRecursive(this.config.notion.rootPageId);
+    }
+    for (const page of remotePages) {
+      const record = this.stateDb.getByNotionId(page.id);
+      if (!record) {
+        changes.push({
+          pageId: page.id,
+          type: "created",
+          lastEdited: page.last_edited_time,
+          previousEdited: null
+        });
+      } else if (page.last_edited_time !== record.notionLastEdited) {
+        changes.push({
+          pageId: page.id,
+          type: "modified",
+          lastEdited: page.last_edited_time,
+          previousEdited: record.notionLastEdited
+        });
+      }
+      trackedPageIds.delete(page.id);
+    }
+    if (this.config.sync.deleteSync && lastPull) {
+      for (const orphanId of trackedPageIds) {
+        const record = syncedRecords.find((r) => r.notionPageId === orphanId);
+        if (record) {
+          changes.push({
+            pageId: orphanId,
+            type: "deleted",
+            lastEdited: (/* @__PURE__ */ new Date()).toISOString(),
+            previousEdited: record.notionLastEdited
+          });
+        }
+      }
+    }
+    return changes;
+  }
+  async pullCreate(pageId) {
+    const page = await this.notionClient.getPage(pageId);
+    const title = this.notionClient.extractTitle(page);
+    const safeName = sanitizeFileName(title);
+    const parentPath = await this.resolveParentPath(page);
+    const children = await this.notionClient.listChildren(pageId, { pageSize: 1 });
+    const hasChildPages = children.results.some((b) => "type" in b && b.type === "child_page");
+    const markdown = await this.blockConverter.notionBlocksToMarkdown(pageId);
+    const hasContent = markdown.trim().length > 0;
+    let filePath;
+    let fileType;
+    if (hasChildPages && hasContent) {
+      const folderPath = parentPath ? `${parentPath}/${safeName}` : safeName;
+      filePath = `${folderPath}/${safeName}.md`;
+      fileType = "folder-note";
+      await this.vaultFs.ensureFolder(folderPath);
+    } else if (hasChildPages && !hasContent) {
+      const folderPath = parentPath ? `${parentPath}/${safeName}` : safeName;
+      filePath = `${folderPath}/${safeName}.md`;
+      fileType = "folder-only";
+      await this.vaultFs.ensureFolder(folderPath);
+    } else {
+      filePath = parentPath ? `${parentPath}/${safeName}.md` : `${safeName}.md`;
+      fileType = "file";
+    }
+    let properties;
+    if (this.isDatabaseMode) {
+      await this.ensureDbSchema();
+      properties = this.propertyMapper.fromNotionProperties(
+        page.properties
+      );
+    } else {
+      properties = this.notionClient.extractProperties(page);
+    }
+    let processedMarkdown = markdown;
+    if (this.config.conversion.imageDownload === "immediate") {
+      const imageResult = await this.imageHandler.downloadAllImages(markdown, title);
+      processedMarkdown = imageResult.content;
+    }
+    const finalContent = this.pipeline.convertToMarkdown(
+      processedMarkdown,
+      {
+        direction: "pull",
+        path: "markdown-api",
+        filePath,
+        parentMode: this.config.notion.parentMode
+      },
+      { properties }
+    );
+    await this.vaultFs.writeFile(filePath, finalContent);
+    const hash = computeHash(finalContent);
+    this.stateDb.transaction(() => {
+      this.stateDb.upsert({
+        obsidianPath: filePath,
+        notionPageId: pageId,
+        notionParentId: this.extractParentId(page),
+        contentHash: hash,
+        notionLastEdited: page.last_edited_time,
+        localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
+        syncDirection: "both",
+        fileType,
+        status: "synced",
+        baseSnapshot: Buffer.from(finalContent, "utf-8")
+      });
+      this.stateDb.upsertWikilink({
+        obsidianPath: filePath,
+        notionPageId: pageId,
+        title,
+        aliases: []
+      });
+    });
+    return filePath;
+  }
+  async pullUpdate(change) {
+    const record = this.stateDb.getByNotionId(change.pageId);
+    if (!record) return {};
+    const page = await this.notionClient.getPage(change.pageId);
+    let markdown = await this.blockConverter.notionBlocksToMarkdown(change.pageId);
+    let properties;
+    if (this.isDatabaseMode) {
+      await this.ensureDbSchema();
+      properties = this.propertyMapper.fromNotionProperties(
+        page.properties
+      );
+    } else {
+      properties = this.notionClient.extractProperties(page);
+    }
+    if (this.config.conversion.imageDownload === "immediate") {
+      const title = this.notionClient.extractTitle(page);
+      const imageResult = await this.imageHandler.downloadAllImages(markdown, title);
+      markdown = imageResult.content;
+    }
+    const savedMarkers = this.stateDb.getPreserveMarkers(record.obsidianPath);
+    const remoteContent = this.pipeline.convertToMarkdown(
+      markdown,
+      {
+        direction: "pull",
+        path: "markdown-api",
+        filePath: record.obsidianPath,
+        parentMode: this.config.notion.parentMode
+      },
+      { properties, preserveMarkers: savedMarkers.length > 0 ? savedMarkers : void 0 }
+    );
+    let localContent;
+    try {
+      localContent = await this.vaultFs.readFile(record.obsidianPath);
+    } catch {
+      localContent = "";
+    }
+    const localHash = computeHash(localContent);
+    const localModified = localHash !== record.contentHash;
+    if (localModified) {
+      const conflict = {
+        syncRecord: record,
+        localChange: {
+          path: record.obsidianPath,
+          type: "modified",
+          currentHash: localHash,
+          previousHash: record.contentHash
+        },
+        remoteChange: change,
+        baseContent: record.baseSnapshot?.toString("utf-8") ?? null,
+        localContent,
+        remoteContent
+      };
+      this.stateDb.updateStatus(record.id, "conflict");
+      return { conflict };
+    }
+    await this.vaultFs.writeFile(record.obsidianPath, remoteContent);
+    const newHash = computeHash(remoteContent);
+    this.stateDb.upsert({
+      obsidianPath: record.obsidianPath,
+      notionPageId: change.pageId,
+      notionParentId: record.notionParentId,
+      contentHash: newHash,
+      notionLastEdited: page.last_edited_time,
+      localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
+      syncDirection: record.syncDirection,
+      fileType: record.fileType,
+      status: "synced",
+      baseSnapshot: Buffer.from(remoteContent, "utf-8")
+    });
+    return { path: record.obsidianPath };
+  }
+  async pullDelete(pageId) {
+    const record = this.stateDb.getByNotionId(pageId);
+    if (!record) return null;
+    if (this.config.sync.deleteSync) {
+      try {
+        await this.vaultFs.deleteFile(record.obsidianPath);
+      } catch {
+      }
+    }
+    this.stateDb.delete(record.id);
+    return record.obsidianPath;
+  }
+  async ensureFolderPage(folderPath) {
+    const existing = this.stateDb.getByPath(folderPath);
+    if (existing?.notionPageId) return;
+    const parts = folderPath.split("/");
+    const folderName = parts[parts.length - 1];
+    let parentId = this.config.notion.rootPageId;
+    if (parts.length > 1) {
+      const parentPath = parts.slice(0, -1).join("/");
+      const parentRecord = this.stateDb.getByPath(parentPath);
+      if (parentRecord?.notionPageId) {
+        parentId = parentRecord.notionPageId;
+      }
+    }
+    const folderPage = await this.notionClient.createPage({
+      parentId,
+      parentType: "page",
+      title: folderName
+    });
+    this.stateDb.upsert({
+      obsidianPath: folderPath,
+      notionPageId: folderPage.id,
+      notionParentId: parentId,
+      contentHash: "",
+      notionLastEdited: folderPage.last_edited_time,
+      localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
+      syncDirection: "both",
+      fileType: "folder-note",
+      status: "synced"
+    });
+  }
+  async resolveNotionParent(filePath) {
+    const parts = filePath.split("/");
+    if (parts.length <= 1) return this.config.notion.rootPageId;
+    const folderPath = parts.slice(0, -1).join("/");
+    const folderRecord = this.stateDb.getByPath(folderPath);
+    if (folderRecord?.notionPageId) return folderRecord.notionPageId;
+    return this.config.notion.rootPageId;
+  }
+  isFolderNote(filePath) {
+    const parts = filePath.split("/");
+    if (parts.length < 2) return false;
+    const fileName = parts[parts.length - 1].replace(/\.md$/, "");
+    const folderName = parts[parts.length - 2];
+    return fileName === folderName;
+  }
+  async resolveParentPath(page) {
+    const parentId = this.extractParentId(page);
+    if (!parentId || notionIdsEqual(parentId, this.config.notion.rootPageId)) return "";
+    const parentRecord = this.stateDb.getByNotionId(parentId);
+    if (parentRecord) {
+      if (parentRecord.fileType === "folder-note" || parentRecord.fileType === "folder-only") {
+        const pathParts2 = parentRecord.obsidianPath.split("/");
+        pathParts2.pop();
+        return pathParts2.join("/");
+      }
+      const pathParts = parentRecord.obsidianPath.split("/");
+      pathParts.pop();
+      const parentDir = pathParts.join("/");
+      return parentDir || sanitizeFileName(this.notionClient.extractTitle(await this.notionClient.getPage(parentId)));
+    }
+    try {
+      const parentPage = await this.notionClient.getPage(parentId);
+      const parentTitle = this.notionClient.extractTitle(parentPage);
+      return sanitizeFileName(parentTitle);
+    } catch {
+      return "";
+    }
+  }
+  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;
+    return null;
+  }
+};
+function extractTitle(filePath) {
+  const parts = filePath.split("/");
+  const filename = parts[parts.length - 1] ?? "";
+  return filename.replace(/\.md$/, "");
+}
+var NodeVaultFS = class {
+  constructor(rootPath, pathConfig) {
+    this.rootPath = rootPath;
+    this.includePatterns = pathConfig?.include ?? [];
+    const configExclude = pathConfig?.exclude ?? [];
+    const ignorePatterns = this.loadImNobsidianIgnore();
+    this.excludePatterns = [...configExclude, ...ignorePatterns];
+  }
+  rootPath;
+  includePatterns;
+  excludePatterns;
+  loadImNobsidianIgnore() {
+    try {
+      const ignorePath = join(this.rootPath, ".im-nobsidian-ignore");
+      const content = readFileSync(ignorePath, "utf-8");
+      return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+    } catch {
+      return [];
+    }
+  }
+  async readFile(path) {
+    const fullPath = join(this.rootPath, path);
+    return readFile(fullPath, "utf-8");
+  }
+  async writeFile(path, content) {
+    const fullPath = join(this.rootPath, path);
+    await mkdir(dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, content, "utf-8");
+  }
+  async writeBinary(path, data) {
+    const fullPath = join(this.rootPath, path);
+    await mkdir(dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, data);
+  }
+  async deleteFile(path) {
+    const fullPath = join(this.rootPath, path);
+    await unlink(fullPath);
+  }
+  async moveFile(from, to) {
+    const fromPath = join(this.rootPath, from);
+    const toPath = join(this.rootPath, to);
+    await mkdir(dirname(toPath), { recursive: true });
+    await rename(fromPath, toPath);
+  }
+  async exists(path) {
+    try {
+      await stat(join(this.rootPath, path));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async ensureFolder(path) {
+    await mkdir(join(this.rootPath, path), { recursive: true });
+  }
+  async listMarkdownFiles() {
+    const files = [];
+    await this.walkDir(this.rootPath, files);
+    return files;
+  }
+  matchesPattern(relativePath, pattern) {
+    if (pattern === "**/*" || pattern === "**") return true;
+    if (pattern.endsWith("/**")) {
+      const dir = pattern.slice(0, -3);
+      return relativePath.startsWith(dir + "/") || relativePath === dir;
+    } else if (pattern.startsWith("*.")) {
+      const ext = pattern.slice(1);
+      return relativePath.endsWith(ext);
+    } else if (pattern.includes("*")) {
+      const regexStr = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+      return new RegExp("^" + regexStr + "$").test(relativePath);
+    } else {
+      return relativePath === pattern || relativePath.startsWith(pattern + "/");
+    }
+  }
+  isExcluded(relativePath) {
+    if (this.includePatterns.length > 0) {
+      const included = this.includePatterns.some((p) => this.matchesPattern(relativePath, p));
+      if (!included) return true;
+    }
+    return this.excludePatterns.some((p) => this.matchesPattern(relativePath, p));
+  }
+  async walkDir(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.walkDir(fullPath, result);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const content = await readFile(fullPath, "utf-8");
+        const fileStat = await stat(fullPath);
+        result.push({
+          path: relativePath,
+          content,
+          mtime: fileStat.mtime.toISOString()
+        });
+      }
+    }
+  }
+};
+
+// src/converter/pre-processors/inline-db.ts
+var INLINE_DB_START = /%% im-nobsidian:inline-db:([^\s]+) %%/g;
+var INLINE_DB_END = /%% im-nobsidian:end %%/g;
+var InlineDBParser = class {
+  name = "InlineDBParser";
+  order = 40;
+  process(input) {
+    const inlineDbBlocks = [];
+    const content = input.content;
+    const startMatches = [...content.matchAll(INLINE_DB_START)];
+    for (const match of startMatches) {
+      const startIdx = match.index;
+      const params = parseParams(match[1]);
+      const afterStart = content.indexOf("\n", startIdx) + 1;
+      const endMatch = INLINE_DB_END.exec(content.slice(afterStart));
+      if (endMatch) {
+        const tableContent = content.slice(afterStart, afterStart + endMatch.index);
+        inlineDbBlocks.push({
+          id: params["id"] ?? "",
+          title: params["title"] ?? "",
+          tableMarkdown: tableContent.trim(),
+          startIdx,
+          endIdx: afterStart + endMatch.index + endMatch[0].length
+        });
+      }
+      INLINE_DB_END.lastIndex = 0;
+    }
+    return {
+      content,
+      metadata: {
+        ...input.metadata,
+        inlineDbBlocks
+      }
+    };
+  }
+};
+function parseParams(paramString) {
+  const params = {};
+  for (const pair of paramString.split("&")) {
+    const [key, value] = pair.split("=");
+    if (key && value) {
+      params[key] = decodeURIComponent(value);
+    }
+  }
+  return params;
+}
+
+// src/conflict/merger.ts
+function threeWayMerge(base, local, remote) {
+  const baseLines = base.split("\n");
+  const localLines = local.split("\n");
+  const remoteLines = remote.split("\n");
+  const localDiff = computeDiff(baseLines, localLines);
+  const remoteDiff = computeDiff(baseLines, remoteLines);
+  const merged = [];
+  const conflicts = [];
+  let success = true;
+  let baseIdx = 0;
+  while (baseIdx < baseLines.length || localDiff.length > 0 || remoteDiff.length > 0) {
+    const localChange = localDiff.find((d) => d.baseStart === baseIdx);
+    const remoteChange = remoteDiff.find((d) => d.baseStart === baseIdx);
+    if (localChange && remoteChange) {
+      if (arraysEqual(localChange.newLines, remoteChange.newLines)) {
+        merged.push(...localChange.newLines);
+      } else {
+        success = false;
+        conflicts.push({
+          localLines: localChange.newLines,
+          remoteLines: remoteChange.newLines
+        });
+        merged.push("<<<<<<< LOCAL");
+        merged.push(...localChange.newLines);
+        merged.push("=======");
+        merged.push(...remoteChange.newLines);
+        merged.push(">>>>>>> REMOTE");
+      }
+      baseIdx = Math.max(localChange.baseEnd, remoteChange.baseEnd);
+      localDiff.splice(localDiff.indexOf(localChange), 1);
+      remoteDiff.splice(remoteDiff.indexOf(remoteChange), 1);
+    } else if (localChange) {
+      merged.push(...localChange.newLines);
+      baseIdx = localChange.baseEnd;
+      localDiff.splice(localDiff.indexOf(localChange), 1);
+    } else if (remoteChange) {
+      merged.push(...remoteChange.newLines);
+      baseIdx = remoteChange.baseEnd;
+      remoteDiff.splice(remoteDiff.indexOf(remoteChange), 1);
+    } else {
+      if (baseIdx < baseLines.length) {
+        merged.push(baseLines[baseIdx]);
+      }
+      baseIdx++;
+    }
+  }
+  return {
+    success,
+    merged: merged.join("\n"),
+    conflicts
+  };
+}
+function computeDiff(base, modified) {
+  const hunks = [];
+  let baseIdx = 0;
+  let modIdx = 0;
+  while (baseIdx < base.length && modIdx < modified.length) {
+    if (base[baseIdx] === modified[modIdx]) {
+      baseIdx++;
+      modIdx++;
+    } else {
+      const hunkStart = baseIdx;
+      const newLines = [];
+      while (modIdx < modified.length && base[baseIdx] !== modified[modIdx]) {
+        newLines.push(modified[modIdx]);
+        modIdx++;
+      }
+      baseIdx++;
+      hunks.push({ baseStart: hunkStart, baseEnd: baseIdx, newLines });
+    }
+  }
+  if (modIdx < modified.length) {
+    hunks.push({
+      baseStart: baseIdx,
+      baseEnd: base.length,
+      newLines: modified.slice(modIdx)
+    });
+  }
+  return hunks;
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  return a.every((val, idx) => val === b[idx]);
+}
+
+// src/conflict/resolver.ts
+var ConflictResolver = class {
+  constructor(stateDb, vaultFs) {
+    this.stateDb = stateDb;
+    this.vaultFs = vaultFs;
+  }
+  stateDb;
+  vaultFs;
+  async resolve(conflict, choice) {
+    switch (choice) {
+      case "local":
+        return this.resolveLocal(conflict);
+      case "remote":
+        return this.resolveRemote(conflict);
+      case "merge":
+        return this.resolveMerge(conflict);
+      case "duplicate":
+        return this.resolveDuplicate(conflict);
+    }
+  }
+  async resolveByStrategy(conflict, strategy) {
+    switch (strategy) {
+      case "local-first":
+        return this.resolve(conflict, "local");
+      case "remote-first":
+        return this.resolve(conflict, "remote");
+      case "duplicate":
+        return this.resolve(conflict, "duplicate");
+      case "manual":
+        return this.resolve(conflict, "merge");
+    }
+  }
+  async resolveAll(conflicts, strategy) {
+    const results = [];
+    for (const conflict of conflicts) {
+      const result = await this.resolveByStrategy(conflict, strategy);
+      results.push(result);
+    }
+    return results;
+  }
+  async resolveLocal(conflict) {
+    const hash = computeHash(conflict.localContent);
+    this.stateDb.updateHash(
+      conflict.syncRecord.id,
+      hash,
+      Buffer.from(conflict.localContent, "utf-8")
+    );
+    this.stateDb.updateStatus(conflict.syncRecord.id, "synced");
+    return { path: conflict.syncRecord.obsidianPath, choice: "local", success: true };
+  }
+  async resolveRemote(conflict) {
+    await this.vaultFs.writeFile(conflict.syncRecord.obsidianPath, conflict.remoteContent);
+    const hash = computeHash(conflict.remoteContent);
+    this.stateDb.updateHash(
+      conflict.syncRecord.id,
+      hash,
+      Buffer.from(conflict.remoteContent, "utf-8")
+    );
+    this.stateDb.updateStatus(conflict.syncRecord.id, "synced");
+    return { path: conflict.syncRecord.obsidianPath, choice: "remote", success: true };
+  }
+  async resolveMerge(conflict) {
+    const base = conflict.baseContent ?? "";
+    const mergeResult = threeWayMerge(base, conflict.localContent, conflict.remoteContent);
+    await this.vaultFs.writeFile(conflict.syncRecord.obsidianPath, mergeResult.merged);
+    const hash = computeHash(mergeResult.merged);
+    this.stateDb.updateHash(conflict.syncRecord.id, hash, Buffer.from(mergeResult.merged, "utf-8"));
+    if (mergeResult.success) {
+      this.stateDb.updateStatus(conflict.syncRecord.id, "synced");
+    }
+    return {
+      path: conflict.syncRecord.obsidianPath,
+      choice: "merge",
+      success: mergeResult.success,
+      mergeHadConflicts: !mergeResult.success
+    };
+  }
+  async resolveDuplicate(conflict) {
+    const originalPath = conflict.syncRecord.obsidianPath;
+    const ext = originalPath.endsWith(".md") ? ".md" : "";
+    const baseName = originalPath.replace(/\.md$/, "");
+    const conflictPath = `${baseName}.conflict${ext}`;
+    await this.vaultFs.writeFile(conflictPath, conflict.remoteContent);
+    const localHash = computeHash(conflict.localContent);
+    this.stateDb.updateHash(
+      conflict.syncRecord.id,
+      localHash,
+      Buffer.from(conflict.localContent, "utf-8")
+    );
+    this.stateDb.updateStatus(conflict.syncRecord.id, "synced");
+    return { path: originalPath, choice: "duplicate", success: true };
+  }
+  generateDiff(conflict) {
+    const localLines = conflict.localContent.split("\n");
+    const remoteLines = conflict.remoteContent.split("\n");
+    const lines = [];
+    lines.push(`--- local: ${conflict.syncRecord.obsidianPath}`);
+    lines.push(`+++ remote: Notion (${conflict.remoteChange.pageId})`);
+    lines.push("");
+    const maxLen = Math.max(localLines.length, remoteLines.length);
+    for (let i = 0; i < maxLen; i++) {
+      const localLine = localLines[i];
+      const remoteLine = remoteLines[i];
+      if (localLine === remoteLine) {
+        lines.push(`  ${localLine ?? ""}`);
+      } else {
+        if (localLine !== void 0) lines.push(`- ${localLine}`);
+        if (remoteLine !== void 0) lines.push(`+ ${remoteLine}`);
+      }
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/structure/tree-mapper.ts
+var TreeMapper = class {
+  mapNotionToObsidian(root, basePath = "") {
+    const results = [];
+    this.mapRecursive(root, basePath, results);
+    return results;
+  }
+  mapRecursive(node, parentPath, results) {
+    const safeName = sanitizeFileName(node.title || "_untitled");
+    const currentPath = parentPath ? `${parentPath}/${safeName}` : safeName;
+    if (node.isDatabase) {
+      results.push({
+        type: "database-folder",
+        obsidianPath: `${currentPath}/`,
+        folderPath: `${currentPath}/`,
+        schemaPath: `${currentPath}/_schema.yml`
+      });
+    } else if (node.hasContent && node.hasChildren) {
+      results.push({
+        type: "folder-note",
+        obsidianPath: `${currentPath}/${safeName}.md`,
+        folderPath: `${currentPath}/`,
+        notePath: `${currentPath}/${safeName}.md`
+      });
+    } else if (!node.hasContent && node.hasChildren) {
+      results.push({
+        type: "folder-only",
+        obsidianPath: `${currentPath}/`,
+        folderPath: `${currentPath}/`
+      });
+    } else {
+      results.push({
+        type: "file",
+        obsidianPath: `${currentPath}.md`
+      });
+    }
+    for (const child of node.children) {
+      this.mapRecursive(child, currentPath, results);
+    }
+  }
+  mapObsidianToNotion(entries, parentPageId) {
+    const plans = [];
+    this.planRecursive(entries, parentPageId, plans);
+    return plans;
+  }
+  planRecursive(entries, parentPageId, plans) {
+    for (const entry of entries) {
+      if (entry.isDirectory) {
+        const folderNote = this.findFolderNote(entry);
+        if (folderNote) {
+          plans.push({
+            type: "page-with-children",
+            title: entry.name,
+            parentPageId,
+            contentSource: folderNote.path,
+            hasContent: true
+          });
+          const childEntries = entry.children.filter((c) => c.path !== folderNote.path);
+          this.planRecursive(childEntries, `placeholder:${entry.path}`, plans);
+        } else {
+          plans.push({
+            type: "empty-page-with-children",
+            title: entry.name,
+            parentPageId,
+            hasContent: false
+          });
+          this.planRecursive(entry.children, `placeholder:${entry.path}`, plans);
+        }
+      } else if (entry.name.endsWith(".md") && !entry.name.startsWith("_")) {
+        plans.push({
+          type: "leaf-page",
+          title: entry.name.replace(/\.md$/, ""),
+          parentPageId,
+          contentSource: entry.path,
+          hasContent: true
+        });
+      }
+    }
+  }
+  findFolderNote(dir) {
+    return dir.children.find((c) => c.name === `${dir.name}.md` || c.name === "index.md") ?? null;
+  }
+  determineFileType(page) {
+    if (page.isDatabase) return "database-folder";
+    if (page.hasContent && page.hasChildren) return "folder-note";
+    if (!page.hasContent && page.hasChildren) return "folder-only";
+    return "file";
+  }
+};
+var FileWatcher = class {
+  constructor(rootPath, callback) {
+    this.rootPath = rootPath;
+    this.callback = callback;
+  }
+  rootPath;
+  callback;
+  watcher = null;
+  start() {
+    this.watcher = watch(this.rootPath, {
+      ignored: [/(^|[/\\])\./, "**/node_modules/**", "**/.im-nobsidian/**"],
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 500,
+        pollInterval: 100
+      }
+    });
+    this.watcher.on("add", (path) => this.callback("add", path));
+    this.watcher.on("change", (path) => this.callback("change", path));
+    this.watcher.on("unlink", (path) => this.callback("unlink", path));
+  }
+  async stop() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+  }
+};
+
+// src/watcher/watch-sync-service.ts
+var DEFAULT_DEBOUNCE_MS = 2e3;
+var WatchSyncService = class {
+  constructor(rootPath, orchestrator, options = {}) {
+    this.rootPath = rootPath;
+    this.orchestrator = orchestrator;
+    this.debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+    this.options = options;
+  }
+  rootPath;
+  orchestrator;
+  debounceMs;
+  options;
+  watcher = null;
+  debounceTimer = null;
+  pendingChanges = /* @__PURE__ */ new Map();
+  syncing = false;
+  syncQueued = false;
+  running = false;
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.watcher = new FileWatcher(this.rootPath, (event, path) => {
+      this.handleFileChange(event, path);
+    });
+    this.watcher.start();
+  }
+  async stop() {
+    if (!this.running) return;
+    this.running = false;
+    this.clearDebounce();
+    this.pendingChanges.clear();
+    if (this.watcher) {
+      await this.watcher.stop();
+      this.watcher = null;
+    }
+  }
+  isRunning() {
+    return this.running;
+  }
+  isSyncing() {
+    return this.syncing;
+  }
+  getPendingCount() {
+    return this.pendingChanges.size;
+  }
+  handleFileChange(event, path) {
+    if (!path.endsWith(".md")) return;
+    this.pendingChanges.set(path, event);
+    this.options.onFileChange?.(event, path);
+    this.scheduleSync();
+  }
+  scheduleSync() {
+    this.clearDebounce();
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = null;
+      void this.executeSync();
+    }, this.debounceMs);
+  }
+  clearDebounce() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+  }
+  async executeSync() {
+    if (this.syncing) {
+      this.syncQueued = true;
+      return;
+    }
+    this.syncing = true;
+    const changedPaths = [...this.pendingChanges.keys()];
+    this.pendingChanges.clear();
+    try {
+      this.options.onSyncStart?.();
+      const result = await this.orchestrator.sync({
+        paths: changedPaths.length > 0 ? changedPaths : void 0
+      });
+      this.options.onSyncComplete?.(result);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.options.onSyncError?.(err);
+    } finally {
+      this.syncing = false;
+      if (this.syncQueued) {
+        this.syncQueued = false;
+        void this.executeSync();
+      }
+    }
+  }
+};
+
+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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map