vaultmd 0.1.0

package/dist/index.js

@@ -0,0 +1,1787 @@
+// src/errors.ts
+var MdVaultError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, { cause: options?.cause });
+    this.code = code;
+    this.name = "MdVaultError";
+  }
+};
+
+// src/frontmatter/edit.ts
+import { Document, parseDocument } from "yaml";
+
+// src/frontmatter/parse.ts
+import { parse } from "yaml";
+
+// src/frontmatter/tags.ts
+function toTagTokens(value) {
+  if (value === null || value === void 0) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap(toTagTokens);
+  }
+  if (typeof value === "string") {
+    return value.split(/[\s,]+/).map((t) => t.trim()).filter(Boolean);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return [String(value)];
+  }
+  return [];
+}
+function deriveTags(frontmatter) {
+  const source = frontmatter.tags !== void 0 ? frontmatter.tags : frontmatter.tag;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const token of toTagTokens(source)) {
+    const stripped = token.replace(/^#+/, "");
+    if (stripped && !seen.has(stripped)) {
+      seen.add(stripped);
+      out.push(stripped);
+    }
+  }
+  return out;
+}
+
+// src/frontmatter/validate.ts
+function isScalar(value) {
+  return value === null || value instanceof Date || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isScalarOrArrayOfScalar(value) {
+  if (Array.isArray(value)) {
+    return value.every(isScalar);
+  }
+  return isScalar(value);
+}
+function isFlatFrontmatter(fm) {
+  for (const value of Object.values(fm)) {
+    if (!isScalarOrArrayOfScalar(value)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/frontmatter/parse.ts
+function extractBlock(content) {
+  const firstNl = content.indexOf("\n");
+  if (firstNl === -1) {
+    return null;
+  }
+  if (content.slice(0, firstNl).replace(/\r$/, "") !== "---") {
+    return null;
+  }
+  const lines = content.slice(firstNl + 1).split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].replace(/\r$/, "") === "---") {
+      const yaml = lines.slice(0, i).join("\n");
+      const body = lines.slice(i + 1).join("\n");
+      return { yaml, body };
+    }
+  }
+  return null;
+}
+function parseFrontmatter(content) {
+  const block = extractBlock(content);
+  if (!block) {
+    return { frontmatter: {}, tags: [], body: content, valid: "none" };
+  }
+  const { yaml: yamlText, body } = block;
+  let parsed;
+  try {
+    parsed = parse(yamlText, { uniqueKeys: false });
+  } catch {
+    return { frontmatter: {}, tags: [], body, valid: "present-but-invalid" };
+  }
+  if (parsed === null || parsed === void 0) {
+    return { frontmatter: {}, tags: [], body, valid: "flat" };
+  }
+  if (typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { frontmatter: {}, tags: [], body, valid: "present-but-invalid" };
+  }
+  const frontmatter = parsed;
+  const valid = isFlatFrontmatter(frontmatter) ? "flat" : "present-but-invalid";
+  return { frontmatter, tags: deriveTags(frontmatter), body, valid };
+}
+
+// src/frontmatter/edit.ts
+function editFrontmatter(content, mutate) {
+  const parsed = parseFrontmatter(content);
+  if (parsed.valid === "present-but-invalid") {
+    return { content, outcome: "unverifiable" };
+  }
+  if (parsed.valid === "none") {
+    const view2 = {};
+    mutate(view2);
+    if (!isFlatFrontmatter(view2)) {
+      return { content, outcome: "unverifiable" };
+    }
+    if (Object.keys(view2).length === 0) {
+      return { content, outcome: "unchanged" };
+    }
+    const block2 = String(new Document(view2)).replace(/\n$/, "");
+    return { content: `---
+${block2}
+---
+${content}`, outcome: "edited" };
+  }
+  const ext = extractBlock(content);
+  if (!ext) {
+    return { content, outcome: "unverifiable" };
+  }
+  const doc = parseDocument(ext.yaml, { uniqueKeys: false });
+  const before = doc.toJS() ?? {};
+  const view = structuredClone(before);
+  mutate(view);
+  if (!isFlatFrontmatter(view)) {
+    return { content, outcome: "unverifiable" };
+  }
+  let changed = false;
+  for (const key of Object.keys(before)) {
+    if (!(key in view)) {
+      doc.delete(key);
+      changed = true;
+    }
+  }
+  for (const key of Object.keys(view)) {
+    if (!(key in before) || JSON.stringify(before[key]) !== JSON.stringify(view[key])) {
+      doc.set(key, view[key]);
+      changed = true;
+    }
+  }
+  if (!changed) {
+    return { content, outcome: "unchanged" };
+  }
+  const serialized = String(doc);
+  const block = serialized.endsWith("\n") ? serialized.slice(0, -1) : serialized;
+  return { content: `---
+${block}
+---
+${ext.body}`, outcome: "edited" };
+}
+
+// src/links/extract.ts
+function stripFencedCode(content) {
+  const lines = content.split("\n");
+  const out = [];
+  let inFence = false;
+  for (const line of lines) {
+    if (/^[ \t]*(```|~~~)/.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (!inFence) {
+      out.push(line);
+    }
+  }
+  return out.join("\n");
+}
+function mdLinkUrl(raw) {
+  const t = raw.trim();
+  if (t.startsWith("<")) {
+    const end = t.indexOf(">");
+    return (end >= 0 ? t.slice(1, end) : t.slice(1)).trim();
+  }
+  return t.split(/\s+/)[0];
+}
+function extractLinks(content) {
+  const src = stripFencedCode(content);
+  const wikilinks = [];
+  const embeds = [];
+  const mdLinks = [];
+  for (const m of src.matchAll(/(!?)\[\[([^\]\n]+)\]\]/g)) {
+    const raw = m[2].trim();
+    if (!raw) {
+      continue;
+    }
+    if (m[1] === "!") {
+      embeds.push(raw);
+    } else {
+      wikilinks.push(raw);
+    }
+  }
+  for (const m of src.matchAll(/(?<!!)\[[^\]]*\]\(([^)]+)\)/g)) {
+    const url = mdLinkUrl(m[1]);
+    if (!url) {
+      continue;
+    }
+    mdLinks.push(url);
+  }
+  return { wikilinks, embeds, mdLinks };
+}
+
+// src/links/resolve.ts
+import { posix } from "path";
+function normalizeWikiTarget(raw) {
+  let t = raw;
+  const pipe = t.indexOf("|");
+  if (pipe >= 0) {
+    t = t.slice(0, pipe);
+  }
+  const hash = t.indexOf("#");
+  if (hash >= 0) {
+    t = t.slice(0, hash);
+  }
+  t = t.trim().replace(/\\/g, "/").normalize("NFC");
+  if (t.startsWith("./")) {
+    t = t.slice(2);
+  }
+  t = t.replace(/\.md$/i, "");
+  return t;
+}
+function resolveRelativeTarget(raw, srcDir) {
+  let t = raw.trim();
+  if (!t) {
+    return null;
+  }
+  if (/^[a-z][a-z0-9+.-]*:/i.test(t)) {
+    return null;
+  }
+  if (t.startsWith("#")) {
+    return null;
+  }
+  t = t.split("#")[0];
+  if (!t) {
+    return null;
+  }
+  if (t.startsWith("/")) {
+    return null;
+  }
+  let resolved = posix.normalize(posix.join(srcDir, t)).normalize("NFC");
+  if (resolved.startsWith("../") || resolved === "..") {
+    return null;
+  }
+  if (resolved.startsWith("./")) {
+    resolved = resolved.slice(2);
+  }
+  if (!resolved) {
+    return null;
+  }
+  if (!/\.md$/i.test(resolved)) {
+    return null;
+  }
+  return resolved;
+}
+function storedLinksFor(content, srcRel, mode) {
+  const links = extractLinks(content);
+  const out = [];
+  if (mode === "wikilink") {
+    const push = (raw, kind) => {
+      const target = normalizeWikiTarget(raw);
+      if (!target) {
+        return;
+      }
+      const base = (target.split("/").pop() ?? target).toLowerCase();
+      out.push({ target, base, kind });
+    };
+    for (const w of links.wikilinks) {
+      push(w, "wikilink");
+    }
+    for (const e of links.embeds) {
+      push(e, "embed");
+    }
+    return out;
+  }
+  const srcDir = posix.dirname(
+    srcRel.trim().replace(/\\/g, "/").normalize("NFC")
+  );
+  for (const raw of links.mdLinks) {
+    const target = resolveRelativeTarget(raw, srcDir);
+    if (!target) {
+      continue;
+    }
+    out.push({ target, base: null, kind: "mdlink" });
+  }
+  return out;
+}
+
+// src/fs-atomic/atomic-write.ts
+import { randomBytes } from "crypto";
+import { link, mkdir, rename, stat as stat2, unlink, writeFile } from "fs/promises";
+import * as path from "path";
+
+// src/fs-atomic/sig.ts
+import { stat } from "fs/promises";
+function makeSig(st) {
+  return { mtimeMs: Math.trunc(st.mtimeMs), size: st.size };
+}
+function sigsEqual(a, b) {
+  return a.mtimeMs === b.mtimeMs && a.size === b.size;
+}
+async function statSig(fullPath) {
+  try {
+    return makeSig(await stat(fullPath));
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return null;
+    }
+    throw err;
+  }
+}
+
+// src/fs-atomic/atomic-write.ts
+function tempPath(fullPath) {
+  const dir = path.dirname(fullPath);
+  const base = path.basename(fullPath);
+  return path.join(
+    dir,
+    `.${base}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`
+  );
+}
+async function atomicWrite(fullPath, content) {
+  await mkdir(path.dirname(fullPath), { recursive: true });
+  const tmp = tempPath(fullPath);
+  await writeFile(tmp, content, "utf8");
+  try {
+    await rename(tmp, fullPath);
+  } catch (err) {
+    await unlink(tmp).catch(() => {
+    });
+    throw err;
+  }
+  return makeSig(await stat2(fullPath));
+}
+async function atomicWriteIfUnchanged(fullPath, content, expected) {
+  const tmp = tempPath(fullPath);
+  await writeFile(tmp, content, "utf8");
+  try {
+    const current = await statSig(fullPath);
+    if (!current || !sigsEqual(current, expected)) {
+      throw new MdVaultError(
+        "MTIME_CONFLICT",
+        `file changed under write: ${fullPath}`
+      );
+    }
+    await rename(tmp, fullPath);
+  } catch (err) {
+    await unlink(tmp).catch(() => {
+    });
+    throw err;
+  }
+  return makeSig(await stat2(fullPath));
+}
+async function exclusiveCreate(fullPath, content) {
+  await mkdir(path.dirname(fullPath), { recursive: true });
+  const tmp = tempPath(fullPath);
+  await writeFile(tmp, content, "utf8");
+  try {
+    await link(tmp, fullPath);
+  } catch (err) {
+    await unlink(tmp).catch(() => {
+    });
+    if (err.code === "EEXIST") {
+      throw new MdVaultError("ALREADY_EXISTS", `already exists: ${fullPath}`, {
+        cause: err
+      });
+    }
+    throw err;
+  }
+  await unlink(tmp).catch(() => {
+  });
+  return makeSig(await stat2(fullPath));
+}
+async function unlinkIfUnchanged(fullPath, expected) {
+  const current = await statSig(fullPath);
+  if (!current) {
+    return false;
+  }
+  if (!sigsEqual(current, expected)) {
+    throw new MdVaultError(
+      "MTIME_CONFLICT",
+      `file changed before delete: ${fullPath}`
+    );
+  }
+  await unlink(fullPath);
+  return true;
+}
+
+// src/fs-atomic/read-consistent.ts
+import { readFile } from "fs/promises";
+async function readConsistent(fullPath) {
+  for (; ; ) {
+    const sig1 = await statSig(fullPath);
+    if (sig1 === null) {
+      return { content: null, sig: null };
+    }
+    let content;
+    try {
+      content = await readFile(fullPath, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        continue;
+      }
+      throw err;
+    }
+    const sig2 = await statSig(fullPath);
+    if (sig2 !== null && sigsEqual(sig1, sig2)) {
+      return { content, sig: sig2 };
+    }
+  }
+}
+
+// src/locks/cross-process.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir2, readFile as readFile2, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
+import { hostname } from "os";
+import * as path2 from "path";
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function tryReclaim(lockfile, payload) {
+  let holder;
+  try {
+    holder = JSON.parse(await readFile2(lockfile, "utf8"));
+  } catch {
+    return false;
+  }
+  if (holder.host !== hostname() || typeof holder.pid !== "number") {
+    return false;
+  }
+  try {
+    process.kill(holder.pid, 0);
+    return false;
+  } catch (err) {
+    if (err.code !== "ESRCH") {
+      return false;
+    }
+  }
+  await unlink2(lockfile).catch(() => {
+  });
+  try {
+    await writeFile2(lockfile, payload, { flag: "wx" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function withCrossProcessLock(lockDir, key, busyTimeoutMs, fn) {
+  await mkdir2(lockDir, { recursive: true });
+  const lockfile = path2.join(
+    lockDir,
+    `${createHash("sha256").update(key).digest("hex")}.lock`
+  );
+  const payload = JSON.stringify({
+    pid: process.pid,
+    host: hostname(),
+    createdAt: Date.now()
+  });
+  const deadline = Date.now() + busyTimeoutMs;
+  for (; ; ) {
+    try {
+      await writeFile2(lockfile, payload, { flag: "wx" });
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST") {
+        throw err;
+      }
+      if (await tryReclaim(lockfile, payload)) {
+        break;
+      }
+      if (Date.now() >= deadline) {
+        throw new MdVaultError(
+          "MTIME_CONFLICT",
+          `cross-process lock busy: ${lockfile}`
+        );
+      }
+      await delay(50);
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    await unlink2(lockfile).catch(() => {
+    });
+  }
+}
+
+// src/locks/in-process.ts
+var fileLocks = /* @__PURE__ */ new Map();
+async function withFileLock(key, fn) {
+  const prev = fileLocks.get(key) ?? Promise.resolve();
+  let release;
+  const gate = new Promise((resolve) => {
+    release = resolve;
+  });
+  const mine = prev.then(() => gate);
+  fileLocks.set(key, mine);
+  await prev;
+  try {
+    return await fn();
+  } finally {
+    release();
+    if (fileLocks.get(key) === mine) {
+      fileLocks.delete(key);
+    }
+  }
+}
+
+// src/locked-file/commit.ts
+async function emitCommit(onCommit, event) {
+  if (!onCommit) {
+    return;
+  }
+  try {
+    await onCommit(event);
+  } catch (cause) {
+    throw new MdVaultError(
+      "COMMIT_FAILED",
+      `onCommit failed for ${event.path}`,
+      { cause }
+    );
+  }
+}
+
+// src/locked-file/delete.ts
+function withFileDelete(fullPath, lockKey, relForCommit, opts = {}) {
+  const { onCommit, cross = false } = opts;
+  const run = async () => {
+    const sig = await statSig(fullPath);
+    if (sig === null) {
+      return { deleted: false };
+    }
+    const removed = await unlinkIfUnchanged(fullPath, sig);
+    if (!removed) {
+      return { deleted: false };
+    }
+    await emitCommit(onCommit, { op: "delete", path: relForCommit });
+    return { deleted: true };
+  };
+  const locked = () => withFileLock(lockKey, run);
+  if (cross) {
+    return withCrossProcessLock(
+      cross.lockDir,
+      lockKey,
+      cross.busyTimeoutMs,
+      locked
+    );
+  }
+  return locked();
+}
+
+// src/locked-file/transform.ts
+function withFileTransform(fullPath, lockKey, relForCommit, transform, opts = {}) {
+  const { allowCreate = false, onCommit, maxRetries = 3, cross = false } = opts;
+  const run = async () => {
+    let attempt = 0;
+    for (; ; ) {
+      const read = await readConsistent(fullPath);
+      const next = transform(read.content);
+      if (next === null) {
+        return { content: read.content, outcome: "unchanged" };
+      }
+      if (read.content === null) {
+        if (!allowCreate) {
+          throw new MdVaultError(
+            "REFUSE_CREATE",
+            `refusing to create missing file: ${relForCommit}`
+          );
+        }
+        await atomicWrite(fullPath, next);
+        await emitCommit(onCommit, {
+          op: "create",
+          path: relForCommit,
+          content: next
+        });
+        return { content: next, outcome: "created" };
+      }
+      try {
+        await atomicWriteIfUnchanged(fullPath, next, read.sig);
+      } catch (err) {
+        if (err instanceof MdVaultError && err.code === "MTIME_CONFLICT" && attempt < maxRetries) {
+          await Bun.sleep(50 * (attempt + 1));
+          attempt++;
+          continue;
+        }
+        throw err;
+      }
+      await emitCommit(onCommit, {
+        op: "update",
+        path: relForCommit,
+        content: next
+      });
+      return { content: next, outcome: "updated" };
+    }
+  };
+  const locked = () => withFileLock(lockKey, run);
+  if (cross) {
+    return withCrossProcessLock(
+      cross.lockDir,
+      lockKey,
+      cross.busyTimeoutMs,
+      locked
+    );
+  }
+  return locked();
+}
+
+// src/vault/create-vault.ts
+import { dirname as dirname3 } from "path";
+
+// src/note-index/project.ts
+import { basename as basename2 } from "path";
+function deriveTitle(frontmatter, body, rel) {
+  const fmTitle = frontmatter.title;
+  if (typeof fmTitle === "string" && fmTitle.trim() !== "") {
+    return fmTitle;
+  }
+  for (const line of body.split("\n")) {
+    const match = /^#\s+(.+?)\s*$/.exec(line);
+    if (match) {
+      return match[1];
+    }
+  }
+  return basename2(rel).replace(/\.md$/i, "");
+}
+function projectRow(content, rel, vaultIo, cfg) {
+  const path3 = vaultIo.toVaultRelative(rel);
+  const pathKey = vaultIo.toKey(rel);
+  const parsed = parseFrontmatter(content);
+  const tags = deriveTags(parsed.frontmatter);
+  const title = deriveTitle(parsed.frontmatter, parsed.body, path3);
+  const links = storedLinksFor(content, path3, cfg.linkResolution);
+  const frontmatterJson = JSON.stringify(parsed.frontmatter);
+  return { path: path3, pathKey, title, frontmatterJson, tags, links };
+}
+
+// src/note-index/index-note.ts
+function indexNote(db, vaultIo, cfg, rel, content, sig) {
+  const row = projectRow(content, rel, vaultIo, cfg);
+  const body = parseFrontmatter(content).body;
+  const tx = db.transaction(() => {
+    const existing = db.query("SELECT id FROM notes WHERE path_key = ?").get(row.pathKey);
+    let id;
+    if (existing) {
+      id = existing.id;
+      db.query(
+        "UPDATE notes SET path = ?, mtime_ms = ?, size = ?, title = ?, frontmatter = ? WHERE id = ?"
+      ).run(
+        row.path,
+        sig.mtimeMs,
+        sig.size,
+        row.title,
+        row.frontmatterJson,
+        id
+      );
+      db.query("DELETE FROM notes_fts WHERE rowid = ?").run(id);
+    } else {
+      const res = db.query(
+        "INSERT INTO notes(path, path_key, mtime_ms, size, title, frontmatter) VALUES (?, ?, ?, ?, ?, ?)"
+      ).run(
+        row.path,
+        row.pathKey,
+        sig.mtimeMs,
+        sig.size,
+        row.title,
+        row.frontmatterJson
+      );
+      id = Number(res.lastInsertRowid);
+    }
+    db.query("INSERT INTO notes_fts(rowid, body) VALUES (?, ?)").run(id, body);
+    db.query("DELETE FROM note_tags WHERE path_key = ?").run(row.pathKey);
+    const insertTag = db.query(
+      "INSERT OR IGNORE INTO note_tags(path_key, tag) VALUES (?, ?)"
+    );
+    for (const tag of row.tags) {
+      insertTag.run(row.pathKey, tag);
+    }
+    db.query("DELETE FROM note_links WHERE src_key = ?").run(row.pathKey);
+    const insertLink = db.query(
+      "INSERT OR IGNORE INTO note_links(src_key, target, base, kind) VALUES (?, ?, ?, ?)"
+    );
+    for (const link2 of row.links) {
+      insertLink.run(row.pathKey, link2.target, link2.base, link2.kind);
+    }
+  });
+  tx();
+}
+function dropNote(db, pathKey) {
+  const tx = db.transaction(() => {
+    const existing = db.query("SELECT id FROM notes WHERE path_key = ?").get(pathKey);
+    if (existing) {
+      db.query("DELETE FROM notes_fts WHERE rowid = ?").run(existing.id);
+    }
+    db.query("DELETE FROM notes WHERE path_key = ?").run(pathKey);
+    db.query("DELETE FROM note_tags WHERE path_key = ?").run(pathKey);
+    db.query("DELETE FROM note_links WHERE src_key = ?").run(pathKey);
+  });
+  tx();
+}
+
+// src/note-index/open.ts
+import { Database } from "bun:sqlite";
+import { createHash as createHash2 } from "crypto";
+
+// src/note-index/schema.ts
+var SCHEMA_VERSION = 1;
+function applySchema(db) {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS notes (
+      id          INTEGER PRIMARY KEY,
+      path        TEXT NOT NULL,
+      path_key    TEXT NOT NULL UNIQUE,
+      mtime_ms    INTEGER NOT NULL,
+      size        INTEGER NOT NULL,
+      title       TEXT NOT NULL,
+      frontmatter TEXT NOT NULL
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS note_tags (
+      path_key TEXT NOT NULL,
+      tag      TEXT NOT NULL,
+      PRIMARY KEY (path_key, tag)
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS note_links (
+      src_key TEXT NOT NULL,
+      target  TEXT NOT NULL,
+      base    TEXT,
+      kind    TEXT NOT NULL,
+      PRIMARY KEY (src_key, target, kind)
+    )
+  `);
+  db.run("CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(body)");
+  db.run("CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)");
+  db.run("CREATE INDEX IF NOT EXISTS idx_note_tags_tag ON note_tags(tag)");
+  db.run(
+    "CREATE INDEX IF NOT EXISTS idx_note_links_target ON note_links(target)"
+  );
+  db.run("CREATE INDEX IF NOT EXISTS idx_note_links_base ON note_links(base)");
+}
+
+// src/note-index/open.ts
+function openIndexDb(indexPath, opts) {
+  const db = new Database(indexPath);
+  db.run("PRAGMA journal_mode = WAL");
+  db.run(`PRAGMA busy_timeout = ${Math.trunc(opts.sqliteBusyTimeoutMs)}`);
+  return db;
+}
+function probeCapabilities(db) {
+  try {
+    db.run("DROP TABLE IF EXISTS temp.__probe");
+    db.run("CREATE VIRTUAL TABLE temp.__probe USING fts5(x)");
+  } catch (cause) {
+    throw new MdVaultError(
+      "INDEX_UNAVAILABLE",
+      "SQLite FTS5 extension is unavailable in this Bun build",
+      { cause }
+    );
+  }
+  try {
+    db.query("SELECT json_extract(?, ?) AS v").get("{}", "$.x");
+  } catch (cause) {
+    throw new MdVaultError(
+      "INDEX_UNAVAILABLE",
+      "SQLite JSON1 extension is unavailable in this Bun build",
+      { cause }
+    );
+  }
+}
+function configFingerprint(cfg) {
+  const canonical = JSON.stringify({
+    linkResolution: cfg.linkResolution,
+    caseSensitive: cfg.caseSensitive,
+    ignore: [...cfg.ignore].sort(),
+    schema: SCHEMA_VERSION
+  });
+  return createHash2("sha256").update(canonical).digest("hex");
+}
+function readMeta(db, key) {
+  const row = db.query("SELECT value FROM meta WHERE key = ?").get(key);
+  return row ? row.value : null;
+}
+function writeMeta(db, key, value) {
+  db.query(
+    "INSERT INTO meta(key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+  ).run(key, value);
+}
+
+// src/note-index/reconcile.ts
+function createReconciler(db, vaultIo, cfg) {
+  function storedSigs() {
+    const rows = db.query("SELECT path_key, path, mtime_ms, size FROM notes").all();
+    const stored = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      if (!vaultIo.can(row.path, "read")) {
+        continue;
+      }
+      stored.set(row.path_key, { mtimeMs: row.mtime_ms, size: row.size });
+    }
+    return stored;
+  }
+  async function reconcile() {
+    const rels = await vaultIo.listMarkdown();
+    const stored = storedSigs();
+    const onDisk = await Promise.all(
+      rels.map(async (rel) => {
+        const full = vaultIo.resolveVaultPath(rel, "read");
+        const sig = await statSig(full);
+        return { rel, key: vaultIo.toKey(rel), full, sig };
+      })
+    );
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of onDisk) {
+      if (entry.sig === null) {
+        continue;
+      }
+      seen.add(entry.key);
+      const prev = stored.get(entry.key);
+      if (prev && prev.mtimeMs === entry.sig.mtimeMs && prev.size === entry.sig.size) {
+        continue;
+      }
+      const read = await readConsistent(entry.full);
+      if (read.content === null || read.sig === null) {
+        continue;
+      }
+      indexNote(db, vaultIo, cfg, entry.rel, read.content, read.sig);
+    }
+    for (const key of stored.keys()) {
+      if (!seen.has(key)) {
+        dropNote(db, key);
+      }
+    }
+  }
+  async function reconcilePaths(rels) {
+    for (const rel of rels) {
+      if (!vaultIo.can(rel, "read")) {
+        continue;
+      }
+      const key = vaultIo.toKey(rel);
+      let full;
+      try {
+        full = vaultIo.resolveVaultPath(rel, "read");
+      } catch {
+        dropNote(db, key);
+        continue;
+      }
+      const read = await readConsistent(full);
+      if (read.content === null || read.sig === null) {
+        dropNote(db, key);
+        continue;
+      }
+      indexNote(db, vaultIo, cfg, rel, read.content, read.sig);
+    }
+  }
+  async function rebuild() {
+    const rels = await vaultIo.listMarkdown();
+    const items = (await Promise.all(
+      rels.map(async (rel) => {
+        const full = vaultIo.resolveVaultPath(rel, "read");
+        const read = await readConsistent(full);
+        if (read.content === null || read.sig === null) {
+          return null;
+        }
+        return { rel, content: read.content, sig: read.sig };
+      })
+    )).filter(
+      (item) => item !== null
+    );
+    const swap = db.transaction(() => {
+      const rows = db.query("SELECT id, path_key, path FROM notes").all();
+      const delNote = db.query("DELETE FROM notes WHERE id = ?");
+      const delFts = db.query("DELETE FROM notes_fts WHERE rowid = ?");
+      const delTags = db.query("DELETE FROM note_tags WHERE path_key = ?");
+      const delLinks = db.query("DELETE FROM note_links WHERE src_key = ?");
+      for (const row of rows) {
+        if (!vaultIo.can(row.path, "read")) {
+          continue;
+        }
+        delFts.run(row.id);
+        delNote.run(row.id);
+        delTags.run(row.path_key);
+        delLinks.run(row.path_key);
+      }
+      for (const item of items) {
+        indexNote(db, vaultIo, cfg, item.rel, item.content, item.sig);
+      }
+      writeMeta(db, "config_fingerprint", configFingerprint(cfg));
+      writeMeta(db, "schema_version", String(SCHEMA_VERSION));
+    });
+    swap();
+  }
+  return { reconcile, reconcilePaths, rebuild };
+}
+
+// src/notes/notes.ts
+function countOccurrences(haystack, needle) {
+  if (needle.length === 0) {
+    return 0;
+  }
+  let count = 0;
+  let idx = haystack.indexOf(needle);
+  while (idx !== -1) {
+    count++;
+    idx = haystack.indexOf(needle, idx + needle.length);
+  }
+  return count;
+}
+function createNotes(deps) {
+  const { db, vaultIo, cfg, query, onCommit, cross = false } = deps;
+  async function readNote(path3, opts) {
+    const read = await vaultIo.readVaultFile(path3);
+    if (!read) {
+      throw new MdVaultError("NOT_FOUND", `note not found: ${path3}`);
+    }
+    const parsed = parseFrontmatter(read.content);
+    const result = {
+      frontmatter: parsed.frontmatter,
+      tags: parsed.tags,
+      body: parsed.body,
+      valid: parsed.valid
+    };
+    if (opts?.withLinks) {
+      result.outbound = query.outboundLinks(path3);
+      result.backlinks = query.backlinks(path3);
+    }
+    return result;
+  }
+  function runLocked(key, fn) {
+    const locked = () => withFileLock(key, fn);
+    if (cross) {
+      return withCrossProcessLock(
+        cross.lockDir,
+        key,
+        cross.busyTimeoutMs,
+        locked
+      );
+    }
+    return locked();
+  }
+  function buildContent(input) {
+    const fm = input.frontmatter;
+    if (!fm || Object.keys(fm).length === 0) {
+      return input.body;
+    }
+    const res = editFrontmatter(input.body, (view) => {
+      for (const [k, v] of Object.entries(fm)) {
+        view[k] = v;
+      }
+    });
+    if (res.outcome === "unverifiable") {
+      throw new MdVaultError(
+        "FRONTMATTER_INVALID",
+        `frontmatter is not flat: ${Object.keys(fm).join(", ")}`
+      );
+    }
+    return res.content;
+  }
+  async function createNote(path3, input) {
+    const content = buildContent(input);
+    const full = vaultIo.resolveVaultPath(path3, "write");
+    const key = vaultIo.toKey(path3);
+    const display = vaultIo.toVaultRelative(path3);
+    await runLocked(key, async () => {
+      const sig = await exclusiveCreate(full, content);
+      indexNote(db, vaultIo, cfg, path3, content, sig);
+      if (onCommit) {
+        try {
+          await onCommit({ op: "create", path: display, content });
+        } catch (cause) {
+          throw new MdVaultError(
+            "COMMIT_FAILED",
+            `onCommit failed for ${display}`,
+            { cause }
+          );
+        }
+      }
+    });
+  }
+  const indexCommit = async (e) => {
+    if (e.op === "delete") {
+      dropNote(db, vaultIo.toKey(e.path));
+    } else {
+      const sig = await statSig(vaultIo.resolveVaultPath(e.path, "write"));
+      if (sig) {
+        indexNote(db, vaultIo, cfg, e.path, e.content, sig);
+      }
+    }
+    if (onCommit) {
+      await onCommit(e);
+    }
+  };
+  async function updateNote(path3, op) {
+    const full = vaultIo.resolveVaultPath(path3, "write");
+    const key = vaultIo.toKey(path3);
+    const display = vaultIo.toVaultRelative(path3);
+    const transform = (current) => {
+      if ("append" in op) {
+        const baseText = current ?? "";
+        const needsNl = baseText.length > 0 && !baseText.endsWith("\n");
+        return `${baseText}${needsNl ? "\n" : ""}${op.append}`;
+      }
+      const { old, new: replacement } = op.editByMatch;
+      if (current === null) {
+        throw new MdVaultError(
+          "NO_MATCH",
+          `no match in missing file: ${display}`
+        );
+      }
+      const count = countOccurrences(current, old);
+      if (count === 0) {
+        throw new MdVaultError(
+          "NO_MATCH",
+          `no match for replacement in ${display}`
+        );
+      }
+      if (count > 1) {
+        throw new MdVaultError(
+          "AMBIGUOUS_MATCH",
+          `ambiguous match (${count}) in ${display}`
+        );
+      }
+      const at = current.indexOf(old);
+      return current.slice(0, at) + replacement + current.slice(at + old.length);
+    };
+    await withFileTransform(full, key, display, transform, {
+      allowCreate: "append" in op,
+      onCommit: indexCommit,
+      cross
+    });
+  }
+  async function editFrontmatter2(path3, mutate) {
+    const full = vaultIo.resolveVaultPath(path3, "write");
+    const key = vaultIo.toKey(path3);
+    const display = vaultIo.toVaultRelative(path3);
+    let outcome = "unchanged";
+    const transform = (current) => {
+      if (current === null) {
+        outcome = "unchanged";
+        return null;
+      }
+      const res = editFrontmatter(current, mutate);
+      outcome = res.outcome;
+      if (res.outcome === "edited") {
+        return res.content;
+      }
+      return null;
+    };
+    await withFileTransform(full, key, display, transform, {
+      allowCreate: false,
+      onCommit: indexCommit,
+      cross
+    });
+    return outcome;
+  }
+  async function deleteNote(path3) {
+    const full = vaultIo.resolveVaultPath(path3, "write");
+    const key = vaultIo.toKey(path3);
+    const display = vaultIo.toVaultRelative(path3);
+    const { deleted } = await withFileDelete(full, key, display, {
+      onCommit: indexCommit,
+      cross
+    });
+    return deleted;
+  }
+  return { readNote, createNote, updateNote, editFrontmatter: editFrontmatter2, deleteNote };
+}
+
+// src/query/query.ts
+var ORDER_FIELDS = /* @__PURE__ */ new Set(["mtime_ms", "path", "title"]);
+var WHERE_KEY_RE = /^[A-Za-z0-9_.-]+$/;
+var DEFAULT_LIMIT = 100;
+var HARD_MAX = 1e3;
+function validatePagination(limit, offset) {
+  const lim = limit ?? DEFAULT_LIMIT;
+  const off = offset ?? 0;
+  if (!Number.isInteger(lim) || lim < 0) {
+    throw new MdVaultError(
+      "VALIDATION_ERROR",
+      `limit must be a non-negative integer, got: ${limit}`
+    );
+  }
+  if (!Number.isInteger(off) || off < 0) {
+    throw new MdVaultError(
+      "VALIDATION_ERROR",
+      `offset must be a non-negative integer, got: ${offset}`
+    );
+  }
+  return { lim: Math.min(lim, HARD_MAX), off };
+}
+function sanitizeFts(q) {
+  const tokens = q.trim().split(/\s+/).filter((t) => t.length > 0);
+  if (tokens.length === 0) {
+    return null;
+  }
+  return tokens.map((t) => `"${t.replace(/"/g, '""')}"`).join(" ");
+}
+function pathBaseLower(p) {
+  return (p.split("/").at(-1) ?? p).replace(/\.md$/i, "").toLowerCase();
+}
+function pathFolder(p) {
+  const i = p.lastIndexOf("/");
+  return i < 0 ? "" : p.slice(0, i);
+}
+function tieBreakWinner(candidates, srcFolder) {
+  const sorted = [...candidates].sort((a, b) => {
+    const af = pathFolder(a.path);
+    const bf = pathFolder(b.path);
+    const as_ = af === srcFolder ? 0 : 1;
+    const bs_ = bf === srcFolder ? 0 : 1;
+    if (as_ !== bs_) {
+      return as_ - bs_;
+    }
+    if (a.path.length !== b.path.length) {
+      return a.path.length - b.path.length;
+    }
+    return a.path.localeCompare(b.path);
+  });
+  return sorted[0]?.path;
+}
+function createQuery(db, vaultIo, cfg) {
+  function inScope(path3) {
+    return vaultIo.can(path3, "read");
+  }
+  function tagsFor(pathKey) {
+    return db.query("SELECT tag FROM note_tags WHERE path_key = ?").all(pathKey).map((r) => r.tag);
+  }
+  function queryNotes(opts = {}) {
+    const { tag, where = {}, folder, orderBy, limit, offset } = opts;
+    const { lim, off } = validatePagination(limit, offset);
+    const order = orderBy ?? { field: "mtime_ms", dir: "desc" };
+    if (!ORDER_FIELDS.has(order.field)) {
+      throw new MdVaultError(
+        "VALIDATION_ERROR",
+        `orderBy.field must be one of ${[...ORDER_FIELDS].join(", ")}, got: ${order.field}`
+      );
+    }
+    const dir = order.dir === "asc" ? "ASC" : "DESC";
+    const parts = [];
+    const params = [];
+    if (tag !== void 0) {
+      parts.push(
+        "EXISTS (SELECT 1 FROM note_tags nt WHERE nt.path_key = n.path_key AND nt.tag = ?)"
+      );
+      params.push(tag);
+    }
+    for (const key of Object.keys(where)) {
+      if (!WHERE_KEY_RE.test(key)) {
+        throw new MdVaultError(
+          "VALIDATION_ERROR",
+          `where key contains invalid characters: ${key}`
+        );
+      }
+      parts.push(`json_extract(n.frontmatter, '$."${key}"') = ?`);
+      params.push(where[key]);
+    }
+    if (folder !== void 0) {
+      parts.push("(n.path = ? OR n.path LIKE ?)");
+      params.push(folder, `${folder}/%`);
+    }
+    const clause = parts.length > 0 ? `WHERE ${parts.join(" AND ")}` : "";
+    const sql = `SELECT n.path, n.path_key, n.title, n.frontmatter FROM notes n ${clause} ORDER BY n.${order.field} ${dir}, n.path ASC`;
+    const rows = db.query(sql).all(...params);
+    const scoped = [];
+    for (const row of rows) {
+      if (!inScope(row.path)) {
+        continue;
+      }
+      scoped.push({
+        path: row.path,
+        title: row.title,
+        frontmatter: JSON.parse(row.frontmatter),
+        tags: tagsFor(row.path_key)
+      });
+    }
+    return scoped.slice(off, off + lim);
+  }
+  function backlinks(path3, opts = {}) {
+    if (!inScope(path3)) {
+      return [];
+    }
+    const { lim, off } = validatePagination(opts.limit, opts.offset);
+    const display = vaultIo.toVaultRelative(path3);
+    const targetKey = vaultIo.toKey(path3);
+    const base = pathBaseLower(display);
+    const sources = [];
+    if (cfg.linkResolution === "relative") {
+      const rows = db.query(
+        `SELECT n.path AS from_path
+           FROM note_links nl
+           JOIN notes n ON n.path_key = nl.src_key
+           JOIN notes tn ON tn.path_key = nl.target
+           WHERE nl.target = ?`
+      ).all(targetKey);
+      for (const r of rows) {
+        if (inScope(r.from_path)) {
+          sources.push(r.from_path);
+        }
+      }
+    } else {
+      const pqRows = db.query(
+        `SELECT n.path AS from_path, nl.target
+           FROM note_links nl
+           JOIN notes n ON n.path_key = nl.src_key
+           WHERE nl.target LIKE '%/%'`
+      ).all();
+      for (const r of pqRows) {
+        if (!inScope(r.from_path)) {
+          continue;
+        }
+        if (vaultIo.toKey(`${r.target}.md`) === targetKey) {
+          sources.push(r.from_path);
+        }
+      }
+      const bareRows = db.query(
+        `SELECT n.path AS from_path
+           FROM note_links nl
+           JOIN notes n ON n.path_key = nl.src_key
+           WHERE nl.base = ?`
+      ).all(base);
+      const rawCandidates = db.query(
+        `SELECT path FROM notes WHERE LOWER(path_key) = ? OR LOWER(path_key) LIKE ?`
+      ).all(`${base}.md`, `%/${base}.md`);
+      const candidates = rawCandidates.filter(
+        (c) => pathBaseLower(c.path) === base && inScope(c.path)
+      );
+      for (const r of bareRows) {
+        if (!inScope(r.from_path)) {
+          continue;
+        }
+        const winner = tieBreakWinner(candidates, pathFolder(r.from_path));
+        if (winner === display) {
+          sources.push(r.from_path);
+        }
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = [];
+    for (const s of sources) {
+      if (!seen.has(s)) {
+        seen.add(s);
+        deduped.push({ from: s });
+      }
+    }
+    return deduped.slice(off, off + lim);
+  }
+  function outboundLinks(path3, opts = {}) {
+    if (!inScope(path3)) {
+      return [];
+    }
+    const { lim, off } = validatePagination(opts.limit, opts.offset);
+    const srcKey = vaultIo.toKey(path3);
+    const display = vaultIo.toVaultRelative(path3);
+    const rows = db.query(
+      `SELECT target, base FROM note_links WHERE src_key = ?`
+    ).all(srcKey).slice(off, off + lim);
+    const results = [];
+    for (const row of rows) {
+      let resolved = null;
+      if (cfg.linkResolution === "relative") {
+        const hit = db.query("SELECT path FROM notes WHERE path_key = ?").get(row.target);
+        if (hit && inScope(hit.path)) {
+          resolved = hit.path;
+        }
+      } else if (row.target.includes("/")) {
+        const tKey = vaultIo.toKey(`${row.target}.md`);
+        const hit = db.query("SELECT path FROM notes WHERE path_key = ?").get(tKey);
+        if (hit && inScope(hit.path)) {
+          resolved = hit.path;
+        }
+      } else if (row.base !== null) {
+        const rawC = db.query(
+          "SELECT path FROM notes WHERE LOWER(path_key) = ? OR LOWER(path_key) LIKE ?"
+        ).all(`${row.base}.md`, `%/${row.base}.md`);
+        const cands = rawC.filter(
+          (c) => pathBaseLower(c.path) === row.base && inScope(c.path)
+        );
+        const winner = tieBreakWinner(cands, pathFolder(display));
+        if (winner !== void 0) {
+          resolved = winner;
+        }
+      }
+      results.push({ target: row.target, resolved });
+    }
+    return results;
+  }
+  function searchText(q, opts = {}) {
+    const { tag, folder, limit, offset } = opts;
+    const { lim, off } = validatePagination(limit, offset);
+    const ftsQ = sanitizeFts(q);
+    if (ftsQ === null) {
+      return [];
+    }
+    const parts = [];
+    const params = [ftsQ];
+    if (tag !== void 0) {
+      parts.push(
+        "EXISTS (SELECT 1 FROM note_tags nt WHERE nt.path_key = n.path_key AND nt.tag = ?)"
+      );
+      params.push(tag);
+    }
+    if (folder !== void 0) {
+      parts.push("(n.path = ? OR n.path LIKE ?)");
+      params.push(folder, `${folder}/%`);
+    }
+    const extra = parts.length > 0 ? `AND ${parts.join(" AND ")}` : "";
+    const sql = `
+      SELECT n.path, n.title,
+             snippet(notes_fts, 0, '<b>', '</b>', '\u2026', 10) AS snippet
+      FROM notes_fts
+      JOIN notes n ON notes_fts.rowid = n.id
+      WHERE notes_fts MATCH ? ${extra}
+      ORDER BY notes_fts.rank
+    `;
+    let rows;
+    try {
+      rows = db.query(sql).all(...params);
+    } catch {
+      return [];
+    }
+    const scoped = [];
+    for (const row of rows) {
+      if (!inScope(row.path)) {
+        continue;
+      }
+      scoped.push({
+        path: row.path,
+        title: row.title,
+        snippet: row.snippet || void 0
+      });
+    }
+    return scoped.slice(off, off + lim);
+  }
+  return { queryNotes, backlinks, outboundLinks, searchText };
+}
+
+// src/vault-io/create-vault-io.ts
+import { join as join5, resolve as resolvePath } from "path";
+
+// src/vault-io/allowlist.ts
+function matches(x, prefixes) {
+  for (const p of prefixes) {
+    if (p === "") {
+      return true;
+    }
+    if (x === p) {
+      return true;
+    }
+    if (x.startsWith(`${p}/`)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/vault-io/case-sensitivity.ts
+import { statSync, unlinkSync, writeFileSync } from "fs";
+import { join as join3 } from "path";
+var caseSensitiveCache = /* @__PURE__ */ new Map();
+function resolveCaseSensitive(root, override) {
+  if (override !== void 0) {
+    return override;
+  }
+  const cached = caseSensitiveCache.get(root);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const detected = detectCaseSensitive(root);
+  caseSensitiveCache.set(root, detected);
+  return detected;
+}
+function detectCaseSensitive(root) {
+  const probe = join3(root, `.vaultmd-case-probe-${process.pid}-${Date.now()}`);
+  try {
+    writeFileSync(probe, "x");
+    const flipped = probe === probe.toUpperCase() ? probe.toLowerCase() : probe.toUpperCase();
+    try {
+      const a = statSync(probe);
+      const b = statSync(flipped);
+      return !(a.ino === b.ino && a.dev === b.dev);
+    } catch {
+      return true;
+    }
+  } catch {
+    return true;
+  } finally {
+    try {
+      unlinkSync(probe);
+    } catch {
+    }
+  }
+}
+
+// src/vault-io/enumerate.ts
+import { readdir, stat as statEntry } from "fs/promises";
+import { join as join4 } from "path";
+
+// src/vault-io/realpath-guard.ts
+import { existsSync, realpathSync } from "fs";
+import { dirname as dirname2, sep } from "path";
+function realTargetWithinRoot(full, root) {
+  let realRoot;
+  try {
+    realRoot = realpathSync(root);
+  } catch {
+    return true;
+  }
+  let probe = full;
+  while (!existsSync(probe)) {
+    const parent = dirname2(probe);
+    if (parent === probe) {
+      return true;
+    }
+    probe = parent;
+  }
+  let real;
+  try {
+    real = realpathSync(probe);
+  } catch {
+    return true;
+  }
+  return real === realRoot || real.startsWith(realRoot + sep);
+}
+
+// src/vault-io/enumerate.ts
+async function walk(root, absDir, relDir, out, deps) {
+  let entries;
+  try {
+    entries = await readdir(absDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const ent of entries) {
+    const name = ent.name;
+    const childRel = relDir === "" ? name : `${relDir}/${name}`;
+    const childAbs = join4(absDir, name);
+    let isDir = ent.isDirectory();
+    let isFile = ent.isFile();
+    if (ent.isSymbolicLink()) {
+      try {
+        const st = await statEntry(childAbs);
+        isDir = st.isDirectory();
+        isFile = st.isFile();
+      } catch {
+        continue;
+      }
+    }
+    if (isDir) {
+      if (name.startsWith(".")) {
+        continue;
+      }
+      if (deps.isIgnored(childRel)) {
+        continue;
+      }
+      if (!realTargetWithinRoot(childAbs, root)) {
+        continue;
+      }
+      await walk(root, childAbs, childRel, out, deps);
+      continue;
+    }
+    if (isFile && name.endsWith(".md")) {
+      if (deps.isIgnored(childRel)) {
+        continue;
+      }
+      try {
+        deps.resolveVaultPath(childRel, "read");
+      } catch {
+        continue;
+      }
+      out.push(deps.toVaultRelative(childRel));
+    }
+  }
+}
+async function listMarkdown(root, dir, deps) {
+  const startRel = dir === void 0 ? "" : deps.toVaultRelative(dir);
+  const startAbs = startRel === "" ? root : join4(root, startRel);
+  if (!realTargetWithinRoot(startAbs, root)) {
+    return [];
+  }
+  const out = [];
+  await walk(root, startAbs, startRel, out, deps);
+  out.sort();
+  return out;
+}
+
+// src/vault-io/glob.ts
+function globToRegExp(glob) {
+  let re = "";
+  let i = 0;
+  while (i < glob.length) {
+    const c = glob[i];
+    if (c === "*" && glob[i + 1] === "*") {
+      i += 2;
+      if (glob[i] === "/") {
+        re += "(?:.*/)?";
+        i += 1;
+      } else {
+        re += ".*";
+      }
+      continue;
+    }
+    if (c === "*") {
+      re += "[^/]*";
+      i += 1;
+      continue;
+    }
+    if (c === "?") {
+      re += "[^/]";
+      i += 1;
+      continue;
+    }
+    re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    i += 1;
+  }
+  return new RegExp(`^${re}$`);
+}
+
+// src/vault-io/paths.ts
+import { isAbsolute } from "path";
+function canonicalizeRelative(rel) {
+  if (isAbsolute(rel)) {
+    throw new MdVaultError(
+      "ALLOWLIST_VIOLATION",
+      `vault path must be relative: ${rel}`
+    );
+  }
+  const nfc = rel.normalize("NFC").replaceAll("\\", "/");
+  const out = [];
+  for (const seg of nfc.split("/")) {
+    if (seg === "" || seg === ".") {
+      continue;
+    }
+    if (seg === "..") {
+      if (out.length === 0) {
+        throw new MdVaultError(
+          "ALLOWLIST_VIOLATION",
+          `vault path escapes root: ${rel}`
+        );
+      }
+      out.pop();
+      continue;
+    }
+    out.push(seg);
+  }
+  return out.join("/");
+}
+function canonPrefix(p) {
+  const nfc = p.normalize("NFC").replaceAll("\\", "/");
+  const out = [];
+  for (const seg of nfc.split("/")) {
+    if (seg === "" || seg === ".") {
+      continue;
+    }
+    if (seg === "..") {
+      throw new MdVaultError(
+        "ALLOWLIST_VIOLATION",
+        `vault prefix may not contain '..': ${p}`
+      );
+    }
+    out.push(seg);
+  }
+  return out.join("/");
+}
+
+// src/vault-io/create-vault-io.ts
+function createVaultIo(config) {
+  const root = resolvePath(config.root);
+  const caseSensitive = resolveCaseSensitive(root, config.caseSensitive);
+  const canonPrefixes = {
+    read: config.prefixes.read.map(canonPrefix),
+    write: config.prefixes.write.map(canonPrefix)
+  };
+  const ignoreRes = (config.ignore ?? []).map(globToRegExp);
+  function toVaultRelative(rel) {
+    return canonicalizeRelative(rel);
+  }
+  function toKey(rel) {
+    const canonical = canonicalizeRelative(rel);
+    return caseSensitive ? canonical : canonical.toLowerCase();
+  }
+  function can(rel, access) {
+    let x;
+    try {
+      x = canonicalizeRelative(rel);
+    } catch {
+      return false;
+    }
+    return matches(x, canonPrefixes[access]);
+  }
+  function resolveVaultPath(rel, access = "read") {
+    const canonical = canonicalizeRelative(rel);
+    if (!canonical.endsWith(".md")) {
+      throw new MdVaultError("NOT_MARKDOWN", `not a markdown path: ${rel}`);
+    }
+    if (!matches(canonical, canonPrefixes[access])) {
+      throw new MdVaultError(
+        "ALLOWLIST_VIOLATION",
+        `path outside ${access} allowlist: ${rel}`
+      );
+    }
+    const full = join5(root, canonical);
+    if (!realTargetWithinRoot(full, root)) {
+      throw new MdVaultError(
+        "ALLOWLIST_VIOLATION",
+        `vault path escapes root (symlink): ${rel}`
+      );
+    }
+    return full;
+  }
+  async function readVaultFile(rel) {
+    const full = resolveVaultPath(rel, "read");
+    const result = await readConsistent(full);
+    if (result.content === null) {
+      return null;
+    }
+    return { content: result.content, sig: result.sig };
+  }
+  async function writeVaultFile(rel, content) {
+    return atomicWrite(resolveVaultPath(rel, "write"), content);
+  }
+  async function rewriteIfUnchanged(rel, content, expected) {
+    return atomicWriteIfUnchanged(
+      resolveVaultPath(rel, "write"),
+      content,
+      expected
+    );
+  }
+  async function unlinkIfUnchanged2(rel, expected) {
+    return unlinkIfUnchanged(resolveVaultPath(rel, "write"), expected);
+  }
+  async function stat3(rel) {
+    return statSig(resolveVaultPath(rel, "read"));
+  }
+  function isIgnored(rel) {
+    return ignoreRes.some((re) => re.test(rel));
+  }
+  function listMarkdown2(dir) {
+    return listMarkdown(root, dir, {
+      isIgnored,
+      resolveVaultPath,
+      toVaultRelative
+    });
+  }
+  return {
+    toVaultRelative,
+    toKey,
+    can,
+    resolveVaultPath,
+    readVaultFile,
+    writeVaultFile,
+    rewriteIfUnchanged,
+    unlinkIfUnchanged: unlinkIfUnchanged2,
+    stat: stat3,
+    listMarkdown: listMarkdown2
+  };
+}
+
+// src/vault/create-vault.ts
+async function createVault(config) {
+  const linkResolution = config.linkResolution ?? "wikilink";
+  const lazyReconcile = config.lazyReconcile ?? true;
+  const reconcileTtlMs = config.reconcileTtlMs ?? 2e3;
+  const sqliteBusyTimeoutMs = config.sqliteBusyTimeoutMs ?? 5e3;
+  const crossProcessWriterLock = config.crossProcessWriterLock ?? true;
+  const io = createVaultIo({
+    root: config.root,
+    prefixes: config.prefixes,
+    caseSensitive: config.caseSensitive,
+    ignore: config.ignore
+  });
+  const caseSensitive = io.toKey("A.md") === io.toVaultRelative("A.md");
+  const cfg = {
+    linkResolution,
+    caseSensitive,
+    ignore: config.ignore ?? []
+  };
+  const db = openIndexDb(config.indexPath, { sqliteBusyTimeoutMs });
+  probeCapabilities(db);
+  applySchema(db);
+  const reconciler = createReconciler(db, io, cfg);
+  const ownsWholeIndex = config.prefixes.read.includes("");
+  const cur = configFingerprint(cfg);
+  const stored = readMeta(db, "config_fingerprint");
+  const storedVer = readMeta(db, "schema_version");
+  if (stored === null) {
+    await reconciler.rebuild();
+  } else if (stored !== cur || storedVer !== String(SCHEMA_VERSION)) {
+    if (ownsWholeIndex) {
+      await reconciler.rebuild();
+    } else {
+      db.close();
+      throw new MdVaultError(
+        "INDEX_UNAVAILABLE",
+        "index config fingerprint mismatch on a shared index not owned by this scope"
+      );
+    }
+  } else {
+    const row = db.query("PRAGMA integrity_check").get();
+    if (row?.integrity_check !== "ok") {
+      await reconciler.rebuild();
+    }
+  }
+  let lastReconcileMs = 0;
+  let inFlight = null;
+  function maybeReconcile() {
+    if (!lazyReconcile || inFlight) {
+      return;
+    }
+    const now = Date.now();
+    if (now - lastReconcileMs < reconcileTtlMs) {
+      return;
+    }
+    lastReconcileMs = now;
+    inFlight = reconciler.reconcile().catch(() => {
+    }).finally(() => {
+      inFlight = null;
+    });
+  }
+  const rawQuery = createQuery(db, io, cfg);
+  const query = {
+    queryNotes(opts) {
+      maybeReconcile();
+      return rawQuery.queryNotes(opts);
+    },
+    backlinks(path3, opts) {
+      maybeReconcile();
+      return rawQuery.backlinks(path3, opts);
+    },
+    outboundLinks(path3, opts) {
+      maybeReconcile();
+      return rawQuery.outboundLinks(path3, opts);
+    },
+    searchText(q, opts) {
+      maybeReconcile();
+      return rawQuery.searchText(q, opts);
+    }
+  };
+  const notes = createNotes({
+    db,
+    vaultIo: io,
+    cfg,
+    query,
+    onCommit: config.onCommit,
+    cross: crossProcessWriterLock ? {
+      lockDir: `${dirname3(config.indexPath)}/.vaultmd-locks`,
+      busyTimeoutMs: sqliteBusyTimeoutMs
+    } : false
+  });
+  return {
+    io,
+    notes,
+    query,
+    reconcile: async () => {
+      await reconciler.reconcile();
+      lastReconcileMs = Date.now();
+    },
+    reconcilePaths: (rels) => reconciler.reconcilePaths(rels),
+    rebuild: () => reconciler.rebuild(),
+    close: () => {
+      db.close();
+    }
+  };
+}
+export {
+  MdVaultError,
+  createVault,
+  createVaultIo,
+  deriveTags,
+  editFrontmatter,
+  extractLinks,
+  isFlatFrontmatter,
+  parseFrontmatter,
+  storedLinksFor,
+  withFileDelete,
+  withFileTransform
+};