diffwiki-core 0.17.3 → 0.18.0

package/dist/index.cjs

@@ -113,6 +113,9 @@ function collectionsDir() {
 function templatesDir() {
   return import_node_path.default.join(resolveHome(), "templates");
 }
+function metaDir() {
+  return import_node_path.default.join(resolveHome(), "meta");
+}
 function collectionDir(name) {
   return import_node_path.default.join(collectionsDir(), name);
 }
@@ -131,13 +134,295 @@ var init_paths = __esm({
   }
 });
 
+// src/meta.ts
+function validateMetaArticlePath(file) {
+  if (!/\.mdx?$/i.test(file) || import_node_path3.default.isAbsolute(file) || /[\\\0]/.test(file) || file.split("/").some((part) => !part || part === "." || part === ".." || part.startsWith("."))) {
+    throw new InvalidTargetError(file, "expected an exact relative .md/.mdx file path without traversal");
+  }
+  return file;
+}
+async function ensureCollectionMeta(entry) {
+  const root = collectionRoot(entry.name);
+  const source = import_node_path3.default.resolve(entry.path);
+  if (within(source, import_node_path3.default.resolve(metaDir())) || within(import_node_path3.default.resolve(metaDir()), source)) {
+    throw new InvalidTargetError(entry.path, "collection content overlaps the metadata store");
+  }
+  const index = import_node_path3.default.join(root, ".meta", "META.md");
+  await seed(index, `Sources for ${entry.name}`);
+  await globalIndex();
+  return index;
+}
+async function ensureArticleMeta(entry, articlePath) {
+  const relative = validateMetaArticlePath(articlePath);
+  await ensureCollectionMeta(entry);
+  const mirror = import_node_path3.default.join(collectionRoot(entry.name), relative);
+  if (await seed(mirror, `Sources for ${entry.name}:${relative}`)) await reindexMeta(entry.name);
+  return mirror;
+}
+async function mirrorSavedArticle(entry, file) {
+  try {
+    await ensureArticleMeta(entry, import_node_path3.default.relative(entry.path, file).split(import_node_path3.default.sep).join("/"));
+  } catch (err) {
+    throw new DiffwikiError(
+      `Article saved at ${file}, but metadata setup failed: ${String(err)}. Repair with: diffwiki meta init ${entry.name}`
+    );
+  }
+}
+async function reindexMeta(collection) {
+  await import_promises3.default.mkdir(await checked(metaDir()), { recursive: true });
+  const result = { created: [], kept: [], index_paths: [], warnings: [], errors: [] };
+  const names = collection ? [collection] : (await import_promises3.default.readdir(metaDir(), { withFileTypes: true })).filter((item) => item.isDirectory() && !item.name.startsWith(".")).map((item) => item.name).sort();
+  for (const name of names) {
+    try {
+      const root = await checked(collectionRoot(name));
+      const index = import_node_path3.default.join(root, ".meta", "META.md");
+      await import_promises3.default.access(await checked(index));
+      const pages = await markdownFiles(root);
+      const recordDir = await checked(import_node_path3.default.join(root, ".meta", "records"));
+      let records = [];
+      try {
+        records = (await import_promises3.default.readdir(recordDir)).filter((file) => file.endsWith(".md")).sort();
+      } catch (err) {
+        if (!missing(err)) throw err;
+      }
+      const pageLines = new Map(pages.map((file) => [file, []]));
+      const sourceLines = [];
+      const dreamLines = [];
+      for (const record of records) {
+        const file = await checked(import_node_path3.default.join(recordDir, record));
+        try {
+          const raw = await import_promises3.default.readFile(file, "utf8");
+          const front = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(raw);
+          if (!front) throw new Error("missing record header");
+          const doc = (0, import_yaml2.parseDocument)(front[1]);
+          if (doc.errors.length) throw new Error("invalid YAML header");
+          const data = doc.toJS();
+          if (!data || !META_KINDS.includes(data.kind) || data.collection !== name || typeof data.captured_at !== "string") {
+            throw new Error("invalid kind, collection, or capture time");
+          }
+          const article = data.article_path === void 0 ? void 0 : validateMetaArticlePath(String(data.article_path));
+          const label = `${data.kind} \xB7 ${record.replace(/\.md$/, "")}`;
+          const bucket = data.kind === "dream-learning" ? dreamLines : sourceLines;
+          bucket.push(`- ${link(index, file, label)}${article ? ` \u2014 \`${article}\`` : " \u2014 collection"}`);
+          if (article) {
+            if (!pageLines.has(article))
+              result.warnings.push(`${file}: no manifest for ${article}; run meta init if the article exists`);
+            else pageLines.get(article).push(`- ${link(import_node_path3.default.join(root, article), file, label)}`);
+          }
+        } catch (err) {
+          result.warnings.push(`${file}: ${String(err)}`);
+        }
+      }
+      for (const [page, lines] of pageLines) {
+        const file = import_node_path3.default.join(root, page);
+        await listing(file, `Sources for ${name}:${page}`, [
+          `Collection: ${link(file, index, "collection sources")}`,
+          "",
+          ...lines.length ? lines : ["No page source history captured."]
+        ]);
+      }
+      await listing(index, `Sources for ${name}`, [
+        "## Raw sources",
+        "",
+        ...sourceLines.length ? sourceLines : ["No raw sources captured."],
+        "",
+        "## Dream learnings",
+        "",
+        ...dreamLines.length ? dreamLines : ["No dream learnings captured."],
+        "",
+        "## Pages",
+        "",
+        ...pages.map((page) => `- ${link(index, import_node_path3.default.join(root, page), page)}`)
+      ]);
+      result.index_paths.push(index);
+    } catch (err) {
+      result.errors.push(`${name}: ${String(err)}`);
+    }
+  }
+  result.index_paths.push(await globalIndex());
+  return result;
+}
+async function initMeta(entries) {
+  const result = { created: [], kept: [], index_paths: [], warnings: [], errors: [] };
+  for (const entry of entries) {
+    try {
+      const files = await markdownFiles(entry.path);
+      await ensureCollectionMeta(entry);
+      for (const file of files) {
+        const mirror = import_node_path3.default.join(collectionRoot(entry.name), validateMetaArticlePath(file));
+        (await seed(mirror, `Sources for ${entry.name}:${file}`) ? result.created : result.kept).push(mirror);
+      }
+      const indexed = await reindexMeta(entry.name);
+      result.index_paths.push(...indexed.index_paths);
+      result.warnings.push(...indexed.warnings);
+      result.errors.push(...indexed.errors);
+    } catch (err) {
+      result.errors.push(`${entry.name}: ${String(err)}`);
+    }
+  }
+  if (!entries.length) result.index_paths.push(await globalIndex());
+  result.index_paths = [...new Set(result.index_paths)];
+  return result;
+}
+async function createMetaRecord(entry, articlePath, kind, body) {
+  if (!META_KINDS.includes(kind)) throw new InvalidTargetError(kind, "unknown metadata template");
+  let mirror;
+  if (articlePath !== void 0) {
+    validateMetaArticlePath(articlePath);
+    const sourceRoot = await import_promises3.default.realpath(entry.path);
+    const source = await import_promises3.default.realpath(import_node_path3.default.resolve(entry.path, articlePath));
+    if (!within(sourceRoot, source) || !(await import_promises3.default.stat(source)).isFile()) {
+      throw new InvalidTargetError(articlePath, "article must be a file within its collection");
+    }
+    mirror = await ensureArticleMeta(entry, articlePath);
+  } else await ensureCollectionMeta(entry);
+  const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const id = `${capturedAt.replace(/[-:.]/g, "")}-${(0, import_node_crypto.randomUUID)().slice(0, 8)}`;
+  const file = await checked(import_node_path3.default.join(collectionRoot(entry.name), ".meta", "records", `${id}.md`));
+  await import_promises3.default.mkdir(import_node_path3.default.dirname(file), { recursive: true });
+  const header = {
+    kind,
+    collection: entry.name,
+    ...articlePath ? { article_path: articlePath } : {},
+    captured_at: capturedAt
+  };
+  await import_promises3.default.writeFile(file, `---
+${(0, import_yaml2.stringify)(header)}---
+${body}`, { flag: "wx" });
+  const indexed = await reindexMeta(entry.name);
+  if (indexed.errors.length)
+    throw new DiffwikiError(
+      `Record saved at ${file}, but indexing failed: ${indexed.errors.join("; ")}. Repair with: diffwiki meta reindex ${entry.name}`
+    );
+  return {
+    id,
+    path: file,
+    target: articlePath ? `${entry.name}:${articlePath}` : entry.name,
+    ...mirror ? { mirror_path: mirror } : {},
+    index_paths: indexed.index_paths
+  };
+}
+function collectionRoot(name) {
+  if (!name || name.startsWith(".") || /[/\\\0]/.test(name) || name.toLowerCase() === "meta.md") {
+    throw new InvalidTargetError(name, "expected a collection name without path segments or reserved names");
+  }
+  return import_node_path3.default.resolve(metaDir(), name);
+}
+async function checked(file) {
+  const root = import_node_path3.default.resolve(metaDir());
+  const absolute = import_node_path3.default.resolve(file);
+  if (!within(root, absolute)) throw new InvalidTargetError(file, "path escapes the metadata root");
+  const parts = import_node_path3.default.relative(root, absolute).split(import_node_path3.default.sep).filter(Boolean);
+  let current = root;
+  for (const part of ["", ...parts]) {
+    current = part ? import_node_path3.default.join(current, part) : current;
+    try {
+      if ((await import_promises3.default.lstat(current)).isSymbolicLink()) throw new DiffwikiError(`metadata path is a symlink: ${current}`);
+    } catch (err) {
+      if (missing(err)) break;
+      throw err;
+    }
+  }
+  return absolute;
+}
+async function seed(file, title) {
+  await checked(file);
+  await import_promises3.default.mkdir(import_node_path3.default.dirname(file), { recursive: true });
+  try {
+    await import_promises3.default.writeFile(file, `# ${title}
+
+${START}
+No source history captured.
+${END}
+`, { flag: "wx" });
+    return true;
+  } catch (err) {
+    if (err.code === "EEXIST") return false;
+    throw err;
+  }
+}
+async function listing(file, title, lines) {
+  await seed(file, title);
+  const raw = await import_promises3.default.readFile(await checked(file), "utf8");
+  const block = `${START}
+${lines.length ? lines.join("\n") : "No source history captured."}
+${END}`;
+  const start = raw.indexOf(START);
+  const end = raw.indexOf(END, start);
+  if (start >= 0 !== end >= 0) throw new DiffwikiError(`incomplete generated section in ${file}`);
+  const next = start >= 0 ? raw.slice(0, start) + block + raw.slice(end + END.length) : `${raw}
+${block}
+`;
+  if (next === raw) return;
+  const temporary = `${file}.${(0, import_node_crypto.randomUUID)()}.tmp`;
+  try {
+    await import_promises3.default.writeFile(await checked(temporary), next, { flag: "wx" });
+    await checked(file);
+    await import_promises3.default.rename(temporary, file);
+  } finally {
+    await import_promises3.default.rm(temporary, { force: true });
+  }
+}
+function link(from, to, label) {
+  const href = import_node_path3.default.relative(import_node_path3.default.dirname(from), to).split(import_node_path3.default.sep).map(encodeURIComponent).join("/");
+  return `[${label.replaceAll("[", "").replaceAll("]", "").replace(/[\r\n]/g, "")}](${href})`;
+}
+async function markdownFiles(root, rel = "") {
+  const out = [];
+  for (const item of (await import_promises3.default.readdir(import_node_path3.default.join(root, rel), { withFileTypes: true })).sort(
+    (a, b) => a.name.localeCompare(b.name)
+  )) {
+    if (item.name.startsWith(".")) continue;
+    const file = rel ? `${rel}/${item.name}` : item.name;
+    if (item.isDirectory()) out.push(...await markdownFiles(root, file));
+    else if (item.isFile() && /\.mdx?$/i.test(file)) out.push(file);
+  }
+  return out;
+}
+async function globalIndex() {
+  await import_promises3.default.mkdir(await checked(metaDir()), { recursive: true });
+  const index = import_node_path3.default.join(metaDir(), "META.md");
+  const lines = [];
+  for (const item of (await import_promises3.default.readdir(metaDir(), { withFileTypes: true })).sort(
+    (a, b) => a.name.localeCompare(b.name)
+  )) {
+    if (!item.isDirectory() || item.name.startsWith(".")) continue;
+    const collectionIndex = import_node_path3.default.join(collectionRoot(item.name), ".meta", "META.md");
+    try {
+      await import_promises3.default.access(await checked(collectionIndex));
+      lines.push(`- ${link(index, collectionIndex, item.name)}`);
+    } catch (err) {
+      if (!missing(err)) throw err;
+    }
+  }
+  await listing(index, "Source collections", lines);
+  return index;
+}
+var import_promises3, import_node_path3, import_node_crypto, import_yaml2, META_KINDS, START, END, within, missing;
+var init_meta = __esm({
+  "src/meta.ts"() {
+    "use strict";
+    import_promises3 = __toESM(require("fs/promises"), 1);
+    import_node_path3 = __toESM(require("path"), 1);
+    import_node_crypto = require("crypto");
+    import_yaml2 = require("yaml");
+    init_paths();
+    init_errors();
+    META_KINDS = ["history", "external-source-extract", "dream-learning"];
+    START = "<!-- diffwiki:meta:start -->";
+    END = "<!-- diffwiki:meta:end -->";
+    within = (root, file) => file === root || file.startsWith(root + import_node_path3.default.sep);
+    missing = (err) => err.code === "ENOENT";
+  }
+});
+
 // src/registry.ts
 function isMissing(err) {
   return err?.code === "ENOENT";
 }
 async function readRegistry() {
   try {
-    const parsed = JSON.parse(await import_promises3.default.readFile(registryPath(), "utf8"));
+    const parsed = JSON.parse(await import_promises4.default.readFile(registryPath(), "utf8"));
     return { version: parsed.version ?? 1, collections: parsed.collections ?? [] };
   } catch (err) {
     if (isMissing(err)) return { version: 1, collections: [] };
@@ -145,8 +430,8 @@ async function readRegistry() {
   }
 }
 async function writeRegistry(registry) {
-  await import_promises3.default.mkdir(resolveHome(), { recursive: true });
-  await import_promises3.default.writeFile(registryPath(), `${JSON.stringify(registry, null, 2)}
+  await import_promises4.default.mkdir(resolveHome(), { recursive: true });
+  await import_promises4.default.writeFile(registryPath(), `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 async function registerCollection(entry) {
@@ -158,18 +443,27 @@ async function registerCollection(entry) {
     registry.collections.push(entry);
   }
   await writeRegistry(registry);
+  try {
+    await ensureCollectionMeta(entry);
+  } catch (err) {
+    throw new DiffwikiError(
+      `Collection ${entry.name} registered, but metadata setup failed: ${String(err)}. Repair with: diffwiki meta init ${entry.name}`
+    );
+  }
 }
 async function unregisterCollection(name) {
   const registry = await readRegistry();
   registry.collections = registry.collections.filter((c) => c.name !== name);
   await writeRegistry(registry);
 }
-var import_promises3;
+var import_promises4;
 var init_registry = __esm({
   "src/registry.ts"() {
     "use strict";
-    import_promises3 = __toESM(require("fs/promises"), 1);
+    import_promises4 = __toESM(require("fs/promises"), 1);
     init_paths();
+    init_meta();
+    init_errors();
   }
 });
 
@@ -179,7 +473,7 @@ function isMissing2(err) {
 }
 async function readPluginRegistry() {
   try {
-    const parsed = JSON.parse(await import_promises4.default.readFile(pluginsRegistryPath(), "utf8"));
+    const parsed = JSON.parse(await import_promises5.default.readFile(pluginsRegistryPath(), "utf8"));
     return { version: parsed.version ?? 1, plugins: parsed.plugins ?? [] };
   } catch (err) {
     if (isMissing2(err)) return { version: 1, plugins: [] };
@@ -187,8 +481,8 @@ async function readPluginRegistry() {
   }
 }
 async function writePluginRegistry(registry) {
-  await import_promises4.default.mkdir(resolveHome(), { recursive: true });
-  await import_promises4.default.writeFile(pluginsRegistryPath(), `${JSON.stringify(registry, null, 2)}
+  await import_promises5.default.mkdir(resolveHome(), { recursive: true });
+  await import_promises5.default.writeFile(pluginsRegistryPath(), `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 async function upsertPlugin(record) {
@@ -219,11 +513,11 @@ async function findPluginRecord(name) {
   const registry = await readPluginRegistry();
   return registry.plugins.find((p) => p.name === name);
 }
-var import_promises4;
+var import_promises5;
 var init_registry2 = __esm({
   "src/plugins/registry.ts"() {
     "use strict";
-    import_promises4 = __toESM(require("fs/promises"), 1);
+    import_promises5 = __toESM(require("fs/promises"), 1);
     init_paths();
   }
 });
@@ -250,7 +544,7 @@ var init_logger = __esm({
 // src/plugins/host.ts
 async function invokePlugin(command, op, params, opts) {
   const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const scope = opts?.name ?? (0, import_node_path3.basename)(command[1] ?? command[0] ?? "plugin");
+  const scope = opts?.name ?? (0, import_node_path4.basename)(command[1] ?? command[0] ?? "plugin");
   return new Promise((resolve, reject) => {
     const child = (0, import_node_child_process.spawn)(command[0], command.slice(1), {
       stdio: ["pipe", "pipe", "pipe"]
@@ -354,7 +648,7 @@ function mapHits(result, collections) {
     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_path3.default.join(coll.path, h.relPath) : h.relPath;
+    const abs = coll ? import_node_path4.default.join(coll.path, h.relPath) : h.relPath;
     out.push({
       collection: h.collection,
       path: abs,
@@ -455,12 +749,12 @@ async function listSearchModes() {
   }
   return modes;
 }
-var import_node_child_process, import_node_path3, LEVEL_METHOD, DEFAULT_TIMEOUT_MS, SEARCH_TIMEOUT_MS, LONG_TIMEOUT_MS;
+var import_node_child_process, import_node_path4, LEVEL_METHOD, DEFAULT_TIMEOUT_MS, SEARCH_TIMEOUT_MS, LONG_TIMEOUT_MS;
 var init_host = __esm({
   "src/plugins/host.ts"() {
     "use strict";
     import_node_child_process = require("child_process");
-    import_node_path3 = __toESM(require("path"), 1);
+    import_node_path4 = __toESM(require("path"), 1);
     init_logger();
     init_types();
     init_registry2();
@@ -534,7 +828,7 @@ async function findCollectionById(id) {
 async function createCollection(name, opts) {
   if (await findCollection(name)) throw new CollectionExistsError(name);
   const dir = collectionDir(name);
-  await import_promises5.default.mkdir(dir, { recursive: true });
+  await import_promises6.default.mkdir(dir, { recursive: true });
   const entry = {
     name,
     type: "global",
@@ -551,16 +845,16 @@ async function removeCollection(name) {
   if (!entry) throw new CollectionNotFoundError(name);
   await unregisterCollection(name);
   if (entry.type === "global") {
-    await import_promises5.default.rm(entry.path, { recursive: true, force: true });
+    await import_promises6.default.rm(entry.path, { recursive: true, force: true });
   }
   void fireHook("collection-removed", name);
   return entry;
 }
-var import_promises5;
+var import_promises6;
 var init_collections = __esm({
   "src/collections.ts"() {
     "use strict";
-    import_promises5 = __toESM(require("fs/promises"), 1);
+    import_promises6 = __toESM(require("fs/promises"), 1);
     init_paths();
     init_registry();
     init_errors();
@@ -577,6 +871,7 @@ __export(index_exports, {
   DiffwikiError: () => DiffwikiError,
   InvalidExportSelectionError: () => InvalidExportSelectionError,
   InvalidTargetError: () => InvalidTargetError,
+  META_KINDS: () => META_KINDS,
   NATIVE_ENGINE: () => NATIVE_ENGINE,
   NoDefaultCollectionError: () => NoDefaultCollectionError,
   PROJECT_CONFIG_FILE: () => PROJECT_CONFIG_FILE,
@@ -598,10 +893,13 @@ __export(index_exports, {
   configPath: () => configPath,
   createArticle: () => createArticle,
   createCollection: () => createCollection,
+  createMetaRecord: () => createMetaRecord,
   currentBranch: () => currentBranch,
   deregisterPlugin: () => deregisterPlugin,
   doctor: () => doctor,
   emitPluginEvent: () => emitPluginEvent,
+  ensureArticleMeta: () => ensureArticleMeta,
+  ensureCollectionMeta: () => ensureCollectionMeta,
   ensureGitRepo: () => ensureGitRepo,
   ensureHome: () => ensureHome,
   ensurePluginRoot: () => ensurePluginRoot,
@@ -613,6 +911,7 @@ __export(index_exports, {
   getConfigValue: () => getConfigValue,
   getLogger: () => getLogger,
   gitToplevel: () => gitToplevel,
+  initMeta: () => initMeta,
   initRepoWiki: () => initRepoWiki,
   installPlugin: () => installPlugin,
   invalidateLinkGraph: () => invalidateLinkGraph,
@@ -629,11 +928,14 @@ __export(index_exports, {
   listTemplates: () => listTemplates,
   loadSearchProvider: () => loadSearchProvider,
   localGraph: () => localGraph,
+  metaDir: () => metaDir,
+  mirrorSavedArticle: () => mirrorSavedArticle,
   nativeSearch: () => nativeSearch,
   parseAddTarget: () => parseAddTarget,
   parseArticle: () => parseArticle,
   parseFrontmatter: () => parseFrontmatter,
   parsePathTarget: () => parsePathTarget,
+  patchArticle: () => patchArticle,
   pluginsDir: () => pluginsDir,
   pluginsRegistryPath: () => pluginsRegistryPath,
   query: () => query,
@@ -649,6 +951,7 @@ __export(index_exports, {
   registerCollection: () => registerCollection,
   registerPlugin: () => registerPlugin,
   registryPath: () => registryPath,
+  reindexMeta: () => reindexMeta,
   removeArticle: () => removeArticle,
   removeCollection: () => removeCollection,
   removePlugin: () => removePlugin,
@@ -682,9 +985,11 @@ __export(index_exports, {
   toTreeNodes: () => toTreeNodes,
   tokenize: () => tokenize,
   unregisterCollection: () => unregisterCollection,
+  updateArticle: () => updateArticle,
   updateArticleBody: () => updateArticleBody,
   upsertPlugin: () => upsertPlugin,
   upstreamStatus: () => upstreamStatus,
+  validateMetaArticlePath: () => validateMetaArticlePath,
   writeConfig: () => writeConfig,
   writePluginRegistry: () => writePluginRegistry,
   writeRegistry: () => writeRegistry
@@ -724,9 +1029,10 @@ init_paths();
 // src/frontmatter.ts
 var import_gray_matter = __toESM(require("gray-matter"), 1);
 var import_yaml = require("yaml");
+init_errors();
 var YAML_ENGINE = {
   parse: (input) => {
-    const data = (0, import_yaml.parse)(input);
+    const data = (0, import_yaml.parse)(input.replace(/\r\n?/g, "\n"));
     return data && typeof data === "object" ? data : {};
   },
   stringify: (data) => (0, import_yaml.stringify)(data)
@@ -770,6 +1076,31 @@ var FRONTMATTER_BLOCK_RE = /^\uFEFF?[ \t]*---\r?\n[\s\S]*?\r?\n---[ \t]*(?:\r?\n
 function stripFrontmatter(raw) {
   return raw.replace(FRONTMATTER_BLOCK_RE, "");
 }
+function patchArticle(raw, fields, body) {
+  const fence = /^(\uFEFF?[ \t]*---[ \t]*\r?\n)([\s\S]*?)(\r?\n---[ \t]*(?:\r?\n|$))/.exec(raw);
+  if (Object.keys(fields).length === 0) return fence ? fence[0] + (body ?? raw.slice(fence[0].length)) : body ?? raw;
+  const originalYaml = fence?.[2] ?? "";
+  const doc = (0, import_yaml.parseDocument)(originalYaml);
+  if (doc.errors.length)
+    throw new DiffwikiError("Cannot update article with invalid YAML frontmatter. Fix its header first.");
+  const titleNode = doc.get("title", true);
+  if (fence && body === void 0 && Object.keys(fields).length === 1 && typeof fields.title === "string" && !/[\r\n]/.test(fields.title) && (0, import_yaml.isScalar)(titleNode) && titleNode.range) {
+    const [start, end] = titleNode.range;
+    if (!/[\r\n]/.test(originalYaml.slice(start, end))) {
+      const scalar = (0, import_yaml.stringify)(fields.title, { lineWidth: 0 }).trimEnd();
+      return fence[1] + originalYaml.slice(0, start) + scalar + originalYaml.slice(end) + fence[3] + raw.slice(fence[0].length);
+    }
+  }
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === void 0) doc.delete(key);
+    else doc.set(key, value);
+  }
+  const newline = fence?.[1].endsWith("\r\n") ? "\r\n" : "\n";
+  const yaml = doc.toString({ lineWidth: 0 }).replace(/\n$/, "").replace(/\r?\n/g, newline);
+  const content = body ?? (fence ? raw.slice(fence[0].length) : raw);
+  const close = fence?.[3] ?? `${newline}---${newline}`;
+  return (fence?.[1] ?? `---${newline}`) + yaml + close + (body && !close.endsWith("\n") ? newline : "") + content;
+}
 function parseFrontmatter(raw) {
   try {
     const { data, content } = (0, import_gray_matter.default)(raw, MATTER_OPTS);
@@ -819,28 +1150,40 @@ async function seedTemplates(srcDir) {
   return { seeded, skipped, dir };
 }
 async function listTemplateShapes(srcDir) {
-  const files = await import_promises2.default.readdir(srcDir);
-  return files.filter((f) => f.endsWith("-template.md")).map((f) => f.replace(/-template\.md$/, "")).sort();
+  return (await listTemplates(srcDir)).map((info) => info.shape).sort();
 }
-async function listTemplates(srcDir) {
-  const files = (await import_promises2.default.readdir(srcDir)).filter((f) => f.endsWith("-template.md")).sort();
+async function listTemplates(srcDir, category = "article") {
+  const files = /* @__PURE__ */ new Map();
+  for (const dir of [srcDir, templatesDir()]) {
+    let names;
+    try {
+      names = await import_promises2.default.readdir(dir);
+    } catch (err) {
+      if (err.code === "ENOENT") continue;
+      throw err;
+    }
+    for (const name of names.filter((name2) => name2.endsWith("-template.md")).sort())
+      files.set(name, import_node_path2.default.resolve(dir, name));
+  }
   const out = [];
-  for (const file of files) {
+  for (const [file, filePath] of [...files].sort(([a], [b]) => a.localeCompare(b))) {
     let data = {};
     try {
-      ({ data } = parseFrontmatter(await import_promises2.default.readFile(import_node_path2.default.join(srcDir, file), "utf8")));
+      ({ data } = parseFrontmatter(await import_promises2.default.readFile(filePath, "utf8")));
     } catch {
     }
     const shape = typeof data.shape === "string" && data.shape ? data.shape : file.replace(/-template\.md$/, "");
     const purpose = typeof data.purpose === "string" ? data.purpose : "";
     const budget = Array.isArray(data.budget) && data.budget.length === 2 ? [Number(data.budget[0]), Number(data.budget[1])] : void 0;
-    out.push({ shape, purpose, budget, file });
+    const templateCategory = data.category === "meta" ? "meta" : "article";
+    if (category === "all" || category === templateCategory)
+      out.push({ shape, purpose, budget, file, path: filePath, category: templateCategory });
   }
   return out;
 }
 
 // src/config.ts
-var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_promises7 = __toESM(require("fs/promises"), 1);
 init_paths();
 init_collections();
 init_errors();
@@ -851,15 +1194,15 @@ function isMissing3(err) {
 }
 async function readConfig() {
   try {
-    return JSON.parse(await import_promises6.default.readFile(configPath(), "utf8"));
+    return JSON.parse(await import_promises7.default.readFile(configPath(), "utf8"));
   } catch (err) {
     if (isMissing3(err)) return {};
     throw err;
   }
 }
 async function writeConfig(config) {
-  await import_promises6.default.mkdir(resolveHome(), { recursive: true });
-  await import_promises6.default.writeFile(configPath(), `${JSON.stringify(config, null, 2)}
+  await import_promises7.default.mkdir(resolveHome(), { recursive: true });
+  await import_promises7.default.writeFile(configPath(), `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
 async function setConfigValue(key, value) {
@@ -892,6 +1235,7 @@ async function showSystemEnabled() {
 }
 
 // src/index.ts
+init_meta();
 init_registry();
 
 // src/slugify.ts
@@ -908,9 +1252,10 @@ function slugifyPath(input) {
 init_collections();
 
 // src/articles.ts
-var import_promises7 = __toESM(require("fs/promises"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
+var import_promises8 = __toESM(require("fs/promises"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 init_collections();
+init_meta();
 init_errors();
 async function fireHook2(event, collection, relPath) {
   try {
@@ -956,63 +1301,53 @@ function ensureMdPath(file) {
 async function createArticle(opts) {
   const { collection, title } = parseAddTarget(opts.target);
   const { name, dir } = await resolveCollectionDir(collection);
-  const filePath = import_node_path4.default.join(dir, `${slugifyPath(title)}.md`);
+  const filePath = import_node_path5.default.join(dir, `${slugifyPath(title)}.md`);
   const body = opts.body ?? `# ${title}
 `;
-  await import_promises7.default.mkdir(import_node_path4.default.dirname(filePath), { recursive: true });
-  await import_promises7.default.writeFile(
+  await import_promises8.default.mkdir(import_node_path5.default.dirname(filePath), { recursive: true });
+  await import_promises8.default.writeFile(
     filePath,
     serializeArticle({ title, tags: opts.tags, body, audience: opts.audience, status: opts.status }),
     "utf8"
   );
-  void fireHook2("article-created", name, import_node_path4.default.relative(dir, filePath));
+  void fireHook2("article-created", name, import_node_path5.default.relative(dir, filePath));
+  await mirrorSavedArticle({ name, path: 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_path4.default.join(dir, ensureMdPath(file));
+  const filePath = import_node_path5.default.join(dir, validateMetaArticlePath(ensureMdPath(file)));
   try {
-    return { filePath, dir, raw: await import_promises7.default.readFile(filePath, "utf8"), collection };
+    return { filePath, dir, raw: await import_promises8.default.readFile(filePath, "utf8"), collection };
   } catch (err) {
     if (err.code === "ENOENT") throw new ArticleNotFoundError(target);
     throw err;
   }
 }
-async function updateArticleBody(target, body) {
+async function updateArticle(target, updates) {
   const { filePath, dir, raw, collection } = await loadArticle(target);
-  const parsed = parseArticle(raw);
-  await import_promises7.default.writeFile(
-    filePath,
-    serializeArticle({
-      title: parsed.title,
-      tags: parsed.tags,
-      audience: parsed.audience,
-      status: parsed.status,
-      body
-    }),
-    "utf8"
-  );
-  void fireHook2("article-updated", collection, import_node_path4.default.relative(dir, filePath));
+  if (updates.title !== void 0 && !updates.title.trim())
+    throw new InvalidTargetError(updates.title, "title cannot be empty");
+  const fields = {};
+  if (updates.title !== void 0) fields.title = updates.title;
+  if (updates.tags !== void 0) fields.tags = Array.from(new Set(updates.tags));
+  if (updates.audience !== void 0) fields.audience = updates.audience === "public" ? void 0 : updates.audience;
+  if (updates.status !== void 0) fields.status = updates.status === "published" ? void 0 : updates.status;
+  const next = patchArticle(raw, fields, updates.body);
+  await import_promises8.default.writeFile(filePath, next, "utf8");
+  const parsed = parseArticle(next);
+  void fireHook2("article-updated", collection, import_node_path5.default.relative(dir, filePath));
+  await mirrorSavedArticle({ name: collection, path: dir }, filePath);
   return { title: parsed.title, tags: parsed.tags, path: filePath, collection };
 }
+function updateArticleBody(target, body) {
+  return updateArticle(target, { body });
+}
 async function mutateTags(target, fn) {
-  const { filePath, dir, raw, collection } = await loadArticle(target);
+  const { raw } = await loadArticle(target);
   const parsed = parseArticle(raw);
-  const tags = fn(parsed.tags);
-  await import_promises7.default.writeFile(
-    filePath,
-    serializeArticle({
-      title: parsed.title,
-      tags,
-      audience: parsed.audience,
-      status: parsed.status,
-      body: parsed.body
-    }),
-    "utf8"
-  );
-  void fireHook2("article-updated", collection, import_node_path4.default.relative(dir, filePath));
-  return { title: parsed.title, tags, path: filePath, collection };
+  return updateArticle(target, { tags: fn(parsed.tags) });
 }
 function addTags(target, tags) {
   return mutateTags(target, (current) => Array.from(/* @__PURE__ */ new Set([...current, ...tags])));
@@ -1025,37 +1360,27 @@ function setTags(target, tags) {
   return mutateTags(target, () => Array.from(new Set(tags)));
 }
 async function setArticleMeta(target, meta) {
-  const { filePath, dir, raw, collection } = await loadArticle(target);
-  const parsed = parseArticle(raw);
-  const audience = meta.audience ?? parsed.audience;
-  const status = meta.status ?? parsed.status;
-  await import_promises7.default.writeFile(
-    filePath,
-    serializeArticle({ title: parsed.title, tags: parsed.tags, audience, status, body: parsed.body }),
-    "utf8"
-  );
-  void fireHook2("article-updated", collection, import_node_path4.default.relative(dir, filePath));
-  return { title: parsed.title, tags: parsed.tags, path: filePath, collection };
+  return updateArticle(target, meta);
 }
 async function removeArticle(target) {
   const { filePath, dir, collection } = await loadArticle(target);
-  await import_promises7.default.rm(filePath);
-  void fireHook2("article-removed", collection, import_node_path4.default.relative(dir, filePath));
+  await import_promises8.default.rm(filePath);
+  void fireHook2("article-removed", collection, import_node_path5.default.relative(dir, filePath));
   return filePath;
 }
 
 // src/repo.ts
-var import_promises9 = __toESM(require("fs/promises"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
+var import_promises10 = __toESM(require("fs/promises"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 var import_node_child_process3 = require("child_process");
 var import_node_util2 = require("util");
-var import_yaml2 = require("yaml");
+var import_yaml3 = require("yaml");
 init_collections();
 init_registry();
 
 // src/git.ts
-var import_promises8 = __toESM(require("fs/promises"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_promises9 = __toESM(require("fs/promises"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 var import_node_child_process2 = require("child_process");
 var import_node_util = require("util");
 init_logger();
@@ -1081,8 +1406,8 @@ async function isLinkedWorktree(cwd) {
   const gitDir = await git(cwd, ["rev-parse", "--absolute-git-dir"]);
   const commonDir = await git(cwd, ["rev-parse", "--git-common-dir"]);
   if (!gitDir || !commonDir) return false;
-  const commonAbs = import_node_path5.default.isAbsolute(commonDir) ? commonDir : import_node_path5.default.resolve(cwd, commonDir);
-  return import_node_path5.default.resolve(gitDir) !== import_node_path5.default.resolve(commonAbs);
+  const commonAbs = import_node_path6.default.isAbsolute(commonDir) ? commonDir : import_node_path6.default.resolve(cwd, commonDir);
+  return import_node_path6.default.resolve(gitDir) !== import_node_path6.default.resolve(commonAbs);
 }
 async function repoRemoteName(cwd) {
   const url = await git(cwd, ["remote", "get-url", "origin"]);
@@ -1124,8 +1449,8 @@ var timestampCache = /* @__PURE__ */ new Map();
 async function fileTimestamps(absPath) {
   const cached2 = timestampCache.get(absPath);
   if (cached2) return cached2;
-  const dir = import_node_path5.default.dirname(absPath);
-  const base = import_node_path5.default.basename(absPath);
+  const dir = import_node_path6.default.dirname(absPath);
+  const base = import_node_path6.default.basename(absPath);
   const [addLog, lastLog] = await Promise.all([
     git(dir, ["log", "--follow", "--diff-filter=A", "--format=%aI", "--", base]),
     git(dir, ["log", "-1", "--format=%aI", "--", base])
@@ -1136,7 +1461,7 @@ async function fileTimestamps(absPath) {
   let updated = gitUpdated;
   if (!created || !updated) {
     try {
-      const st = await import_promises8.default.stat(absPath);
+      const st = await import_promises9.default.stat(absPath);
       if (!updated) updated = st.mtime.toISOString();
       if (!created) created = isEpochish(st.birthtime) ? st.mtime.toISOString() : st.birthtime.toISOString();
     } catch {
@@ -1154,18 +1479,18 @@ var REPO_CONFIG_FILE = "diffwiki.yaml";
 async function detectRepoName(cwd) {
   try {
     const { stdout } = await execFileAsync2("git", ["rev-parse", "--show-toplevel"], { cwd });
-    return import_node_path6.default.basename(stdout.trim());
+    return import_node_path7.default.basename(stdout.trim());
   } catch {
-    return import_node_path6.default.basename(import_node_path6.default.resolve(cwd));
+    return import_node_path7.default.basename(import_node_path7.default.resolve(cwd));
   }
 }
 async function readRepoConfig(cwd) {
   try {
-    const raw = await import_promises9.default.readFile(import_node_path6.default.join(cwd, REPO_CONFIG_FILE), "utf8");
-    const parsed = (0, import_yaml2.parse)(raw) ?? {};
+    const raw = await import_promises10.default.readFile(import_node_path7.default.join(cwd, REPO_CONFIG_FILE), "utf8");
+    const parsed = (0, import_yaml3.parse)(raw) ?? {};
     if (!parsed.path) return void 0;
     return {
-      collection: parsed.collection ?? import_node_path6.default.basename(import_node_path6.default.resolve(cwd)),
+      collection: parsed.collection ?? import_node_path7.default.basename(import_node_path7.default.resolve(cwd)),
       path: parsed.path
     };
   } catch (err) {
@@ -1174,9 +1499,9 @@ async function readRepoConfig(cwd) {
   }
 }
 async function initRepoWiki(opts) {
-  const cwd = import_node_path6.default.resolve(opts.cwd);
+  const cwd = import_node_path7.default.resolve(opts.cwd);
   const wikiPath = opts.wikiPath ?? "wiki";
-  const absWiki = import_node_path6.default.join(cwd, wikiPath);
+  const absWiki = import_node_path7.default.join(cwd, wikiPath);
   let name = opts.collection ?? await detectRepoName(cwd);
   const existing = await findCollection(name);
   if (existing && existing.path !== absWiki) {
@@ -1191,9 +1516,9 @@ async function initRepoWiki(opts) {
       n += 1;
     }
   }
-  await import_promises9.default.mkdir(absWiki, { recursive: true });
+  await import_promises10.default.mkdir(absWiki, { recursive: true });
   const config = { collection: name, path: wikiPath };
-  await import_promises9.default.writeFile(import_node_path6.default.join(cwd, REPO_CONFIG_FILE), (0, import_yaml2.stringify)(config), "utf8");
+  await import_promises10.default.writeFile(import_node_path7.default.join(cwd, REPO_CONFIG_FILE), (0, import_yaml3.stringify)(config), "utf8");
   const entry = {
     name,
     type: "repo",
@@ -1204,15 +1529,15 @@ async function initRepoWiki(opts) {
   return entry;
 }
 async function addExternalCollection(opts) {
-  const cwd = import_node_path6.default.resolve(opts.cwd);
+  const cwd = import_node_path7.default.resolve(opts.cwd);
   const root = await ensureGitRepo(cwd);
   if (await isLinkedWorktree(cwd)) throw new WorktreeNotAllowedError(root);
   const id = await repoId(root) ?? `path:${root}`;
   const already = await findCollectionById(id);
   if (already) throw new CollectionAlreadyAddedError(already.name);
   const docsRel = opts.docsDir ?? "docs";
-  const contentDir = import_node_path6.default.join(root, docsRel);
-  let name = await repoRemoteName(root) ?? import_node_path6.default.basename(root);
+  const contentDir = import_node_path7.default.join(root, docsRel);
+  let name = await repoRemoteName(root) ?? import_node_path7.default.basename(root);
   if (await findCollection(name)) {
     let n = 2;
     while (await findCollection(`${name}-${n}`)) n += 1;
@@ -1231,21 +1556,21 @@ async function addExternalCollection(opts) {
   return entry;
 }
 async function resolveCwdCollection(cwd) {
-  const abs = import_node_path6.default.resolve(cwd);
+  const abs = import_node_path7.default.resolve(cwd);
   const root = await gitToplevel(abs);
   if (root) {
     const id = await repoId(root) ?? `path:${root}`;
     const byId = await findCollectionById(id);
     if (byId) return byId;
   }
-  const within = (base) => abs === base || abs.startsWith(base + import_node_path6.default.sep);
+  const within2 = (base) => abs === base || abs.startsWith(base + import_node_path7.default.sep);
   const all = await listCollections();
   let best;
   let bestLen = -1;
   for (const c of all) {
     const bases = [c.path, c.repoRoot].filter((b) => b !== void 0);
     for (const b of bases) {
-      if (within(b) && b.length > bestLen) {
+      if (within2(b) && b.length > bestLen) {
         best = c;
         bestLen = b.length;
       }
@@ -1262,10 +1587,10 @@ async function collectionGitStatus(entry) {
 }
 
 // src/project.ts
-var import_promises10 = __toESM(require("fs/promises"), 1);
+var import_promises11 = __toESM(require("fs/promises"), 1);
 var import_node_os2 = __toESM(require("os"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
-var import_yaml3 = require("yaml");
+var import_node_path8 = __toESM(require("path"), 1);
+var import_yaml4 = require("yaml");
 var PROJECT_CONFIG_FILE = "diffwiki.yaml";
 function normaliseSite(raw) {
   if (!raw || typeof raw !== "object") return void 0;
@@ -1319,12 +1644,12 @@ function normaliseContext(raw) {
 async function readProjectConfig(dir) {
   let raw;
   try {
-    raw = await import_promises10.default.readFile(import_node_path7.default.join(dir, PROJECT_CONFIG_FILE), "utf8");
+    raw = await import_promises11.default.readFile(import_node_path8.default.join(dir, PROJECT_CONFIG_FILE), "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return void 0;
     throw err;
   }
-  const parsed = (0, import_yaml3.parse)(raw) ?? {};
+  const parsed = (0, import_yaml4.parse)(raw) ?? {};
   const collections = [];
   if (Array.isArray(parsed.collections)) {
     for (const c of parsed.collections) {
@@ -1340,7 +1665,7 @@ async function readProjectConfig(dir) {
     }
     collections.sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
   } else if (typeof parsed.path === "string") {
-    const name = typeof parsed.collection === "string" ? parsed.collection : import_node_path7.default.basename(import_node_path7.default.resolve(dir));
+    const name = typeof parsed.collection === "string" ? parsed.collection : import_node_path8.default.basename(import_node_path8.default.resolve(dir));
     collections.push({ name, path: parsed.path });
   }
   const site = normaliseSite(parsed.site);
@@ -1351,27 +1676,27 @@ async function readContextCollections(dir) {
   return (await readProjectConfig(dir))?.context?.collections ?? [];
 }
 async function setContextCollections(dir, collections) {
-  const file = import_node_path7.default.join(dir, PROJECT_CONFIG_FILE);
+  const file = import_node_path8.default.join(dir, PROJECT_CONFIG_FILE);
   let raw = "";
   try {
-    raw = await import_promises10.default.readFile(file, "utf8");
+    raw = await import_promises11.default.readFile(file, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
-  const doc = (0, import_yaml3.parseDocument)(raw);
+  const doc = (0, import_yaml4.parseDocument)(raw);
   doc.setIn(["context", "collections"], collections);
-  await import_promises10.default.writeFile(file, doc.toString(), "utf8");
+  await import_promises11.default.writeFile(file, doc.toString(), "utf8");
   return file;
 }
 async function resolveProjectCollections(dir) {
   const config = await readProjectConfig(dir);
   if (!config) return [];
-  const root = import_node_path7.default.resolve(dir);
+  const root = import_node_path8.default.resolve(dir);
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
   return config.collections.map((c) => ({
     name: c.name,
     type: "repo",
-    path: import_node_path7.default.resolve(root, c.path),
+    path: import_node_path8.default.resolve(root, c.path),
     createdAt
   }));
 }
@@ -1381,11 +1706,11 @@ async function readSiteConfig(dir) {
 async function seedProjectHome(dir) {
   const entries = await resolveProjectCollections(dir);
   if (entries.length === 0) {
-    throw new Error(`No collections to render from diffwiki.yaml in ${import_node_path7.default.resolve(dir)}`);
+    throw new Error(`No collections to render from diffwiki.yaml in ${import_node_path8.default.resolve(dir)}`);
   }
-  const home = await import_promises10.default.mkdtemp(import_node_path7.default.join(import_node_os2.default.tmpdir(), "diffwiki-project-"));
-  await import_promises10.default.writeFile(
-    import_node_path7.default.join(home, "registry.json"),
+  const home = await import_promises11.default.mkdtemp(import_node_path8.default.join(import_node_os2.default.tmpdir(), "diffwiki-project-"));
+  await import_promises11.default.writeFile(
+    import_node_path8.default.join(home, "registry.json"),
     `${JSON.stringify({ version: 1, collections: entries }, null, 2)}
 `,
     "utf8"
@@ -1397,8 +1722,8 @@ async function seedProjectHome(dir) {
 init_collections();
 
 // src/browse.ts
-var import_promises11 = __toESM(require("fs/promises"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
+var import_promises12 = __toESM(require("fs/promises"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 init_collections();
 init_errors();
 var INDEX_RE = /^(index|readme)\.mdx?$/i;
@@ -1444,7 +1769,7 @@ function buildArticleTree(relPaths) {
 async function collectRelPaths(dir, rel = "") {
   let dirents;
   try {
-    dirents = await import_promises11.default.readdir(dir, { withFileTypes: true });
+    dirents = await import_promises12.default.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -1453,7 +1778,7 @@ async function collectRelPaths(dir, rel = "") {
     if (d.name.startsWith(".")) continue;
     const childRel = rel ? `${rel}/${d.name}` : d.name;
     if (d.isDirectory()) {
-      out.push(...await collectRelPaths(import_node_path8.default.join(dir, d.name), childRel));
+      out.push(...await collectRelPaths(import_node_path9.default.join(dir, d.name), childRel));
     } else if (/\.(mdx?)$/.test(d.name)) {
       out.push(childRel);
     }
@@ -1462,7 +1787,7 @@ async function collectRelPaths(dir, rel = "") {
 }
 async function readdirSafe(dir) {
   try {
-    return await import_promises11.default.readdir(dir);
+    return await import_promises12.default.readdir(dir);
   } catch {
     return [];
   }
@@ -1480,7 +1805,7 @@ var CHEAP_META_BYTES = 8192;
 async function cheapMeta(absPath) {
   let handle;
   try {
-    handle = await import_promises11.default.open(absPath, "r");
+    handle = await import_promises12.default.open(absPath, "r");
     const buf = Buffer.alloc(CHEAP_META_BYTES);
     const { bytesRead } = await handle.read(buf, 0, CHEAP_META_BYTES, 0);
     const snippet = buf.subarray(0, bytesRead).toString("utf8");
@@ -1514,10 +1839,10 @@ async function enrichTitles(nodes, collDir) {
         let status = node.status;
         let order = node.order;
         if (node.slug) {
-          const dir = import_node_path8.default.join(collDir, node.slug);
+          const dir = import_node_path9.default.join(collDir, node.slug);
           const idx = pickIndexFile(await readdirSafe(dir));
           if (idx) {
-            const meta = await cheapMeta(import_node_path8.default.join(dir, idx));
+            const meta = await cheapMeta(import_node_path9.default.join(dir, idx));
             title = meta.title ?? title;
             audience = meta.audience ?? audience;
             status = meta.status ?? status;
@@ -1527,7 +1852,7 @@ async function enrichTitles(nodes, collDir) {
         return { ...node, title, audience, status, order, children };
       }
       for (const ext of [".mdx", ".md"]) {
-        const meta = await cheapMeta(import_node_path8.default.join(collDir, `${node.slug}${ext}`));
+        const meta = await cheapMeta(import_node_path9.default.join(collDir, `${node.slug}${ext}`));
         if (meta.title || meta.audience || meta.status || meta.order != null) {
           return {
             ...node,
@@ -1546,49 +1871,49 @@ async function enrichTitles(nodes, collDir) {
 async function collectionMeta(collDir) {
   const idx = pickIndexFile(await readdirSafe(collDir));
   if (!idx) return {};
-  const meta = await cheapMeta(import_node_path8.default.join(collDir, idx));
+  const meta = await cheapMeta(import_node_path9.default.join(collDir, idx));
   return { title: meta.title, audience: meta.audience, status: meta.status };
 }
 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_path8.default.resolve(entry.path));
+  return enrichTitles(buildArticleTree(rels), import_node_path9.default.resolve(entry.path));
 }
 async function readArticle(coll, slug) {
   const entry = await findCollection(coll);
   if (!entry) throw new CollectionNotFoundError(coll);
-  const collDir = import_node_path8.default.resolve(entry.path);
+  const collDir = import_node_path9.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_path8.default.sep);
+  const inJail = (p) => p === collDir || p.startsWith(collDir + import_node_path9.default.sep);
   let abs;
   let isIndex = false;
   for (const rel of safeSlug ? [`${safeSlug}.mdx`, `${safeSlug}.md`] : []) {
-    const candidate = import_node_path8.default.resolve(collDir, rel);
+    const candidate = import_node_path9.default.resolve(collDir, rel);
     if (!inJail(candidate)) throw new InvalidTargetError(slug, "path traversal detected");
     try {
-      await import_promises11.default.access(candidate);
+      await import_promises12.default.access(candidate);
       abs = candidate;
       break;
     } catch {
     }
   }
   if (!abs) {
-    const dir = import_node_path8.default.resolve(collDir, safeSlug);
+    const dir = import_node_path9.default.resolve(collDir, safeSlug);
     if (inJail(dir)) {
       const idx = pickIndexFile(await readdirSafe(dir));
       if (idx) {
-        abs = import_node_path8.default.join(dir, idx);
+        abs = import_node_path9.default.join(dir, idx);
         isIndex = true;
       }
     }
   }
   if (!abs) throw new ArticleNotFoundError(`${coll}/${safeSlug}`);
-  const parsed = parseArticle(await import_promises11.default.readFile(abs, "utf8"));
+  const parsed = parseArticle(await import_promises12.default.readFile(abs, "utf8"));
   const title = parsed.title?.trim() || (safeSlug ? safeSlug.split("/").pop() ?? safeSlug : coll);
   return {
     coll,
@@ -1604,7 +1929,7 @@ async function readArticle(coll, slug) {
 }
 
 // src/render.ts
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 var import_unified = require("unified");
 var import_remark_parse = __toESM(require("remark-parse"), 1);
 var import_remark_gfm = __toESM(require("remark-gfm"), 1);
@@ -1621,7 +1946,7 @@ function isNonRelativeHref(href) {
   return /^[a-z][a-z0-9+.-]*:/i.test(href);
 }
 function rehypeRewriteLinks(ctx) {
-  const slugDir = ctx.isIndex ? ctx.slug || "." : import_node_path9.default.posix.dirname(ctx.slug || ".");
+  const slugDir = ctx.isIndex ? ctx.slug || "." : import_node_path10.default.posix.dirname(ctx.slug || ".");
   return (tree) => {
     (0, import_unist_util_visit.visit)(tree, "element", (node) => {
       if (node.tagName !== "a") return;
@@ -1631,8 +1956,8 @@ function rehypeRewriteLinks(ctx) {
       const suffix = suffixMatch ? suffixMatch[0] : "";
       const pathPart = suffix ? raw.slice(0, raw.length - suffix.length) : raw;
       if (pathPart === "") return;
-      const joined = import_node_path9.default.posix.join(slugDir === "." ? "" : slugDir, pathPart);
-      const normalized = import_node_path9.default.posix.normalize(joined);
+      const joined = import_node_path10.default.posix.join(slugDir === "." ? "" : slugDir, pathPart);
+      const normalized = import_node_path10.default.posix.normalize(joined);
       const toRoute = (p) => p.replace(/\.(mdx?)$/i, "").replace(/(^|\/)(index|readme)$/i, "$1").replace(/\/+$/, "").replace(/^\/+/, "");
       if (normalized.startsWith("../")) {
         const sibling = normalized.slice(3);
@@ -2035,8 +2360,8 @@ function resolveCollectionSelection(all, sel = {}) {
 }
 
 // src/query.ts
-var import_promises12 = __toESM(require("fs/promises"), 1);
-var import_node_path10 = __toESM(require("path"), 1);
+var import_promises13 = __toESM(require("fs/promises"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 init_collections();
 init_errors();
 init_logger();
@@ -2111,13 +2436,13 @@ var log2 = getLogger("query");
 async function collectMarkdownFiles(dir) {
   let entries;
   try {
-    entries = await import_promises12.default.readdir(dir, { withFileTypes: true });
+    entries = await import_promises13.default.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const files = [];
   for (const entry of entries) {
-    const full = import_node_path10.default.join(dir, entry.name);
+    const full = import_node_path11.default.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await collectMarkdownFiles(full));
     } else if (entry.isFile() && /\.mdx?$/.test(entry.name)) {
@@ -2144,12 +2469,12 @@ async function nativeSearch(term, collections, collection, hideSystem = false) {
   const docs = [];
   for (const entry of targets) {
     for (const full of await collectMarkdownFiles(entry.path)) {
-      const fallbackTitle = import_node_path10.default.basename(full).replace(/\.mdx?$/, "");
+      const fallbackTitle = import_node_path11.default.basename(full).replace(/\.mdx?$/, "");
       let title = fallbackTitle;
       let tags = [];
       let body = "";
       try {
-        const parsed = parseArticle(await import_promises12.default.readFile(full, "utf8"));
+        const parsed = parseArticle(await import_promises13.default.readFile(full, "utf8"));
         if (hideSystem && parsed.audience === "system") continue;
         if (parsed.title) title = parsed.title;
         tags = parsed.tags;
@@ -2207,7 +2532,7 @@ async function dropSystemHits(hits) {
   const kept = [];
   for (const hit of hits) {
     try {
-      if (parseArticle(await import_promises12.default.readFile(hit.path, "utf8")).audience === "system") continue;
+      if (parseArticle(await import_promises13.default.readFile(hit.path, "utf8")).audience === "system") continue;
     } catch {
     }
     kept.push(hit);
@@ -2255,14 +2580,14 @@ async function query(term, opts) {
 }
 
 // src/search.ts
-var import_promises13 = __toESM(require("fs/promises"), 1);
-var import_node_path11 = __toESM(require("path"), 1);
+var import_promises14 = __toESM(require("fs/promises"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 init_collections();
 var isStatic2 = () => process.env.DIFFWIKI_STATIC === "1";
 async function readArticleParts(collDir, slug) {
   for (const ext of [".mdx", ".md"]) {
     try {
-      const parsed = parseArticle(await import_promises13.default.readFile(import_node_path11.default.join(collDir, `${slug}${ext}`), "utf8"));
+      const parsed = parseArticle(await import_promises14.default.readFile(import_node_path12.default.join(collDir, `${slug}${ext}`), "utf8"));
       return { tags: parsed.tags, body: parsed.body };
     } catch {
     }
@@ -2298,7 +2623,7 @@ async function buildSearchIndex(collection) {
   for (const e of entries) {
     try {
       const collEntry = await findCollection(e.name);
-      const collDir = import_node_path11.default.resolve(collEntry?.path ?? e.path);
+      const collDir = import_node_path12.default.resolve(collEntry?.path ?? e.path);
       if (collEntry?.audience === "system") continue;
       if (isStatic2()) {
         const cm = await collectionMeta(collDir);
@@ -2312,15 +2637,15 @@ async function buildSearchIndex(collection) {
 }
 
 // src/doctor.ts
-var import_promises15 = __toESM(require("fs/promises"), 1);
+var import_promises16 = __toESM(require("fs/promises"), 1);
 init_paths();
 init_registry();
 init_collections();
 
 // src/plugins/manager.ts
-var import_promises14 = __toESM(require("fs/promises"), 1);
+var import_promises15 = __toESM(require("fs/promises"), 1);
 var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
 init_paths();
 init_errors();
 init_collections();
@@ -2331,7 +2656,7 @@ init_host();
 var import_node_child_process4 = require("child_process");
 var import_node_util3 = require("util");
 var import_node_fs = require("fs");
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 var import_node_url = require("url");
 var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process4.execFile);
 async function runProcess(file, args, opts) {
@@ -2347,7 +2672,7 @@ async function runProcess(file, args, opts) {
 // src/plugins/manager.ts
 async function readPackageJson(file) {
   try {
-    return JSON.parse(await import_promises14.default.readFile(file, "utf8"));
+    return JSON.parse(await import_promises15.default.readFile(file, "utf8"));
   } catch {
     return null;
   }
@@ -2363,7 +2688,7 @@ function binOf(manifest) {
 async function pluginManifestDirs(nodeModules) {
   let entries;
   try {
-    entries = await import_promises14.default.readdir(nodeModules);
+    entries = await import_promises15.default.readdir(nodeModules);
   } catch {
     return [];
   }
@@ -2373,44 +2698,44 @@ async function pluginManifestDirs(nodeModules) {
     if (entry.startsWith("@")) {
       let scoped;
       try {
-        scoped = await import_promises14.default.readdir(import_node_path13.default.join(nodeModules, entry));
+        scoped = await import_promises15.default.readdir(import_node_path14.default.join(nodeModules, entry));
       } catch {
         continue;
       }
       for (const pkg of scoped) {
         if (pkg.startsWith(".")) continue;
-        dirs.push(import_node_path13.default.join(nodeModules, entry, pkg));
+        dirs.push(import_node_path14.default.join(nodeModules, entry, pkg));
       }
     } else {
-      dirs.push(import_node_path13.default.join(nodeModules, entry));
+      dirs.push(import_node_path14.default.join(nodeModules, entry));
     }
   }
   return dirs;
 }
 async function ensurePluginRoot() {
   const dir = pluginsDir();
-  await import_promises14.default.mkdir(dir, { recursive: true });
-  const pkgPath = import_node_path13.default.join(dir, "package.json");
+  await import_promises15.default.mkdir(dir, { recursive: true });
+  const pkgPath = import_node_path14.default.join(dir, "package.json");
   if (await readPackageJson(pkgPath) === null) {
     const pkg = { name: "diffwiki-plugins", private: true, version: "0.0.0" };
-    await import_promises14.default.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
+    await import_promises15.default.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
   }
   return dir;
 }
 async function asSearchPackage(pkgDir) {
-  const manifest = await readPackageJson(import_node_path13.default.join(pkgDir, "package.json"));
+  const manifest = await readPackageJson(import_node_path14.default.join(pkgDir, "package.json"));
   if (!manifest?.name || manifest.diffwiki?.kind !== "search") return null;
   const bin = binOf(manifest);
   if (!bin) return null;
-  return { name: manifest.name, version: manifest.version, binAbs: import_node_path13.default.resolve(pkgDir, bin) };
+  return { name: manifest.name, version: manifest.version, binAbs: import_node_path14.default.resolve(pkgDir, bin) };
 }
 async function packageNameFromSpec(spec) {
   const looksLikePath = spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("~") || spec.startsWith("file:");
   if (looksLikePath) {
     const raw = spec.startsWith("file:") ? spec.slice("file:".length) : spec;
-    const abs = import_node_path13.default.resolve(raw.replace(/^~(?=$|\/)/, import_node_os3.default.homedir()));
-    return (await readPackageJson(import_node_path13.default.join(abs, "package.json")))?.name ?? null;
+    const abs = import_node_path14.default.resolve(raw.replace(/^~(?=$|\/)/, import_node_os3.default.homedir()));
+    return (await readPackageJson(import_node_path14.default.join(abs, "package.json")))?.name ?? null;
   }
   if (/^(git\+|git:|https?:|ssh:)/.test(spec)) return null;
   if (spec.startsWith("@")) {
@@ -2421,10 +2746,10 @@ async function packageNameFromSpec(spec) {
   return at <= 0 ? spec : spec.slice(0, at);
 }
 async function resolveSearchPackage(dir, name) {
-  return asSearchPackage(import_node_path13.default.join(dir, "node_modules", ...name.split("/")));
+  return asSearchPackage(import_node_path14.default.join(dir, "node_modules", ...name.split("/")));
 }
 async function discoverSearchPackage(dir) {
-  const nodeModules = import_node_path13.default.join(dir, "node_modules");
+  const nodeModules = import_node_path14.default.join(dir, "node_modules");
   for (const pkgDir of await pluginManifestDirs(nodeModules)) {
     const found = await asSearchPackage(pkgDir);
     if (found) return found;
@@ -2564,7 +2889,7 @@ init_host();
 init_types();
 async function exists(target) {
   try {
-    await import_promises15.default.access(target);
+    await import_promises16.default.access(target);
     return true;
   } catch {
     return false;
@@ -2670,8 +2995,8 @@ async function appendPluginDiagnostics(out, config) {
 }
 
 // src/lint.ts
-var import_promises16 = __toESM(require("fs/promises"), 1);
-var import_node_path14 = __toESM(require("path"), 1);
+var import_promises17 = __toESM(require("fs/promises"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
 init_collections();
 init_errors();
 var BUDGETS = {
@@ -2765,13 +3090,13 @@ function lintArticle(article) {
 async function walkMarkdown(dir) {
   let entries;
   try {
-    entries = await import_promises16.default.readdir(dir, { withFileTypes: true });
+    entries = await import_promises17.default.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const e of entries) {
-    const full = import_node_path14.default.join(dir, e.name);
+    const full = import_node_path15.default.join(dir, e.name);
     if (e.isDirectory()) out.push(...await walkMarkdown(full));
     else if (e.isFile() && /\.mdx?$/.test(e.name) && !/-template\.mdx?$/.test(e.name)) out.push(full);
   }
@@ -2801,11 +3126,11 @@ async function lintCollections(scope) {
   let warnCount = 0;
   for (const coll of collections) {
     for (const full of await walkMarkdown(coll.path)) {
-      const rel = import_node_path14.default.relative(coll.path, full);
+      const rel = import_node_path15.default.relative(coll.path, full);
       const label = `${coll.name}/${rel}`;
       let findings = [];
       try {
-        const parsed = parseArticle(await import_promises16.default.readFile(full, "utf8"));
+        const parsed = parseArticle(await import_promises17.default.readFile(full, "utf8"));
         findings = lintArticle(parsed);
       } catch (err) {
         findings = [{ level: "error", rule: "parse", message: `could not parse: ${err.message}` }];
@@ -2885,6 +3210,7 @@ init_registry2();
   DiffwikiError,
   InvalidExportSelectionError,
   InvalidTargetError,
+  META_KINDS,
   NATIVE_ENGINE,
   NoDefaultCollectionError,
   PROJECT_CONFIG_FILE,
@@ -2906,10 +3232,13 @@ init_registry2();
   configPath,
   createArticle,
   createCollection,
+  createMetaRecord,
   currentBranch,
   deregisterPlugin,
   doctor,
   emitPluginEvent,
+  ensureArticleMeta,
+  ensureCollectionMeta,
   ensureGitRepo,
   ensureHome,
   ensurePluginRoot,
@@ -2921,6 +3250,7 @@ init_registry2();
   getConfigValue,
   getLogger,
   gitToplevel,
+  initMeta,
   initRepoWiki,
   installPlugin,
   invalidateLinkGraph,
@@ -2937,11 +3267,14 @@ init_registry2();
   listTemplates,
   loadSearchProvider,
   localGraph,
+  metaDir,
+  mirrorSavedArticle,
   nativeSearch,
   parseAddTarget,
   parseArticle,
   parseFrontmatter,
   parsePathTarget,
+  patchArticle,
   pluginsDir,
   pluginsRegistryPath,
   query,
@@ -2957,6 +3290,7 @@ init_registry2();
   registerCollection,
   registerPlugin,
   registryPath,
+  reindexMeta,
   removeArticle,
   removeCollection,
   removePlugin,
@@ -2990,9 +3324,11 @@ init_registry2();
   toTreeNodes,
   tokenize,
   unregisterCollection,
+  updateArticle,
   updateArticleBody,
   upsertPlugin,
   upstreamStatus,
+  validateMetaArticlePath,
   writeConfig,
   writePluginRegistry,
   writeRegistry