diffwiki-core 0.3.0 → 0.4.0-rc.202607220518.0ade9d3

package/dist/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,87 +30,57 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ArticleNotFoundError: () => ArticleNotFoundError,
-  CollectionExistsError: () => CollectionExistsError,
-  CollectionNotFoundError: () => CollectionNotFoundError,
-  DiffwikiError: () => DiffwikiError,
-  InvalidTargetError: () => InvalidTargetError,
-  NoDefaultCollectionError: () => NoDefaultCollectionError,
-  REPO_CONFIG_FILE: () => REPO_CONFIG_FILE,
-  addTags: () => addTags,
-  collectionDir: () => collectionDir,
-  collectionsDir: () => collectionsDir,
-  configPath: () => configPath,
-  createArticle: () => createArticle,
-  createCollection: () => createCollection,
-  doctor: () => doctor,
-  findCollection: () => findCollection,
-  getConfigValue: () => getConfigValue,
-  initRepoWiki: () => initRepoWiki,
-  listCollections: () => listCollections,
-  parseAddTarget: () => parseAddTarget,
-  parseArticle: () => parseArticle,
-  parsePathTarget: () => parsePathTarget,
-  query: () => query,
-  readConfig: () => readConfig,
-  readRegistry: () => readRegistry,
-  readRepoConfig: () => readRepoConfig,
-  registerCollection: () => registerCollection,
-  registryPath: () => registryPath,
-  removeArticle: () => removeArticle,
-  removeCollection: () => removeCollection,
-  removeTags: () => removeTags,
-  resolveHome: () => resolveHome,
-  serializeArticle: () => serializeArticle,
-  setConfigValue: () => setConfigValue,
-  setTags: () => setTags,
-  slugify: () => slugify,
-  unregisterCollection: () => unregisterCollection,
-  updateArticleBody: () => updateArticleBody,
-  writeConfig: () => writeConfig,
-  writeRegistry: () => writeRegistry
+// src/types.ts
+var NATIVE_ENGINE;
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+    NATIVE_ENGINE = "native";
+  }
 });
-module.exports = __toCommonJS(index_exports);
 
 // src/errors.ts
-var DiffwikiError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = new.target.name;
-  }
-};
-var CollectionExistsError = class extends DiffwikiError {
-  constructor(name) {
-    super(`collection "${name}" already exists`);
-  }
-};
-var CollectionNotFoundError = class extends DiffwikiError {
-  constructor(name) {
-    super(`collection "${name}" not found`);
-  }
-};
-var NoDefaultCollectionError = class extends DiffwikiError {
-  constructor() {
-    super("no default collection set (use: diffwiki config-set defaultCollection <name>)");
-  }
-};
-var ArticleNotFoundError = class extends DiffwikiError {
-  constructor(target) {
-    super(`article "${target}" not found`);
-  }
-};
-var InvalidTargetError = class extends DiffwikiError {
-  constructor(target, expected) {
-    super(`invalid target "${target}" \u2014 ${expected}`);
+var DiffwikiError, CollectionExistsError, CollectionNotFoundError, NoDefaultCollectionError, ArticleNotFoundError, InvalidTargetError, PluginError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    DiffwikiError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = new.target.name;
+      }
+    };
+    CollectionExistsError = class extends DiffwikiError {
+      constructor(name) {
+        super(`collection "${name}" already exists`);
+      }
+    };
+    CollectionNotFoundError = class extends DiffwikiError {
+      constructor(name) {
+        super(`collection "${name}" not found`);
+      }
+    };
+    NoDefaultCollectionError = class extends DiffwikiError {
+      constructor() {
+        super("no default collection set (use: diffwiki config-set defaultCollection <name>)");
+      }
+    };
+    ArticleNotFoundError = class extends DiffwikiError {
+      constructor(target) {
+        super(`article "${target}" not found`);
+      }
+    };
+    InvalidTargetError = class extends DiffwikiError {
+      constructor(target, expected) {
+        super(`invalid target "${target}" \u2014 ${expected}`);
+      }
+    };
+    PluginError = class extends DiffwikiError {
+    };
   }
-};
+});
 
 // src/paths.ts
-var import_node_os = __toESM(require("os"), 1);
-var import_node_path = __toESM(require("path"), 1);
 function resolveHome() {
   const override = process.env.DIFFWIKI_HOME;
   return override && override.length > 0 ? override : import_node_path.default.join(import_node_os.default.homedir(), ".diffwiki");
@@ -124,15 +97,22 @@ function collectionsDir() {
 function collectionDir(name) {
   return import_node_path.default.join(collectionsDir(), name);
 }
-
-// src/config.ts
-var import_promises3 = __toESM(require("fs/promises"), 1);
-
-// src/collections.ts
-var import_promises2 = __toESM(require("fs/promises"), 1);
+function pluginsDir() {
+  return import_node_path.default.join(resolveHome(), "plugins");
+}
+function pluginsRegistryPath() {
+  return import_node_path.default.join(resolveHome(), "plugins.json");
+}
+var import_node_os, import_node_path;
+var init_paths = __esm({
+  "src/paths.ts"() {
+    "use strict";
+    import_node_os = __toESM(require("os"), 1);
+    import_node_path = __toESM(require("path"), 1);
+  }
+});
 
 // src/registry.ts
-var import_promises = __toESM(require("fs/promises"), 1);
 function isMissing(err) {
   return err?.code === "ENOENT";
 }
@@ -165,8 +145,352 @@ async function unregisterCollection(name) {
   registry.collections = registry.collections.filter((c) => c.name !== name);
   await writeRegistry(registry);
 }
+var import_promises;
+var init_registry = __esm({
+  "src/registry.ts"() {
+    "use strict";
+    import_promises = __toESM(require("fs/promises"), 1);
+    init_paths();
+  }
+});
+
+// src/plugins/registry.ts
+function isMissing2(err) {
+  return err?.code === "ENOENT";
+}
+async function readPluginRegistry() {
+  try {
+    const parsed = JSON.parse(await import_promises2.default.readFile(pluginsRegistryPath(), "utf8"));
+    return { version: parsed.version ?? 1, plugins: parsed.plugins ?? [] };
+  } catch (err) {
+    if (isMissing2(err)) return { version: 1, plugins: [] };
+    throw err;
+  }
+}
+async function writePluginRegistry(registry) {
+  await import_promises2.default.mkdir(resolveHome(), { recursive: true });
+  await import_promises2.default.writeFile(pluginsRegistryPath(), `${JSON.stringify(registry, null, 2)}
+`, "utf8");
+}
+async function upsertPlugin(record) {
+  const registry = await readPluginRegistry();
+  const index = registry.plugins.findIndex((p) => p.name === record.name);
+  if (index >= 0) {
+    registry.plugins[index] = record;
+  } else {
+    registry.plugins.push(record);
+  }
+  await writePluginRegistry(registry);
+}
+async function deregisterPlugin(name) {
+  const registry = await readPluginRegistry();
+  registry.plugins = registry.plugins.filter((p) => p.name !== name);
+  await writePluginRegistry(registry);
+}
+async function listEnabledPlugins(kind) {
+  const registry = await readPluginRegistry();
+  return registry.plugins.filter((p) => p.enabled && p.kind === kind);
+}
+async function findEnabledPlugin(kind, name) {
+  const enabled = await listEnabledPlugins(kind);
+  if (name) return enabled.find((p) => p.name === name);
+  return enabled[0];
+}
+var import_promises2;
+var init_registry2 = __esm({
+  "src/plugins/registry.ts"() {
+    "use strict";
+    import_promises2 = __toESM(require("fs/promises"), 1);
+    init_paths();
+  }
+});
+
+// src/plugins/client.ts
+function toWireCollections(collections) {
+  return collections.map((c) => ({ name: c.name, path: c.path }));
+}
+async function spawnPluginClient(record) {
+  const child = (0, import_node_child_process.spawn)(record.command[0], record.command.slice(1), {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const pending = /* @__PURE__ */ new Map();
+  let nextId = 1;
+  let buffer = "";
+  let closed = false;
+  const failAll = (err) => {
+    for (const [, p] of pending) {
+      clearTimeout(p.timer);
+      p.reject(err);
+    }
+    pending.clear();
+  };
+  const handleLine = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let msg;
+    try {
+      msg = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    if (typeof msg !== "object" || msg === null) return;
+    const payload = msg;
+    if ("log" in payload && !("id" in payload)) return;
+    const id = payload.id;
+    if (typeof id !== "number") return;
+    const p = pending.get(id);
+    if (!p) return;
+    pending.delete(id);
+    clearTimeout(p.timer);
+    if (payload.ok === true) {
+      p.resolve(payload.result);
+    } else {
+      const error = payload.error;
+      const message = typeof error?.message === "string" ? error.message : "plugin request failed";
+      p.reject(new Error(message));
+    }
+  };
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk;
+    let newlineIndex = buffer.indexOf("\n");
+    while (newlineIndex >= 0) {
+      const line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      handleLine(line);
+      newlineIndex = buffer.indexOf("\n");
+    }
+  });
+  child.on("error", (err) => {
+    closed = true;
+    failAll(err);
+  });
+  child.on("exit", () => {
+    closed = true;
+    failAll(new Error("plugin process exited"));
+  });
+  const request = (op, params) => {
+    if (closed) return Promise.reject(new Error("plugin process is not running"));
+    return new Promise((resolve, reject) => {
+      const id = nextId++;
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`plugin request "${op}" timed out`));
+      }, REQUEST_TIMEOUT_MS);
+      pending.set(id, {
+        resolve: (result) => resolve(result),
+        reject,
+        timer
+      });
+      child.stdin.write(`${JSON.stringify({ id, op, params })}
+`, (err) => {
+        if (!err) return;
+        const p = pending.get(id);
+        if (!p) return;
+        pending.delete(id);
+        clearTimeout(p.timer);
+        p.reject(err);
+      });
+    });
+  };
+  let handshake;
+  try {
+    handshake = await request("initialize", { protocol: 1, home: resolveHome() });
+    if (handshake.kind !== "search") {
+      throw new Error(`plugin "${record.name}" reported kind "${handshake.kind}", expected "search"`);
+    }
+  } catch (err) {
+    closed = true;
+    child.kill("SIGKILL");
+    throw err;
+  }
+  const capabilities = handshake.capabilities;
+  const name = handshake.name;
+  const mapHits = (result, collections) => {
+    const raw = result?.hits;
+    const hits = Array.isArray(raw) ? raw : [];
+    const out = [];
+    for (const item of hits) {
+      if (typeof item !== "object" || item === null) continue;
+      const h = item;
+      if (typeof h.collection !== "string" || typeof h.relPath !== "string") continue;
+      const title = typeof h.title === "string" ? h.title : h.relPath;
+      const coll = collections.find((c) => c.name === h.collection);
+      const abs = coll ? import_node_path2.default.join(coll.path, h.relPath) : h.relPath;
+      out.push({
+        collection: h.collection,
+        path: abs,
+        title,
+        tags: Array.isArray(h.tags) ? h.tags.filter((t) => typeof t === "string") : [],
+        snippet: typeof h.snippet === "string" ? h.snippet : void 0,
+        score: typeof h.score === "number" ? h.score : void 0,
+        docid: typeof h.docid === "string" ? h.docid : void 0
+      });
+    }
+    return out;
+  };
+  const close = async () => {
+    if (!closed) {
+      try {
+        await request("shutdown", {});
+      } catch {
+      }
+    }
+    closed = true;
+    try {
+      child.stdin.end();
+    } catch {
+    }
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        child.kill();
+        resolve();
+      }, SHUTDOWN_GRACE_MS);
+      child.once("exit", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+  };
+  const provider = {
+    name,
+    capabilities,
+    async setup(collections, opts) {
+      const result = await request("setup", {
+        collections: toWireCollections(collections),
+        embed: opts?.embed,
+        prefetchModels: opts?.prefetchModels
+      });
+      return { ready: result?.ready === true };
+    },
+    async reindex(collections, opts) {
+      const result = await request("index", {
+        collections: toWireCollections(collections),
+        embed: opts?.embed
+      });
+      return result?.indexed ?? 0;
+    },
+    async search(term, collections, opts) {
+      const result = await request("search", {
+        term,
+        collections: toWireCollections(collections),
+        collection: opts?.collection,
+        type: opts?.type,
+        limit: opts?.limit
+      });
+      return mapHits(result, collections);
+    },
+    async notify(event, collection, relPath, collections) {
+      try {
+        const entry = collections.find((c) => c.name === collection);
+        await request("notify", {
+          event,
+          collection: entry ? { name: entry.name, path: entry.path } : { name: collection, path: "" },
+          relPath,
+          collections: toWireCollections(collections)
+        });
+      } catch {
+      }
+    },
+    async health(collections) {
+      const result = await request("health", { collections: toWireCollections(collections) });
+      return {
+        ready: result?.ready === true,
+        readiness: result?.readiness,
+        diagnostics: result?.diagnostics ?? []
+      };
+    },
+    close
+  };
+  return provider;
+}
+var import_node_child_process, import_node_path2, REQUEST_TIMEOUT_MS, SHUTDOWN_GRACE_MS;
+var init_client = __esm({
+  "src/plugins/client.ts"() {
+    "use strict";
+    import_node_child_process = require("child_process");
+    import_node_path2 = __toESM(require("path"), 1);
+    init_paths();
+    REQUEST_TIMEOUT_MS = 3e4;
+    SHUTDOWN_GRACE_MS = 500;
+  }
+});
+
+// src/plugins/loader.ts
+async function loadSearchProvider(name) {
+  const record = await findEnabledPlugin("search", name);
+  if (!record) return null;
+  try {
+    return await spawnPluginClient(record);
+  } catch {
+    return null;
+  }
+}
+async function listSearchModes() {
+  const modes = [{ plugin: NATIVE_ENGINE, type: "basic", label: "native \xB7 bm25" }];
+  const plugins = await listEnabledPlugins("search");
+  for (const record of plugins) {
+    let provider = null;
+    try {
+      provider = await spawnPluginClient(record);
+      for (const type of provider.capabilities.searchTypes) {
+        modes.push({ plugin: record.name, type, label: `${record.name} \xB7 ${type}` });
+      }
+    } catch {
+    } finally {
+      if (provider) {
+        try {
+          await provider.close();
+        } catch {
+        }
+      }
+    }
+  }
+  return modes;
+}
+var init_loader = __esm({
+  "src/plugins/loader.ts"() {
+    "use strict";
+    init_types();
+    init_registry2();
+    init_client();
+  }
+});
+
+// src/plugins/events.ts
+var events_exports = {};
+__export(events_exports, {
+  emitPluginEvent: () => emitPluginEvent
+});
+async function emitPluginEvent(event, collection, relPath) {
+  try {
+    const provider = await loadSearchProvider();
+    try {
+      if (provider?.capabilities.hooks) {
+        await provider.notify(event, collection, relPath, await listCollections());
+      }
+    } finally {
+      await provider?.close();
+    }
+  } catch {
+  }
+}
+var init_events = __esm({
+  "src/plugins/events.ts"() {
+    "use strict";
+    init_loader();
+    init_collections();
+  }
+});
 
 // src/collections.ts
+async function fireHook(event, collection) {
+  try {
+    const { emitPluginEvent: emitPluginEvent2 } = await Promise.resolve().then(() => (init_events(), events_exports));
+    await emitPluginEvent2(event, collection);
+  } catch {
+  }
+}
 async function listCollections() {
   return (await readRegistry()).collections;
 }
@@ -176,7 +500,7 @@ async function findCollection(name) {
 async function createCollection(name) {
   if (await findCollection(name)) throw new CollectionExistsError(name);
   const dir = collectionDir(name);
-  await import_promises2.default.mkdir(dir, { recursive: true });
+  await import_promises3.default.mkdir(dir, { recursive: true });
   const entry = {
     name,
     type: "global",
@@ -184,6 +508,7 @@ async function createCollection(name) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   await registerCollection(entry);
+  void fireHook("collection-added", name);
   return entry;
 }
 async function removeCollection(name) {
@@ -191,32 +516,133 @@ async function removeCollection(name) {
   if (!entry) throw new CollectionNotFoundError(name);
   await unregisterCollection(name);
   if (entry.type === "global") {
-    await import_promises2.default.rm(entry.path, { recursive: true, force: true });
+    await import_promises3.default.rm(entry.path, { recursive: true, force: true });
   }
+  void fireHook("collection-removed", name);
   return entry;
 }
+var import_promises3;
+var init_collections = __esm({
+  "src/collections.ts"() {
+    "use strict";
+    import_promises3 = __toESM(require("fs/promises"), 1);
+    init_paths();
+    init_registry();
+    init_errors();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ArticleNotFoundError: () => ArticleNotFoundError,
+  CollectionExistsError: () => CollectionExistsError,
+  CollectionNotFoundError: () => CollectionNotFoundError,
+  DiffwikiError: () => DiffwikiError,
+  InvalidTargetError: () => InvalidTargetError,
+  NATIVE_ENGINE: () => NATIVE_ENGINE,
+  NoDefaultCollectionError: () => NoDefaultCollectionError,
+  PluginError: () => PluginError,
+  REPO_CONFIG_FILE: () => REPO_CONFIG_FILE,
+  addTags: () => addTags,
+  buildArticleTree: () => buildArticleTree,
+  collectionDir: () => collectionDir,
+  collectionsDir: () => collectionsDir,
+  configPath: () => configPath,
+  createArticle: () => createArticle,
+  createCollection: () => createCollection,
+  deregisterPlugin: () => deregisterPlugin,
+  doctor: () => doctor,
+  emitPluginEvent: () => emitPluginEvent,
+  ensurePluginRoot: () => ensurePluginRoot,
+  findCollection: () => findCollection,
+  findEnabledPlugin: () => findEnabledPlugin,
+  getConfigValue: () => getConfigValue,
+  initRepoWiki: () => initRepoWiki,
+  installPlugin: () => installPlugin,
+  listArticleTree: () => listArticleTree,
+  listCollections: () => listCollections,
+  listEnabledPlugins: () => listEnabledPlugins,
+  listPlugins: () => listPlugins,
+  listSearchModes: () => listSearchModes,
+  loadSearchProvider: () => loadSearchProvider,
+  nativeSearch: () => nativeSearch,
+  parseAddTarget: () => parseAddTarget,
+  parseArticle: () => parseArticle,
+  parsePathTarget: () => parsePathTarget,
+  pluginsDir: () => pluginsDir,
+  pluginsRegistryPath: () => pluginsRegistryPath,
+  query: () => query,
+  readArticle: () => readArticle,
+  readConfig: () => readConfig,
+  readPluginRegistry: () => readPluginRegistry,
+  readRegistry: () => readRegistry,
+  readRepoConfig: () => readRepoConfig,
+  registerCollection: () => registerCollection,
+  registerPlugin: () => registerPlugin,
+  registryPath: () => registryPath,
+  removeArticle: () => removeArticle,
+  removeCollection: () => removeCollection,
+  removePlugin: () => removePlugin,
+  removeTags: () => removeTags,
+  renderArticle: () => renderArticle,
+  resolveDefaultSearchMode: () => resolveDefaultSearchMode,
+  resolveHome: () => resolveHome,
+  serializeArticle: () => serializeArticle,
+  setConfigValue: () => setConfigValue,
+  setTags: () => setTags,
+  slugify: () => slugify,
+  spawnPluginClient: () => spawnPluginClient,
+  unregisterCollection: () => unregisterCollection,
+  updateArticleBody: () => updateArticleBody,
+  upsertPlugin: () => upsertPlugin,
+  writeConfig: () => writeConfig,
+  writePluginRegistry: () => writePluginRegistry,
+  writeRegistry: () => writeRegistry
+});
+module.exports = __toCommonJS(index_exports);
+init_types();
+init_errors();
+init_paths();
 
 // src/config.ts
-function isMissing2(err) {
+var import_promises4 = __toESM(require("fs/promises"), 1);
+init_paths();
+init_collections();
+init_errors();
+init_registry2();
+init_types();
+function isMissing3(err) {
   return err?.code === "ENOENT";
 }
 async function readConfig() {
   try {
-    return JSON.parse(await import_promises3.default.readFile(configPath(), "utf8"));
+    return JSON.parse(await import_promises4.default.readFile(configPath(), "utf8"));
   } catch (err) {
-    if (isMissing2(err)) return {};
+    if (isMissing3(err)) return {};
     throw err;
   }
 }
 async function writeConfig(config) {
-  await import_promises3.default.mkdir(resolveHome(), { recursive: true });
-  await import_promises3.default.writeFile(configPath(), `${JSON.stringify(config, null, 2)}
+  await import_promises4.default.mkdir(resolveHome(), { recursive: true });
+  await import_promises4.default.writeFile(configPath(), `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
 async function setConfigValue(key, value) {
   if (key === "defaultCollection" && !await findCollection(value)) {
     throw new CollectionNotFoundError(value);
   }
+  if (key === "defaultSearch") {
+    const engine = value.split(":")[0];
+    if (engine !== NATIVE_ENGINE) {
+      const enabled = await listEnabledPlugins("search");
+      if (!enabled.some((p) => p.name === engine)) {
+        console.warn(
+          `! defaultSearch "${value}" names an engine that is not installed/enabled \u2014 native will be used until it is`
+        );
+      }
+    }
+  }
   const config = await readConfig();
   config[key] = value;
   await writeConfig(config);
@@ -227,6 +653,9 @@ async function getConfigValue(key) {
   return typeof value === "string" ? value : void 0;
 }
 
+// src/index.ts
+init_registry();
+
 // src/slugify.ts
 function slugify(input) {
   const slug = input.toLowerCase().replace(/^#+\s*/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80).replace(/-+$/g, "");
@@ -235,23 +664,65 @@ function slugify(input) {
 
 // src/frontmatter.ts
 var import_gray_matter = __toESM(require("gray-matter"), 1);
+var import_yaml = require("yaml");
+var YAML_ENGINE = {
+  parse: (input) => {
+    const data = (0, import_yaml.parse)(input);
+    return data && typeof data === "object" ? data : {};
+  },
+  stringify: (data) => (0, import_yaml.stringify)(data)
+};
+var MATTER_OPTS = { engines: { yaml: YAML_ENGINE } };
+function parseFallback(raw) {
+  const fenceRe = /^---[ \t]*\n([\s\S]*?)\n---[ \t]*\n/;
+  const fenceMatch = fenceRe.exec(raw);
+  let title = "";
+  let body;
+  if (fenceMatch) {
+    const inner = fenceMatch[1];
+    const titleMatch = /^title:\s*(.+)$/m.exec(inner);
+    if (titleMatch) {
+      title = titleMatch[1].trim().replace(/^["']|["']$/g, "");
+    }
+    body = raw.slice(fenceMatch[0].length);
+  } else {
+    body = raw;
+  }
+  return { title, tags: [], body: body.replace(/^\n+/, "") };
+}
 function parseArticle(raw) {
-  const { data, content } = (0, import_gray_matter.default)(raw);
-  const title = typeof data.title === "string" ? data.title : "";
-  const tags = Array.isArray(data.tags) ? data.tags.map((t) => String(t)) : [];
-  const created = typeof data.created === "string" ? data.created : void 0;
-  return { title, tags, created, body: content.replace(/^\n+/, "") };
+  try {
+    const { data, content } = (0, import_gray_matter.default)(raw, MATTER_OPTS);
+    const title = typeof data.title === "string" ? data.title : "";
+    const tags = Array.isArray(data.tags) ? data.tags.map((t) => String(t)) : [];
+    const created = typeof data.created === "string" ? data.created : void 0;
+    return { title, tags, created, body: content.replace(/^\n+/, "") };
+  } catch {
+    return parseFallback(raw);
+  }
 }
 function serializeArticle(article) {
   const front = { title: article.title, tags: article.tags };
   if (article.created) front.created = article.created;
   if (article.updated) front.updated = article.updated;
-  return import_gray_matter.default.stringify(article.body, front);
+  return import_gray_matter.default.stringify(article.body, front, MATTER_OPTS);
 }
 
+// src/index.ts
+init_collections();
+
 // src/articles.ts
-var import_promises4 = __toESM(require("fs/promises"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+init_collections();
+init_errors();
+async function fireHook2(event, collection, relPath) {
+  try {
+    const { emitPluginEvent: emitPluginEvent2 } = await Promise.resolve().then(() => (init_events(), events_exports));
+    await emitPluginEvent2(event, collection, relPath);
+  } catch {
+  }
+}
 function parseAddTarget(target) {
   const idx = target.indexOf(":");
   if (idx === -1) {
@@ -284,37 +755,38 @@ async function resolveCollectionDir(name) {
 }
 function ensureMdPath(file) {
   if (/\.mdx?$/.test(file)) return file;
-  const dir = import_node_path2.default.dirname(file);
-  const base = slugify(import_node_path2.default.basename(file));
-  const rel = dir === "." ? `${base}.md` : import_node_path2.default.join(dir, `${base}.md`);
+  const dir = import_node_path3.default.dirname(file);
+  const base = slugify(import_node_path3.default.basename(file));
+  const rel = dir === "." ? `${base}.md` : import_node_path3.default.join(dir, `${base}.md`);
   return rel;
 }
 async function createArticle(opts) {
   const { collection, title } = parseAddTarget(opts.target);
   const { name, dir } = await resolveCollectionDir(collection);
-  const filePath = import_node_path2.default.join(dir, `${slugify(title)}.md`);
+  const filePath = import_node_path3.default.join(dir, `${slugify(title)}.md`);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const body = opts.body ?? `# ${title}
 `;
-  await import_promises4.default.mkdir(dir, { recursive: true });
-  await import_promises4.default.writeFile(filePath, serializeArticle({ title, tags: opts.tags, created: now, updated: now, body }), "utf8");
+  await import_promises5.default.mkdir(dir, { recursive: true });
+  await import_promises5.default.writeFile(filePath, serializeArticle({ title, tags: opts.tags, created: now, updated: now, body }), "utf8");
+  void fireHook2("article-created", name, import_node_path3.default.relative(dir, filePath));
   return { title, tags: opts.tags, path: filePath, collection: name };
 }
 async function loadArticle(target) {
   const { collection, file } = parsePathTarget(target);
   const { dir } = await resolveCollectionDir(collection);
-  const filePath = import_node_path2.default.join(dir, ensureMdPath(file));
+  const filePath = import_node_path3.default.join(dir, ensureMdPath(file));
   try {
-    return { filePath, raw: await import_promises4.default.readFile(filePath, "utf8"), collection };
+    return { filePath, dir, raw: await import_promises5.default.readFile(filePath, "utf8"), collection };
   } catch (err) {
     if (err.code === "ENOENT") throw new ArticleNotFoundError(target);
     throw err;
   }
 }
 async function updateArticleBody(target, body) {
-  const { filePath, raw, collection } = await loadArticle(target);
+  const { filePath, dir, raw, collection } = await loadArticle(target);
   const parsed = parseArticle(raw);
-  await import_promises4.default.writeFile(
+  await import_promises5.default.writeFile(
     filePath,
     serializeArticle({
       title: parsed.title,
@@ -325,13 +797,14 @@ async function updateArticleBody(target, body) {
     }),
     "utf8"
   );
+  void fireHook2("article-updated", collection, import_node_path3.default.relative(dir, filePath));
   return { title: parsed.title, tags: parsed.tags, path: filePath, collection };
 }
 async function mutateTags(target, fn) {
-  const { filePath, raw, collection } = await loadArticle(target);
+  const { filePath, dir, raw, collection } = await loadArticle(target);
   const parsed = parseArticle(raw);
   const tags = fn(parsed.tags);
-  await import_promises4.default.writeFile(
+  await import_promises5.default.writeFile(
     filePath,
     serializeArticle({
       title: parsed.title,
@@ -342,6 +815,7 @@ async function mutateTags(target, fn) {
     }),
     "utf8"
   );
+  void fireHook2("article-updated", collection, import_node_path3.default.relative(dir, filePath));
   return { title: parsed.title, tags, path: filePath, collection };
 }
 function addTags(target, tags) {
@@ -355,34 +829,37 @@ function setTags(target, tags) {
   return mutateTags(target, () => Array.from(new Set(tags)));
 }
 async function removeArticle(target) {
-  const { filePath } = await loadArticle(target);
-  await import_promises4.default.rm(filePath);
+  const { filePath, dir, collection } = await loadArticle(target);
+  await import_promises5.default.rm(filePath);
+  void fireHook2("article-removed", collection, import_node_path3.default.relative(dir, filePath));
   return filePath;
 }
 
 // src/repo.ts
-var import_promises5 = __toESM(require("fs/promises"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
-var import_node_child_process = require("child_process");
+var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_node_child_process2 = require("child_process");
 var import_node_util = require("util");
-var import_yaml = require("yaml");
-var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var import_yaml2 = require("yaml");
+init_collections();
+init_registry();
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process2.execFile);
 var REPO_CONFIG_FILE = "diffwiki.yaml";
 async function detectRepoName(cwd) {
   try {
     const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd });
-    return import_node_path3.default.basename(stdout.trim());
+    return import_node_path4.default.basename(stdout.trim());
   } catch {
-    return import_node_path3.default.basename(import_node_path3.default.resolve(cwd));
+    return import_node_path4.default.basename(import_node_path4.default.resolve(cwd));
   }
 }
 async function readRepoConfig(cwd) {
   try {
-    const raw = await import_promises5.default.readFile(import_node_path3.default.join(cwd, REPO_CONFIG_FILE), "utf8");
-    const parsed = (0, import_yaml.parse)(raw) ?? {};
+    const raw = await import_promises6.default.readFile(import_node_path4.default.join(cwd, REPO_CONFIG_FILE), "utf8");
+    const parsed = (0, import_yaml2.parse)(raw) ?? {};
     if (!parsed.path) return void 0;
     return {
-      collection: parsed.collection ?? import_node_path3.default.basename(import_node_path3.default.resolve(cwd)),
+      collection: parsed.collection ?? import_node_path4.default.basename(import_node_path4.default.resolve(cwd)),
       path: parsed.path
     };
   } catch (err) {
@@ -391,9 +868,9 @@ async function readRepoConfig(cwd) {
   }
 }
 async function initRepoWiki(opts) {
-  const cwd = import_node_path3.default.resolve(opts.cwd);
+  const cwd = import_node_path4.default.resolve(opts.cwd);
   const wikiPath = opts.wikiPath ?? "wiki";
-  const absWiki = import_node_path3.default.join(cwd, wikiPath);
+  const absWiki = import_node_path4.default.join(cwd, wikiPath);
   let name = opts.collection ?? await detectRepoName(cwd);
   const existing = await findCollection(name);
   if (existing && existing.path !== absWiki) {
@@ -408,9 +885,9 @@ async function initRepoWiki(opts) {
       n += 1;
     }
   }
-  await import_promises5.default.mkdir(absWiki, { recursive: true });
+  await import_promises6.default.mkdir(absWiki, { recursive: true });
   const config = { collection: name, path: wikiPath };
-  await import_promises5.default.writeFile(import_node_path3.default.join(cwd, REPO_CONFIG_FILE), (0, import_yaml.stringify)(config), "utf8");
+  await import_promises6.default.writeFile(import_node_path4.default.join(cwd, REPO_CONFIG_FILE), (0, import_yaml2.stringify)(config), "utf8");
   const entry = {
     name,
     type: "repo",
@@ -422,44 +899,371 @@ async function initRepoWiki(opts) {
 }
 
 // src/query.ts
-var import_promises6 = __toESM(require("fs/promises"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
-async function query(term, collection) {
-  let targets;
+var import_promises7 = __toESM(require("fs/promises"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+init_collections();
+init_errors();
+init_loader();
+init_registry2();
+init_types();
+async function collectMarkdownFiles(dir) {
+  let entries;
+  try {
+    entries = await import_promises7.default.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const full = import_node_path5.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectMarkdownFiles(full));
+    } else if (entry.isFile() && /\.mdx?$/.test(entry.name)) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+var K1 = 1.5;
+var B = 0.75;
+var FIELD_WEIGHTS = { title: 3, tags: 2, collection: 1.5, body: 1 };
+function tokenize(text) {
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 0);
+}
+function termFreqs(tokens) {
+  const freqs = /* @__PURE__ */ new Map();
+  for (const t of tokens) {
+    freqs.set(t, (freqs.get(t) ?? 0) + 1);
+  }
+  return freqs;
+}
+function bm25FieldScore(queryTerms, fieldTokens, avgFieldLen, idf) {
+  const tf = termFreqs(fieldTokens);
+  const dl = fieldTokens.length;
+  const avgDl = avgFieldLen || 1;
+  let score = 0;
+  for (const term of queryTerms) {
+    const freq = tf.get(term) ?? 0;
+    if (freq === 0) continue;
+    const termIdf = idf.get(term) ?? 0;
+    const numerator = freq * (K1 + 1);
+    const denominator = freq + K1 * (1 - B + B * (dl / avgDl));
+    score += termIdf * (numerator / denominator);
+  }
+  return score;
+}
+async function nativeSearch(term, collections, collection) {
+  let targets = collections;
   if (collection) {
-    const one = await findCollection(collection);
+    const one = collections.find((c) => c.name === collection);
     if (!one) throw new CollectionNotFoundError(collection);
     targets = [one];
-  } else {
-    targets = await listCollections();
   }
-  const needle = term.toLowerCase();
-  const hits = [];
+  const docs = [];
   for (const entry of targets) {
-    let files;
-    try {
-      files = await import_promises6.default.readdir(entry.path);
-    } catch {
-      continue;
+    for (const full of await collectMarkdownFiles(entry.path)) {
+      const fallbackTitle = import_node_path5.default.basename(full).replace(/\.mdx?$/, "");
+      let title = fallbackTitle;
+      let tags = [];
+      let body = "";
+      try {
+        const parsed = parseArticle(await import_promises7.default.readFile(full, "utf8"));
+        if (parsed.title) title = parsed.title;
+        tags = parsed.tags;
+        body = parsed.body;
+      } catch {
+      }
+      docs.push({
+        collectionName: entry.name,
+        filePath: full,
+        title,
+        tags,
+        fields: {
+          title: tokenize(title),
+          tags: tokenize(tags.join(" ")),
+          collection: tokenize(entry.name),
+          body: tokenize(body)
+        }
+      });
     }
-    for (const file of files) {
-      if (!/\.mdx?$/.test(file)) continue;
-      const full = import_node_path4.default.join(entry.path, file);
-      const parsed = parseArticle(await import_promises6.default.readFile(full, "utf8"));
-      const haystack = [parsed.title, file, ...parsed.tags].join(" ").toLowerCase();
-      if (!needle || haystack.includes(needle)) {
-        hits.push({ collection: entry.name, path: full, title: parsed.title, tags: parsed.tags });
+  }
+  if (!term.trim()) {
+    return docs.map((d) => ({
+      collection: d.collectionName,
+      path: d.filePath,
+      title: d.title,
+      tags: d.tags
+    }));
+  }
+  const queryTerms = tokenize(term);
+  if (queryTerms.length === 0) {
+    return docs.map((d) => ({
+      collection: d.collectionName,
+      path: d.filePath,
+      title: d.title,
+      tags: d.tags
+    }));
+  }
+  const docTokenSets = docs.map(
+    (doc) => /* @__PURE__ */ new Set([...doc.fields.title, ...doc.fields.tags, ...doc.fields.collection, ...doc.fields.body])
+  );
+  const N = docs.length;
+  const idf = /* @__PURE__ */ new Map();
+  for (const qt of queryTerms) {
+    let docFreq = 0;
+    for (const tokenSet of docTokenSets) {
+      if (tokenSet.has(qt)) docFreq++;
+    }
+    idf.set(qt, Math.log((N - docFreq + 0.5) / (docFreq + 0.5) + 1));
+  }
+  const avgLens = {
+    title: docs.reduce((sum, d) => sum + d.fields.title.length, 0) / (N || 1),
+    tags: docs.reduce((sum, d) => sum + d.fields.tags.length, 0) / (N || 1),
+    collection: docs.reduce((sum, d) => sum + d.fields.collection.length, 0) / (N || 1),
+    body: docs.reduce((sum, d) => sum + d.fields.body.length, 0) / (N || 1)
+  };
+  const scored = [];
+  for (const doc of docs) {
+    const titleScore = bm25FieldScore(queryTerms, doc.fields.title, avgLens.title, idf) * FIELD_WEIGHTS.title;
+    const tagsScore = bm25FieldScore(queryTerms, doc.fields.tags, avgLens.tags, idf) * FIELD_WEIGHTS.tags;
+    const collScore = bm25FieldScore(queryTerms, doc.fields.collection, avgLens.collection, idf) * FIELD_WEIGHTS.collection;
+    const bodyScore = bm25FieldScore(queryTerms, doc.fields.body, avgLens.body, idf) * FIELD_WEIGHTS.body;
+    const total = titleScore + tagsScore + collScore + bodyScore;
+    if (total > 0) {
+      scored.push({ doc, score: total });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.map((s) => ({
+    collection: s.doc.collectionName,
+    path: s.doc.filePath,
+    title: s.doc.title,
+    tags: s.doc.tags,
+    score: s.score
+  }));
+}
+async function resolveDefaultEngine() {
+  const config = await readConfig();
+  const enabled = await listEnabledPlugins("search");
+  const configured = config.defaultSearch?.split(":")[0];
+  if (configured && enabled.some((p) => p.name === configured)) return configured;
+  if (enabled.length > 0) return enabled[0].name;
+  return NATIVE_ENGINE;
+}
+async function resolveDefaultSearchMode() {
+  const config = await readConfig();
+  const enabled = await listEnabledPlugins("search");
+  const configured = config.defaultSearch?.split(":")[0];
+  const configuredType = config.defaultSearch?.split(":")[1];
+  let engine = NATIVE_ENGINE;
+  if (configured && enabled.some((p) => p.name === configured)) engine = configured;
+  else if (enabled.length > 0) engine = enabled[0].name;
+  if (engine === NATIVE_ENGINE) return { engine, type: "basic" };
+  const modes = await listSearchModes();
+  const engineModes = modes.filter((m) => m.plugin === engine);
+  if (engineModes.length === 0) return { engine: NATIVE_ENGINE, type: "basic" };
+  if (configuredType && engineModes.some((m) => m.type === configuredType)) {
+    return { engine, type: configuredType };
+  }
+  return { engine, type: engineModes[0].type };
+}
+async function query(term, opts) {
+  const collections = await listCollections();
+  const engine = opts?.engine ?? await resolveDefaultEngine();
+  if (engine === NATIVE_ENGINE) return nativeSearch(term, collections, opts?.collection);
+  const provider = await loadSearchProvider(engine);
+  if (!provider) return nativeSearch(term, collections, opts?.collection);
+  try {
+    return await provider.search(term, collections, opts);
+  } catch {
+    return nativeSearch(term, collections, opts?.collection);
+  } finally {
+    await provider.close();
+  }
+}
+
+// src/doctor.ts
+var import_promises9 = __toESM(require("fs/promises"), 1);
+init_paths();
+init_registry();
+init_collections();
+
+// src/plugins/manager.ts
+var import_promises8 = __toESM(require("fs/promises"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var import_node_child_process3 = require("child_process");
+var import_node_util2 = require("util");
+init_paths();
+init_errors();
+init_collections();
+init_registry2();
+init_loader();
+var run = (0, import_node_util2.promisify)(import_node_child_process3.execFile);
+async function readPackageJson(file) {
+  try {
+    return JSON.parse(await import_promises8.default.readFile(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function binOf(manifest) {
+  if (typeof manifest.bin === "string") return manifest.bin;
+  if (manifest.bin && typeof manifest.bin === "object") {
+    const first = Object.values(manifest.bin)[0];
+    return typeof first === "string" ? first : null;
+  }
+  return null;
+}
+async function pluginManifestDirs(nodeModules) {
+  let entries;
+  try {
+    entries = await import_promises8.default.readdir(nodeModules);
+  } catch {
+    return [];
+  }
+  const dirs = [];
+  for (const entry of entries) {
+    if (entry.startsWith(".")) continue;
+    if (entry.startsWith("@")) {
+      let scoped;
+      try {
+        scoped = await import_promises8.default.readdir(import_node_path6.default.join(nodeModules, entry));
+      } catch {
+        continue;
+      }
+      for (const pkg of scoped) {
+        if (pkg.startsWith(".")) continue;
+        dirs.push(import_node_path6.default.join(nodeModules, entry, pkg));
       }
+    } else {
+      dirs.push(import_node_path6.default.join(nodeModules, entry));
     }
   }
-  return hits;
+  return dirs;
+}
+async function ensurePluginRoot() {
+  const dir = pluginsDir();
+  await import_promises8.default.mkdir(dir, { recursive: true });
+  const pkgPath = import_node_path6.default.join(dir, "package.json");
+  if (await readPackageJson(pkgPath) === null) {
+    const pkg = { name: "diffwiki-plugins", private: true, version: "0.0.0" };
+    await import_promises8.default.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+  }
+  return dir;
+}
+async function discoverSearchPackage(dir) {
+  const nodeModules = import_node_path6.default.join(dir, "node_modules");
+  for (const pkgDir of await pluginManifestDirs(nodeModules)) {
+    const manifest = await readPackageJson(import_node_path6.default.join(pkgDir, "package.json"));
+    if (!manifest?.name || manifest.diffwiki?.kind !== "search") continue;
+    const bin = binOf(manifest);
+    if (!bin) continue;
+    return { name: manifest.name, version: manifest.version, binAbs: import_node_path6.default.resolve(pkgDir, bin) };
+  }
+  return null;
+}
+async function bestEffortClose(provider) {
+  try {
+    await provider?.close();
+  } catch {
+  }
+}
+async function runSetup(name, prefetchModels) {
+  let provider = null;
+  try {
+    provider = await loadSearchProvider(name);
+    if (provider) {
+      await provider.setup(await listCollections(), { embed: false, prefetchModels });
+    }
+  } catch {
+  } finally {
+    await bestEffortClose(provider);
+  }
+}
+async function installPlugin(spec, opts) {
+  const dir = await ensurePluginRoot();
+  try {
+    await run("npm", ["install", spec, "--prefix", dir]);
+  } catch (err) {
+    throw new PluginError(`npm install ${spec} failed: ${err.message}`);
+  }
+  const discovered = await discoverSearchPackage(dir);
+  if (!discovered) {
+    throw new PluginError(
+      `no diffwiki search plugin found in "${spec}" (need package.json diffwiki.kind === "search" + bin)`
+    );
+  }
+  const record = {
+    name: discovered.name,
+    kind: "search",
+    command: ["node", discovered.binAbs],
+    version: discovered.version,
+    enabled: true,
+    managed: true
+  };
+  await upsertPlugin(record);
+  if (opts?.setup !== false) {
+    await runSetup(record.name, !!opts?.prefetchModels);
+  }
+  return record;
+}
+async function registerPlugin(name, command) {
+  if (command.length === 0) throw new PluginError(`register "${name}": --command must not be empty`);
+  const record = { name, kind: "search", command, enabled: true, managed: false };
+  await upsertPlugin(record);
+  const provider = await loadSearchProvider(name);
+  if (!provider) {
+    await deregisterPlugin(name);
+    throw new PluginError(`plugin "${name}" did not spawn as a search plugin (command: ${command.join(" ")})`);
+  }
+  try {
+    await provider.setup(await listCollections(), { embed: false, prefetchModels: false });
+  } catch {
+  } finally {
+    await bestEffortClose(provider);
+  }
+  return record;
+}
+async function removePlugin(name) {
+  const record = (await readPluginRegistry()).plugins.find((p) => p.name === name);
+  if (!record) throw new PluginError(`plugin "${name}" is not registered`);
+  if (record.managed) {
+    const dir = await ensurePluginRoot();
+    try {
+      await run("npm", ["uninstall", name, "--prefix", dir]);
+    } catch {
+    }
+  }
+  await deregisterPlugin(name);
+}
+async function probeSpawnable(name) {
+  let provider = null;
+  try {
+    provider = await loadSearchProvider(name);
+    return provider !== null;
+  } catch {
+    return false;
+  } finally {
+    await bestEffortClose(provider);
+  }
+}
+async function listPlugins() {
+  const registry = await readPluginRegistry();
+  const out = [];
+  for (const record of registry.plugins) {
+    const spawnable = record.enabled ? await probeSpawnable(record.name) : false;
+    out.push({ ...record, spawnable });
+  }
+  return out;
 }
 
 // src/doctor.ts
-var import_promises7 = __toESM(require("fs/promises"), 1);
+init_loader();
+init_types();
 async function exists(target) {
   try {
-    await import_promises7.default.access(target);
+    await import_promises9.default.access(target);
     return true;
   } catch {
     return false;
@@ -492,8 +1296,309 @@ async function doctor() {
   } else {
     out.push({ level: "warn", message: "no default collection set" });
   }
+  await appendPluginDiagnostics(out, config);
   return out;
 }
+function readinessLine(name, health) {
+  const r = health.readiness;
+  if (!r) {
+    return { level: health.ready ? "ok" : "warn", message: `plugin "${name}" ${health.ready ? "ready" : "not ready"}` };
+  }
+  if (r.firstSearchCost === "model-download") {
+    return {
+      level: "warn",
+      message: `plugin "${name}": ${r.docsIndexed} doc(s) indexed \u2014 first search will download models (~2GB)`
+    };
+  }
+  if (r.firstSearchCost === "model-load") {
+    return {
+      level: "warn",
+      message: `plugin "${name}": ${r.docsIndexed} doc(s) indexed \u2014 first search loads models (a few seconds)`
+    };
+  }
+  return { level: "ok", message: `plugin "${name}": ${r.docsIndexed} doc(s) indexed \u2014 first search is instant` };
+}
+async function appendPluginDiagnostics(out, config) {
+  let plugins = [];
+  try {
+    plugins = await listPlugins();
+  } catch (err) {
+    out.push({ level: "error", message: `failed to read plugin registry: ${err.message}` });
+    return;
+  }
+  if (plugins.length === 0) {
+    out.push({ level: "warn", message: "no search plugins installed \u2014 using built-in native search" });
+  }
+  const collections = await listCollections();
+  for (const p of plugins) {
+    if (!p.enabled) {
+      out.push({ level: "warn", message: `plugin "${p.name}" registered but disabled` });
+      continue;
+    }
+    if (!p.spawnable) {
+      out.push({
+        level: "error",
+        message: `plugin "${p.name}" registered but its command is not spawnable: ${p.command.join(" ")}`
+      });
+      continue;
+    }
+    out.push({ level: "ok", message: `plugin "${p.name}" enabled and spawnable` });
+    let provider = null;
+    try {
+      provider = await loadSearchProvider(p.name);
+      if (!provider) {
+        out.push({ level: "error", message: `plugin "${p.name}" failed to load for a health check` });
+        continue;
+      }
+      const health = await provider.health(collections);
+      for (const d of health.diagnostics) out.push({ level: d.level, message: `${p.name} \xB7 ${d.message}` });
+      out.push(readinessLine(p.name, health));
+    } catch (err) {
+      out.push({ level: "error", message: `plugin "${p.name}" health check failed: ${err.message}` });
+    } finally {
+      try {
+        await provider?.close();
+      } catch {
+      }
+    }
+  }
+  if (config.defaultSearch) {
+    const engine = config.defaultSearch.split(":")[0];
+    const known = engine === NATIVE_ENGINE || plugins.some((p) => p.name === engine && p.enabled);
+    if (!known) {
+      out.push({
+        level: "warn",
+        message: `defaultSearch "${config.defaultSearch}" is not installed/enabled \u2014 using native`
+      });
+    }
+  }
+}
+
+// src/browse.ts
+var import_promises10 = __toESM(require("fs/promises"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+init_collections();
+init_errors();
+var INDEX_RE = /^(index|readme)\.mdx?$/i;
+function buildArticleTree(relPaths) {
+  const root = {};
+  for (const raw of relPaths) {
+    const rel = raw.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!rel) continue;
+    const segs = rel.split("/");
+    let cur = root;
+    segs.forEach((seg, i) => {
+      if (i === segs.length - 1) {
+        if (!(seg in cur)) cur[seg] = null;
+      } else {
+        if (cur[seg] === null || !(seg in cur)) cur[seg] = {};
+        cur = cur[seg];
+      }
+    });
+  }
+  const stripExt = (f) => f.replace(/\.(mdx?)$/, "");
+  const walk = (trie, parents) => {
+    const entries = Object.entries(trie);
+    const branches = entries.filter(([, v]) => v !== null);
+    const leaves = entries.filter(([, v]) => v === null).map(([k]) => k).filter((f) => !INDEX_RE.test(f));
+    branches.sort(([a], [b]) => a.toLowerCase().localeCompare(b.toLowerCase()));
+    leaves.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+    const branchNodes = branches.map(([seg, sub]) => ({
+      name: seg,
+      title: seg,
+      // Folders are navigable to their index page (an authored index.md/README,
+      // else a generated listing).
+      slug: [...parents, seg].join("/"),
+      children: walk(sub, [...parents, seg])
+    }));
+    const leafNodes = leaves.map((file) => {
+      const nameNoExt = stripExt(file);
+      return { name: nameNoExt, title: nameNoExt, slug: [...parents, nameNoExt].join("/") };
+    });
+    return [...branchNodes, ...leafNodes];
+  };
+  return walk(root, []);
+}
+async function collectRelPaths(dir, rel = "") {
+  let dirents;
+  try {
+    dirents = await import_promises10.default.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const d of dirents) {
+    if (d.name.startsWith(".")) continue;
+    const childRel = rel ? `${rel}/${d.name}` : d.name;
+    if (d.isDirectory()) {
+      out.push(...await collectRelPaths(import_node_path7.default.join(dir, d.name), childRel));
+    } else if (/\.(mdx?)$/.test(d.name)) {
+      out.push(childRel);
+    }
+  }
+  return out;
+}
+async function readdirSafe(dir) {
+  try {
+    return await import_promises10.default.readdir(dir);
+  } catch {
+    return [];
+  }
+}
+function pickIndexFile(names) {
+  const rank = (n) => {
+    const lower = n.toLowerCase();
+    const base = lower.startsWith("index") ? 0 : 1;
+    const ext = lower.endsWith(".mdx") ? 0 : 1;
+    return base * 2 + ext;
+  };
+  return names.filter((n) => INDEX_RE.test(n)).sort((a, b) => rank(a) - rank(b))[0];
+}
+async function cheapTitle(absPath) {
+  let handle;
+  try {
+    handle = await import_promises10.default.open(absPath, "r");
+    const buf = Buffer.alloc(512);
+    const { bytesRead } = await handle.read(buf, 0, 512, 0);
+    const snippet = buf.subarray(0, bytesRead).toString("utf8");
+    const m = snippet.match(/^---[\s\S]*?^title:\s*(.+)$/m);
+    if (m) return m[1].trim().replace(/^["']|["']$/g, "");
+  } catch {
+  } finally {
+    await handle?.close();
+  }
+  return void 0;
+}
+async function enrichTitles(nodes, collDir) {
+  return Promise.all(
+    nodes.map(async (node) => {
+      if (node.children) {
+        const children = await enrichTitles(node.children, collDir);
+        let title = node.title;
+        if (node.slug) {
+          const dir = import_node_path7.default.join(collDir, node.slug);
+          const idx = pickIndexFile(await readdirSafe(dir));
+          if (idx) title = await cheapTitle(import_node_path7.default.join(dir, idx)) ?? title;
+        }
+        return { ...node, title, children };
+      }
+      for (const ext of [".mdx", ".md"]) {
+        const title = await cheapTitle(import_node_path7.default.join(collDir, `${node.slug}${ext}`));
+        if (title) return { ...node, title };
+      }
+      return node;
+    })
+  );
+}
+async function listArticleTree(coll) {
+  const entry = await findCollection(coll);
+  if (!entry) throw new CollectionNotFoundError(coll);
+  const rels = await collectRelPaths(entry.path);
+  return enrichTitles(buildArticleTree(rels), import_node_path7.default.resolve(entry.path));
+}
+async function readArticle(coll, slug) {
+  const entry = await findCollection(coll);
+  if (!entry) throw new CollectionNotFoundError(coll);
+  const collDir = import_node_path7.default.resolve(entry.path);
+  const normalized = slug.replace(/\\/g, "/");
+  if (normalized.split("/").some((s) => s === "..")) {
+    throw new InvalidTargetError(slug, "path traversal detected");
+  }
+  const safeSlug = normalized.split("/").filter((s) => s !== "" && s !== ".").join("/");
+  const inJail = (p) => p === collDir || p.startsWith(collDir + import_node_path7.default.sep);
+  let abs;
+  for (const rel of safeSlug ? [`${safeSlug}.mdx`, `${safeSlug}.md`] : []) {
+    const candidate = import_node_path7.default.resolve(collDir, rel);
+    if (!inJail(candidate)) throw new InvalidTargetError(slug, "path traversal detected");
+    try {
+      await import_promises10.default.access(candidate);
+      abs = candidate;
+      break;
+    } catch {
+    }
+  }
+  if (!abs) {
+    const dir = import_node_path7.default.resolve(collDir, safeSlug);
+    if (inJail(dir)) {
+      const idx = pickIndexFile(await readdirSafe(dir));
+      if (idx) abs = import_node_path7.default.join(dir, idx);
+    }
+  }
+  if (!abs) throw new ArticleNotFoundError(`${coll}/${safeSlug}`);
+  const parsed = parseArticle(await import_promises10.default.readFile(abs, "utf8"));
+  const title = parsed.title?.trim() || (safeSlug ? safeSlug.split("/").pop() ?? safeSlug : coll);
+  return { coll, slug: safeSlug, title, tags: parsed.tags, body: parsed.body, path: abs };
+}
+
+// src/render.ts
+var import_unified = require("unified");
+var import_remark_parse = __toESM(require("remark-parse"), 1);
+var import_remark_gfm = __toESM(require("remark-gfm"), 1);
+var import_remark_rehype = __toESM(require("remark-rehype"), 1);
+var import_rehype_slug = __toESM(require("rehype-slug"), 1);
+var import_rehype = __toESM(require("@shikijs/rehype"), 1);
+var import_rehype_stringify = __toESM(require("rehype-stringify"), 1);
+var import_unist_util_visit = require("unist-util-visit");
+var import_hast_util_to_string = require("hast-util-to-string");
+var LANG_ALIASES = {
+  "c#": "csharp",
+  cs: "csharp",
+  "c++": "cpp",
+  cxx: "cpp",
+  hs: "haskell",
+  ex: "elixir"
+};
+function rehypeCollectToc(toc) {
+  return (tree) => {
+    (0, import_unist_util_visit.visit)(tree, "element", (node) => {
+      if (node.tagName !== "h2" && node.tagName !== "h3") return;
+      const id = node.properties?.id;
+      if (!id) return;
+      toc.push({ slug: String(id), text: (0, import_hast_util_to_string.toString)(node), depth: node.tagName === "h2" ? 2 : 3 });
+    });
+  };
+}
+function rehypeStripLeadingH1() {
+  return (tree) => {
+    let removed = false;
+    (0, import_unist_util_visit.visit)(tree, "element", (node, index, parent) => {
+      if (!removed && node.tagName === "h1" && parent && index != null) {
+        parent.children.splice(index, 1);
+        removed = true;
+        return [import_unist_util_visit.SKIP, index];
+      }
+    });
+  };
+}
+function rehypeMarkMermaid() {
+  return (tree) => {
+    (0, import_unist_util_visit.visit)(tree, "element", (node) => {
+      if (node.tagName !== "pre") return;
+      const code = node.children.find((c) => c.type === "element" && c.tagName === "code");
+      const cls = code?.properties?.className ?? [];
+      if (!code || !cls.includes("language-mermaid")) return;
+      const source = (0, import_hast_util_to_string.toString)(code);
+      node.properties = { className: ["mermaid"] };
+      node.children = [{ type: "text", value: source }];
+    });
+  };
+}
+async function renderArticle(body) {
+  const toc = [];
+  const file = await (0, import_unified.unified)().use(import_remark_parse.default).use(import_remark_gfm.default).use(import_remark_rehype.default).use(import_rehype_slug.default).use(rehypeCollectToc, toc).use(rehypeStripLeadingH1).use(rehypeMarkMermaid).use(import_rehype.default, {
+    themes: { light: "github-light", dark: "github-dark" },
+    defaultColor: false,
+    langAlias: LANG_ALIASES,
+    fallbackLanguage: "plaintext"
+  }).use(import_rehype_stringify.default).process(body);
+  return { html: String(file), toc };
+}
+
+// src/index.ts
+init_registry2();
+init_client();
+init_loader();
+init_events();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArticleNotFoundError,
@@ -501,38 +1606,63 @@ async function doctor() {
   CollectionNotFoundError,
   DiffwikiError,
   InvalidTargetError,
+  NATIVE_ENGINE,
   NoDefaultCollectionError,
+  PluginError,
   REPO_CONFIG_FILE,
   addTags,
+  buildArticleTree,
   collectionDir,
   collectionsDir,
   configPath,
   createArticle,
   createCollection,
+  deregisterPlugin,
   doctor,
+  emitPluginEvent,
+  ensurePluginRoot,
   findCollection,
+  findEnabledPlugin,
   getConfigValue,
   initRepoWiki,
+  installPlugin,
+  listArticleTree,
   listCollections,
+  listEnabledPlugins,
+  listPlugins,
+  listSearchModes,
+  loadSearchProvider,
+  nativeSearch,
   parseAddTarget,
   parseArticle,
   parsePathTarget,
+  pluginsDir,
+  pluginsRegistryPath,
   query,
+  readArticle,
   readConfig,
+  readPluginRegistry,
   readRegistry,
   readRepoConfig,
   registerCollection,
+  registerPlugin,
   registryPath,
   removeArticle,
   removeCollection,
+  removePlugin,
   removeTags,
+  renderArticle,
+  resolveDefaultSearchMode,
   resolveHome,
   serializeArticle,
   setConfigValue,
   setTags,
   slugify,
+  spawnPluginClient,
   unregisterCollection,
   updateArticleBody,
+  upsertPlugin,
   writeConfig,
+  writePluginRegistry,
   writeRegistry
 });