@riebeckite/core 0.0.26 → 0.0.28

package/dist/index.js

@@ -826,7 +826,7 @@ function getFileName(filePath) {
 }
 
 // src/content/content_build_state.ts
-var CONTENT_BUILD_STATE_VERSION = 16;
+var CONTENT_BUILD_STATE_VERSION = 19;
 var CONTENT_BUILD_STATE_DIRECTORY = ".riebeckite";
 var CONTENT_BUILD_STATE_EXCLUDE = `${CONTENT_BUILD_STATE_DIRECTORY}/**`;
 
@@ -922,9 +922,12 @@ function isContentBuildStateShape(value) {
 }
 function isManifestHookCache(value) {
   return Array.isArray(value) && value.every(
-    (entry) => isRecord2(entry) && typeof entry.pluginName === "string" && typeof entry.cacheable === "boolean" && (entry.pipelineFingerprint === void 0 || typeof entry.pipelineFingerprint === "string") && typeof entry.inputFingerprint === "string" && typeof entry.outputFingerprint === "string" && isRecord2(entry.snapshot) && Array.isArray(entry.snapshot.entries)
+    (entry) => isRecord2(entry) && typeof entry.pluginName === "string" && typeof entry.cacheable === "boolean" && (entry.pipelineFingerprint === void 0 || typeof entry.pipelineFingerprint === "string") && typeof entry.inputFingerprint === "string" && (entry.outputFingerprint === void 0 || typeof entry.outputFingerprint === "string") && (entry.snapshot === void 0 || isManifestHookSnapshot(entry.snapshot))
   );
 }
+function isManifestHookSnapshot(value) {
+  return isRecord2(value) && Array.isArray(value.entries) && (value.order === void 0 || Array.isArray(value.order) && value.order.every((slug) => typeof slug === "string"));
+}
 function isOutputDescriptors(value) {
   return Array.isArray(value) && value.every(
     (output) => isRecord2(output) && (output.kind === "content" || output.kind === "redirect" || output.kind === "plugin-page" || output.kind === "generated") && isOutputPath(output.path) && typeof output.producer === "string" && Array.isArray(output.dependencies) && output.dependencies.every(isOutputDependency)
@@ -939,7 +942,10 @@ function isOutputPath(value) {
 function isOutputDependency(value) {
   if (!isRecord2(value) || typeof value.type !== "string") return false;
   if (value.type === "global" || value.type === "unknown") return true;
-  return value.type === "content" && typeof value.slug === "string" || value.type === "tag" && typeof value.tag === "string" || value.type === "folder" && typeof value.folder === "string" || value.type === "file" && typeof value.path === "string" || value.type === "external" && typeof value.id === "string" || value.type === "projection" && (value.projection === "navigation" || value.projection === "recent-posts" || value.projection === "taxonomy-tags" || value.projection === "taxonomy-folders");
+  if (value.type === "content-query") {
+    return Array.isArray(value.properties) && value.properties.every((property) => typeof property === "string") && (value.unknown === void 0 || typeof value.unknown === "boolean");
+  }
+  return value.type === "content" && typeof value.slug === "string" || value.type === "tag" && typeof value.tag === "string" || value.type === "folder" && typeof value.folder === "string" || value.type === "file" && typeof value.path === "string" || value.type === "public-location" && typeof value.pathname === "string" || value.type === "external" && typeof value.id === "string" || value.type === "projection" && (value.projection === "navigation" || value.projection === "recent-posts" || value.projection === "taxonomy-tags" || value.projection === "taxonomy-folders");
 }
 function isExternalDependencies(value) {
   return Array.isArray(value) && value.every(
@@ -1291,15 +1297,8 @@ function normalizePath(value) {
 
 // src/content/content_fingerprint.ts
 import { createHash } from "node:crypto";
-async function fingerprintContentEntries(entries, read) {
-  const sortedEntries = [...entries].sort(
-    (left, right) => left.path.localeCompare(right.path)
-  );
-  return await mapConcurrent(sortedEntries, 64, async (entry) => ({
-    entry,
-    fingerprint: await fingerprintContentEntry(entry, read)
-  }));
-}
+
+// src/utils/concurrency.ts
 async function mapConcurrent(values, concurrency, map) {
   const results = new Array(values.length);
   let nextIndex = 0;
@@ -1319,12 +1318,37 @@ async function mapConcurrent(values, concurrency, map) {
   );
   return results;
 }
-async function fingerprintContentEntry(entry, read) {
-  if (entry.metadata?.hash) return `hash:${entry.metadata.hash}`;
-  if (entry.metadata?.etag) return `etag:${entry.metadata.etag}`;
+
+// src/content/content_fingerprint.ts
+async function fingerprintContentEntries(entries, read, includeMetadata = true) {
+  const sortedEntries = [...entries].sort(
+    (left, right) => left.path.localeCompare(right.path)
+  );
+  return await mapConcurrent(sortedEntries, 64, async (entry) => ({
+    entry,
+    fingerprint: await fingerprintContentEntry(entry, read, includeMetadata)
+  }));
+}
+async function fingerprintContentEntry(entry, read, includeMetadata) {
+  const contentFingerprint = entry.metadata?.hash ? `hash:${entry.metadata.hash}` : entry.metadata?.etag ? `etag:${entry.metadata.etag}` : await fingerprintContent(entry, read);
+  return includeMetadata ? `${contentFingerprint}:${fingerprintMetadata(entry)}` : contentFingerprint;
+}
+async function fingerprintContent(entry, read) {
   const content = await read(entry);
   return `sha256:${createHash("sha256").update(typeof content === "string" ? content : content).digest("hex")}`;
 }
+function fingerprintMetadata(entry) {
+  const metadata = entry.metadata;
+  if (!metadata) return "metadata:none";
+  return JSON.stringify({
+    createdAt: finiteMetadataValue(metadata.createdAt),
+    modifiedAt: finiteMetadataValue(metadata.modifiedAt),
+    size: finiteMetadataValue(metadata.size)
+  });
+}
+function finiteMetadataValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
 
 // src/utils/collections.ts
 function uniqueStrings(values) {
@@ -1391,6 +1415,48 @@ function selectEntriesByLanguage(entries, language) {
   return localized.filter((entry) => getEntryLanguage(entry) === language);
 }
 
+// src/content/content_links.ts
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+var WIKILINK_PATTERN = /(!)?\[\[([^\]|#^]+)(?:[#^][^\]|]+)?(?:\|[^\]]+)?\]\]/g;
+function extractContentLinks(markdown, contentIndex) {
+  WIKILINK_PATTERN.lastIndex = 0;
+  const links = [];
+  for (let match = WIKILINK_PATTERN.exec(markdown); match !== null; match = WIKILINK_PATTERN.exec(markdown)) {
+    const rawTarget = match[2]?.trim();
+    if (!rawTarget) continue;
+    const resolved = contentIndex.get(rawTarget.toLowerCase()) ?? null;
+    links.push({
+      raw: rawTarget,
+      slug: resolved,
+      kind: resolved ? linkKind(resolved) : "unresolved",
+      embed: match[1] === "!"
+    });
+  }
+  return links;
+}
+function extractMarkdownLinkUrls(markdown) {
+  const urls = [];
+  visitMarkdownNodes(
+    unified().use(remarkParse).parse(markdown),
+    (node) => {
+      if (node.type === "link" && typeof node.url === "string") {
+        urls.push(node.url);
+      }
+    }
+  );
+  return urls;
+}
+function visitMarkdownNodes(node, visit) {
+  visit(node);
+  for (const child of node.children ?? []) visitMarkdownNodes(child, visit);
+}
+function linkKind(value) {
+  if (isImagePath(value)) return "image";
+  if (isAttachmentPath(value)) return "attachment";
+  return "note";
+}
+
 // src/content/content_location.ts
 function resolveDefaultContentLocation(content) {
   return {
@@ -1541,9 +1607,9 @@ import remarkDirective from "remark-directive";
 import remarkFrontmatter from "remark-frontmatter";
 import remarkGfm from "remark-gfm";
 import remarkMath from "remark-math";
-import remarkParse2 from "remark-parse";
+import remarkParse3 from "remark-parse";
 import remarkRehype from "remark-rehype";
-import { unified as unified2 } from "unified";
+import { unified as unified3 } from "unified";
 import { matter as matter2 } from "vfile-matter";
 
 // src/content/content_dependency_tracker.ts
@@ -1556,7 +1622,7 @@ function createContentDependencyTracker(source) {
     const normalized = normalizeDependencyIdentity(identity);
     dependencies.set(dependencyKey(normalized), {
       ...normalized,
-      fingerprint: fingerprintContent(content)
+      fingerprint: fingerprintContent2(content)
     });
   };
   return {
@@ -1581,7 +1647,7 @@ function createContentDependencyTracker(source) {
     )
   };
 }
-function fingerprintContent(content) {
+function fingerprintContent2(content) {
   return `sha256:${createHash2("sha256").update(typeof content === "string" ? content : content).digest("hex")}`;
 }
 function normalizeDependencyIdentity(dependency) {
@@ -1595,30 +1661,6 @@ function dependencyKey(dependency) {
   return `${normalized.kind}:${normalized.id}`;
 }
 
-// src/content/content_links.ts
-var WIKILINK_PATTERN = /(!)?\[\[([^\]|#^]+)(?:[#^][^\]|]+)?(?:\|[^\]]+)?\]\]/g;
-function extractContentLinks(markdown, contentIndex) {
-  WIKILINK_PATTERN.lastIndex = 0;
-  const links = [];
-  for (let match = WIKILINK_PATTERN.exec(markdown); match !== null; match = WIKILINK_PATTERN.exec(markdown)) {
-    const rawTarget = match[2]?.trim();
-    if (!rawTarget) continue;
-    const resolved = contentIndex.get(rawTarget.toLowerCase()) ?? null;
-    links.push({
-      raw: rawTarget,
-      slug: resolved,
-      kind: resolved ? linkKind(resolved) : "unresolved",
-      embed: match[1] === "!"
-    });
-  }
-  return links;
-}
-function linkKind(value) {
-  if (isImagePath(value)) return "image";
-  if (isAttachmentPath(value)) return "attachment";
-  return "note";
-}
-
 // src/content/content_persistent_cache.ts
 import { createHash as createHash4 } from "node:crypto";
 import fs2 from "node:fs/promises";
@@ -2005,14 +2047,47 @@ function extractFrontmatter(markdown) {
 }
 
 // src/content/markdown_image.ts
-import remarkParse from "remark-parse";
-import { unified } from "unified";
+import remarkParse2 from "remark-parse";
+import { unified as unified2 } from "unified";
+
+// src/utils/markdown.ts
+var FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+var FENCE_CLOSE = /^ {0,3}(`{3,}|~{3,})\s*$/;
+function splitOnce(value, separator) {
+  const index = value.indexOf(separator);
+  if (index < 0) return [value];
+  return [value.slice(0, index), value.slice(index + separator.length)];
+}
+function scanMarkdownFenceLines(source) {
+  const lines = [];
+  let fence = null;
+  for (const value of source.split("\n")) {
+    if (fence === null) {
+      const open = FENCE_OPEN.exec(value);
+      if (open && !(open[1][0] === "`" && open[2].includes("`"))) {
+        fence = { marker: open[1][0], length: open[1].length };
+      }
+      lines.push({ value, inFence: false });
+      continue;
+    }
+    const close = FENCE_CLOSE.exec(value);
+    if (close && close[1][0] === fence.marker && close[1].length >= fence.length) {
+      fence = null;
+      lines.push({ value, inFence: false });
+      continue;
+    }
+    lines.push({ value, inFence: true });
+  }
+  return lines;
+}
+
+// src/content/markdown_image.ts
 function extractMarkdownImages(markdown, sourceSlug) {
-  const tree = unified().use(remarkParse).parse(markdown);
+  const tree = unified2().use(remarkParse2).parse(markdown);
   const definitions = /* @__PURE__ */ new Map();
   const references = [];
   const urls = [];
-  visitMarkdownNodes(tree, (node) => {
+  visitMarkdownNodes2(tree, (node) => {
     if (node.type === "definition" && typeof node.url === "string") {
       const identifier = normalizeIdentifier(node.identifier);
       if (identifier) definitions.set(identifier, node.url);
@@ -2037,7 +2112,7 @@ function normalizeMarkdownImages(sourceSlug) {
   return () => (tree) => {
     const definitions = /* @__PURE__ */ new Map();
     const references = /* @__PURE__ */ new Set();
-    visitMarkdownNodes(tree, (node) => {
+    visitMarkdownNodes2(tree, (node) => {
       if (node.type === "definition" && typeof node.url === "string") {
         const identifier = normalizeIdentifier(node.identifier);
         if (identifier) definitions.set(identifier, node);
@@ -2091,11 +2166,11 @@ function resolveContentAssetPath(sourceSlug, targetPath) {
   }
   return normalized.length > 0 ? normalized.join("/").normalize("NFC") : null;
 }
-function visitMarkdownNodes(node, visitor) {
+function visitMarkdownNodes2(node, visitor) {
   const markdownNode = node;
   visitor(markdownNode);
   for (const child of markdownNode.children ?? [])
-    visitMarkdownNodes(child, visitor);
+    visitMarkdownNodes2(child, visitor);
 }
 function normalizeIdentifier(value) {
   return typeof value === "string" ? value.toLowerCase() : null;
@@ -2107,114 +2182,264 @@ function decodeUriPath(path6) {
     return null;
   }
 }
-function splitOnce(value, separator) {
-  const index = value.indexOf(separator);
-  return index < 0 ? [value] : [value.slice(0, index), value.slice(index + 1)];
-}
 function uniqueImages(images) {
   return [...new Map(images.map((image) => [image.path, image])).values()];
 }
 
-// src/plugin/plugin_cache.ts
-import { createHash as createHash5, randomUUID as randomUUID2 } from "node:crypto";
-import fs3 from "node:fs/promises";
-import path3 from "node:path";
-function createUnavailablePluginCache() {
-  return {
-    get: unavailableAtRuntime,
-    set: unavailableAtRuntime,
-    delete: unavailableAtRuntime,
-    clear: unavailableAtRuntime
-  };
-}
-function createPluginCache(options) {
-  const pluginDirectory = path3.join(
-    options.cacheDirectory,
-    pluginNamespace(options.pluginName)
-  );
-  const versionDirectory2 = path3.join(
-    pluginDirectory,
-    hash3(options.cacheVersion ?? "1")
-  );
-  const writes = /* @__PURE__ */ new Map();
-  return {
-    async get(key) {
-      let raw;
-      try {
-        raw = await fs3.readFile(cachePath(versionDirectory2, key), "utf8");
-      } catch (error) {
-        if (isNotFoundError2(error)) {
-          options.tracer?.event("cache.miss", { plugin: options.pluginName });
-          return void 0;
-        }
-        throw error;
-      }
-      try {
-        const value = JSON.parse(raw);
-        options.tracer?.event("cache.hit", { plugin: options.pluginName });
-        return value;
-      } catch {
-        options.logger?.warn(
-          "Plugin cache entry is corrupted and will be ignored.",
-          {
-            plugin: options.pluginName
-          }
-        );
-        return void 0;
-      }
-    },
-    async set(key, value) {
-      const targetPath = cachePath(versionDirectory2, key);
-      const serialized = JSON.stringify(value);
-      if (serialized === void 0) {
-        throw new TypeError("Plugin cache values must be JSON serializable.");
-      }
-      const previousWrite = writes.get(targetPath) ?? Promise.resolve();
-      const write = previousWrite.catch(() => void 0).then(() => writeAtomically2(targetPath, versionDirectory2, serialized));
-      writes.set(targetPath, write);
-      try {
-        await write;
-      } finally {
-        if (writes.get(targetPath) === write) {
-          writes.delete(targetPath);
-        }
-      }
-    },
-    async delete(key) {
-      await fs3.rm(cachePath(versionDirectory2, key), { force: true });
-    },
-    async clear() {
-      await fs3.rm(pluginDirectory, { recursive: true, force: true });
-    }
-  };
+// src/utils/text.ts
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-async function writeAtomically2(targetPath, versionDirectory2, serialized) {
-  await fs3.mkdir(versionDirectory2, { recursive: true });
-  const temporaryPath = `${targetPath}.${randomUUID2()}.tmp`;
-  try {
-    await fs3.writeFile(temporaryPath, serialized, "utf8");
-    await fs3.rename(temporaryPath, targetPath);
-  } catch (error) {
-    await fs3.rm(temporaryPath, { force: true }).catch(() => void 0);
-    throw error;
-  }
+function stripHtml(html) {
+  return html.replace(/<script\b[\s\S]*?<\/script>/gi, " ").replace(/<style\b[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ");
 }
-function resolvePluginCacheDirectory(config) {
-  if (!config) return path3.resolve(process.cwd(), ".riebeckite", "cache");
-  if (config.cache?.directory) return config.cache.directory;
-  if (config.buildDirectory) return path3.join(config.buildDirectory, "cache");
-  return path3.resolve(config.content.directory, "..", ".riebeckite", "cache");
+function calculateReadingTime(html) {
+  const text = stripHtml(html).trim();
+  if (!text) return 1;
+  const cjkCharacters = text.match(/\p{Script=Han}|\p{Script=Hiragana}|\p{Script=Katakana}/gu)?.length ?? 0;
+  const latinWords = text.replace(/\p{Script=Han}|\p{Script=Hiragana}|\p{Script=Katakana}/gu, " ").match(/[\p{L}\p{N}]+/gu)?.length ?? 0;
+  return Math.max(1, Math.ceil(cjkCharacters / 500 + latinWords / 220));
 }
-function cachePath(versionDirectory2, key) {
-  return path3.join(versionDirectory2, `${hash3(key)}.json`);
+
+// src/markdown_fragments.ts
+function selectEmbedMarkdownFragment(markdown, fragment) {
+  if (!fragment) return markdown;
+  if (fragment.kind === "block")
+    return selectBlockFragment(markdown, fragment.value);
+  return selectHeadingFragment(markdown, fragment.value);
 }
-function pluginNamespace(pluginName) {
-  return /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(pluginName) ? pluginName : hash3(pluginName);
+function selectBlockFragment(markdown, blockId) {
+  const lines = markdown.split(/\r?\n/);
+  const blockIdRe = new RegExp(`(?:^|\\s)\\^${escapeRegExp(blockId)}\\s*$`);
+  const line = lines.find((currentLine) => blockIdRe.test(currentLine));
+  return line?.replace(blockIdRe, "").trimEnd() || null;
 }
-function hash3(value) {
-  return createHash5("sha256").update(value).digest("hex");
+function selectHeadingFragment(markdown, heading) {
+  const lines = markdown.split(/\r?\n/);
+  const targetHeading = heading.trim().toLowerCase();
+  const startIndex = lines.findIndex((line) => {
+    const match = line.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/);
+    return match?.[2]?.trim().toLowerCase() === targetHeading;
+  });
+  if (startIndex < 0) return null;
+  const level = lines[startIndex]?.match(/^(#{1,6})\s+/)?.[1]?.length ?? 6;
+  const endIndex = lines.findIndex((line, index) => {
+    if (index <= startIndex) return false;
+    const match = line.match(/^(#{1,6})\s+/);
+    return match !== null && match[1].length <= level;
+  });
+  const selectedLines = lines.slice(
+    startIndex,
+    endIndex === -1 ? void 0 : endIndex
+  );
+  return selectedLines.join("\n").trim() || null;
 }
-function isNotFoundError2(error) {
+
+// src/markdown_links.ts
+function normalizeMarkdownLinks(context) {
+  return (tree) => {
+    visitMarkdownLinkNodes(tree, (node) => {
+      const normalizedUrl = normalizeMarkdownLinkUrl(node.url, context);
+      if (normalizedUrl) node.url = normalizedUrl;
+    });
+  };
+}
+function resolveLinkDependencyValue(id, contentIndex, lookupPermalink, isRoutable) {
+  if (id.startsWith(LINK_INDEX_PREFIX)) {
+    return contentIndex.get(id.slice(LINK_INDEX_PREFIX.length)) ?? "";
+  }
+  if (id.startsWith(LINK_LOCATION_PREFIX)) {
+    const slug = id.slice(LINK_LOCATION_PREFIX.length);
+    const permalink = lookupPermalink(slug);
+    if (permalink === void 0) return "";
+    if (isRoutable && !isRoutable(slug)) return "";
+    return permalink;
+  }
+  return "";
+}
+function visitMarkdownLinkNodes(node, visitor) {
+  const linkNode = node;
+  if ((node.type === "link" || node.type === "definition") && typeof linkNode.url === "string") {
+    visitor(linkNode);
+  }
+  for (const child of linkNode.children ?? []) {
+    visitMarkdownLinkNodes(child, visitor);
+  }
+}
+function normalizeMarkdownLinkUrl(url, context) {
+  if (!context.sourceSlug) return null;
+  if (!isMarkdownContentLink(url)) return null;
+  const [pathAndQuery, hash4 = ""] = splitOnce(url, "#");
+  const [rawPath, query = ""] = splitOnce(pathAndQuery, "?");
+  const decodedPath = decodeUriPath2(rawPath);
+  if (!decodedPath?.toLowerCase().endsWith(".md")) return null;
+  const resolvedSlug = resolveRelativeMarkdownSlug(
+    context.sourceSlug,
+    decodedPath
+  );
+  if (!resolvedSlug) return null;
+  const indexedSlug = getExactContentSlug(context, resolvedSlug);
+  if (!indexedSlug) return null;
+  recordLinkResolution(context, LINK_LOCATION_PREFIX, indexedSlug);
+  if (context.isRoutable && !context.isRoutable(indexedSlug)) return null;
+  const suffix = `${query ? `?${query}` : ""}${hash4 ? `#${hash4}` : ""}`;
+  return `${context.resolvePermalink(indexedSlug)}${suffix}`;
+}
+function recordLinkResolution(context, prefix, key) {
+  if (!context.recordLinkResolution) return;
+  const value = prefix === LINK_INDEX_PREFIX ? context.contentIndex.get(key) ?? "" : resolveLinkDependencyValue(
+    `${prefix}${key}`,
+    context.contentIndex,
+    (slug) => {
+      try {
+        return context.resolvePermalink(slug);
+      } catch {
+        return void 0;
+      }
+    },
+    context.isRoutable
+  );
+  context.recordLinkResolution(`${prefix}${key}`, value);
+}
+function getExactContentSlug(context, slug) {
+  try {
+    context.resolvePermalink(slug);
+    return slug;
+  } catch {
+    const indexKey = slug.toLowerCase();
+    recordLinkResolution(context, LINK_INDEX_PREFIX, indexKey);
+    return context.contentIndex.get(indexKey) ?? null;
+  }
+}
+function isMarkdownContentLink(url) {
+  if (url.startsWith("#") || url.startsWith("//")) return false;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(url)) return false;
+  return true;
+}
+function resolveRelativeMarkdownSlug(sourceSlug, targetPath) {
+  const sourceDirectory = sourceSlug.includes("/") ? sourceSlug.slice(0, sourceSlug.lastIndexOf("/")) : "";
+  const baseParts = targetPath.startsWith("/") ? [] : sourceDirectory.split("/");
+  const parts = [...baseParts, ...targetPath.replace(/^\/+/, "").split("/")];
+  const normalizedParts = [];
+  for (const part of parts) {
+    if (!part || part === ".") continue;
+    if (part === "..") {
+      if (normalizedParts.length === 0) return null;
+      normalizedParts.pop();
+      continue;
+    }
+    normalizedParts.push(part);
+  }
+  return normalizedParts.join("/").replace(/\.md$/i, "");
+}
+function decodeUriPath2(path6) {
+  try {
+    return decodeURI(path6);
+  } catch {
+    return null;
+  }
+}
+
+// src/plugin/plugin_cache.ts
+import { createHash as createHash5, randomUUID as randomUUID2 } from "node:crypto";
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+function createUnavailablePluginCache() {
+  return {
+    get: unavailableAtRuntime,
+    set: unavailableAtRuntime,
+    delete: unavailableAtRuntime,
+    clear: unavailableAtRuntime
+  };
+}
+function createPluginCache(options) {
+  const pluginDirectory = path3.join(
+    options.cacheDirectory,
+    pluginNamespace(options.pluginName)
+  );
+  const versionDirectory2 = path3.join(
+    pluginDirectory,
+    hash3(options.cacheVersion ?? "1")
+  );
+  const writes = /* @__PURE__ */ new Map();
+  return {
+    async get(key) {
+      let raw;
+      try {
+        raw = await fs3.readFile(cachePath(versionDirectory2, key), "utf8");
+      } catch (error) {
+        if (isNotFoundError2(error)) {
+          options.tracer?.event("cache.miss", { plugin: options.pluginName });
+          return void 0;
+        }
+        throw error;
+      }
+      try {
+        const value = JSON.parse(raw);
+        options.tracer?.event("cache.hit", { plugin: options.pluginName });
+        return value;
+      } catch {
+        options.logger?.warn(
+          "Plugin cache entry is corrupted and will be ignored.",
+          {
+            plugin: options.pluginName
+          }
+        );
+        return void 0;
+      }
+    },
+    async set(key, value) {
+      const targetPath = cachePath(versionDirectory2, key);
+      const serialized = JSON.stringify(value);
+      if (serialized === void 0) {
+        throw new TypeError("Plugin cache values must be JSON serializable.");
+      }
+      const previousWrite = writes.get(targetPath) ?? Promise.resolve();
+      const write = previousWrite.catch(() => void 0).then(() => writeAtomically2(targetPath, versionDirectory2, serialized));
+      writes.set(targetPath, write);
+      try {
+        await write;
+      } finally {
+        if (writes.get(targetPath) === write) {
+          writes.delete(targetPath);
+        }
+      }
+    },
+    async delete(key) {
+      await fs3.rm(cachePath(versionDirectory2, key), { force: true });
+    },
+    async clear() {
+      await fs3.rm(pluginDirectory, { recursive: true, force: true });
+    }
+  };
+}
+async function writeAtomically2(targetPath, versionDirectory2, serialized) {
+  await fs3.mkdir(versionDirectory2, { recursive: true });
+  const temporaryPath = `${targetPath}.${randomUUID2()}.tmp`;
+  try {
+    await fs3.writeFile(temporaryPath, serialized, "utf8");
+    await fs3.rename(temporaryPath, targetPath);
+  } catch (error) {
+    await fs3.rm(temporaryPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+function resolvePluginCacheDirectory(config) {
+  if (!config) return path3.resolve(process.cwd(), ".riebeckite", "cache");
+  if (config.cache?.directory) return config.cache.directory;
+  if (config.buildDirectory) return path3.join(config.buildDirectory, "cache");
+  return path3.resolve(config.content.directory, "..", ".riebeckite", "cache");
+}
+function cachePath(versionDirectory2, key) {
+  return path3.join(versionDirectory2, `${hash3(key)}.json`);
+}
+function pluginNamespace(pluginName) {
+  return /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(pluginName) ? pluginName : hash3(pluginName);
+}
+function hash3(value) {
+  return createHash5("sha256").update(value).digest("hex");
+}
+function isNotFoundError2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 async function unavailableAtRuntime() {
@@ -2409,9 +2634,9 @@ var Pipeline = class {
         this.options.onPersistentContentCacheResult?.("bypass");
       }
     }
-    const processor = unified2();
+    const processor = unified3();
     const plugins = this.resolvePlugins();
-    this.use(processor, remarkParse2);
+    this.use(processor, remarkParse3);
     this.use(processor, remarkDirective);
     this.use(processor, remarkFrontmatter, ["yaml", "toml"]);
     this.use(processor, function loadFrontmatter() {
@@ -2535,14 +2760,14 @@ var Pipeline = class {
           dep.id,
           async () => await this.getMarkdownBySlug?.(dep.id) ?? ""
         );
-        if (fingerprintContent(content) !== dep.fingerprint) return dep;
+        if (fingerprintContent2(content) !== dep.fingerprint) return dep;
       } else if (dep.kind === "file") {
         const fileContent = await validationTracker.contentSource.read({
           path: dep.id
         });
-        if (fingerprintContent(fileContent) !== dep.fingerprint) return dep;
+        if (fingerprintContent2(fileContent) !== dep.fingerprint) return dep;
       } else if (dep.kind === "link") {
-        if (fingerprintContent(this.resolveLinkDependency(dep.id)) !== dep.fingerprint) {
+        if (fingerprintContent2(this.resolveLinkDependency(dep.id)) !== dep.fingerprint) {
           return dep;
         }
       }
@@ -2666,170 +2891,135 @@ var Pipeline = class {
     return cache;
   }
 };
-function selectEmbedMarkdownFragment(markdown, fragment) {
-  if (!fragment) return markdown;
-  if (fragment.kind === "block")
-    return selectBlockFragment(markdown, fragment.value);
-  return selectHeadingFragment(markdown, fragment.value);
-}
-function selectBlockFragment(markdown, blockId) {
-  const lines = markdown.split(/\r?\n/);
-  const blockIdRe = new RegExp(`(?:^|\\s)\\^${escapeRegExp(blockId)}\\s*$`);
-  const line = lines.find((currentLine) => blockIdRe.test(currentLine));
-  return line?.replace(blockIdRe, "").trimEnd() || null;
+
+// src/types/plugin_asset.ts
+function createStyleAsset(pluginName, moduleSpecifier) {
+  return {
+    pluginName,
+    kind: "style",
+    moduleSpecifier
+  };
 }
-function normalizeMarkdownLinks(context) {
-  return (tree) => {
-    visitMarkdownLinkNodes(tree, (node) => {
-      const normalizedUrl = normalizeMarkdownLinkUrl(node.url, context);
-      if (normalizedUrl) node.url = normalizedUrl;
-    });
+function createClientEntry(pluginName, moduleSpecifier, exportName, publicConfig) {
+  return {
+    pluginName,
+    moduleSpecifier,
+    ...exportName === void 0 ? {} : { exportName },
+    ...publicConfig === void 0 ? {} : { publicConfig }
   };
 }
-function resolveLinkDependencyValue(id, contentIndex, lookupPermalink, isRoutable) {
-  if (id.startsWith(LINK_INDEX_PREFIX)) {
-    return contentIndex.get(id.slice(LINK_INDEX_PREFIX.length)) ?? "";
+function serializePublicClientConfig(value) {
+  assertJsonValue(value, /* @__PURE__ */ new Set());
+  return JSON.stringify(value);
+}
+function assertJsonValue(value, ancestors) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return;
   }
-  if (id.startsWith(LINK_LOCATION_PREFIX)) {
-    const slug = id.slice(LINK_LOCATION_PREFIX.length);
-    const permalink = lookupPermalink(slug);
-    if (permalink === void 0) return "";
-    if (isRoutable && !isRoutable(slug)) return "";
-    return permalink;
+  if (typeof value === "number") {
+    if (Number.isFinite(value)) return;
+    throw new TypeError("Public client configuration numbers must be finite.");
   }
-  return "";
-}
-function visitMarkdownLinkNodes(node, visitor) {
-  const linkNode = node;
-  if ((node.type === "link" || node.type === "definition") && typeof linkNode.url === "string") {
-    visitor(linkNode);
+  if (typeof value !== "object") {
+    throw new TypeError(
+      "Public client configuration must be JSON-serializable."
+    );
   }
-  for (const child of linkNode.children ?? []) {
-    visitMarkdownLinkNodes(child, visitor);
+  if (ancestors.has(value)) {
+    throw new TypeError("Public client configuration must not contain cycles.");
   }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null && !Array.isArray(value)) {
+    throw new TypeError(
+      "Public client configuration must contain only plain objects."
+    );
+  }
+  ancestors.add(value);
+  for (const item of Array.isArray(value) ? value : Object.values(value)) {
+    assertJsonValue(item, ancestors);
+  }
+  ancestors.delete(value);
 }
-function normalizeMarkdownLinkUrl(url, context) {
-  if (!context.sourceSlug) return null;
-  if (!isMarkdownContentLink(url)) return null;
-  const [pathAndQuery, hash4 = ""] = splitOnce2(url, "#");
-  const [rawPath, query = ""] = splitOnce2(pathAndQuery, "?");
-  const decodedPath = decodeUriPath2(rawPath);
-  if (!decodedPath?.toLowerCase().endsWith(".md")) return null;
-  const resolvedSlug = resolveRelativeMarkdownSlug(
-    context.sourceSlug,
-    decodedPath
-  );
-  if (!resolvedSlug) return null;
-  const indexedSlug = getExactContentSlug(context, resolvedSlug);
-  if (!indexedSlug) return null;
-  recordLinkResolution(context, LINK_LOCATION_PREFIX, indexedSlug);
-  if (context.isRoutable && !context.isRoutable(indexedSlug)) return null;
-  const suffix = `${query ? `?${query}` : ""}${hash4 ? `#${hash4}` : ""}`;
-  return `${context.resolvePermalink(indexedSlug)}${suffix}`;
-}
-function recordLinkResolution(context, prefix, key) {
-  if (!context.recordLinkResolution) return;
-  const value = prefix === LINK_INDEX_PREFIX ? context.contentIndex.get(key) ?? "" : resolveLinkDependencyValue(
-    `${prefix}${key}`,
-    context.contentIndex,
-    (slug) => {
-      try {
-        return context.resolvePermalink(slug);
-      } catch {
-        return void 0;
+
+// src/plugin/generated_output_registry.ts
+var GeneratedOutputRegistry = class {
+  outputs = [];
+  owners = /* @__PURE__ */ new Map();
+  sinkFor(pluginName) {
+    const register = (path6, output) => {
+      const owner = this.owners.get(path6);
+      if (owner) {
+        throw new Error(
+          `Duplicate generated output path "${path6}" declared by "${owner}" and "${pluginName}".`
+        );
       }
-    },
-    context.isRoutable
-  );
-  context.recordLinkResolution(`${prefix}${key}`, value);
-}
-function getExactContentSlug(context, slug) {
-  try {
-    context.resolvePermalink(slug);
-    return slug;
-  } catch {
-    const indexKey = slug.toLowerCase();
-    recordLinkResolution(context, LINK_INDEX_PREFIX, indexKey);
-    return context.contentIndex.get(indexKey) ?? null;
+      this.owners.set(path6, pluginName);
+      this.outputs.push({
+        path: path6,
+        content: output.content,
+        dependencies: output.dependencies,
+        owner: pluginName
+      });
+    };
+    return {
+      emit: (output) => {
+        register(normalizeGeneratedOutputPath(output.path), output);
+      },
+      emitAsset: (output) => {
+        register(normalizeContentAssetOutputPath(output.path), output);
+      }
+    };
   }
-}
-function isMarkdownContentLink(url) {
-  if (url.startsWith("#") || url.startsWith("//")) return false;
-  if (/^[a-z][a-z0-9+.-]*:/i.test(url)) return false;
-  return true;
-}
-function resolveRelativeMarkdownSlug(sourceSlug, targetPath) {
-  const sourceDirectory = sourceSlug.includes("/") ? sourceSlug.slice(0, sourceSlug.lastIndexOf("/")) : "";
-  const baseParts = targetPath.startsWith("/") ? [] : sourceDirectory.split("/");
-  const parts = [...baseParts, ...targetPath.replace(/^\/+/, "").split("/")];
-  const normalizedParts = [];
-  for (const part of parts) {
-    if (!part || part === ".") continue;
-    if (part === "..") {
-      if (normalizedParts.length === 0) return null;
-      normalizedParts.pop();
-      continue;
-    }
-    normalizedParts.push(part);
+  all() {
+    return [...this.outputs].sort(
+      (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+    );
   }
-  return normalizedParts.join("/").replace(/\.md$/i, "");
-}
-function decodeUriPath2(path6) {
-  try {
-    return decodeURI(path6);
-  } catch {
-    return null;
+  count() {
+    return this.outputs.length;
   }
-}
-function splitOnce2(value, separator) {
-  const index = value.indexOf(separator);
-  if (index < 0) return [value];
-  return [value.slice(0, index), value.slice(index + separator.length)];
-}
-function selectHeadingFragment(markdown, heading) {
-  const lines = markdown.split(/\r?\n/);
-  const targetHeading = heading.trim().toLowerCase();
-  const startIndex = lines.findIndex((line) => {
-    const match = line.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/);
-    return match?.[2]?.trim().toLowerCase() === targetHeading;
-  });
-  if (startIndex < 0) return null;
-  const level = lines[startIndex]?.match(/^(#{1,6})\s+/)?.[1]?.length ?? 6;
-  const endIndex = lines.findIndex((line, index) => {
-    if (index <= startIndex) return false;
-    const match = line.match(/^(#{1,6})\s+/);
-    return match !== null && match[1].length <= level;
-  });
-  const selectedLines = lines.slice(
-    startIndex,
-    endIndex === -1 ? void 0 : endIndex
-  );
-  return selectedLines.join("\n").trim() || null;
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
+};
 
 // src/content/manifest_hook_cache.ts
 import { createHash as createHash6 } from "node:crypto";
 function fingerprintManifestHookInput(manifest) {
   return fingerprintManifest(manifestFingerprintValue(manifest));
 }
-function createManifestHookCacheEntry(pluginName, cacheable, pipelineFingerprint, inputFingerprint, manifest) {
-  const snapshot = {
-    entries: JSON.parse(
-      JSON.stringify(manifest.entries)
-    )
-  };
+function serializeManifestEntries(entries) {
+  const serialized = /* @__PURE__ */ new Map();
+  for (const entry of entries)
+    serialized.set(entry.slug, JSON.stringify(entry));
+  return serialized;
+}
+function createManifestHookCacheEntry(pluginName, cacheable, pipelineFingerprint, inputFingerprint, manifest, beforeEntries, afterEntries) {
+  if (!cacheable)
+    return {
+      pluginName,
+      cacheable,
+      pipelineFingerprint,
+      inputFingerprint
+    };
   return {
     pluginName,
     cacheable,
     pipelineFingerprint,
     inputFingerprint,
-    outputFingerprint: fingerprintManifestHookSnapshot(snapshot, manifest),
-    snapshot
+    outputFingerprint: fingerprintManifestHookSnapshot(manifest),
+    snapshot: createManifestHookSnapshot(beforeEntries, afterEntries)
   };
 }
+function createManifestHookSnapshot(beforeEntries, afterEntries) {
+  const changed = [];
+  const order = [];
+  for (const [slug, serialized] of afterEntries) {
+    order.push(slug);
+    if (beforeEntries.get(slug) === serialized) continue;
+    changed.push(JSON.parse(serialized));
+  }
+  const beforeOrder = [...beforeEntries.keys()];
+  const orderChanged = beforeOrder.length !== order.length || beforeOrder.some((slug, index) => slug !== order[index]);
+  return orderChanged ? { entries: changed, order } : { entries: changed };
+}
 function fingerprintManifestHookSideEffects(manifest) {
   const value = {
     ...manifest,
@@ -2837,70 +3027,138 @@ function fingerprintManifestHookSideEffects(manifest) {
   };
   return fingerprintManifest(manifestFingerprintValue(value));
 }
-function fingerprintManifestHookSnapshot(snapshot, manifest) {
-  return fingerprintManifest(
-    manifestFingerprintValue({
-      ...manifest,
-      entries: [...snapshot.entries]
-    })
-  );
+function fingerprintManifestHookSnapshot(manifest) {
+  return fingerprintManifest(manifestFingerprintValue(manifest));
 }
-function applyManifestHookSnapshot(manifest, snapshot) {
+function captureManifestHookRestorePoint(manifest) {
+  return {
+    entries: manifest.entries,
+    publicEntries: manifest.publicEntries,
+    discoverableEntries: manifest.discoverableEntries
+  };
+}
+function restoreManifestHookEntries(manifest, point) {
   try {
-    const entries = structuredClone(snapshot.entries);
-    if (!entries.every(isManifestEntry)) return false;
-    const entriesBySlug = new Map(entries.map((entry) => [entry.slug, entry]));
-    if (entriesBySlug.size !== entries.length) return false;
-    manifest.entries = entries;
-    manifest.publicEntries = manifest.publicEntries.map((entry) => entriesBySlug.get(entry.slug)).filter((entry) => entry !== void 0);
-    manifest.discoverableEntries = manifest.discoverableEntries.map((entry) => entriesBySlug.get(entry.slug)).filter((entry) => entry !== void 0);
-    manifest.bySlug = new Map(entries.map((entry) => [entry.slug, entry]));
-    manifest.byContentId = new Map(
-      entries.filter((entry) => entry.contentId !== void 0).map((entry) => [entry.contentId, entry])
-    );
-    manifest.byPermalink = new Map(
-      entries.map((entry) => [entry.permalink, entry])
+    manifest.publicEntries = point.publicEntries;
+    manifest.discoverableEntries = point.discoverableEntries;
+    const entriesBySlug = new Map(
+      point.entries.map((entry) => [entry.slug, entry])
     );
-    manifest.byRoutablePermalink = new Map(
-      manifest.publicEntries.map((entry) => [entry.permalink, entry])
+    if (entriesBySlug.size !== point.entries.length) return false;
+    return commitManifestEntries(manifest, entriesBySlug);
+  } catch {
+    return false;
+  }
+}
+function applyManifestHookSnapshot(manifest, snapshot) {
+  try {
+    const entriesBySlug = new Map(
+      manifest.entries.map((entry) => [entry.slug, entry])
     );
-    manifest.byAlias = /* @__PURE__ */ new Map();
-    manifest.byTag = /* @__PURE__ */ new Map();
-    manifest.byAsset = /* @__PURE__ */ new Map();
-    manifest.outgoingLinks = /* @__PURE__ */ new Map();
-    manifest.incomingLinks = /* @__PURE__ */ new Map();
-    for (const entry of entries) {
-      manifest.outgoingLinks.set(entry.slug, entry.links);
-      for (const alias of entry.aliases ?? []) {
-        const aliases = manifest.byAlias.get(alias.toLowerCase()) ?? [];
-        aliases.push(entry);
-        manifest.byAlias.set(alias.toLowerCase(), aliases);
-      }
-      for (const tag of entry.tags) {
-        const tagged = manifest.byTag.get(tag) ?? [];
-        tagged.push(entry);
-        manifest.byTag.set(tag, tagged);
-      }
-      for (const asset of entry.assets) {
-        const assets = manifest.byAsset.get(asset.path) ?? [];
-        assets.push(entry);
-        manifest.byAsset.set(asset.path, assets);
-      }
-      for (const link of entry.links) {
-        if (link.kind !== "note" || link.slug === null || link.slug === entry.slug)
-          continue;
-        const incoming = manifest.incomingLinks.get(link.slug) ?? [];
-        if (!incoming.includes(entry.slug)) incoming.push(entry.slug);
-        manifest.incomingLinks.set(link.slug, incoming);
-      }
+    const delta = [];
+    for (const entry of structuredClone(snapshot.entries).map(
+      reviveManifestEntry
+    )) {
+      if (entry === null || !isManifestEntry(entry)) return false;
+      delta.push(entry);
     }
-    for (const entry of entries)
-      entry.backlinks = manifest.incomingLinks.get(entry.slug) ?? [];
-    return true;
+    for (const entry of delta) entriesBySlug.set(entry.slug, entry);
+    return commitManifestEntries(manifest, entriesBySlug, snapshot.order);
   } catch {
     return false;
   }
 }
+function commitManifestEntries(manifest, entriesBySlug, order) {
+  let entries;
+  if (order) {
+    entries = [];
+    for (const slug of order) {
+      const entry = entriesBySlug.get(slug);
+      if (!entry) return false;
+      entries.push(entry);
+    }
+    if (entries.length !== entriesBySlug.size) return false;
+  } else {
+    entries = [...entriesBySlug.values()];
+  }
+  manifest.entries = entries;
+  manifest.publicEntries = manifest.publicEntries.map((entry) => entriesBySlug.get(entry.slug)).filter((entry) => entry !== void 0);
+  manifest.discoverableEntries = manifest.discoverableEntries.map((entry) => entriesBySlug.get(entry.slug)).filter((entry) => entry !== void 0);
+  manifest.bySlug = new Map(entries.map((entry) => [entry.slug, entry]));
+  manifest.byContentId = new Map(
+    entries.filter((entry) => entry.contentId !== void 0).map((entry) => [entry.contentId, entry])
+  );
+  manifest.byPermalink = new Map(
+    entries.map((entry) => [entry.permalink, entry])
+  );
+  manifest.byRoutablePermalink = new Map(
+    manifest.publicEntries.map((entry) => [entry.permalink, entry])
+  );
+  manifest.byAlias = /* @__PURE__ */ new Map();
+  manifest.byTag = /* @__PURE__ */ new Map();
+  manifest.byAsset = /* @__PURE__ */ new Map();
+  manifest.outgoingLinks = /* @__PURE__ */ new Map();
+  manifest.incomingLinks = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    manifest.outgoingLinks.set(entry.slug, entry.links);
+    for (const alias of entry.aliases ?? []) {
+      const aliases = manifest.byAlias.get(alias.toLowerCase()) ?? [];
+      aliases.push(entry);
+      manifest.byAlias.set(alias.toLowerCase(), aliases);
+    }
+    for (const tag of entry.tags) {
+      const tagged = manifest.byTag.get(tag) ?? [];
+      tagged.push(entry);
+      manifest.byTag.set(tag, tagged);
+    }
+    for (const asset of entry.assets) {
+      const assets = manifest.byAsset.get(asset.path) ?? [];
+      assets.push(entry);
+      manifest.byAsset.set(asset.path, assets);
+    }
+    for (const link of entry.links) {
+      if (link.kind !== "note" || link.slug === null || link.slug === entry.slug)
+        continue;
+      const incoming = manifest.incomingLinks.get(link.slug) ?? [];
+      if (!incoming.includes(entry.slug)) incoming.push(entry.slug);
+      manifest.incomingLinks.set(link.slug, incoming);
+    }
+  }
+  for (const entry of entries)
+    entry.backlinks = manifest.incomingLinks.get(entry.slug) ?? [];
+  return true;
+}
+function reviveManifestEntry(entry) {
+  const publishAt = entry.publishing.publishAt;
+  const parsed = typeof publishAt === "string" ? new Date(publishAt) : publishAt;
+  if (parsed instanceof Date && Number.isNaN(parsed.getTime())) return null;
+  const file = reviveFileMetadata(entry.file);
+  if (file === null) return null;
+  return {
+    ...entry,
+    publishing: {
+      ...entry.publishing,
+      ...parsed ? { publishAt: parsed } : {}
+    },
+    ...file ? { file } : {}
+  };
+}
+function reviveFileMetadata(file) {
+  if (file === void 0) return void 0;
+  const ctime = reviveDate(file.ctime);
+  const mtime = reviveDate(file.mtime);
+  if (ctime === null || mtime === null) return null;
+  return {
+    ...typeof file.size === "number" && Number.isSafeInteger(file.size) && file.size >= 0 ? { size: file.size } : {},
+    ...ctime ? { ctime } : {},
+    ...mtime ? { mtime } : {}
+  };
+}
+function reviveDate(value) {
+  if (value === void 0) return void 0;
+  const parsed = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
 function manifestFingerprintValue(manifest) {
   return {
     entries: manifest.entries,
@@ -2933,212 +3191,457 @@ function isManifestEntry(value) {
   return typeof value === "object" && value !== null && typeof value.slug === "string" && typeof value.html === "string";
 }
 
-// src/types/plugin_asset.ts
-function createStyleAsset(pluginName, moduleSpecifier) {
-  return {
-    pluginName,
-    kind: "style",
-    moduleSpecifier
-  };
-}
-function createClientEntry(pluginName, moduleSpecifier, exportName, publicConfig) {
-  return {
-    pluginName,
-    moduleSpecifier,
-    ...exportName === void 0 ? {} : { exportName },
-    ...publicConfig === void 0 ? {} : { publicConfig }
-  };
-}
-function serializePublicClientConfig(value) {
-  assertJsonValue(value, /* @__PURE__ */ new Set());
-  return JSON.stringify(value);
-}
-function assertJsonValue(value, ancestors) {
-  if (value === null || typeof value === "boolean" || typeof value === "string") {
-    return;
-  }
-  if (typeof value === "number") {
-    if (Number.isFinite(value)) return;
-    throw new TypeError("Public client configuration numbers must be finite.");
+// src/plugin/plugin_lifecycle.ts
+var PluginHookError = class extends Error {
+  path;
+  constructor(pluginName, hookName, cause) {
+    super(`Plugin "${pluginName}" failed during "${hookName}"`, { cause });
+    this.name = "PluginHookError";
+    const path6 = cause?.path;
+    if (typeof path6 === "string") this.path = path6;
   }
-  if (typeof value !== "object") {
+};
+async function runPluginHook(plugin, hookName, context, hook) {
+  try {
+    return await context.tracer.span(
+      `plugin.${hookName}`,
+      {
+        plugin: plugin.name,
+        hook: hookName
+      },
+      () => hook(context)
+    );
+  } catch (error) {
+    throw new PluginHookError(plugin.name, hookName, error);
+  }
+}
+async function runSetup(plugins, createContext) {
+  await runLifecycleHook(
+    plugins,
+    "setup",
+    (plugin) => plugin.setup,
+    createContext
+  );
+}
+async function runBuildStart(plugins, createContext) {
+  await runLifecycleHook(
+    plugins,
+    "buildStart",
+    (plugin) => plugin.buildStart,
+    createContext
+  );
+}
+async function runBuildEnd(plugins, createContext) {
+  await runLifecycleHook(
+    plugins,
+    "buildEnd",
+    (plugin) => plugin.buildEnd,
+    createContext
+  );
+}
+async function runDispose(plugins, createContext) {
+  await runLifecycleHook(
+    [...plugins].reverse(),
+    "dispose",
+    (plugin) => plugin.dispose,
+    createContext
+  );
+}
+async function runLifecycleHook(plugins, hookName, getHook, createContext) {
+  for (const plugin of plugins) {
+    const hook = getHook(plugin);
+    if (!hook) continue;
+    await runPluginHook(plugin, hookName, createContext(plugin), hook);
+  }
+}
+
+// src/plugin/manifest_hooks.ts
+var ManifestHookRunner = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  manifestHooksExecuted = 0;
+  manifestHookDurationMs = 0;
+  manifestHooksReused = 0;
+  manifestHookCache = [];
+  manifestHookMetricsByPlugin = /* @__PURE__ */ new Map();
+  getMetrics() {
+    return {
+      manifestHooksExecuted: this.manifestHooksExecuted,
+      manifestHooksReused: this.manifestHooksReused,
+      manifestHookCacheHit: this.manifestHooksReused,
+      manifestHookCacheMiss: this.manifestHooksExecuted,
+      manifestHookDurationMs: this.manifestHookDurationMs,
+      byPlugin: Object.fromEntries(this.manifestHookMetricsByPlugin)
+    };
+  }
+  getNoChangeFastPathBlockReason(previousCache, pipelineFingerprint) {
+    let cacheIndex = 0;
+    for (const plugin of this.options.plugins()) {
+      if (plugin.buildEnd) return "plugin-build-end";
+      if (plugin.planGeneratedOutputs) return "plugin-generated-output-plan";
+      if (!plugin.onManifestCreated) continue;
+      const cached = previousCache[cacheIndex];
+      cacheIndex += 1;
+      if (cached?.pluginName !== plugin.name || !cached.cacheable || cached.pipelineFingerprint !== pipelineFingerprint)
+        return "manifest-hook-cache-miss";
+    }
+    return void 0;
+  }
+  getCache() {
+    return this.manifestHookCache;
+  }
+  async runManifestCreated(manifest, contentIndex, previousCache = [], pipelineFingerprint) {
+    const context = {
+      ...this.options.createContext(contentIndex),
+      manifest
+    };
+    let cacheIndex = 0;
+    let entriesBeforeHook = serializeManifestEntries(manifest.entries);
+    for (const plugin of this.options.plugins()) {
+      const hook = plugin.onManifestCreated;
+      if (!hook) continue;
+      const inputFingerprint = fingerprintManifestHookInput(manifest);
+      const cached = previousCache[cacheIndex];
+      cacheIndex += 1;
+      const reason = manifestHookCacheMissReason(
+        cached,
+        plugin.name,
+        pipelineFingerprint,
+        inputFingerprint
+      );
+      let restored = false;
+      let restorePoint;
+      if (cached !== void 0 && cached.pluginName === plugin.name && cached.cacheable && cached.pipelineFingerprint === pipelineFingerprint && cached.inputFingerprint === inputFingerprint && cached.snapshot !== void 0 && cached.outputFingerprint !== void 0) {
+        restorePoint = captureManifestHookRestorePoint(manifest);
+        restored = applyManifestHookSnapshot(manifest, cached.snapshot);
+        if (restored && fingerprintManifestHookSnapshot(manifest) === cached.outputFingerprint) {
+          this.manifestHooksReused += 1;
+          this.manifestHookCache.push(cached);
+          this.recordManifestHookMetric(plugin.name, "reused", "cache-hit", 0);
+          entriesBeforeHook = serializeManifestEntries(manifest.entries);
+          continue;
+        }
+      }
+      if (restored && restorePoint)
+        restoreManifestHookEntries(manifest, restorePoint);
+      const sideEffectsBefore = fingerprintManifestHookSideEffects(manifest);
+      const outputCountBefore = this.options.generatedOutputCount();
+      const diagnosticCountBefore = this.options.diagnosticCount();
+      const manifestDiagnosticCountBefore = manifest.diagnostics.length;
+      const started = performance.now();
+      this.manifestHooksExecuted += 1;
+      try {
+        await runPluginHook(
+          plugin,
+          "onManifestCreated",
+          this.options.createPluginContext(plugin, context),
+          hook
+        );
+      } finally {
+        const durationMs = performance.now() - started;
+        this.manifestHookDurationMs += durationMs;
+        this.recordManifestHookMetric(
+          plugin.name,
+          "executed",
+          reason,
+          durationMs
+        );
+      }
+      const entriesAfterHook = serializeManifestEntries(manifest.entries);
+      this.manifestHookCache.push(
+        createManifestHookCacheEntry(
+          plugin.name,
+          plugin.resolveExternalDependencies === void 0 && sideEffectsBefore === fingerprintManifestHookSideEffects(manifest) && outputCountBefore === this.options.generatedOutputCount() && diagnosticCountBefore === this.options.diagnosticCount() && manifestDiagnosticCountBefore === manifest.diagnostics.length,
+          pipelineFingerprint,
+          inputFingerprint,
+          manifest,
+          entriesBeforeHook,
+          entriesAfterHook
+        )
+      );
+      entriesBeforeHook = entriesAfterHook;
+    }
+  }
+  recordManifestHookMetric(pluginName, outcome, reason, durationMs) {
+    const previous = this.manifestHookMetricsByPlugin.get(pluginName) ?? {
+      executed: 0,
+      reused: 0,
+      cacheHit: 0,
+      cacheMiss: 0,
+      durationMs: 0,
+      reason
+    };
+    this.manifestHookMetricsByPlugin.set(pluginName, {
+      executed: previous.executed + (outcome === "executed" ? 1 : 0),
+      reused: previous.reused + (outcome === "reused" ? 1 : 0),
+      cacheHit: previous.cacheHit + (outcome === "reused" ? 1 : 0),
+      cacheMiss: previous.cacheMiss + (outcome === "executed" ? 1 : 0),
+      durationMs: previous.durationMs + durationMs,
+      reason
+    });
+  }
+};
+function manifestHookCacheMissReason(cached, pluginName, pipelineFingerprint, inputFingerprint) {
+  if (!cached) return "cache-missing";
+  if (cached.pluginName !== pluginName) return "plugin-order-changed";
+  if (!cached.cacheable) return "uncacheable";
+  if (cached.pipelineFingerprint !== pipelineFingerprint)
+    return "pipeline-fingerprint-changed";
+  if (cached.inputFingerprint !== inputFingerprint)
+    return "manifest-input-changed";
+  return "snapshot-invalid";
+}
+
+// src/plugin/plugin_pages.ts
+var PluginPageResolver = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  pageDeclarations = /* @__PURE__ */ new WeakMap();
+  async resolvePage(pathname, manifest, contentIndex) {
+    const matches = [];
+    const requestedPathname = normalizePagePath(pathname);
+    for (const plugin of this.options.plugins()) {
+      for (const pageType of plugin.pageTypes ?? []) {
+        const pagePathname = normalizePageTypePath(pathname, pageType);
+        const context = {
+          ...this.options.createContext(contentIndex),
+          manifest,
+          pathname: pagePathname
+        };
+        const page = await pageType.resolve(
+          this.options.createPluginContext(plugin, context)
+        );
+        if (page) {
+          matches.push({
+            page: {
+              ...page,
+              pathname: pageType.directoryIndex ? normalizeDirectoryPagePath(page.pathname) : page.pathname,
+              type: pageType.id,
+              pluginName: plugin.name
+            },
+            priority: pageType.priority ?? 0
+          });
+        }
+      }
+    }
+    if (matches.length === 0) return null;
+    const highestPriority = Math.max(...matches.map((match) => match.priority));
+    const highest = matches.filter(
+      (match) => match.priority === highestPriority
+    );
+    if (highest.length !== 1) {
+      throw new Error(
+        `Multiple plugin page types match ${requestedPathname} at priority ${highestPriority}: ${highest.map((match) => match.page.type).join(", ")}`
+      );
+    }
+    return highest[0].page;
+  }
+  async getPagePaths(manifest, contentIndex) {
+    return [
+      ...new Set(
+        (await this.getPageDeclarations(manifest, contentIndex)).map(
+          (declaration) => declaration.pathname
+        )
+      )
+    ];
+  }
+  async getPageRoutes(manifest, contentIndex) {
+    return (await this.getPageDeclarations(manifest, contentIndex)).map(
+      ({ pathname, plugin, pageType }) => ({
+        pathname,
+        pluginName: plugin.name,
+        pageType: pageType.id
+      })
+    );
+  }
+  async getPageOutputs(manifest, contentIndex) {
+    const outputs = await Promise.all(
+      (await this.getPageDeclarations(manifest, contentIndex)).map(
+        async ({ pathname, plugin, pageType }) => {
+          const context = {
+            ...this.options.createContext(contentIndex),
+            manifest,
+            pathname
+          };
+          const dependencies = pageType.outputDependencies ? typeof pageType.outputDependencies === "function" ? await pageType.outputDependencies(
+            this.options.createPluginContext(plugin, context)
+          ) : pageType.outputDependencies : [{ type: "unknown" }];
+          return {
+            output: {
+              kind: "plugin-page",
+              path: pathname,
+              producer: `plugin:${plugin.name}:page:${pageType.id}`,
+              dependencies
+            },
+            priority: pageType.priority ?? 0
+          };
+        }
+      )
+    );
+    return uniqueOutputs(outputs);
+  }
+  async getPageDeclarations(manifest, contentIndex) {
+    const existing = this.pageDeclarations.get(manifest);
+    if (existing) return await existing;
+    const declarations = this.resolvePageDeclarations(manifest, contentIndex);
+    this.pageDeclarations.set(manifest, declarations);
+    return await declarations;
+  }
+  async resolvePageDeclarations(manifest, contentIndex) {
+    const declarations = [];
+    const context = {
+      ...this.options.createContext(contentIndex),
+      manifest
+    };
+    for (const plugin of this.options.plugins()) {
+      for (const pageType of plugin.pageTypes ?? []) {
+        const paths = pageType.paths;
+        if (!paths) continue;
+        const resolved = typeof paths === "function" ? await paths(this.options.createPluginContext(plugin, context)) : paths;
+        for (const pathname of resolved) {
+          declarations.push({
+            pathname: normalizePageTypePath(pathname, pageType),
+            plugin,
+            pageType
+          });
+        }
+      }
+    }
+    return declarations;
+  }
+};
+function collectPageTypeOwners(plugins) {
+  const pageTypes = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    const declaredPageTypes = plugin.pageTypes;
+    if (declaredPageTypes !== void 0 && !Array.isArray(declaredPageTypes)) {
+      throw new TypeError(`Plugin ${plugin.name} pageTypes must be an array`);
+    }
+    for (const pageType of declaredPageTypes ?? []) {
+      validatePageType(plugin.name, pageType);
+      const previous = pageTypes.get(pageType.id);
+      if (previous) {
+        throw new Error(
+          `Plugin page type "${pageType.id}" is provided by both ${previous} and ${plugin.name}`
+        );
+      }
+      pageTypes.set(pageType.id, plugin.name);
+    }
+  }
+}
+function validatePageType(pluginName, pageType) {
+  if (typeof pageType !== "object" || pageType === null) {
+    throw new TypeError(`Plugin ${pluginName} pageTypes must contain objects`);
+  }
+  const candidate = pageType;
+  if (typeof candidate.id !== "string" || candidate.id.trim() === "") {
     throw new TypeError(
-      "Public client configuration must be JSON-serializable."
+      `Plugin ${pluginName} page type id must be a non-empty string`
     );
   }
-  if (ancestors.has(value)) {
-    throw new TypeError("Public client configuration must not contain cycles.");
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null && !Array.isArray(value)) {
+  if (typeof candidate.resolve !== "function") {
     throw new TypeError(
-      "Public client configuration must contain only plain objects."
+      `Plugin ${pluginName} page type "${candidate.id}" must provide a resolve function`
     );
   }
-  ancestors.add(value);
-  for (const item of Array.isArray(value) ? value : Object.values(value)) {
-    assertJsonValue(item, ancestors);
-  }
-  ancestors.delete(value);
-}
-
-// src/plugin/generated_output_registry.ts
-var GeneratedOutputRegistry = class {
-  outputs = [];
-  owners = /* @__PURE__ */ new Map();
-  sinkFor(pluginName) {
-    const register = (path6, output) => {
-      const owner = this.owners.get(path6);
-      if (owner) {
-        throw new Error(
-          `Duplicate generated output path "${path6}" declared by "${owner}" and "${pluginName}".`
-        );
-      }
-      this.owners.set(path6, pluginName);
-      this.outputs.push({
-        path: path6,
-        content: output.content,
-        dependencies: output.dependencies,
-        owner: pluginName
-      });
-    };
-    return {
-      emit: (output) => {
-        register(normalizeGeneratedOutputPath(output.path), output);
-      },
-      emitAsset: (output) => {
-        register(normalizeContentAssetOutputPath(output.path), output);
-      }
-    };
-  }
-  all() {
-    return [...this.outputs].sort(
-      (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+  if (candidate.paths !== void 0 && !Array.isArray(candidate.paths) && typeof candidate.paths !== "function") {
+    throw new TypeError(
+      `Plugin ${pluginName} page type "${candidate.id}" paths must be an array or function`
     );
   }
-  count() {
-    return this.outputs.length;
+  if (candidate.priority !== void 0 && (typeof candidate.priority !== "number" || !Number.isFinite(candidate.priority))) {
+    throw new TypeError(
+      `Plugin ${pluginName} page type "${candidate.id}" priority must be a finite number`
+    );
   }
-};
-
-// src/plugin/plugin_lifecycle.ts
-var PluginHookError = class extends Error {
-  path;
-  constructor(pluginName, hookName, cause) {
-    super(`Plugin "${pluginName}" failed during "${hookName}"`, { cause });
-    this.name = "PluginHookError";
-    const path6 = cause?.path;
-    if (typeof path6 === "string") this.path = path6;
+  if (candidate.outputDependencies !== void 0 && !Array.isArray(candidate.outputDependencies) && typeof candidate.outputDependencies !== "function") {
+    throw new TypeError(
+      `Plugin ${pluginName} page type "${candidate.id}" outputDependencies must be an array or function`
+    );
   }
-};
-async function runPluginHook(plugin, hookName, context, hook) {
-  try {
-    return await context.tracer.span(
-      `plugin.${hookName}`,
-      {
-        plugin: plugin.name,
-        hook: hookName
-      },
-      () => hook(context)
+  if (candidate.directoryIndex !== void 0 && typeof candidate.directoryIndex !== "boolean") {
+    throw new TypeError(
+      `Plugin ${pluginName} page type "${candidate.id}" directoryIndex must be a boolean`
     );
-  } catch (error) {
-    throw new PluginHookError(plugin.name, hookName, error);
   }
 }
-async function runSetup(plugins, createContext) {
-  await runLifecycleHook(
-    plugins,
-    "setup",
-    (plugin) => plugin.setup,
-    createContext
-  );
-}
-async function runBuildStart(plugins, createContext) {
-  await runLifecycleHook(
-    plugins,
-    "buildStart",
-    (plugin) => plugin.buildStart,
-    createContext
-  );
+function normalizePageTypePath(pathname, pageType) {
+  return pageType.directoryIndex ? normalizeDirectoryPagePath(pathname) : normalizePagePath(pathname);
 }
-async function runBuildEnd(plugins, createContext) {
-  await runLifecycleHook(
-    plugins,
-    "buildEnd",
-    (plugin) => plugin.buildEnd,
-    createContext
-  );
+function normalizeDirectoryPagePath(pathname) {
+  const path6 = normalizePagePath(pathname);
+  return path6 === "/" ? path6 : `${path6}/`;
 }
-async function runDispose(plugins, createContext) {
-  await runLifecycleHook(
-    [...plugins].reverse(),
-    "dispose",
-    (plugin) => plugin.dispose,
-    createContext
-  );
+function normalizePagePath(pathname) {
+  const path6 = `/${pathname.split("/").filter(Boolean).join("/")}`;
+  return path6 === "/" ? path6 : path6.replace(/\/$/, "");
 }
-async function runLifecycleHook(plugins, hookName, getHook, createContext) {
-  for (const plugin of plugins) {
-    const hook = getHook(plugin);
-    if (!hook) continue;
-    await runPluginHook(plugin, hookName, createContext(plugin), hook);
+function uniqueOutputs(outputs) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const output of outputs) {
+    const previous = byPath.get(output.output.path);
+    if (!previous || output.priority > previous.priority) {
+      byPath.set(output.output.path, output);
+      continue;
+    }
+    if (output.output.producer === previous.output.producer) continue;
+    if (output.priority === previous.priority) {
+      throw new Error(
+        `Multiple plugin page types declare ${output.output.path} at priority ${output.priority}: ${previous.output.producer}, ${output.output.producer}`
+      );
+    }
   }
+  return [...byPath.values()].map(({ output }) => output).sort((left, right) => left.path.localeCompare(right.path));
 }
 
 // src/plugin/plugin_runtime.ts
 var PluginRuntime = class {
   constructor(pipelineOptions = {}) {
     this.pipelineOptions = pipelineOptions;
+    this.pageResolver = new PluginPageResolver({
+      plugins: () => this.plugins(),
+      createContext: (contentIndex) => this.createContext(contentIndex),
+      createPluginContext: (plugin, context) => this.createPluginContext(plugin, context)
+    });
+    this.manifestHooks = new ManifestHookRunner({
+      plugins: () => this.plugins(),
+      createContext: (contentIndex) => this.createContext(contentIndex),
+      createPluginContext: (plugin, context) => this.createPluginContext(plugin, context),
+      generatedOutputCount: () => this.generatedOutputs.count(),
+      diagnosticCount: () => this.diagnostics.length
+    });
   }
   pipelineOptions;
   buildLifecycle = null;
-  buildStage = "idle";
   disposed = false;
   diagnostics = [];
   pluginCaches = /* @__PURE__ */ new Map();
   generatedOutputs = new GeneratedOutputRegistry();
   isBuildTime = false;
   resolvedPlugins = null;
-  pageDeclarations = /* @__PURE__ */ new WeakMap();
   externalDependencies = /* @__PURE__ */ new Map();
   externalDependencyFailures = [];
   externalDependenciesResolved = false;
-  manifestHooksExecuted = 0;
-  manifestHookDurationMs = 0;
-  manifestHooksReused = 0;
-  manifestHookCache = [];
-  manifestHookMetricsByPlugin = /* @__PURE__ */ new Map();
+  pageResolver;
+  manifestHooks;
   getDiagnostics() {
     return this.diagnostics;
   }
-  getBuildStage() {
-    return this.buildStage;
-  }
   getManifestHookMetrics() {
-    return {
-      manifestHooksExecuted: this.manifestHooksExecuted,
-      manifestHooksReused: this.manifestHooksReused,
-      manifestHookCacheHit: this.manifestHooksReused,
-      manifestHookCacheMiss: this.manifestHooksExecuted,
-      manifestHookDurationMs: this.manifestHookDurationMs,
-      byPlugin: Object.fromEntries(this.manifestHookMetricsByPlugin)
-    };
+    return this.manifestHooks.getMetrics();
   }
   getNoChangeFastPathBlockReason(previousCache, pipelineFingerprint) {
-    let cacheIndex = 0;
-    for (const plugin of this.plugins()) {
-      if (plugin.buildEnd) return "plugin-build-end";
-      if (plugin.planGeneratedOutputs) return "plugin-generated-output-plan";
-      if (!plugin.onManifestCreated) continue;
-      const cached = previousCache[cacheIndex];
-      cacheIndex += 1;
-      if (cached?.pluginName !== plugin.name || !cached.cacheable || cached.pipelineFingerprint !== pipelineFingerprint)
-        return "manifest-hook-cache-miss";
-    }
-    return void 0;
+    return this.manifestHooks.getNoChangeFastPathBlockReason(
+      previousCache,
+      pipelineFingerprint
+    );
   }
   getManifestHookCache() {
-    return this.manifestHookCache;
+    return this.manifestHooks.getCache();
   }
   /**
    * Starts the plugin build lifecycle exactly once, regardless of which public
@@ -3204,124 +3707,51 @@ var PluginRuntime = class {
       const pluginContext = this.createPluginContext(plugin, context);
       const resolved = await runPluginHook(
         plugin,
-        "resolveContentLocations",
-        pluginContext,
-        resolver
-      );
-      locations.push(...resolved);
-    }
-    return locations;
-  }
-  async extendContentLocations(entries, locations, contentIndex) {
-    await this.runHook(
-      "extendContentLocations",
-      (plugin) => plugin.extendContentLocations,
-      {
-        ...this.createContext(contentIndex),
-        entries,
-        locations
-      }
-    );
-  }
-  async runPostHook(hookName, slug, markdown, content, contentIndex) {
-    await this.runHook(hookName, (plugin) => plugin[hookName], {
-      ...this.createContext(contentIndex),
-      slug,
-      markdown,
-      content
-    });
-  }
-  async runGraphHook(entries, contentIndex) {
-    await this.runHook(
-      "extendContentGraph",
-      (plugin) => plugin.extendContentGraph,
-      {
-        ...this.createContext(contentIndex),
-        entries
-      }
-    );
-  }
-  async runManifestCreated(manifest, contentIndex, previousCache = [], pipelineFingerprint) {
-    const context = { ...this.createContext(contentIndex), manifest };
-    let cacheIndex = 0;
-    for (const plugin of this.plugins()) {
-      const hook = plugin.onManifestCreated;
-      if (!hook) continue;
-      const inputFingerprint = fingerprintManifestHookInput(manifest);
-      const cached = previousCache[cacheIndex];
-      cacheIndex += 1;
-      const reason = manifestHookCacheMissReason(
-        cached,
-        plugin.name,
-        pipelineFingerprint,
-        inputFingerprint
-      );
-      const canRestore = cached?.pluginName === plugin.name && cached.cacheable && cached.pipelineFingerprint === pipelineFingerprint && cached.inputFingerprint === inputFingerprint;
-      const manifestBeforeRestore = canRestore ? {
-        entries: structuredClone(manifest.entries)
-      } : void 0;
-      const restored = canRestore && applyManifestHookSnapshot(manifest, cached.snapshot);
-      const cacheHit = restored && fingerprintManifestHookSnapshot(cached.snapshot, manifest) === cached.outputFingerprint;
-      if (cacheHit) {
-        this.manifestHooksReused += 1;
-        this.manifestHookCache.push(cached);
-        this.recordManifestHookMetric(plugin.name, "reused", "cache-hit", 0);
-        continue;
-      }
-      if (restored && manifestBeforeRestore)
-        applyManifestHookSnapshot(manifest, manifestBeforeRestore);
-      const sideEffectsBefore = fingerprintManifestHookSideEffects(manifest);
-      const outputCountBefore = this.generatedOutputs.count();
-      const diagnosticCountBefore = this.diagnostics.length;
-      const manifestDiagnosticCountBefore = manifest.diagnostics.length;
-      const started = performance.now();
-      this.manifestHooksExecuted += 1;
-      try {
-        await runPluginHook(
-          plugin,
-          "onManifestCreated",
-          this.createPluginContext(plugin, context),
-          hook
-        );
-      } finally {
-        const durationMs = performance.now() - started;
-        this.manifestHookDurationMs += durationMs;
-        this.recordManifestHookMetric(
-          plugin.name,
-          "executed",
-          reason,
-          durationMs
-        );
-      }
-      this.manifestHookCache.push(
-        createManifestHookCacheEntry(
-          plugin.name,
-          plugin.resolveExternalDependencies === void 0 && sideEffectsBefore === fingerprintManifestHookSideEffects(manifest) && outputCountBefore === this.generatedOutputs.count() && diagnosticCountBefore === this.diagnostics.length && manifestDiagnosticCountBefore === manifest.diagnostics.length,
-          pipelineFingerprint,
-          inputFingerprint,
-          manifest
-        )
+        "resolveContentLocations",
+        pluginContext,
+        resolver
       );
+      locations.push(...resolved);
     }
+    return locations;
   }
-  recordManifestHookMetric(pluginName, outcome, reason, durationMs) {
-    const previous = this.manifestHookMetricsByPlugin.get(pluginName) ?? {
-      executed: 0,
-      reused: 0,
-      cacheHit: 0,
-      cacheMiss: 0,
-      durationMs: 0,
-      reason
-    };
-    this.manifestHookMetricsByPlugin.set(pluginName, {
-      executed: previous.executed + (outcome === "executed" ? 1 : 0),
-      reused: previous.reused + (outcome === "reused" ? 1 : 0),
-      cacheHit: previous.cacheHit + (outcome === "reused" ? 1 : 0),
-      cacheMiss: previous.cacheMiss + (outcome === "executed" ? 1 : 0),
-      durationMs: previous.durationMs + durationMs,
-      reason
+  async extendContentLocations(entries, locations, contentIndex) {
+    await this.runHook(
+      "extendContentLocations",
+      (plugin) => plugin.extendContentLocations,
+      {
+        ...this.createContext(contentIndex),
+        entries,
+        locations
+      }
+    );
+  }
+  async runPostHook(hookName, slug, markdown, content, contentIndex) {
+    await this.runHook(hookName, (plugin) => plugin[hookName], {
+      ...this.createContext(contentIndex),
+      slug,
+      markdown,
+      content
     });
   }
+  async runGraphHook(entries, contentIndex) {
+    await this.runHook(
+      "extendContentGraph",
+      (plugin) => plugin.extendContentGraph,
+      {
+        ...this.createContext(contentIndex),
+        entries
+      }
+    );
+  }
+  async runManifestCreated(manifest, contentIndex, previousCache = [], pipelineFingerprint) {
+    await this.manifestHooks.runManifestCreated(
+      manifest,
+      contentIndex,
+      previousCache,
+      pipelineFingerprint
+    );
+  }
   async runBuildEnd(manifest, contentIndex) {
     const context = {
       ...this.createContext(contentIndex),
@@ -3404,118 +3834,27 @@ var PluginRuntime = class {
     });
   }
   async resolvePage(pathname, manifest, contentIndex) {
-    const matches = [];
-    const requestedPathname = normalizePagePath(pathname);
-    for (const plugin of this.plugins()) {
-      for (const pageType of plugin.pageTypes ?? []) {
-        const pagePathname = normalizePageTypePath(pathname, pageType);
-        const context = {
-          ...this.createContext(contentIndex),
-          manifest,
-          pathname: pagePathname
-        };
-        const page = await pageType.resolve(
-          this.createPluginContext(plugin, context)
-        );
-        if (page) {
-          matches.push({
-            page: {
-              ...page,
-              pathname: pageType.directoryIndex ? normalizeDirectoryPagePath(page.pathname) : page.pathname,
-              type: pageType.id,
-              pluginName: plugin.name
-            },
-            priority: pageType.priority ?? 0
-          });
-        }
-      }
-    }
-    if (matches.length === 0) return null;
-    const highestPriority = Math.max(...matches.map((match) => match.priority));
-    const highest = matches.filter(
-      (match) => match.priority === highestPriority
+    return await this.pageResolver.resolvePage(
+      pathname,
+      manifest,
+      contentIndex
     );
-    if (highest.length !== 1) {
-      throw new Error(
-        `Multiple plugin page types match ${requestedPathname} at priority ${highestPriority}: ${highest.map((match) => match.page.type).join(", ")}`
-      );
-    }
-    return highest[0].page;
   }
   async getPagePaths(manifest, contentIndex) {
-    return [
-      ...new Set(
-        (await this.getPageDeclarations(manifest, contentIndex)).map(
-          (declaration) => declaration.pathname
-        )
-      )
-    ];
+    return await this.pageResolver.getPagePaths(manifest, contentIndex);
   }
   async getPageRoutes(manifest, contentIndex) {
-    return (await this.getPageDeclarations(manifest, contentIndex)).map(
-      ({ pathname, plugin, pageType }) => ({
-        pathname,
-        pluginName: plugin.name,
-        pageType: pageType.id
-      })
-    );
+    return await this.pageResolver.getPageRoutes(manifest, contentIndex);
   }
   async getPageOutputs(manifest, contentIndex) {
-    const outputs = await Promise.all(
-      (await this.getPageDeclarations(manifest, contentIndex)).map(
-        async ({ pathname, plugin, pageType }) => {
-          const context = {
-            ...this.createContext(contentIndex),
-            manifest,
-            pathname
-          };
-          const dependencies = pageType.outputDependencies ? typeof pageType.outputDependencies === "function" ? await pageType.outputDependencies(
-            this.createPluginContext(plugin, context)
-          ) : pageType.outputDependencies : [{ type: "unknown" }];
-          return {
-            output: {
-              kind: "plugin-page",
-              path: pathname,
-              producer: `plugin:${plugin.name}:page:${pageType.id}`,
-              dependencies
-            },
-            priority: pageType.priority ?? 0
-          };
-        }
-      )
-    );
-    return uniqueOutputs(outputs);
-  }
-  async getPageDeclarations(manifest, contentIndex) {
-    const existing = this.pageDeclarations.get(manifest);
-    if (existing) return await existing;
-    const declarations = this.resolvePageDeclarations(manifest, contentIndex);
-    this.pageDeclarations.set(manifest, declarations);
-    return await declarations;
-  }
-  async resolvePageDeclarations(manifest, contentIndex) {
-    const declarations = [];
-    const context = { ...this.createContext(contentIndex), manifest };
-    for (const plugin of this.plugins()) {
-      for (const pageType of plugin.pageTypes ?? []) {
-        const paths = pageType.paths;
-        if (!paths) continue;
-        const resolved = typeof paths === "function" ? await paths(this.createPluginContext(plugin, context)) : paths;
-        for (const pathname of resolved) {
-          declarations.push({
-            pathname: normalizePageTypePath(pathname, pageType),
-            plugin,
-            pageType
-          });
-        }
-      }
-    }
-    return declarations;
+    return await this.pageResolver.getPageOutputs(manifest, contentIndex);
   }
   getContentOutputDependencies() {
-    return this.plugins().flatMap(
-      (plugin) => plugin.contentOutputDependencies ?? []
-    );
+    const plugins = this.plugins();
+    return ({ entry, manifest }) => plugins.flatMap((plugin) => [
+      ...plugin.contentOutputDependencies ?? [],
+      ...plugin.resolveContentOutputDependencies?.({ entry, manifest }) ?? []
+    ]);
   }
   async collectDiagnostics(contentIndex) {
     const tracer = this.observability().tracer;
@@ -3550,28 +3889,17 @@ var PluginRuntime = class {
     const context = this.createContext(contentIndex);
     const createPluginContext = (plugin) => this.createPluginContext(plugin, context);
     const stages = [
-      {
-        stage: "setup",
-        run: () => runSetup(this.plugins(), createPluginContext)
-      },
-      {
-        stage: "buildStart",
-        run: () => runBuildStart(this.plugins(), createPluginContext)
-      },
-      {
-        stage: "onConfigResolved",
-        run: () => this.runHook(
-          "onConfigResolved",
-          (plugin) => plugin.onConfigResolved,
-          context
-        )
-      }
+      () => runSetup(this.plugins(), createPluginContext),
+      () => runBuildStart(this.plugins(), createPluginContext),
+      () => this.runHook(
+        "onConfigResolved",
+        (plugin) => plugin.onConfigResolved,
+        context
+      )
     ];
-    for (const { stage, run } of stages) {
-      this.buildStage = stage;
+    for (const run of stages) {
       await run();
     }
-    this.buildStage = "started";
   }
   createContext(contentIndex) {
     return {
@@ -3639,101 +3967,8 @@ function deepFreeze(value) {
   for (const property of Object.values(value)) deepFreeze(property);
   return value;
 }
-function collectPageTypeOwners(plugins) {
-  const pageTypes = /* @__PURE__ */ new Map();
-  for (const plugin of plugins) {
-    const declaredPageTypes = plugin.pageTypes;
-    if (declaredPageTypes !== void 0 && !Array.isArray(declaredPageTypes)) {
-      throw new TypeError(`Plugin ${plugin.name} pageTypes must be an array`);
-    }
-    for (const pageType of declaredPageTypes ?? []) {
-      validatePageType(plugin.name, pageType);
-      const previous = pageTypes.get(pageType.id);
-      if (previous) {
-        throw new Error(
-          `Plugin page type "${pageType.id}" is provided by both ${previous} and ${plugin.name}`
-        );
-      }
-      pageTypes.set(pageType.id, plugin.name);
-    }
-  }
-}
-function validatePageType(pluginName, pageType) {
-  if (typeof pageType !== "object" || pageType === null) {
-    throw new TypeError(`Plugin ${pluginName} pageTypes must contain objects`);
-  }
-  const candidate = pageType;
-  if (typeof candidate.id !== "string" || candidate.id.trim() === "") {
-    throw new TypeError(
-      `Plugin ${pluginName} page type id must be a non-empty string`
-    );
-  }
-  if (typeof candidate.resolve !== "function") {
-    throw new TypeError(
-      `Plugin ${pluginName} page type "${candidate.id}" must provide a resolve function`
-    );
-  }
-  if (candidate.paths !== void 0 && !Array.isArray(candidate.paths) && typeof candidate.paths !== "function") {
-    throw new TypeError(
-      `Plugin ${pluginName} page type "${candidate.id}" paths must be an array or function`
-    );
-  }
-  if (candidate.priority !== void 0 && (typeof candidate.priority !== "number" || !Number.isFinite(candidate.priority))) {
-    throw new TypeError(
-      `Plugin ${pluginName} page type "${candidate.id}" priority must be a finite number`
-    );
-  }
-  if (candidate.outputDependencies !== void 0 && !Array.isArray(candidate.outputDependencies) && typeof candidate.outputDependencies !== "function") {
-    throw new TypeError(
-      `Plugin ${pluginName} page type "${candidate.id}" outputDependencies must be an array or function`
-    );
-  }
-  if (candidate.directoryIndex !== void 0 && typeof candidate.directoryIndex !== "boolean") {
-    throw new TypeError(
-      `Plugin ${pluginName} page type "${candidate.id}" directoryIndex must be a boolean`
-    );
-  }
-}
-function normalizePageTypePath(pathname, pageType) {
-  return pageType.directoryIndex ? normalizeDirectoryPagePath(pathname) : normalizePagePath(pathname);
-}
-function normalizeDirectoryPagePath(pathname) {
-  const path6 = normalizePagePath(pathname);
-  return path6 === "/" ? path6 : `${path6}/`;
-}
-function manifestHookCacheMissReason(cached, pluginName, pipelineFingerprint, inputFingerprint) {
-  if (!cached) return "cache-missing";
-  if (cached.pluginName !== pluginName) return "plugin-order-changed";
-  if (!cached.cacheable) return "uncacheable";
-  if (cached.pipelineFingerprint !== pipelineFingerprint)
-    return "pipeline-fingerprint-changed";
-  if (cached.inputFingerprint !== inputFingerprint)
-    return "manifest-input-changed";
-  return "snapshot-invalid";
-}
-function normalizePagePath(pathname) {
-  const path6 = `/${pathname.split("/").filter(Boolean).join("/")}`;
-  return path6 === "/" ? path6 : path6.replace(/\/$/, "");
-}
-function countSeverity(diagnostics, severity) {
-  return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
-}
-function uniqueOutputs(outputs) {
-  const byPath = /* @__PURE__ */ new Map();
-  for (const output of outputs) {
-    const previous = byPath.get(output.output.path);
-    if (!previous || output.priority > previous.priority) {
-      byPath.set(output.output.path, output);
-      continue;
-    }
-    if (output.output.producer === previous.output.producer) continue;
-    if (output.priority === previous.priority) {
-      throw new Error(
-        `Multiple plugin page types declare ${output.output.path} at priority ${output.priority}: ${previous.output.producer}, ${output.output.producer}`
-      );
-    }
-  }
-  return [...byPath.values()].map(({ output }) => output).sort((left, right) => left.path.localeCompare(right.path));
+function countSeverity(diagnostics, severity) {
+  return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
 }
 
 // src/utils/error.ts
@@ -4106,7 +4341,8 @@ var ContentBuildCoordinator = class {
       {},
       () => fingerprintContentEntries(
         entries,
-        (entry) => this.dependencies.readEntry(entry)
+        (entry) => this.dependencies.readEntry(entry),
+        this.dependencies.includeFileMetadata
       )
     );
     const previousState = await this.dependencies.observability.tracer.span(
@@ -4412,7 +4648,7 @@ var ContentLocationResolver = class {
       this.dependencies.getContentIndex()
     ]);
     await this.dependencies.pluginRuntime.startBuild(contentIndex);
-    const inputs = await mapConcurrent2(
+    const inputs = await mapConcurrent(
       entries.filter((entry) => entry.path.endsWith(".md")),
       64,
       async (entry) => ({
@@ -4473,24 +4709,52 @@ var ContentLocationResolver = class {
 function toSlug2(path6) {
   return path6.replace(/\.md$/, "");
 }
-async function mapConcurrent2(values, concurrency, map) {
-  const results = new Array(values.length);
-  let nextIndex = 0;
-  async function worker() {
-    while (nextIndex < values.length) {
-      const index = nextIndex;
-      nextIndex += 1;
-      const value = values[index];
-      if (value !== void 0) results[index] = await map(value);
-    }
+
+// src/content/content_manifest_reuse.ts
+function reuseManifestEntry(input) {
+  const { plan, slug } = input;
+  if (!plan.previousState?.manifestEntries) return null;
+  if (plan.previousState.pipelineFingerprint !== input.pipelineFingerprint) {
+    return null;
   }
-  await Promise.all(
-    Array.from(
-      { length: Math.min(concurrency, values.length) },
-      () => worker()
-    )
-  );
-  return results;
+  if (plan.affectedContent.direct.has(slug)) return null;
+  if (plan.affectedContent.dependent.has(slug)) return null;
+  const contentCacheFingerprint = input.getContentCacheFingerprint();
+  if (!contentCacheFingerprint) return null;
+  if (plan.previousState.entries[`${slug}.md`]?.processedContentCacheFingerprint !== contentCacheFingerprint) {
+    return null;
+  }
+  const entry = plan.previousManifestEntriesBySlug.get(slug);
+  if (!entry) return null;
+  return {
+    entry: cloneManifestEntry(entry),
+    contentCacheFingerprint
+  };
+}
+function cloneManifestEntry(entry) {
+  return {
+    ...entry,
+    publicLocation: { ...entry.publicLocation },
+    frontmatter: { ...entry.frontmatter },
+    ...entry.file ? {
+      file: {
+        ...entry.file.size === void 0 ? {} : { size: entry.file.size },
+        ...reviveFileDate(entry.file.ctime, "ctime"),
+        ...reviveFileDate(entry.file.mtime, "mtime")
+      }
+    } : {},
+    aliases: [...entry.aliases ?? []],
+    tags: [...entry.tags],
+    links: entry.links.map((link) => ({ ...link })),
+    backlinks: [...entry.backlinks],
+    assets: entry.assets.map((asset) => ({ ...asset })),
+    ...entry.headTags ? { headTags: [...entry.headTags] } : {}
+  };
+}
+function reviveFileDate(value, key) {
+  if (value === void 0) return {};
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? {} : { [key]: date };
 }
 
 // src/content/file_system_content_source.ts
@@ -4583,12 +4847,25 @@ var FileSystemContentSource = class {
         continue;
       }
       if (!directoryEntry.isFile()) continue;
-      const stats = await fs4.stat(filePath);
+      let stats;
+      try {
+        stats = await fs4.stat(filePath);
+      } catch (error) {
+        if (isFileNotFoundError(error)) continue;
+        throw new Error(
+          `Could not read content file metadata: ${logicalPath}`,
+          { cause: error }
+        );
+      }
+      const createdAt = validTimestamp(stats.birthtimeMs, logicalPath, "ctime");
+      const modifiedAt = validTimestamp(stats.mtimeMs, logicalPath, "mtime");
+      const size = validSize(stats.size, logicalPath);
       entries.push({
         path: logicalPath,
         metadata: {
-          modifiedAt: stats.mtimeMs,
-          size: stats.size
+          createdAt,
+          modifiedAt,
+          size
         }
       });
     }
@@ -4661,6 +4938,14 @@ function isMissingDirectoryError(error, directory) {
 function isFileNotFoundError(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
+function validTimestamp(value, logicalPath, name) {
+  if (Number.isFinite(value)) return value;
+  throw new Error(`Invalid ${name} metadata for content file: ${logicalPath}`);
+}
+function validSize(value, logicalPath) {
+  if (Number.isSafeInteger(value) && value >= 0) return value;
+  throw new Error(`Invalid size metadata for content file: ${logicalPath}`);
+}
 function missingContentDirectoryError(directory) {
   const relative = path4.relative(process.cwd(), directory);
   const display = relative && !relative.startsWith("..") ? relative : directory;
@@ -4696,7 +4981,7 @@ function readOptionalStableId(value) {
 
 // src/content/manifest_builder.ts
 var ManifestBuilder = class {
-  createEntry(slug, markdown, processed, contentIndex, location, publishing) {
+  createEntry(slug, markdown, processed, contentIndex, location, publishing, sourceMetadata) {
     const links = extractContentLinks(markdown, contentIndex);
     const assets = [
       ...links.filter(
@@ -4713,6 +4998,7 @@ var ManifestBuilder = class {
       permalink: location.permalink,
       publicLocation: location,
       title: getManifestTitle(slug, processed.frontmatter.title),
+      file: toFileMetadata(sourceMetadata),
       aliases: extractFrontmatterAliases(markdown),
       frontmatter: processed.frontmatter,
       publishing,
@@ -4779,6 +5065,21 @@ var ManifestBuilder = class {
     return { ...manifest, graph: createContentGraph(manifest) };
   }
 };
+function toFileMetadata(metadata) {
+  return {
+    ...validSize2(metadata?.size) ? { size: metadata.size } : {},
+    ...toDate(metadata?.createdAt, "ctime"),
+    ...toDate(metadata?.modifiedAt, "mtime")
+  };
+}
+function validSize2(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function toDate(value, key) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return {};
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? {} : { [key]: date };
+}
 function createAliasIndex(entries) {
   const byAlias = /* @__PURE__ */ new Map();
   for (const entry of entries) {
@@ -4823,6 +5124,64 @@ function appendUniqueToMap(map, key, value) {
   map.set(key, values);
 }
 
+// src/content/manifest_assembler.ts
+var ManifestAssembler = class {
+  constructor(contentCache) {
+    this.contentCache = contentCache;
+  }
+  contentCache;
+  builder = new ManifestBuilder();
+  createEntry(...args) {
+    return this.builder.createEntry(...args);
+  }
+  build(...args) {
+    return this.builder.build(...args);
+  }
+  applyPublicView(manifest, strategy, publishingBuildTime) {
+    for (const entry of manifest.entries) {
+      entry.publishing = resolvePublishingState(entry.frontmatter, {
+        strategy,
+        buildTime: publishingBuildTime
+      });
+    }
+    manifest.publicEntries = manifest.entries.filter(
+      (entry) => entry.publishing.routable
+    );
+    manifest.discoverableEntries = manifest.entries.filter(
+      (entry) => entry.publishing.discoverable
+    );
+    const publicSlugs = new Set(
+      manifest.publicEntries.map((entry) => entry.slug)
+    );
+    const publicPermalinks = new Map(
+      manifest.publicEntries.map((entry) => [entry.permalink, entry])
+    );
+    manifest.byRoutablePermalink = publicPermalinks;
+    manifest.publicRedirects = new Map(
+      [...manifest.redirects].filter(
+        ([, redirect]) => publicSlugs.has(redirect.slug)
+      )
+    );
+  }
+  synchronizeHtml(manifest, preHookEntries) {
+    const preHookHtml = new Map(
+      preHookEntries.map((entry) => [entry.slug, entry.html])
+    );
+    for (const entry of manifest.entries) {
+      const changed = preHookHtml.get(entry.slug) !== entry.html;
+      const cached = this.contentCache.get(entry.slug);
+      if (cached) {
+        if (changed) cached.html = entry.html;
+        continue;
+      }
+      this.contentCache.set(entry.slug, {
+        frontmatter: entry.frontmatter,
+        html: entry.html
+      });
+    }
+  }
+};
+
 // src/content/output_dependency.ts
 function determineOutputChanges(input) {
   const current = buildOutputInventory(
@@ -4833,7 +5192,16 @@ function determineOutputChanges(input) {
   const previous = new Map(
     (input.previousState?.outputs ?? []).map((output) => [output.path, output])
   );
+  const currentPublicLocations = publicLocationOwners(
+    input.manifest.publicEntries
+  );
+  const previousPublicLocations = publicLocationOwners(
+    (input.previousState?.manifestEntries ?? []).filter(
+      (entry) => entry.publishing.routable
+    )
+  );
   const changedContent = collectChangedContent(input);
+  const refreshedContent = collectRefreshedContent(input);
   const changedFiles = /* @__PURE__ */ new Set([
     ...input.changeSet.added,
     ...input.changeSet.changed,
@@ -4855,13 +5223,18 @@ function determineOutputChanges(input) {
   const unchanged = [];
   for (const output of current) {
     if (isOutputAffected(
-      output,
+      withPreviousDependencies(output, previous.get(output.path)),
       changedContent,
+      refreshedContent,
       changedTags,
       changedFolders,
       changedFiles,
       changedExternal,
-      changedExternalScopes
+      changedExternalScopes,
+      currentPublicLocations,
+      previousPublicLocations,
+      input.previousState?.manifestEntries ?? [],
+      input.manifest.entries
     )) {
       affected.set(output.path, output);
     } else {
@@ -4897,7 +5270,10 @@ function determineOutputChanges(input) {
 function buildOutputInventory(manifest, pluginPageOutputs = [], contentOutputDependencies = []) {
   const outputs = /* @__PURE__ */ new Map();
   for (const entry of manifest.publicEntries) {
-    addOutput(outputs, contentOutput(entry, contentOutputDependencies));
+    addOutput(
+      outputs,
+      contentOutput(entry, manifest, contentOutputDependencies)
+    );
   }
   for (const [path6, redirect] of manifest.publicRedirects) {
     addOutput(outputs, {
@@ -4930,21 +5306,26 @@ function htmlOutputPath(pathname) {
   if (pathname.endsWith("/")) return `${withoutSlash}/index.html`;
   return `${withoutSlash}.html`;
 }
-function contentOutput(entry, dependencies) {
+function contentOutput(entry, manifest, dependencies) {
   return {
     kind: "content",
     path: htmlOutputPath(entry.permalink),
     producer: `content:${entry.slug}`,
-    dependencies: [{ type: "content", slug: entry.slug }, ...dependencies]
+    dependencies: [
+      { type: "content", slug: entry.slug },
+      ...resolveContentOutputDependencies(dependencies, entry, manifest)
+    ]
   };
 }
-function isOutputAffected(output, changedContent, changedTags, changedFolders, changedFiles, changedExternal, changedExternalScopes) {
+function isOutputAffected(output, changedContent, refreshedContent, changedTags, changedFolders, changedFiles, changedExternal, changedExternalScopes, currentPublicLocations, previousPublicLocations, previousEntries, currentEntries) {
   if (isAffectedByExternalScope(output, changedExternalScopes)) return true;
   for (const dependency of output.dependencies) {
     if (dependency.type === "unknown") return true;
     if (dependency.type === "external" && changedExternal.has(dependency.id))
       return true;
     if (dependency.type === "global") return changedContent.size > 0;
+    if (dependency.type === "content-query" && isContentQueryAffected(dependency, previousEntries, currentEntries))
+      return true;
     if (dependency.type === "projection" && (dependency.projection === "navigation" || dependency.projection === "recent-posts")) {
       return changedContent.size > 0;
     }
@@ -4954,7 +5335,7 @@ function isOutputAffected(output, changedContent, changedTags, changedFolders, c
     if (dependency.type === "projection" && dependency.projection === "taxonomy-folders") {
       return changedFolders.size > 0;
     }
-    if (dependency.type === "content" && changedContent.has(dependency.slug)) {
+    if (dependency.type === "content" && (changedContent.has(dependency.slug) || refreshedContent.has(dependency.slug))) {
       return true;
     }
     if (dependency.type === "tag" && changedTags.has(dependency.tag))
@@ -4965,9 +5346,98 @@ function isOutputAffected(output, changedContent, changedTags, changedFolders, c
     if (dependency.type === "file" && changedFiles.has(dependency.path)) {
       return true;
     }
+    if (dependency.type === "public-location") {
+      const currentOwner = currentPublicLocations.get(
+        normalizePublicPath(dependency.pathname)
+      );
+      const previousOwner = previousPublicLocations.get(
+        normalizePublicPath(dependency.pathname)
+      );
+      if (currentOwner?.slug !== previousOwner?.slug) return true;
+      if (currentOwner && (changedContent.has(currentOwner.slug) || refreshedContent.has(currentOwner.slug)) || previousOwner && (changedContent.has(previousOwner.slug) || refreshedContent.has(previousOwner.slug))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isContentQueryAffected(dependency, previousEntries, currentEntries) {
+  const previous = new Map(previousEntries.map((entry) => [entry.slug, entry]));
+  const current = new Map(currentEntries.map((entry) => [entry.slug, entry]));
+  const slugs = /* @__PURE__ */ new Set([...previous.keys(), ...current.keys()]);
+  for (const slug of slugs) {
+    const before = previous.get(slug);
+    const after = current.get(slug);
+    if (!before || !after) {
+      if ((before ?? after)?.publishing.discoverable) return true;
+      continue;
+    }
+    if (before.publishing.discoverable !== after.publishing.discoverable)
+      return true;
+    if (!before.publishing.discoverable && !after.publishing.discoverable)
+      continue;
+    if (dependency.unknown || dependency.properties.some(
+      (property) => propertyChanged(before, after, property)
+    ))
+      return true;
   }
   return false;
 }
+function propertyChanged(before, after, property) {
+  if (property === "*")
+    return JSON.stringify(before.frontmatter) !== JSON.stringify(after.frontmatter);
+  return JSON.stringify(contentQueryValue(before, property)) !== JSON.stringify(contentQueryValue(after, property));
+}
+function contentQueryValue(entry, property) {
+  switch (property) {
+    case "file.name":
+      return `${entry.slug.split("/").at(-1) ?? entry.slug}.md`;
+    case "file.path":
+      return `${entry.slug}.md`;
+    case "file.slug":
+      return entry.slug;
+    case "file.folder":
+      return entry.slug.split("/").slice(0, -1).join("/");
+    case "file.title":
+      return entry.title;
+    case "file.link":
+    case "file.permalink":
+      return entry.permalink;
+    case "file.tags":
+      return entry.tags;
+    case "file.size":
+      return entry.file?.size;
+    case "file.ctime":
+      return entry.file?.ctime;
+    case "file.mtime":
+      return entry.file?.mtime;
+    case "file.links":
+      return entry.links;
+    default:
+      return property.split(".").reduce(
+        (value, key) => value && typeof value === "object" && Object.hasOwn(value, key) ? value[key] : void 0,
+        entry.frontmatter
+      );
+  }
+}
+function resolveContentOutputDependencies(dependencies, entry, manifest) {
+  return typeof dependencies === "function" ? dependencies({ entry, manifest }) : dependencies;
+}
+function withPreviousDependencies(output, previous) {
+  if (!previous || previous.kind !== output.kind) return output;
+  return {
+    ...output,
+    dependencies: [...output.dependencies, ...previous.dependencies]
+  };
+}
+function publicLocationOwners(entries) {
+  return new Map(
+    entries.map((entry) => [
+      normalizePublicPath(entry.publicLocation.permalink),
+      entry
+    ])
+  );
+}
 function isAffectedByExternalScope(output, changedExternalScopes) {
   for (const scope of changedExternalScopes.values()) {
     if (scope.type === "all") return true;
@@ -5014,6 +5484,21 @@ function changedExternalDependencyScopes(input) {
   }
   return changed;
 }
+function collectRefreshedContent(input) {
+  const refreshed = /* @__PURE__ */ new Set();
+  const fingerprints = input.contentFingerprints;
+  const previousEntries = input.previousState?.entries;
+  if (!fingerprints || !previousEntries) return refreshed;
+  for (const entry of input.manifest.entries) {
+    const fingerprint = fingerprints.get(entry.slug);
+    if (fingerprint === void 0) continue;
+    if (previousEntries[`${entry.slug}.md`]?.processedContentCacheFingerprint === fingerprint) {
+      continue;
+    }
+    refreshed.add(entry.slug);
+  }
+  return refreshed;
+}
 function collectChangedContent(input) {
   const changed = /* @__PURE__ */ new Set([
     ...input.affectedContent.direct,
@@ -5141,6 +5626,7 @@ var ContentManager = class {
       }
     };
     this.contentIndexBuilder = new ContentIndexBuilder(this.source);
+    this.manifestAssembler = new ManifestAssembler(this.contentCache);
     this.pluginRuntime = new PluginRuntime(this.pipelineOptions);
     const buildStatePath = resolveContentBuildStatePath(
       pipelineOptions.config,
@@ -5159,13 +5645,16 @@ var ContentManager = class {
       buildStatePath,
       getEntries: () => this.entryReader.getEntries(),
       readEntry: (entry) => this.entryReader.read(entry),
-      observability
+      observability,
+      includeFileMetadata: this.pipelineOptions.plugins?.some(
+        (plugin) => plugin && plugin.contentFileMetadata === true
+      ) ?? false
     });
   }
   pipelineOptions;
   source;
   contentIndexBuilder;
-  manifestBuilder = new ManifestBuilder();
+  manifestAssembler;
   pluginRuntime;
   contentIndex = null;
   contentIndexAmbiguities = /* @__PURE__ */ new Map();
@@ -5327,10 +5816,13 @@ var ContentManager = class {
           this.getAllPosts(),
           this.getContentIndex(plan)
         ]);
+        const entriesByPath = new Map(
+          (await this.scan()).map((entry) => [entry.path, entry])
+        );
         const entries = await this.observability().tracer.span(
           "content.manifest.entries",
           {},
-          () => mapConcurrent3(
+          () => mapConcurrent(
             posts,
             CONTENT_PROCESSING_CONCURRENCY,
             async (post) => {
@@ -5348,7 +5840,7 @@ var ContentManager = class {
                   `Content public location was not resolved: ${post.slug}`
                 );
               }
-              return this.manifestBuilder.createEntry(
+              return this.manifestAssembler.createEntry(
                 post.slug,
                 rawPost,
                 processed,
@@ -5357,7 +5849,8 @@ var ContentManager = class {
                 resolvePublishingState(processed.frontmatter, {
                   strategy: this.publishStrategy(),
                   buildTime: this.publishingBuildTime
-                })
+                }),
+                entriesByPath.get(`${post.slug}.md`)?.metadata
               );
             }
           )
@@ -5366,7 +5859,7 @@ var ContentManager = class {
         const manifest = await this.observability().tracer.span(
           "content.graph",
           {},
-          () => this.manifestBuilder.build(
+          () => this.manifestAssembler.build(
             entries,
             contentIndex,
             this.contentIndexAmbiguities
@@ -5374,7 +5867,11 @@ var ContentManager = class {
         );
         const cacheManifestEntries = structuredClone(manifest.entries);
         this.locationResolver.populateRedirects(manifest, locations);
-        this.applyPublicView(manifest);
+        this.manifestAssembler.applyPublicView(
+          manifest,
+          this.publishStrategy(),
+          this.publishingBuildTime
+        );
         manifest.pagePaths = [
           ...await this.pluginRuntime.getPagePaths(manifest, contentIndex)
         ];
@@ -5387,7 +5884,7 @@ var ContentManager = class {
           plan.previousState?.manifestHookCache,
           this.getPipelineFingerprint()
         );
-        this.synchronizeManifestHtml(manifest, cacheManifestEntries);
+        this.manifestAssembler.synchronizeHtml(manifest, cacheManifestEntries);
         manifest.assets = this.pluginRuntime.collectAssets();
         manifest.clientEntries = this.pluginRuntime.collectClientEntries();
         manifest.diagnostics = [
@@ -5414,7 +5911,8 @@ var ContentManager = class {
             pluginPageOutputs,
             contentOutputDependencies: this.pluginRuntime.getContentOutputDependencies(),
             externalDependencies: plan.externalDependencies,
-            externalDependencyFailures: plan.externalDependencyFailures
+            externalDependencyFailures: plan.externalDependencyFailures,
+            contentFingerprints: this.processedContentCacheFingerprints
           })
         );
         if (this.outputChangeSet) {
@@ -5565,74 +6063,24 @@ var ContentManager = class {
   async getContentLocations() {
     return await this.locationResolver.getLocations();
   }
-  applyPublicView(manifest) {
-    const strategy = this.publishStrategy();
-    for (const entry of manifest.entries) {
-      entry.publishing = resolvePublishingState(entry.frontmatter, {
-        strategy,
-        buildTime: this.publishingBuildTime
-      });
-    }
-    manifest.publicEntries = manifest.entries.filter(
-      (entry) => entry.publishing.routable
-    );
-    manifest.discoverableEntries = manifest.entries.filter(
-      (entry) => entry.publishing.discoverable
-    );
-    const publicSlugs = new Set(
-      manifest.publicEntries.map((entry) => entry.slug)
-    );
-    const publicPermalinks = new Map(
-      manifest.publicEntries.map((entry) => [entry.permalink, entry])
-    );
-    manifest.byRoutablePermalink = publicPermalinks;
-    manifest.publicRedirects = new Map(
-      [...manifest.redirects].filter(
-        ([, redirect]) => publicSlugs.has(redirect.slug)
-      )
-    );
-  }
-  synchronizeManifestHtml(manifest, preHookEntries) {
-    const preHookHtml = new Map(
-      preHookEntries.map((entry) => [entry.slug, entry.html])
-    );
-    for (const entry of manifest.entries) {
-      const changed = preHookHtml.get(entry.slug) !== entry.html;
-      const cached = this.contentCache.get(entry.slug);
-      if (cached) {
-        if (changed) cached.html = entry.html;
-        continue;
-      }
-      this.contentCache.set(entry.slug, {
-        frontmatter: entry.frontmatter,
-        html: entry.html
-      });
-    }
-  }
   publishStrategy() {
     return this.pipelineOptions.config?.content.filters.publishStrategy ?? "explicit";
   }
   reuseManifestEntry(slug, source, plan) {
-    if (!plan.previousState?.manifestEntries) return null;
-    if (plan.previousState.pipelineFingerprint !== this.getPipelineFingerprint()) {
-      return null;
-    }
-    if (plan.affectedContent.direct.has(slug)) return null;
-    if (plan.affectedContent.dependent.has(slug)) return null;
-    const contentCacheFingerprint = this.getProcessedContentCacheFingerprint(
+    const reused = reuseManifestEntry({
       slug,
-      source
-    );
-    if (!contentCacheFingerprint) return null;
-    if (plan.previousState.entries[`${slug}.md`]?.processedContentCacheFingerprint !== contentCacheFingerprint) {
-      return null;
-    }
-    const entry = plan.previousManifestEntriesBySlug.get(slug);
-    if (!entry) return null;
+      plan,
+      pipelineFingerprint: this.getPipelineFingerprint(),
+      getContentCacheFingerprint: () => this.getProcessedContentCacheFingerprint(slug, source)
+    });
+    if (!reused) return null;
     this.reusedContentCount += 1;
-    this.processedContentCacheFingerprints.set(slug, contentCacheFingerprint);
+    this.processedContentCacheFingerprints.set(
+      slug,
+      reused.contentCacheFingerprint
+    );
     this.observability().tracer.event("content.reuse", { slug });
-    return cloneManifestEntry(entry);
+    return reused.entry;
   }
   getPipelineFingerprint() {
     if (!this.pipelineOptions.config) return void 0;
@@ -5679,6 +6127,7 @@ var ContentManager = class {
     return plan;
   }
   async createBuildPlan(options) {
+    this.enableBuildTime();
     const config = this.pipelineOptions.config;
     if (config && hasGlobalContentDependency(config)) {
       this.pipelineFingerprint = this.computePipelineFingerprint(
@@ -5741,7 +6190,7 @@ var ContentManager = class {
     const strategy = this.publishStrategy();
     const posts = await this.getAllPosts();
     const routableSlugs = /* @__PURE__ */ new Set();
-    await mapConcurrent3(posts, CONTENT_PROCESSING_CONCURRENCY, async (post) => {
+    await mapConcurrent(posts, CONTENT_PROCESSING_CONCURRENCY, async (post) => {
       const markdown = await this.getPost(post.slug);
       let frontmatter;
       try {
@@ -5785,38 +6234,6 @@ function readFrontmatter(markdown) {
   matter3(file);
   return file.data.matter ?? {};
 }
-function cloneManifestEntry(entry) {
-  return {
-    ...entry,
-    publicLocation: { ...entry.publicLocation },
-    frontmatter: { ...entry.frontmatter },
-    aliases: [...entry.aliases ?? []],
-    tags: [...entry.tags],
-    links: entry.links.map((link) => ({ ...link })),
-    backlinks: [...entry.backlinks],
-    assets: entry.assets.map((asset) => ({ ...asset })),
-    ...entry.headTags ? { headTags: [...entry.headTags] } : {}
-  };
-}
-async function mapConcurrent3(values, concurrency, map) {
-  const results = new Array(values.length);
-  let nextIndex = 0;
-  async function worker() {
-    while (nextIndex < values.length) {
-      const index = nextIndex;
-      nextIndex += 1;
-      const value = values[index];
-      if (value !== void 0) results[index] = await map(value);
-    }
-  }
-  await Promise.all(
-    Array.from(
-      { length: Math.min(concurrency, values.length) },
-      () => worker()
-    )
-  );
-  return results;
-}
 
 // src/content/content_source.ts
 async function readContentSourceEntry(source, logicalPath) {
@@ -6288,44 +6705,6 @@ function escapeHtmlAttribute(value) {
 function escapeScriptJson(value) {
   return value.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
 }
-
-// src/utils/markdown.ts
-var FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/;
-var FENCE_CLOSE = /^ {0,3}(`{3,}|~{3,})\s*$/;
-function scanMarkdownFenceLines(source) {
-  const lines = [];
-  let fence = null;
-  for (const value of source.split("\n")) {
-    if (fence === null) {
-      const open = FENCE_OPEN.exec(value);
-      if (open && !(open[1][0] === "`" && open[2].includes("`"))) {
-        fence = { marker: open[1][0], length: open[1].length };
-      }
-      lines.push({ value, inFence: false });
-      continue;
-    }
-    const close = FENCE_CLOSE.exec(value);
-    if (close && close[1][0] === fence.marker && close[1].length >= fence.length) {
-      fence = null;
-      lines.push({ value, inFence: false });
-      continue;
-    }
-    lines.push({ value, inFence: true });
-  }
-  return lines;
-}
-
-// src/utils/text.ts
-function stripHtml(html) {
-  return html.replace(/<script\b[\s\S]*?<\/script>/gi, " ").replace(/<style\b[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ");
-}
-function calculateReadingTime(html) {
-  const text = stripHtml(html).trim();
-  if (!text) return 1;
-  const cjkCharacters = text.match(/\p{Script=Han}|\p{Script=Hiragana}|\p{Script=Katakana}/gu)?.length ?? 0;
-  const latinWords = text.replace(/\p{Script=Han}|\p{Script=Hiragana}|\p{Script=Katakana}/gu, " ").match(/[\p{L}\p{N}]+/gu)?.length ?? 0;
-  return Math.max(1, Math.ceil(cjkCharacters / 500 + latinWords / 220));
-}
 export {
   ATTACHMENTS_BASE_PATH,
   CONTENT_BUILD_STATE_VERSION,
@@ -6362,8 +6741,11 @@ export {
   determineOutputChanges,
   escapeHtml,
   escapeHtmlAttribute,
+  escapeRegExp,
   escapeScriptJson,
+  extractContentLinks,
   extractFrontmatterAliases,
+  extractMarkdownLinkUrls,
   fingerprintContentEntries,
   fingerprintExternalValue,
   getContentSourceEntry,