diffwiki-core 0.17.3 → 0.18.0

package/dist/chunk-FJ5XD2JN.js

@@ -0,0 +1,63 @@
+// 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 PluginError = class extends DiffwikiError {
+};
+var WorktreeNotAllowedError = class extends DiffwikiError {
+  constructor(root) {
+    super(`refusing to add a linked worktree \u2014 add the source repository instead (${root})`);
+  }
+};
+var CollectionAlreadyAddedError = class extends DiffwikiError {
+  constructor(name) {
+    super(`this repository is already added as collection "${name}"`);
+  }
+};
+var InvalidExportSelectionError = class extends DiffwikiError {
+  constructor(problems) {
+    super(`export aborted \u2014 ${problems.length} selection problem(s):
+${problems.map((p) => `  - ${p}`).join("\n")}`);
+  }
+};
+
+export {
+  DiffwikiError,
+  CollectionExistsError,
+  CollectionNotFoundError,
+  NoDefaultCollectionError,
+  ArticleNotFoundError,
+  InvalidTargetError,
+  PluginError,
+  WorktreeNotAllowedError,
+  CollectionAlreadyAddedError,
+  InvalidExportSelectionError
+};

package/dist/{chunk-TXM4OGBA.js → chunk-KUX7GHHM.js}

@@ -1,5 +1,12 @@
+import {
+  CollectionExistsError,
+  CollectionNotFoundError,
+  DiffwikiError,
+  InvalidTargetError
+} from "./chunk-FJ5XD2JN.js";
+
 // src/collections.ts
-import fs2 from "fs/promises";
+import fs3 from "fs/promises";
 
 // src/paths.ts
 import os from "os";
@@ -20,6 +27,9 @@ function collectionsDir() {
 function templatesDir() {
   return path.join(resolveHome(), "templates");
 }
+function metaDir() {
+  return path.join(resolveHome(), "meta");
+}
 function collectionDir(name) {
   return path.join(collectionsDir(), name);
 }
@@ -31,13 +41,289 @@ function pluginsRegistryPath() {
 }
 
 // src/registry.ts
+import fs2 from "fs/promises";
+
+// src/meta.ts
 import fs from "fs/promises";
+import path2 from "path";
+import { randomUUID } from "crypto";
+import { stringify, parseDocument } from "yaml";
+var META_KINDS = ["history", "external-source-extract", "dream-learning"];
+function validateMetaArticlePath(file) {
+  if (!/\.mdx?$/i.test(file) || path2.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 = path2.resolve(entry.path);
+  if (within(source, path2.resolve(metaDir())) || within(path2.resolve(metaDir()), source)) {
+    throw new InvalidTargetError(entry.path, "collection content overlaps the metadata store");
+  }
+  const index = path2.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 = path2.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, path2.relative(entry.path, file).split(path2.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 fs.mkdir(await checked(metaDir()), { recursive: true });
+  const result = { created: [], kept: [], index_paths: [], warnings: [], errors: [] };
+  const names = collection ? [collection] : (await fs.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 = path2.join(root, ".meta", "META.md");
+      await fs.access(await checked(index));
+      const pages = await markdownFiles(root);
+      const recordDir = await checked(path2.join(root, ".meta", "records"));
+      let records = [];
+      try {
+        records = (await fs.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(path2.join(recordDir, record));
+        try {
+          const raw = await fs.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 = 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(path2.join(root, article), file, label)}`);
+          }
+        } catch (err) {
+          result.warnings.push(`${file}: ${String(err)}`);
+        }
+      }
+      for (const [page, lines] of pageLines) {
+        const file = path2.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, path2.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 = path2.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 fs.realpath(entry.path);
+    const source = await fs.realpath(path2.resolve(entry.path, articlePath));
+    if (!within(sourceRoot, source) || !(await fs.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, "")}-${randomUUID().slice(0, 8)}`;
+  const file = await checked(path2.join(collectionRoot(entry.name), ".meta", "records", `${id}.md`));
+  await fs.mkdir(path2.dirname(file), { recursive: true });
+  const header = {
+    kind,
+    collection: entry.name,
+    ...articlePath ? { article_path: articlePath } : {},
+    captured_at: capturedAt
+  };
+  await fs.writeFile(file, `---
+${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
+  };
+}
+var START = "<!-- diffwiki:meta:start -->";
+var END = "<!-- diffwiki:meta:end -->";
+var within = (root, file) => file === root || file.startsWith(root + path2.sep);
+var missing = (err) => err.code === "ENOENT";
+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 path2.resolve(metaDir(), name);
+}
+async function checked(file) {
+  const root = path2.resolve(metaDir());
+  const absolute = path2.resolve(file);
+  if (!within(root, absolute)) throw new InvalidTargetError(file, "path escapes the metadata root");
+  const parts = path2.relative(root, absolute).split(path2.sep).filter(Boolean);
+  let current = root;
+  for (const part of ["", ...parts]) {
+    current = part ? path2.join(current, part) : current;
+    try {
+      if ((await fs.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 fs.mkdir(path2.dirname(file), { recursive: true });
+  try {
+    await fs.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 fs.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}.${randomUUID()}.tmp`;
+  try {
+    await fs.writeFile(await checked(temporary), next, { flag: "wx" });
+    await checked(file);
+    await fs.rename(temporary, file);
+  } finally {
+    await fs.rm(temporary, { force: true });
+  }
+}
+function link(from, to, label) {
+  const href = path2.relative(path2.dirname(from), to).split(path2.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 fs.readdir(path2.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 fs.mkdir(await checked(metaDir()), { recursive: true });
+  const index = path2.join(metaDir(), "META.md");
+  const lines = [];
+  for (const item of (await fs.readdir(metaDir(), { withFileTypes: true })).sort(
+    (a, b) => a.name.localeCompare(b.name)
+  )) {
+    if (!item.isDirectory() || item.name.startsWith(".")) continue;
+    const collectionIndex = path2.join(collectionRoot(item.name), ".meta", "META.md");
+    try {
+      await fs.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;
+}
+
+// src/registry.ts
 function isMissing(err) {
   return err?.code === "ENOENT";
 }
 async function readRegistry() {
   try {
-    const parsed = JSON.parse(await fs.readFile(registryPath(), "utf8"));
+    const parsed = JSON.parse(await fs2.readFile(registryPath(), "utf8"));
     return { version: parsed.version ?? 1, collections: parsed.collections ?? [] };
   } catch (err) {
     if (isMissing(err)) return { version: 1, collections: [] };
@@ -45,8 +331,8 @@ async function readRegistry() {
   }
 }
 async function writeRegistry(registry) {
-  await fs.mkdir(resolveHome(), { recursive: true });
-  await fs.writeFile(registryPath(), `${JSON.stringify(registry, null, 2)}
+  await fs2.mkdir(resolveHome(), { recursive: true });
+  await fs2.writeFile(registryPath(), `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 async function registerCollection(entry) {
@@ -58,6 +344,13 @@ 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();
@@ -65,61 +358,10 @@ async function unregisterCollection(name) {
   await writeRegistry(registry);
 }
 
-// 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 PluginError = class extends DiffwikiError {
-};
-var WorktreeNotAllowedError = class extends DiffwikiError {
-  constructor(root) {
-    super(`refusing to add a linked worktree \u2014 add the source repository instead (${root})`);
-  }
-};
-var CollectionAlreadyAddedError = class extends DiffwikiError {
-  constructor(name) {
-    super(`this repository is already added as collection "${name}"`);
-  }
-};
-var InvalidExportSelectionError = class extends DiffwikiError {
-  constructor(problems) {
-    super(`export aborted \u2014 ${problems.length} selection problem(s):
-${problems.map((p) => `  - ${p}`).join("\n")}`);
-  }
-};
-
 // src/collections.ts
 async function fireHook(event, collection) {
   try {
-    const { emitPluginEvent: emitPluginEvent2 } = await import("./events-K3MKWACA.js");
+    const { emitPluginEvent: emitPluginEvent2 } = await import("./events-UG4JPZDZ.js");
     await emitPluginEvent2(event, collection);
   } catch {
   }
@@ -136,7 +378,7 @@ async function findCollectionById(id) {
 async function createCollection(name, opts) {
   if (await findCollection(name)) throw new CollectionExistsError(name);
   const dir = collectionDir(name);
-  await fs2.mkdir(dir, { recursive: true });
+  await fs3.mkdir(dir, { recursive: true });
   const entry = {
     name,
     type: "global",
@@ -153,20 +395,20 @@ async function removeCollection(name) {
   if (!entry) throw new CollectionNotFoundError(name);
   await unregisterCollection(name);
   if (entry.type === "global") {
-    await fs2.rm(entry.path, { recursive: true, force: true });
+    await fs3.rm(entry.path, { recursive: true, force: true });
   }
   void fireHook("collection-removed", name);
   return entry;
 }
 
 // src/plugins/registry.ts
-import fs3 from "fs/promises";
+import fs4 from "fs/promises";
 function isMissing2(err) {
   return err?.code === "ENOENT";
 }
 async function readPluginRegistry() {
   try {
-    const parsed = JSON.parse(await fs3.readFile(pluginsRegistryPath(), "utf8"));
+    const parsed = JSON.parse(await fs4.readFile(pluginsRegistryPath(), "utf8"));
     return { version: parsed.version ?? 1, plugins: parsed.plugins ?? [] };
   } catch (err) {
     if (isMissing2(err)) return { version: 1, plugins: [] };
@@ -174,8 +416,8 @@ async function readPluginRegistry() {
   }
 }
 async function writePluginRegistry(registry) {
-  await fs3.mkdir(resolveHome(), { recursive: true });
-  await fs3.writeFile(pluginsRegistryPath(), `${JSON.stringify(registry, null, 2)}
+  await fs4.mkdir(resolveHome(), { recursive: true });
+  await fs4.writeFile(pluginsRegistryPath(), `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 async function upsertPlugin(record) {
@@ -209,7 +451,7 @@ async function findPluginRecord(name) {
 
 // src/plugins/host.ts
 import { spawn } from "child_process";
-import path2, { basename } from "path";
+import path3, { basename } from "path";
 
 // src/logger.ts
 import { getLogger as logtapeGetLogger } from "@logtape/logtape";
@@ -346,7 +588,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 ? path2.join(coll.path, h.relPath) : h.relPath;
+    const abs = coll ? path3.join(coll.path, h.relPath) : h.relPath;
     out.push({
       collection: h.collection,
       path: abs,
@@ -473,24 +715,23 @@ async function emitPluginEvent(event, collection, relPath) {
 
 export {
   NATIVE_ENGINE,
-  DiffwikiError,
-  CollectionExistsError,
-  CollectionNotFoundError,
-  NoDefaultCollectionError,
-  ArticleNotFoundError,
-  InvalidTargetError,
-  PluginError,
-  WorktreeNotAllowedError,
-  CollectionAlreadyAddedError,
-  InvalidExportSelectionError,
   resolveHome,
   registryPath,
   configPath,
   collectionsDir,
   templatesDir,
+  metaDir,
   collectionDir,
   pluginsDir,
   pluginsRegistryPath,
+  META_KINDS,
+  validateMetaArticlePath,
+  ensureCollectionMeta,
+  ensureArticleMeta,
+  mirrorSavedArticle,
+  reindexMeta,
+  initMeta,
+  createMetaRecord,
   readRegistry,
   writeRegistry,
   registerCollection,

package/dist/{chunk-6MW6KSS4.js → chunk-NLBHSMHA.js}

@@ -1,9 +1,13 @@
+import {
+  DiffwikiError
+} from "./chunk-FJ5XD2JN.js";
+
 // src/frontmatter.ts
 import matter from "gray-matter";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { parse as parseYaml, stringify as stringifyYaml, parseDocument, isScalar } from "yaml";
 var YAML_ENGINE = {
   parse: (input) => {
-    const data = parseYaml(input);
+    const data = parseYaml(input.replace(/\r\n?/g, "\n"));
     return data && typeof data === "object" ? data : {};
   },
   stringify: (data) => stringifyYaml(data)
@@ -47,6 +51,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 = 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) && isScalar(titleNode) && titleNode.range) {
+    const [start, end] = titleNode.range;
+    if (!/[\r\n]/.test(originalYaml.slice(start, end))) {
+      const scalar = stringifyYaml(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 } = matter(raw, MATTER_OPTS);
@@ -266,6 +295,7 @@ function definePlugin(def) {
 
 export {
   stripFrontmatter,
+  patchArticle,
   parseFrontmatter,
   parseArticle,
   serializeArticle,

package/dist/events-UG4JPZDZ.js

@@ -0,0 +1,7 @@
+import {
+  emitPluginEvent
+} from "./chunk-KUX7GHHM.js";
+import "./chunk-FJ5XD2JN.js";
+export {
+  emitPluginEvent
+};

package/dist/{frontmatter-ghMCpLNf.d.ts → frontmatter-D7gO1fg4.d.cts}

@@ -569,6 +569,8 @@ interface SerializableArticle {
  * span. Returns the input unchanged when there is no frontmatter.
  */
 declare function stripFrontmatter(raw: string): string;
+/** Edit requested fields while preserving unknown YAML keys, comments, and the untouched body. */
+declare function patchArticle(raw: string, fields: Record<string, unknown>, body?: string): string;
 /**
  * Parse a document's YAML frontmatter into a raw key/value object (every key,
  * not just the article axes), plus the body. Bundler-safe via the pinned `yaml`
@@ -582,4 +584,4 @@ declare function parseFrontmatter(raw: string): {
 declare function parseArticle(raw: string): ParsedArticle;
 declare function serializeArticle(article: SerializableArticle): string;
 
-export { type ResolvedDependency as $, type Audience as A, type PluginHealth as B, type Config as C, type Diagnostic as D, type PluginReadiness as E, type ProjectCollection as F, type GraphEdge as G, type HomeCard as H, type ProjectContext as I, type SearchExpansion as J, type SerializableArticle as K, type LinkGraph as L, type SiteCopyright as M, NATIVE_ENGINE as N, type SiteHome as O, type PublishStatus as P, type QueryHit as Q, type Registry as R, type SiteConfig as S, type TreeNode as T, parseArticle as U, parseFrontmatter as V, serializeArticle as W, stripFrontmatter as X, type PluginDefinition as Y, type DefinedPlugin as Z, type PluginDependency as _, type CollectionEntry as a, type RunProcessOptions as a0, type EventHandlerResult as a1, type EventParams as a2, type HealthHandlerResult as a3, type HealthParams as a4, type IndexHandlerResult as a5, type IndexParams as a6, type LogLevel as a7, type PluginCapabilities$1 as a8, type PluginHandlers as a9, type PluginLogFn as aa, type SearchHandlerHit as ab, type SearchHandlerResult as ac, type SearchParams as ad, type SetupHandlerResult as ae, type SetupParams as af, type WireCollection as ag, type WireDiagnostic as ah, type WireReadiness as ai, type Article as b, type RepoConfig as c, type ProjectConfig as d, type CollectionInfo as e, type CollectionTree as f, type PageData as g, type ArticleNode as h, type QueryOptions as i, type ParsedArticle as j, type ArticleContent as k, type TocItem as l, type LocalGraph as m, type SearchMode as n, type SearchProvider as o, type PluginRecord as p, type PluginEvent as q, type PluginKind as r, type PluginRegistryFile as s, type CollectionType as t, type DiagnosticLevel as u, type DocData as v, type GraphNode as w, type ListingEntry as x, type NodeMeta as y, type PluginCapabilities as z };
+export { type PluginDependency as $, type Audience as A, type PluginHealth as B, type Config as C, type Diagnostic as D, type PluginReadiness as E, type ProjectCollection as F, type GraphEdge as G, type HomeCard as H, type ProjectContext as I, type SearchExpansion as J, type SerializableArticle as K, type LinkGraph as L, type SiteCopyright as M, NATIVE_ENGINE as N, type SiteHome as O, type PublishStatus as P, type QueryHit as Q, type Registry as R, type SiteConfig as S, type TreeNode as T, parseArticle as U, parseFrontmatter as V, patchArticle as W, serializeArticle as X, stripFrontmatter as Y, type PluginDefinition as Z, type DefinedPlugin as _, type CollectionEntry as a, type ResolvedDependency as a0, type RunProcessOptions as a1, type EventHandlerResult as a2, type EventParams as a3, type HealthHandlerResult as a4, type HealthParams as a5, type IndexHandlerResult as a6, type IndexParams as a7, type LogLevel as a8, type PluginCapabilities$1 as a9, type PluginHandlers as aa, type PluginLogFn as ab, type SearchHandlerHit as ac, type SearchHandlerResult as ad, type SearchParams as ae, type SetupHandlerResult as af, type SetupParams as ag, type WireCollection as ah, type WireDiagnostic as ai, type WireReadiness as aj, type Article as b, type RepoConfig as c, type ProjectConfig as d, type CollectionInfo as e, type CollectionTree as f, type PageData as g, type ArticleNode as h, type QueryOptions as i, type ParsedArticle as j, type ArticleContent as k, type TocItem as l, type LocalGraph as m, type SearchMode as n, type SearchProvider as o, type PluginRecord as p, type PluginEvent as q, type PluginKind as r, type PluginRegistryFile as s, type CollectionType as t, type DiagnosticLevel as u, type DocData as v, type GraphNode as w, type ListingEntry as x, type NodeMeta as y, type PluginCapabilities as z };

package/dist/{frontmatter-ghMCpLNf.d.cts → frontmatter-D7gO1fg4.d.ts}

@@ -569,6 +569,8 @@ interface SerializableArticle {
  * span. Returns the input unchanged when there is no frontmatter.
  */
 declare function stripFrontmatter(raw: string): string;
+/** Edit requested fields while preserving unknown YAML keys, comments, and the untouched body. */
+declare function patchArticle(raw: string, fields: Record<string, unknown>, body?: string): string;
 /**
  * Parse a document's YAML frontmatter into a raw key/value object (every key,
  * not just the article axes), plus the body. Bundler-safe via the pinned `yaml`
@@ -582,4 +584,4 @@ declare function parseFrontmatter(raw: string): {
 declare function parseArticle(raw: string): ParsedArticle;
 declare function serializeArticle(article: SerializableArticle): string;
 
-export { type ResolvedDependency as $, type Audience as A, type PluginHealth as B, type Config as C, type Diagnostic as D, type PluginReadiness as E, type ProjectCollection as F, type GraphEdge as G, type HomeCard as H, type ProjectContext as I, type SearchExpansion as J, type SerializableArticle as K, type LinkGraph as L, type SiteCopyright as M, NATIVE_ENGINE as N, type SiteHome as O, type PublishStatus as P, type QueryHit as Q, type Registry as R, type SiteConfig as S, type TreeNode as T, parseArticle as U, parseFrontmatter as V, serializeArticle as W, stripFrontmatter as X, type PluginDefinition as Y, type DefinedPlugin as Z, type PluginDependency as _, type CollectionEntry as a, type RunProcessOptions as a0, type EventHandlerResult as a1, type EventParams as a2, type HealthHandlerResult as a3, type HealthParams as a4, type IndexHandlerResult as a5, type IndexParams as a6, type LogLevel as a7, type PluginCapabilities$1 as a8, type PluginHandlers as a9, type PluginLogFn as aa, type SearchHandlerHit as ab, type SearchHandlerResult as ac, type SearchParams as ad, type SetupHandlerResult as ae, type SetupParams as af, type WireCollection as ag, type WireDiagnostic as ah, type WireReadiness as ai, type Article as b, type RepoConfig as c, type ProjectConfig as d, type CollectionInfo as e, type CollectionTree as f, type PageData as g, type ArticleNode as h, type QueryOptions as i, type ParsedArticle as j, type ArticleContent as k, type TocItem as l, type LocalGraph as m, type SearchMode as n, type SearchProvider as o, type PluginRecord as p, type PluginEvent as q, type PluginKind as r, type PluginRegistryFile as s, type CollectionType as t, type DiagnosticLevel as u, type DocData as v, type GraphNode as w, type ListingEntry as x, type NodeMeta as y, type PluginCapabilities as z };
+export { type PluginDependency as $, type Audience as A, type PluginHealth as B, type Config as C, type Diagnostic as D, type PluginReadiness as E, type ProjectCollection as F, type GraphEdge as G, type HomeCard as H, type ProjectContext as I, type SearchExpansion as J, type SerializableArticle as K, type LinkGraph as L, type SiteCopyright as M, NATIVE_ENGINE as N, type SiteHome as O, type PublishStatus as P, type QueryHit as Q, type Registry as R, type SiteConfig as S, type TreeNode as T, parseArticle as U, parseFrontmatter as V, patchArticle as W, serializeArticle as X, stripFrontmatter as Y, type PluginDefinition as Z, type DefinedPlugin as _, type CollectionEntry as a, type ResolvedDependency as a0, type RunProcessOptions as a1, type EventHandlerResult as a2, type EventParams as a3, type HealthHandlerResult as a4, type HealthParams as a5, type IndexHandlerResult as a6, type IndexParams as a7, type LogLevel as a8, type PluginCapabilities$1 as a9, type PluginHandlers as aa, type PluginLogFn as ab, type SearchHandlerHit as ac, type SearchHandlerResult as ad, type SearchParams as ae, type SetupHandlerResult as af, type SetupParams as ag, type WireCollection as ah, type WireDiagnostic as ai, type WireReadiness as aj, type Article as b, type RepoConfig as c, type ProjectConfig as d, type CollectionInfo as e, type CollectionTree as f, type PageData as g, type ArticleNode as h, type QueryOptions as i, type ParsedArticle as j, type ArticleContent as k, type TocItem as l, type LocalGraph as m, type SearchMode as n, type SearchProvider as o, type PluginRecord as p, type PluginEvent as q, type PluginKind as r, type PluginRegistryFile as s, type CollectionType as t, type DiagnosticLevel as u, type DocData as v, type GraphNode as w, type ListingEntry as x, type NodeMeta as y, type PluginCapabilities as z };