@riebeckite/core 0.0.21 → 0.0.23

package/dist/index.js

@@ -825,17 +825,15 @@ function getFileName(filePath) {
   return normalizedPath.slice(normalizedPath.lastIndexOf("/") + 1);
 }
 
-// src/content/content_build_state_store.ts
-import { randomUUID } from "node:crypto";
-import fs from "node:fs/promises";
-import path from "node:path";
-
 // src/content/content_build_state.ts
-var CONTENT_BUILD_STATE_VERSION = 8;
+var CONTENT_BUILD_STATE_VERSION = 16;
 var CONTENT_BUILD_STATE_DIRECTORY = ".riebeckite";
 var CONTENT_BUILD_STATE_EXCLUDE = `${CONTENT_BUILD_STATE_DIRECTORY}/**`;
 
 // src/content/content_build_state_store.ts
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
 async function loadContentBuildState(statePath) {
   try {
     const parsed = JSON.parse(await fs.readFile(statePath, "utf8"));
@@ -876,13 +874,26 @@ async function saveContentBuildState(statePath, state2) {
   const temporaryPath = `${statePath}.${randomUUID()}.tmp`;
   await fs.mkdir(directory, { recursive: true });
   try {
+    await waitForFaultInjection("content-build-state-save-start");
     await fs.writeFile(temporaryPath, JSON.stringify(state2), "utf8");
     await fs.rename(temporaryPath, statePath);
+    await waitForFaultInjection("content-build-state-committed");
   } catch (error) {
     await fs.rm(temporaryPath, { force: true }).catch(() => void 0);
     throw error;
   }
 }
+async function waitForFaultInjection(point) {
+  if (process.env.NODE_ENV !== "test" || process.env.RIEBECKITE_SSG_FAULT_INJECTION !== "1" || process.env.RIEBECKITE_SSG_FAULT_POINT !== point) {
+    return;
+  }
+  const signalFile = process.env.RIEBECKITE_SSG_FAULT_SIGNAL_FILE;
+  if (!signalFile) return;
+  await fs.writeFile(signalFile, `${point}
+`, "utf8");
+  await new Promise(() => {
+  });
+}
 function resolveContentBuildStatePath(config, contentDirectory) {
   if (config?.buildDirectory) {
     return path.join(config.buildDirectory, "build", "content-state.json");
@@ -898,7 +909,7 @@ function isContentBuildState(value) {
   return isRecord2(value) && value.version === CONTENT_BUILD_STATE_VERSION && isContentBuildStateShape(value);
 }
 function isContentBuildStateShape(value) {
-  if (!isRecord2(value.entries) || !isRecord2(value.contentIndex) || value.outputs !== void 0 && !isOutputDescriptors(value.outputs)) {
+  if (!isRecord2(value.entries) || !isRecord2(value.contentIndex) || !isExternalDependencies(value.externalDependencies) || value.outputs !== void 0 && !isOutputDescriptors(value.outputs) || value.manifestHookCache !== void 0 && !isManifestHookCache(value.manifestHookCache) || value.nextPublishingChangeAt !== void 0 && (typeof value.nextPublishingChangeAt !== "string" || Number.isNaN(Date.parse(value.nextPublishingChangeAt)))) {
     return false;
   }
   return Object.values(value.entries).every(
@@ -909,6 +920,11 @@ function isContentBuildStateShape(value) {
     (entry) => typeof entry === "string"
   );
 }
+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)
+  );
+}
 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)
@@ -923,7 +939,17 @@ 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";
+  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");
+}
+function isExternalDependencies(value) {
+  return Array.isArray(value) && value.every(
+    (dependency) => isRecord2(dependency) && typeof dependency.id === "string" && dependency.id.length > 0 && typeof dependency.fingerprint === "string" && dependency.fingerprint.length > 0 && isExternalScope(dependency.scope) && (dependency.expiresAt === void 0 || typeof dependency.expiresAt === "string" && !Number.isNaN(Date.parse(dependency.expiresAt)))
+  );
+}
+function isExternalScope(value) {
+  if (!isRecord2(value) || typeof value.type !== "string") return false;
+  if (value.type === "content" || value.type === "all") return true;
+  return value.type === "output" && Array.isArray(value.paths) && value.paths.every((path6) => isOutputPath(path6));
 }
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1515,9 +1541,9 @@ import remarkDirective from "remark-directive";
 import remarkFrontmatter from "remark-frontmatter";
 import remarkGfm from "remark-gfm";
 import remarkMath from "remark-math";
-import remarkParse from "remark-parse";
+import remarkParse2 from "remark-parse";
 import remarkRehype from "remark-rehype";
-import { unified } from "unified";
+import { unified as unified2 } from "unified";
 import { matter as matter2 } from "vfile-matter";
 
 // src/content/content_dependency_tracker.ts
@@ -1652,8 +1678,8 @@ function warn(logger, message, key, error) {
 
 // src/content/content_persistent_cache.ts
 var CONTENT_CACHE_NAMESPACE = "content";
-var CONTENT_CACHE_SCHEMA_VERSION = 3;
-var CONTENT_CACHE_COMPATIBILITY_VERSION = 1;
+var CONTENT_CACHE_SCHEMA_VERSION = 5;
+var CONTENT_CACHE_COMPATIBILITY_VERSION = 3;
 function hash2(value) {
   return createHash4("sha256").update(value).digest("hex");
 }
@@ -1813,17 +1839,35 @@ function normalizeFrontmatterForCache(frontmatter) {
   }
   return normalized;
 }
-function computePipelineFingerprint(config) {
+function computePipelineFingerprint(config, contentScopeFingerprint) {
   const plugins = config.plugins;
   const fingerprintData = {
     compatibilityVersion: CONTENT_CACHE_COMPATIBILITY_VERSION,
     plugins: plugins.map((p) => pluginFingerprint(p)),
     content: {
       filters: config.content.filters
-    }
+    },
+    contentScopeFingerprint
   };
   return hash2(stableStringify(fingerprintData));
 }
+function computeContentScopeFingerprint(locations) {
+  return hash2(
+    stableStringify(
+      [...locations.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([slug, location]) => ({
+        slug,
+        permalink: location.permalink,
+        ...location.language ? { language: location.language } : {},
+        ...location.redirects ? {
+          redirects: location.redirects.map((redirect) => ({
+            ...redirect
+          }))
+        } : {},
+        ...location.metadata ? { metadata: { ...location.metadata } } : {}
+      }))
+    )
+  );
+}
 var pluginFingerprints = /* @__PURE__ */ new WeakMap();
 function pluginFingerprint(plugin) {
   const cached = pluginFingerprints.get(plugin);
@@ -1859,23 +1903,25 @@ function sanitizeForFingerprint(value) {
   }
   return value;
 }
-function isPersistentlyCacheable(_slug, config) {
-  const hasL10n = config.plugins.some(
-    (p) => p.name === "l10n" && p.enabled !== false
-  );
-  if (hasL10n) {
-    return { cacheable: false, reason: "l10n plugin is enabled" };
-  }
+function isPersistentlyCacheable(slug, config, source) {
+  const context = source === void 0 ? void 0 : { slug, source };
   const unsafePlugin = config.plugins.find((plugin) => {
     if (plugin.enabled === false) return false;
     if (!canAffectProcessedContent(plugin)) return false;
-    return plugin.processedContentCache?.dependencyMode !== "none" && plugin.processedContentCache?.dependencyMode !== "tracked";
+    const contract = plugin.processedContentCache;
+    if (!contract) return true;
+    if (!context) return contract.dependencyMode === "unsafe";
+    const applicability = getApplicability(contract.appliesToContent, context);
+    if (applicability === "does-not-apply") return false;
+    if (applicability === "unknown") return true;
+    if (contract.dependencyMode === "unsafe") return true;
+    return getContractDependencyFingerprint(contract, context) === void 0;
   });
   if (unsafePlugin) {
     if (unsafePlugin.processedContentCache?.dependencyMode === "unsafe") {
       return {
         cacheable: false,
-        reason: `plugin ${unsafePlugin.name} explicitly marks processed content cache as unsafe`
+        reason: `plugin ${unsafePlugin.name} explicitly marks processed content cache as unsafe and cannot prove safety for this content`
       };
     }
     return {
@@ -1885,6 +1931,68 @@ function isPersistentlyCacheable(_slug, config) {
   }
   return { cacheable: true };
 }
+function computeContentCacheFingerprint(slug, source, config) {
+  const context = { slug, source };
+  const plugins = config.plugins.filter(
+    (plugin) => plugin.enabled !== false && canAffectProcessedContent(plugin)
+  ).map((plugin) => {
+    const contract = plugin.processedContentCache;
+    if (!contract) return { name: plugin.name, applicability: "unknown" };
+    const applicability = getApplicability(
+      contract.appliesToContent,
+      context
+    );
+    return {
+      name: plugin.name,
+      applicability,
+      dependencyFingerprint: applicability === "applies" ? getContractDependencyFingerprint(contract, context) : void 0
+    };
+  });
+  return hash2(stableStringify(plugins));
+}
+function getApplicability(appliesToContent, context) {
+  if (!context) return "unknown";
+  if (!appliesToContent) return "applies";
+  try {
+    const applicability = appliesToContent(context);
+    return applicability === "applies" || applicability === "does-not-apply" || applicability === "unknown" ? applicability : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function getContractDependencyFingerprint(contract, context) {
+  if (!context) return void 0;
+  try {
+    const content = contract.contentDependencyFingerprint?.(context);
+    if (contract.contentDependencyFingerprint && content === void 0)
+      return void 0;
+    const environment = contract.environmentFingerprint?.();
+    if (contract.environmentFingerprint && environment === void 0)
+      return void 0;
+    return hash2(
+      stableStringify({
+        content: content ?? null,
+        environment: environment ?? null
+      })
+    );
+  } catch {
+    return void 0;
+  }
+}
+function hasGlobalContentDependency(config) {
+  return config.plugins.some(
+    (plugin) => plugin.enabled !== false && canAffectProcessedContent(plugin) && plugin.processedContentCache?.dependencyMode === "global"
+  );
+}
+function requiresFullContentRegeneration(config) {
+  return config.plugins.some((plugin) => {
+    if (plugin.enabled === false || !canAffectProcessedContent(plugin)) {
+      return false;
+    }
+    const contract = plugin.processedContentCache;
+    return !contract || contract.dependencyMode === "unsafe" && !contract.appliesToContent;
+  });
+}
 function canAffectProcessedContent(plugin) {
   return Boolean(
     plugin.remarkPlugins?.length || plugin.rehypePlugins?.length || plugin.extendMarkdownPipeline || plugin.extendHtmlPipeline || plugin.renderers?.length || plugin.onContentLoaded || plugin.onPostParsed || plugin.onPostProcessed
@@ -1896,6 +2004,117 @@ function extractFrontmatter(markdown) {
   return vfile.data.matter ?? {};
 }
 
+// src/content/markdown_image.ts
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+function extractMarkdownImages(markdown, sourceSlug) {
+  const tree = unified().use(remarkParse).parse(markdown);
+  const definitions = /* @__PURE__ */ new Map();
+  const references = [];
+  const urls = [];
+  visitMarkdownNodes(tree, (node) => {
+    if (node.type === "definition" && typeof node.url === "string") {
+      const identifier = normalizeIdentifier(node.identifier);
+      if (identifier) definitions.set(identifier, node.url);
+    }
+    if (node.type === "image" && typeof node.url === "string") {
+      urls.push(node.url);
+    }
+    if (node.type === "imageReference") {
+      const identifier = normalizeIdentifier(node.identifier);
+      if (identifier) references.push(identifier);
+    }
+  });
+  for (const reference of references) {
+    const url = definitions.get(reference);
+    if (url) urls.push(url);
+  }
+  return uniqueImages(
+    urls.map((url) => resolveMarkdownImage(url, sourceSlug)).filter((image) => image !== null)
+  );
+}
+function normalizeMarkdownImages(sourceSlug) {
+  return () => (tree) => {
+    const definitions = /* @__PURE__ */ new Map();
+    const references = /* @__PURE__ */ new Set();
+    visitMarkdownNodes(tree, (node) => {
+      if (node.type === "definition" && typeof node.url === "string") {
+        const identifier = normalizeIdentifier(node.identifier);
+        if (identifier) definitions.set(identifier, node);
+      }
+      if (node.type === "image" && typeof node.url === "string") {
+        const image = resolveMarkdownImage(node.url, sourceSlug);
+        if (image) node.url = image.url;
+      }
+      if (node.type === "imageReference") {
+        const identifier = normalizeIdentifier(node.identifier);
+        if (identifier) references.add(identifier);
+      }
+    });
+    for (const identifier of references) {
+      const definition = definitions.get(identifier);
+      if (!definition || typeof definition.url !== "string") continue;
+      const image = resolveMarkdownImage(definition.url, sourceSlug);
+      if (image) definition.url = image.url;
+    }
+  };
+}
+function resolveMarkdownImage(input, sourceSlug) {
+  if (input.startsWith("//") || /^[a-z][a-z0-9+.-]*:/i.test(input)) {
+    return null;
+  }
+  const [pathAndQuery, hash4 = ""] = splitOnce(input, "#");
+  const [rawPath, query = ""] = splitOnce(pathAndQuery, "?");
+  const decodedPath = decodeUriPath(rawPath);
+  if (!decodedPath || !isImagePath(decodedPath)) return null;
+  const path6 = resolveContentAssetPath(sourceSlug, decodedPath);
+  if (!path6) return null;
+  const encodedPath = path6.split("/").map(encodeURIComponent).join("/");
+  const suffix = `${query ? `?${query}` : ""}${hash4 ? `#${hash4}` : ""}`;
+  return { path: path6, url: `/${encodedPath}${suffix}` };
+}
+function resolveContentAssetPath(sourceSlug, targetPath) {
+  const sourceDirectory = sourceSlug.includes("/") ? sourceSlug.slice(0, sourceSlug.lastIndexOf("/")) : "";
+  const parts = [
+    ...targetPath.startsWith("/") ? [] : sourceDirectory.split("/"),
+    ...normalizeContentPath(targetPath).replace(/^\/+/, "").split("/")
+  ];
+  const normalized = [];
+  for (const part of parts) {
+    if (!part || part === ".") continue;
+    if (part === "..") {
+      if (normalized.length === 0) return null;
+      normalized.pop();
+      continue;
+    }
+    normalized.push(part);
+  }
+  return normalized.length > 0 ? normalized.join("/").normalize("NFC") : null;
+}
+function visitMarkdownNodes(node, visitor) {
+  const markdownNode = node;
+  visitor(markdownNode);
+  for (const child of markdownNode.children ?? [])
+    visitMarkdownNodes(child, visitor);
+}
+function normalizeIdentifier(value) {
+  return typeof value === "string" ? value.toLowerCase() : null;
+}
+function decodeUriPath(path6) {
+  try {
+    return decodeURI(path6);
+  } catch {
+    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";
@@ -2086,7 +2305,8 @@ var Pipeline = class {
         tracer: this.options.observability?.tracer
       });
       this.pipelineFingerprint = computePipelineFingerprint(
-        this.options.config
+        this.options.config,
+        this.options.contentScopeFingerprint
       );
     }
   }
@@ -2113,9 +2333,11 @@ var Pipeline = class {
     const effectiveContentSource = dependencyTracker ? dependencyTracker.contentSource : this.options.contentSource;
     const sourceSlug = context.sourceSlug;
     if (embedDepth === 0 && this.persistentCache && this.pipelineFingerprint && sourceSlug && this.options.contentSource && this.options.config) {
+      const persistentCache = this.persistentCache;
       const cacheable = isPersistentlyCacheable(
         sourceSlug,
-        this.options.config
+        this.options.config,
+        markDownContent
       );
       if (cacheable.cacheable) {
         const frontmatter = extractFrontmatter(markDownContent);
@@ -2123,12 +2345,21 @@ var Pipeline = class {
           slug: sourceSlug,
           source: markDownContent,
           frontmatter,
-          pipelineFingerprint: this.pipelineFingerprint
+          pipelineFingerprint: this.contentPipelineFingerprint(
+            sourceSlug,
+            markDownContent
+          )
         });
-        const lookup = await this.persistentCache.lookup(cacheKey);
+        const lookup = await (this.options.observability ?? noopObservability).tracer.span(
+          "persistentContentCache.lookup",
+          {},
+          () => persistentCache.lookup(cacheKey)
+        );
         if (lookup.status === "hit") {
-          const invalidDependency = await this.findInvalidDependency(
-            lookup.entry.dependencies
+          const invalidDependency = await (this.options.observability ?? noopObservability).tracer.span(
+            "persistentContentCache.validation",
+            { dependencyCount: lookup.entry.dependencies.length },
+            () => this.findInvalidDependency(lookup.entry.dependencies)
           );
           if (!invalidDependency) {
             this.reportContentDependencies(
@@ -2178,9 +2409,9 @@ var Pipeline = class {
         this.options.onPersistentContentCacheResult?.("bypass");
       }
     }
-    const processor = unified();
+    const processor = unified2();
     const plugins = this.resolvePlugins();
-    this.use(processor, remarkParse);
+    this.use(processor, remarkParse2);
     this.use(processor, remarkDirective);
     this.use(processor, remarkFrontmatter, ["yaml", "toml"]);
     this.use(processor, function loadFrontmatter() {
@@ -2220,6 +2451,9 @@ var Pipeline = class {
       ...markdownPipelineContext,
       recordLinkResolution: dependencyTracker ? (id, value) => dependencyTracker.recordLinkResolution(id, value) : void 0
     });
+    if (context.sourceSlug) {
+      this.use(processor, normalizeMarkdownImages(context.sourceSlug));
+    }
     this.use(processor, remarkRehype, { allowDangerousHtml: true });
     this.use(processor, rehypeRaw);
     for (const plugin of plugins) {
@@ -2236,7 +2470,11 @@ var Pipeline = class {
     this.use(processor, rehypeKatex, { output: "mathml", strict: false });
     this.use(processor, rehypeFormat);
     this.use(processor, rehypeStringify, { allowDangerousHtml: true });
-    const file = await processor.process(markDownContent.trim());
+    const file = await (this.options.observability ?? noopObservability).tracer.span(
+      "content.markdown",
+      { embedded: embedDepth > 0 },
+      async () => await processor.process(markDownContent.trim())
+    );
     const result = {
       frontmatter: file.data.matter || {},
       html: String(file.value)
@@ -2253,7 +2491,8 @@ var Pipeline = class {
     if (embedDepth === 0 && this.persistentCache && this.pipelineFingerprint && sourceSlug && dependencyTracker && this.options.config) {
       const cacheable = isPersistentlyCacheable(
         sourceSlug,
-        this.options.config
+        this.options.config,
+        markDownContent
       );
       if (cacheable.cacheable) {
         const frontmatter = extractFrontmatter(markDownContent);
@@ -2261,7 +2500,10 @@ var Pipeline = class {
           slug: sourceSlug,
           source: markDownContent,
           frontmatter,
-          pipelineFingerprint: this.pipelineFingerprint
+          pipelineFingerprint: this.contentPipelineFingerprint(
+            sourceSlug,
+            markDownContent
+          )
         });
         const dependencies = dependencyTracker.dependencies();
         const entry = {
@@ -2278,6 +2520,11 @@ var Pipeline = class {
   reportContentDependencies(slug, dependencies) {
     this.options.onContentDependencies?.(slug, dependencies);
   }
+  contentPipelineFingerprint(slug, source) {
+    const config = this.options.config;
+    if (!config || !this.pipelineFingerprint) return "";
+    return `${this.pipelineFingerprint}:${computeContentCacheFingerprint(slug, source, config)}`;
+  }
   async findInvalidDependency(dependencies) {
     const contentSource = this.options.contentSource;
     if (!contentSource) return null;
@@ -2464,9 +2711,9 @@ function visitMarkdownLinkNodes(node, 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 = decodeUriPath(rawPath);
+  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,
@@ -2527,14 +2774,14 @@ function resolveRelativeMarkdownSlug(sourceSlug, targetPath) {
   }
   return normalizedParts.join("/").replace(/\.md$/i, "");
 }
-function decodeUriPath(path6) {
+function decodeUriPath2(path6) {
   try {
     return decodeURI(path6);
   } catch {
     return null;
   }
 }
-function splitOnce(value, separator) {
+function splitOnce2(value, separator) {
   const index = value.indexOf(separator);
   if (index < 0) return [value];
   return [value.slice(0, index), value.slice(index + separator.length)];
@@ -2563,18 +2810,141 @@ 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)
+    )
+  };
+  return {
+    pluginName,
+    cacheable,
+    pipelineFingerprint,
+    inputFingerprint,
+    outputFingerprint: fingerprintManifestHookSnapshot(snapshot, manifest),
+    snapshot
+  };
+}
+function fingerprintManifestHookSideEffects(manifest) {
+  const value = {
+    ...manifest,
+    entries: []
+  };
+  return fingerprintManifest(manifestFingerprintValue(value));
+}
+function fingerprintManifestHookSnapshot(snapshot, manifest) {
+  return fingerprintManifest(
+    manifestFingerprintValue({
+      ...manifest,
+      entries: [...snapshot.entries]
+    })
+  );
+}
+function applyManifestHookSnapshot(manifest, snapshot) {
+  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.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;
+  } catch {
+    return false;
+  }
+}
+function manifestFingerprintValue(manifest) {
+  return {
+    entries: manifest.entries,
+    publicEntries: manifest.publicEntries.map((entry) => entry.slug),
+    discoverableEntries: manifest.discoverableEntries.map(
+      (entry) => entry.slug
+    ),
+    redirects: [...manifest.redirects.entries()].sort(
+      ([left], [right]) => left.localeCompare(right)
+    ),
+    publicRedirects: [...manifest.publicRedirects.entries()].sort(
+      ([left], [right]) => left.localeCompare(right)
+    ),
+    assets: manifest.assets,
+    clientEntries: manifest.clientEntries,
+    diagnostics: manifest.diagnostics,
+    generatedOutputs: manifest.generatedOutputs,
+    folderLocations: [...manifest.folderLocations.entries()].sort(
+      ([left], [right]) => left.localeCompare(right)
+    ),
+    pageRoutes: manifest.pageRoutes,
+    pagePaths: manifest.pagePaths
+  };
+}
+function fingerprintManifest(value) {
+  const normalized = JSON.parse(JSON.stringify(value));
+  return createHash6("sha256").update(stableStringify(normalized)).digest("hex");
+}
+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) {
+function createStyleAsset(pluginName, moduleSpecifier) {
   return {
     pluginName,
     kind: "style",
-    moduleSpecifier: `@riebeckite/plugin-${pluginName}/style.css`
+    moduleSpecifier
   };
 }
-function createClientEntry(pluginName, exportName, publicConfig) {
+function createClientEntry(pluginName, moduleSpecifier, exportName, publicConfig) {
   return {
     pluginName,
-    moduleSpecifier: `@riebeckite/plugin-${pluginName}/client`,
+    moduleSpecifier,
     ...exportName === void 0 ? {} : { exportName },
     ...publicConfig === void 0 ? {} : { publicConfig }
   };
@@ -2646,6 +3016,9 @@ var GeneratedOutputRegistry = class {
       (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
     );
   }
+  count() {
+    return this.outputs.length;
+  }
 };
 
 // src/plugin/plugin_lifecycle.ts
@@ -2727,12 +3100,46 @@ var PluginRuntime = class {
   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();
   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)
+    };
+  }
+  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;
+  }
+  getManifestHookCache() {
+    return this.manifestHookCache;
+  }
   /**
    * Starts the plugin build lifecycle exactly once, regardless of which public
    * entry point (content processing or location resolution) reaches it first.
@@ -2751,6 +3158,43 @@ var PluginRuntime = class {
       markdown
     });
   }
+  async resolveExternalDependencies(contentIndex) {
+    if (this.externalDependenciesResolved) {
+      return {
+        snapshots: [...this.externalDependencies.values()],
+        failures: this.externalDependencyFailures
+      };
+    }
+    await this.startBuild(contentIndex);
+    const snapshots = /* @__PURE__ */ new Map();
+    const failures = [];
+    for (const plugin of this.plugins()) {
+      const resolve = plugin.resolveExternalDependencies;
+      if (!resolve) continue;
+      const results = await resolve({
+        config: this.pipelineOptions.config,
+        contentIndex,
+        cache: this.cacheFor(plugin)
+      });
+      for (const result of results) {
+        if (result.kind === "unavailable") {
+          failures.push(result.failure);
+          continue;
+        }
+        const snapshot = result.snapshot;
+        if (snapshots.has(snapshot.id)) {
+          throw new Error(
+            `External dependency ID "${snapshot.id}" is declared more than once.`
+          );
+        }
+        snapshots.set(snapshot.id, snapshot);
+      }
+    }
+    this.externalDependencies = snapshots;
+    this.externalDependencyFailures = failures;
+    this.externalDependenciesResolved = true;
+    return { snapshots: [...snapshots.values()], failures };
+  }
   async resolveContentLocations(entries, contentIndex) {
     const context = { ...this.createContext(contentIndex), entries };
     const locations = [];
@@ -2797,15 +3241,86 @@ var PluginRuntime = class {
       }
     );
   }
-  async runManifestCreated(manifest, contentIndex) {
-    await this.runHook(
-      "onManifestCreated",
-      (plugin) => plugin.onManifestCreated,
-      {
-        ...this.createContext(contentIndex),
-        manifest
+  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
+        )
+      );
+    }
+  }
+  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 runBuildEnd(manifest, contentIndex) {
     const context = {
@@ -2817,6 +3332,30 @@ var PluginRuntime = class {
       (plugin) => this.createPluginContext(plugin, context)
     );
   }
+  async runGeneratedOutputPlans(manifest) {
+    for (const plugin of this.plugins()) {
+      const hook = plugin.planGeneratedOutputs;
+      if (!hook) continue;
+      const outputs = await hook(
+        freezeGeneratedOutputPlanContext({
+          manifest: {
+            discoverableEntries: manifest.discoverableEntries,
+            routableEntries: manifest.publicEntries
+          },
+          site: this.pipelineOptions.config?.site
+        })
+      );
+      const sink = this.generatedOutputs.sinkFor(plugin.name);
+      for (const output of outputs) {
+        if (output.dependencies.length === 0) {
+          throw new Error(
+            `Generated output plan from "${plugin.name}" must declare at least one dependency.`
+          );
+        }
+        sink.emit(output);
+      }
+    }
+  }
   enableBuildTime() {
     this.isBuildTime = true;
   }
@@ -2857,6 +3396,13 @@ var PluginRuntime = class {
   collectGeneratedOutputs() {
     return this.generatedOutputs.all();
   }
+  emitCoreAsset(path6, content) {
+    this.generatedOutputs.sinkFor("core").emitAsset({
+      path: path6,
+      content,
+      dependencies: [{ type: "file", path: path6 }]
+    });
+  }
   async resolvePage(pathname, manifest, contentIndex) {
     const matches = [];
     const requestedPathname = normalizePagePath(pathname);
@@ -2967,7 +3513,9 @@ var PluginRuntime = class {
     return declarations;
   }
   getContentOutputDependencies() {
-    return this.plugins().flatMap((plugin) => plugin.outputDependencies ?? []);
+    return this.plugins().flatMap(
+      (plugin) => plugin.contentOutputDependencies ?? []
+    );
   }
   async collectDiagnostics(contentIndex) {
     const tracer = this.observability().tracer;
@@ -3030,7 +3578,8 @@ var PluginRuntime = class {
       config: this.pipelineOptions.config,
       contentIndex,
       contentSource: this.pipelineOptions.contentSource,
-      diagnostics: this.diagnostics
+      diagnostics: this.diagnostics,
+      externalDependencies: this.externalDependencies
     };
   }
   createPluginContext(plugin, context) {
@@ -3081,6 +3630,15 @@ var PluginRuntime = class {
     return this.resolvedPlugins;
   }
 };
+function freezeGeneratedOutputPlanContext(context) {
+  return deepFreeze(structuredClone(context));
+}
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object") return value;
+  Object.freeze(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) {
@@ -3143,6 +3701,16 @@ 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(/\/$/, "");
@@ -3450,34 +4018,46 @@ var ContentBuildCoordinator = class {
     this.dependencies = dependencies;
   }
   dependencies;
-  preparation = null;
-  getPreparation(incremental, pipelineFingerprint, fullContentRegenerationRequired = false) {
-    this.preparation ??= this.prepare(
+  plan = null;
+  getPlan(incremental, pipelineFingerprint, fullContentRegenerationRequired = false, externalDependencies = [], externalDependencyFailures = [], publishingBuildTime = /* @__PURE__ */ new Date()) {
+    if (this.plan) return this.plan;
+    const plan = this.prepare(
       incremental,
       pipelineFingerprint,
-      fullContentRegenerationRequired
+      fullContentRegenerationRequired,
+      externalDependencies,
+      externalDependencyFailures,
+      publishingBuildTime
     );
-    return this.preparation;
+    this.plan = plan;
+    void plan.catch(() => {
+      if (this.plan === plan) this.plan = null;
+    });
+    return plan;
   }
-  async commit(preparation, manifest, pipelineFingerprint, outputs = [], manifestEntries = manifest.entries, trackedDependencies = /* @__PURE__ */ new Map()) {
+  async commit(plan, manifest, pipelineFingerprint, outputs = [], manifestEntries = manifest.entries, trackedDependencies = /* @__PURE__ */ new Map(), externalDependencies = [], processedContentCacheFingerprints = /* @__PURE__ */ new Map(), manifestHookCache = [], publishingBuildTime) {
     const entriesBySlug = new Map(
       manifest.entries.map((entry) => [entry.slug, entry])
     );
+    const nextChangeAt = nextPublishingChangeAt(manifest, publishingBuildTime);
     const state2 = {
       version: CONTENT_BUILD_STATE_VERSION,
       entries: Object.fromEntries(
-        preparation.currentEntries.map(({ entry, fingerprint }) => {
+        plan.currentEntries.map(({ entry, fingerprint }) => {
           const manifestEntry = entriesBySlug.get(toSlug(entry.path));
           return [
             entry.path,
             {
               fingerprint,
-              aliases: preparation.currentContentAliases.get(entry.path) ?? [],
+              aliases: plan.currentContentAliases.get(entry.path) ?? [],
               dependencies: collectDependencies2(
                 manifestEntry,
-                trackedDependencies.get(toSlug(entry.path)) ?? preparation.previousState?.entries[entry.path]?.dependencies ?? []
+                trackedDependencies.get(toSlug(entry.path)) ?? plan.previousState?.entries[entry.path]?.dependencies ?? []
               ),
-              linkTargets: collectLinkTargets(manifestEntry)
+              linkTargets: collectLinkTargets(manifestEntry),
+              ...processedContentCacheFingerprints.get(toSlug(entry.path)) ? {
+                processedContentCacheFingerprint: processedContentCacheFingerprints.get(toSlug(entry.path))
+              } : {}
             }
           ];
         })
@@ -3489,7 +4069,19 @@ var ContentBuildCoordinator = class {
       ),
       pipelineFingerprint,
       manifestEntries,
-      outputs
+      outputs,
+      externalDependencies: externalDependencies.map(
+        ({ id, fingerprint, scope, expiresAt }) => ({
+          id,
+          fingerprint,
+          scope,
+          ...expiresAt === void 0 ? {} : { expiresAt }
+        })
+      ),
+      manifestHookCache,
+      ...nextChangeAt ? {
+        nextPublishingChangeAt: nextChangeAt
+      } : {}
     };
     try {
       await saveContentBuildState(this.dependencies.buildStatePath, state2);
@@ -3503,7 +4095,7 @@ var ContentBuildCoordinator = class {
       );
     }
   }
-  async prepare(incremental, pipelineFingerprint, fullContentRegenerationRequired) {
+  async prepare(incremental, pipelineFingerprint, fullContentRegenerationRequired, externalDependencies, externalDependencyFailures, publishingBuildTime) {
     const entries = await this.dependencies.observability.tracer.span(
       "content.discovery",
       {},
@@ -3517,12 +4109,20 @@ var ContentBuildCoordinator = class {
         (entry) => this.dependencies.readEntry(entry)
       )
     );
-    const previousState = incremental === false ? void 0 : await loadContentBuildState(this.dependencies.buildStatePath);
-    const changeSet = previousState ? diffContentEntries(previousState, currentEntries) : allContentChanged(currentEntries);
-    const currentContentAliases = await this.getContentAliases(
-      currentEntries,
-      previousState,
-      changeSet
+    const previousState = await this.dependencies.observability.tracer.span(
+      "content.build-state.load",
+      { incremental },
+      async () => incremental ? await loadContentBuildState(this.dependencies.buildStatePath) : void 0
+    );
+    const changeSet = await this.dependencies.observability.tracer.span(
+      "content.change-set",
+      {},
+      () => previousState ? diffContentEntries(previousState, currentEntries) : allContentChanged(currentEntries)
+    );
+    const currentContentAliases = await this.dependencies.observability.tracer.span(
+      "content.aliases",
+      {},
+      () => this.getContentAliases(currentEntries, previousState, changeSet)
     );
     const {
       index: currentContentIndex,
@@ -3535,26 +4135,54 @@ var ContentBuildCoordinator = class {
         currentContentAliases
       )
     );
-    const affected = !fullContentRegenerationRequired && previousState?.pipelineFingerprint === pipelineFingerprint ? determineAffectedContent(
-      changeSet,
+    const publishingStateExpired = isPublishingStateExpired(
       previousState,
-      currentEntries.map(({ entry }) => entry.path),
-      currentContentIndex
-    ) : determineAffectedContent(
-      allContentChanged(currentEntries),
-      void 0,
-      currentEntries.map(({ entry }) => entry.path),
-      currentContentIndex
+      publishingBuildTime
+    );
+    const affected = await this.dependencies.observability.tracer.span(
+      "content.affected",
+      { fullContentRegenerationRequired },
+      () => !fullContentRegenerationRequired && !publishingStateExpired && previousState?.pipelineFingerprint === pipelineFingerprint ? determineAffectedContent(
+        changeSet,
+        previousState,
+        currentEntries.map(({ entry }) => entry.path),
+        currentContentIndex
+      ) : determineAffectedContent(
+        allContentChanged(currentEntries),
+        void 0,
+        currentEntries.map(({ entry }) => entry.path),
+        currentContentIndex
+      )
     );
+    const fullRegenerationReasons = [];
+    if (!incremental) fullRegenerationReasons.push("incremental-disabled");
+    else if (!previousState)
+      fullRegenerationReasons.push("cache-missing-or-invalid");
+    if (previousState && previousState.pipelineFingerprint !== pipelineFingerprint)
+      fullRegenerationReasons.push("pipeline-fingerprint-changed");
+    if (fullContentRegenerationRequired)
+      fullRegenerationReasons.push("content-plugin-uncacheable");
+    if (publishingStateExpired)
+      fullRegenerationReasons.push("publishing-state-expired");
+    if (externalDependencyFailures.length > 0)
+      fullRegenerationReasons.push("external-dependency-unavailable");
     this.dependencies.observability.tracer.event("build.incremental", {
-      incremental: incremental !== false,
+      incremental,
+      cacheValid: previousState !== void 0,
+      fullRegenerationReasons: fullRegenerationReasons.join(","),
+      externalDependencyFailures: externalDependencyFailures.length,
       added: changeSet.added.length,
       changed: changeSet.changed.length,
       removed: changeSet.removed.length,
       unchanged: changeSet.unchanged.length,
       affected: affected.direct.size + affected.dependent.size
     });
+    const reusableOutputs = incremental && previousState?.pipelineFingerprint === pipelineFingerprint && externalDependencyFailures.length === 0 && !publishingStateExpired && externalDependenciesEqual(
+      previousState?.externalDependencies ?? [],
+      externalDependencies
+    ) && changeSet.added.length === 0 && changeSet.changed.length === 0 && changeSet.removed.length === 0 ? previousState?.outputs : void 0;
     return {
+      incremental,
       previousState,
       previousManifestEntriesBySlug: new Map(
         (previousState?.manifestEntries ?? []).map((entry) => [
@@ -3567,7 +4195,12 @@ var ContentBuildCoordinator = class {
       currentContentIndex,
       currentContentIndexAmbiguities,
       changeSet,
-      affectedContent: affected
+      affectedContent: affected,
+      cacheValid: previousState !== void 0,
+      fullRegenerationReasons,
+      reusableOutputs,
+      externalDependencies,
+      externalDependencyFailures
     };
   }
   async getContentAliases(currentEntries, previousState, changeSet) {
@@ -3590,6 +4223,31 @@ var ContentBuildCoordinator = class {
     return aliases;
   }
 };
+function externalDependenciesEqual(previous, current) {
+  if (previous.length !== current.length) return false;
+  const currentById = new Map(
+    current.map((dependency) => [dependency.id, dependency])
+  );
+  return previous.every((dependency) => {
+    const candidate = currentById.get(dependency.id);
+    return candidate !== void 0 && candidate.fingerprint === dependency.fingerprint && candidate.expiresAt === dependency.expiresAt && !isExpired(candidate.expiresAt);
+  });
+}
+function isExpired(expiresAt) {
+  return expiresAt !== void 0 && Date.parse(expiresAt) <= Date.now();
+}
+function isPublishingStateExpired(state2, buildTime) {
+  return state2?.nextPublishingChangeAt !== void 0 && Date.parse(state2.nextPublishingChangeAt) <= buildTime.getTime();
+}
+function nextPublishingChangeAt(manifest, buildTime) {
+  const next = manifest.entries.filter((entry) => entry.publishing.visibility === "scheduled").map((entry) => entry.publishing.publishAt?.getTime()).filter(
+    (time) => time !== void 0 && time > buildTime.getTime()
+  ).reduce(
+    (earliest, time) => earliest === void 0 || time < earliest ? time : earliest,
+    void 0
+  );
+  return next === void 0 ? void 0 : new Date(next).toISOString();
+}
 function readText2(content) {
   return typeof content === "string" ? content : new TextDecoder().decode(content);
 }
@@ -3642,7 +4300,27 @@ function collectLinkTargets(manifestEntry) {
   ].sort();
 }
 
+// src/content/content_build_plan.ts
+function reusableOutputChangeSet(outputs) {
+  const unchanged = [...outputs].sort(
+    (left, right) => left.path.localeCompare(right.path)
+  );
+  return {
+    affected: [],
+    removed: [],
+    unchanged,
+    fullRegenerationRequired: unchanged.some(
+      (output) => output.dependencies.some((dependency) => dependency.type === "unknown")
+    ),
+    candidateOutputCount: unchanged.length,
+    affectedOutputCount: 0,
+    removedOutputCount: 0,
+    unchangedOutputCount: unchanged.length
+  };
+}
+
 // src/content/content_entry_reader.ts
+var textDecoder = new TextDecoder();
 var ContentEntryReader = class {
   constructor(source, observability) {
     this.source = source;
@@ -3681,8 +4359,18 @@ var ContentEntryReader = class {
   read(entry) {
     const cached = this.texts.get(entry.path);
     if (cached) return cached;
-    const content = this.source.read(entry).then(
-      (value) => typeof value === "string" ? value : new TextDecoder().decode(value)
+    const content = this.observability.tracer.span(
+      "content.read",
+      { extension: entry.path.endsWith(".md") ? "markdown" : "asset" },
+      async () => {
+        const value = await this.source.read(entry);
+        const text = typeof value === "string" ? value : textDecoder.decode(value);
+        this.observability.tracer.event("content.read.bytes", {
+          bytes: Buffer.byteLength(text, "utf8"),
+          extension: entry.path.endsWith(".md") ? "markdown" : "asset"
+        });
+        return text;
+      }
     );
     const retain = entry.path.endsWith(".md");
     const tracked = retain ? content : content.finally(() => this.texts.delete(entry.path));
@@ -3809,6 +4497,8 @@ async function mapConcurrent2(values, concurrency, map) {
 import fs4 from "node:fs/promises";
 import path4 from "node:path";
 var INTERNAL_CONTENT_IGNORE_PATTERNS = [
+  ".riebeckite",
+  ".riebeckite/**",
   ".git",
   ".git/**",
   ".github",
@@ -3858,9 +4548,9 @@ var FileSystemContentSource = class {
     return await fs4.readFile(filePath);
   }
   async scanDirectory(directory, parentPath2, exclusions, templaterTemplateFolder) {
-    const directoryEntries = await fs4.readdir(directory, {
+    const directoryEntries = (await fs4.readdir(directory, {
       withFileTypes: true
-    });
+    })).toSorted((left, right) => left.name.localeCompare(right.name, "en"));
     const entries = [];
     for (const directoryEntry of directoryEntries) {
       if (directoryEntry.isSymbolicLink()) continue;
@@ -4008,9 +4698,14 @@ function readOptionalStableId(value) {
 var ManifestBuilder = class {
   createEntry(slug, markdown, processed, contentIndex, location, publishing) {
     const links = extractContentLinks(markdown, contentIndex);
-    const assets = links.filter(
-      (link) => (link.kind === "image" || link.kind === "attachment") && link.slug !== null
-    ).map((link) => ({ path: link.slug }));
+    const assets = [
+      ...links.filter(
+        (link) => (link.kind === "image" || link.kind === "attachment") && link.slug !== null
+      ).map((link) => ({ path: link.slug })),
+      ...extractMarkdownImages(markdown, slug).map((image) => ({
+        path: image.path
+      }))
+    ];
     const contentId = resolveContentStableId(processed.frontmatter);
     return {
       slug,
@@ -4139,6 +4834,11 @@ function determineOutputChanges(input) {
     (input.previousState?.outputs ?? []).map((output) => [output.path, output])
   );
   const changedContent = collectChangedContent(input);
+  const changedFiles = /* @__PURE__ */ new Set([
+    ...input.changeSet.added,
+    ...input.changeSet.changed,
+    ...input.changeSet.removed
+  ]);
   const changedTags = collectChangedTags(
     input.previousState,
     input.manifest,
@@ -4149,10 +4849,20 @@ function determineOutputChanges(input) {
     input.manifest,
     changedContent
   );
+  const changedExternal = changedExternalDependencies(input);
+  const changedExternalScopes = changedExternalDependencyScopes(input);
   const affected = /* @__PURE__ */ new Map();
   const unchanged = [];
   for (const output of current) {
-    if (isOutputAffected(output, changedContent, changedTags, changedFolders)) {
+    if (isOutputAffected(
+      output,
+      changedContent,
+      changedTags,
+      changedFolders,
+      changedFiles,
+      changedExternal,
+      changedExternalScopes
+    )) {
       affected.set(output.path, output);
     } else {
       unchanged.push(output);
@@ -4168,7 +4878,7 @@ function determineOutputChanges(input) {
   const removed = [...previous.values()].filter(
     (output) => !currentPaths.has(output.path)
   );
-  const fullRegenerationRequired = current.some(
+  const fullRegenerationRequired = (input.externalDependencyFailures?.length ?? 0) > 0 || current.some(
     (output) => output.dependencies.some((dependency) => dependency.type === "unknown")
   );
   const affectedValues = [...affected.values()].sort(compareOutput);
@@ -4198,7 +4908,10 @@ function buildOutputInventory(manifest, pluginPageOutputs = [], contentOutputDep
     });
   }
   for (const output of pluginPageOutputs) {
-    addOutput(outputs, { ...output, path: htmlOutputPath(output.path) });
+    addOutput(outputs, {
+      ...output,
+      path: htmlOutputPath(output.path)
+    });
   }
   for (const output of manifest.generatedOutputs) {
     addOutput(outputs, {
@@ -4225,10 +4938,22 @@ function contentOutput(entry, dependencies) {
     dependencies: [{ type: "content", slug: entry.slug }, ...dependencies]
   };
 }
-function isOutputAffected(output, changedContent, changedTags, changedFolders) {
+function isOutputAffected(output, changedContent, changedTags, changedFolders, changedFiles, changedExternal, changedExternalScopes) {
+  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 === "projection" && (dependency.projection === "navigation" || dependency.projection === "recent-posts")) {
+      return changedContent.size > 0;
+    }
+    if (dependency.type === "projection" && dependency.projection === "taxonomy-tags") {
+      return changedTags.size > 0;
+    }
+    if (dependency.type === "projection" && dependency.projection === "taxonomy-folders") {
+      return changedFolders.size > 0;
+    }
     if (dependency.type === "content" && changedContent.has(dependency.slug)) {
       return true;
     }
@@ -4237,9 +4962,58 @@ function isOutputAffected(output, changedContent, changedTags, changedFolders) {
     if (dependency.type === "folder" && changedFolders.has(dependency.folder)) {
       return true;
     }
+    if (dependency.type === "file" && changedFiles.has(dependency.path)) {
+      return true;
+    }
   }
   return false;
 }
+function isAffectedByExternalScope(output, changedExternalScopes) {
+  for (const scope of changedExternalScopes.values()) {
+    if (scope.type === "all") return true;
+    if (scope.type === "content" && output.kind === "content") return true;
+    if (scope.type === "output" && scope.paths.includes(output.path))
+      return true;
+  }
+  return false;
+}
+function changedExternalDependencies(input) {
+  const previous = new Map(
+    (input.previousState?.externalDependencies ?? []).map((dependency) => [
+      dependency.id,
+      dependency
+    ])
+  );
+  const changed = /* @__PURE__ */ new Set();
+  for (const dependency of input.externalDependencies ?? []) {
+    const prior = previous.get(dependency.id);
+    if (!prior || prior.fingerprint !== dependency.fingerprint || prior.expiresAt !== dependency.expiresAt || isExpired2(dependency.expiresAt))
+      changed.add(dependency.id);
+    previous.delete(dependency.id);
+  }
+  for (const id of previous.keys()) changed.add(id);
+  return changed;
+}
+function changedExternalDependencyScopes(input) {
+  const previous = new Map(
+    (input.previousState?.externalDependencies ?? []).map((dependency) => [
+      dependency.id,
+      dependency
+    ])
+  );
+  const changed = /* @__PURE__ */ new Map();
+  for (const dependency of input.externalDependencies ?? []) {
+    const prior = previous.get(dependency.id);
+    if (!prior || prior.fingerprint !== dependency.fingerprint || prior.expiresAt !== dependency.expiresAt || isExpired2(dependency.expiresAt)) {
+      changed.set(dependency.id, dependency.scope);
+    }
+    previous.delete(dependency.id);
+  }
+  for (const dependency of previous.values()) {
+    changed.set(dependency.id, dependency.scope);
+  }
+  return changed;
+}
 function collectChangedContent(input) {
   const changed = /* @__PURE__ */ new Set([
     ...input.affectedContent.direct,
@@ -4262,6 +5036,9 @@ function collectChangedContent(input) {
   }
   return changed;
 }
+function isExpired2(expiresAt) {
+  return expiresAt !== void 0 && Date.parse(expiresAt) <= Date.now();
+}
 function collectChangedTags(previousState, manifest, changedContent) {
   const previousBySlug = new Map(
     (previousState?.manifestEntries ?? []).map((entry) => [entry.slug, entry])
@@ -4408,7 +5185,12 @@ var ContentManager = class {
   processedContentCount = 0;
   reusedContentCount = 0;
   outputChangeSet = null;
+  buildPlan = null;
+  buildStateCommitRequested = false;
+  buildStateCommitted = false;
+  cacheManifestEntries = [];
   trackedContentDependencies = /* @__PURE__ */ new Map();
+  processedContentCacheFingerprints = /* @__PURE__ */ new Map();
   async getAllPosts() {
     return (await this.scan()).filter((entry) => entry.path.endsWith(".md")).map((entry) => ({ slug: entry.path.replace(/\.md$/, "") }));
   }
@@ -4418,13 +5200,13 @@ var ContentManager = class {
   async getPost(slug) {
     return await this.entryReader.readText(`${slug}.md`);
   }
-  async getContentIndex(preparation) {
+  async getContentIndex(plan) {
     if (this.contentIndex) return this.contentIndex;
-    if (!preparation && this.contentIndexPromise)
+    if (!plan && this.contentIndexPromise)
       return (await this.contentIndexPromise).index;
-    if (preparation) {
-      this.contentIndex = preparation.currentContentIndex;
-      this.contentIndexAmbiguities = preparation.currentContentIndexAmbiguities;
+    if (plan) {
+      this.contentIndex = plan.currentContentIndex;
+      this.contentIndexAmbiguities = plan.currentContentIndexAmbiguities;
       return this.contentIndex;
     }
     const promise = this.observability().tracer.span(
@@ -4435,14 +5217,14 @@ var ContentManager = class {
         (entry) => this.entryReader.read(entry)
       )
     );
-    if (!preparation) this.contentIndexPromise = promise;
+    if (!plan) this.contentIndexPromise = promise;
     try {
       const built = await promise;
       this.contentIndex = built.index;
       this.contentIndexAmbiguities = built.ambiguities;
       return this.contentIndex;
     } finally {
-      if (!preparation) this.contentIndexPromise = null;
+      if (!plan) this.contentIndexPromise = null;
     }
   }
   async getProcessedContent(slug) {
@@ -4467,14 +5249,27 @@ var ContentManager = class {
       this.getContentIndex(),
       this.getPost(slug)
     ]);
+    this.getProcessedContentCacheFingerprint(slug, rawPost);
     await this.pluginRuntime.startBuild(contentIndex);
     await this.pluginRuntime.runContentLoaded(slug, rawPost, contentIndex);
     await this.ensureRoutableSlugs();
+    const locations = await this.getContentLocations();
+    if (this.pipelineOptions.config) {
+      this.pipelineFingerprint = this.computePipelineFingerprint(locations);
+    }
     this.pipeline ??= new Pipeline(
       contentIndex,
-      await this.locationResolver.getPermalinks(),
+      new Map(
+        [...locations.entries()].map(([locationSlug, location]) => [
+          locationSlug,
+          location.permalink
+        ])
+      ),
       (postSlug) => this.getPost(postSlug),
-      this.pipelineOptions,
+      {
+        ...this.pipelineOptions,
+        contentScopeFingerprint: this.pipelineFingerprint ?? void 0
+      },
       this.isBuildTime
     );
     const content = await this.pipeline.execute(rawPost, {
@@ -4504,6 +5299,7 @@ var ContentManager = class {
     return content;
   }
   async getManifest(options) {
+    this.requestBuildStateCommit(options);
     if (this.manifest) return this.manifest;
     if (this.manifestPromise) return await this.manifestPromise;
     this.manifestPromise = this.buildManifest(options);
@@ -4517,19 +5313,19 @@ var ContentManager = class {
   async buildManifest(options) {
     if (this.manifest) return this.manifest;
     this.enableBuildTime();
-    const preparation = options ? await this.buildCoordinator.getPreparation(
-      options.incremental,
-      this.getPipelineFingerprint(),
-      this.requiresFullContentRegeneration()
-    ) : void 0;
+    const config = this.pipelineOptions.config;
+    const plan = await this.getBuildPlan(options);
+    const locations = await this.getContentLocations();
+    if (config) {
+      this.pipelineFingerprint = this.computePipelineFingerprint(locations);
+    }
     return await this.observability().tracer.span(
       "content.manifest",
       {},
       async () => {
-        const [posts, contentIndex, locations] = await Promise.all([
+        const [posts, contentIndex] = await Promise.all([
           this.getAllPosts(),
-          this.getContentIndex(preparation),
-          this.getContentLocations()
+          this.getContentIndex(plan)
         ]);
         const entries = await this.observability().tracer.span(
           "content.manifest.entries",
@@ -4538,12 +5334,14 @@ var ContentManager = class {
             posts,
             CONTENT_PROCESSING_CONCURRENCY,
             async (post) => {
-              const reused = this.reuseManifestEntry(post.slug, preparation);
+              const rawPost = await this.getPost(post.slug);
+              const reused = this.reuseManifestEntry(
+                post.slug,
+                rawPost,
+                plan
+              );
               if (reused) return reused;
-              const [rawPost, processed] = await Promise.all([
-                this.getPost(post.slug),
-                this.getProcessedContent(post.slug)
-              ]);
+              const processed = await this.getProcessedContent(post.slug);
               const location = locations.get(post.slug);
               if (!location) {
                 throw new Error(
@@ -4583,7 +5381,12 @@ var ContentManager = class {
         manifest.pageRoutes = [
           ...await this.pluginRuntime.getPageRoutes(manifest, contentIndex)
         ];
-        await this.pluginRuntime.runManifestCreated(manifest, contentIndex);
+        await this.pluginRuntime.runManifestCreated(
+          manifest,
+          contentIndex,
+          plan.previousState?.manifestHookCache,
+          this.getPipelineFingerprint()
+        );
         this.synchronizeManifestHtml(manifest, cacheManifestEntries);
         manifest.assets = this.pluginRuntime.collectAssets();
         manifest.clientEntries = this.pluginRuntime.collectClientEntries();
@@ -4591,20 +5394,29 @@ var ContentManager = class {
           ...this.pluginRuntime.getDiagnostics(),
           ...await this.pluginRuntime.collectDiagnostics(contentIndex)
         ];
+        await this.pluginRuntime.runGeneratedOutputPlans(manifest);
         await this.pluginRuntime.runBuildEnd(manifest, contentIndex);
+        await this.emitPublicImageAssets(manifest);
         manifest.generatedOutputs = this.pluginRuntime.collectGeneratedOutputs();
-        const pluginPageOutputs = await this.pluginRuntime.getPageOutputs(
-          manifest,
-          contentIndex
+        const pluginPageOutputs = await this.observability().tracer.span(
+          "output.dependencies.plugin",
+          {},
+          () => this.pluginRuntime.getPageOutputs(manifest, contentIndex)
+        );
+        this.outputChangeSet = await this.observability().tracer.span(
+          "output.dependencies.resolve",
+          {},
+          () => determineOutputChanges({
+            manifest,
+            previousState: plan.previousState,
+            changeSet: plan.changeSet,
+            affectedContent: plan.affectedContent,
+            pluginPageOutputs,
+            contentOutputDependencies: this.pluginRuntime.getContentOutputDependencies(),
+            externalDependencies: plan.externalDependencies,
+            externalDependencyFailures: plan.externalDependencyFailures
+          })
         );
-        this.outputChangeSet = preparation ? determineOutputChanges({
-          manifest,
-          previousState: preparation.previousState,
-          changeSet: preparation.changeSet,
-          affectedContent: preparation.affectedContent,
-          pluginPageOutputs,
-          contentOutputDependencies: this.pluginRuntime.getContentOutputDependencies()
-        }) : null;
         if (this.outputChangeSet) {
           this.observability().tracer.event("build.incremental.outputs", {
             candidateOutputCount: this.outputChangeSet.candidateOutputCount,
@@ -4614,19 +5426,9 @@ var ContentManager = class {
             fullRegenerationRequired: this.outputChangeSet.fullRegenerationRequired
           });
         }
-        if (preparation)
-          await this.buildCoordinator.commit(
-            preparation,
-            manifest,
-            this.getPipelineFingerprint(),
-            this.outputChangeSet ? [
-              ...this.outputChangeSet.affected,
-              ...this.outputChangeSet.unchanged
-            ] : [],
-            cacheManifestEntries,
-            this.trackedContentDependencies
-          );
         this.manifest = manifest;
+        this.cacheManifestEntries = cacheManifestEntries;
+        await this.commitBuildState();
         return manifest;
       }
     );
@@ -4640,31 +5442,72 @@ var ContentManager = class {
   getReusedContentCount() {
     return this.reusedContentCount;
   }
+  getManifestHookMetrics() {
+    return this.pluginRuntime.getManifestHookMetrics();
+  }
+  async getNoChangeFastPathBlockReason(options = {}) {
+    const plan = await this.getBuildPlan(options);
+    if (plan.fullRegenerationReasons.includes("publishing-state-expired"))
+      return "publishing-state-expired";
+    if (plan.reusableOutputs?.some(
+      (output) => output.dependencies.some((dependency) => dependency.type === "unknown")
+    ))
+      return "output-dependency-unknown";
+    return this.pluginRuntime.getNoChangeFastPathBlockReason(
+      plan.previousState?.manifestHookCache ?? [],
+      this.getPipelineFingerprint()
+    );
+  }
   async getOutputChangeSet(options = {}) {
-    await this.getManifest(options);
+    this.requestBuildStateCommit(options);
+    if (this.outputChangeSet) {
+      await this.commitBuildState();
+      return this.outputChangeSet;
+    }
+    const plan = await this.getBuildPlan(options);
+    if (plan.reusableOutputs) {
+      this.outputChangeSet = await this.observability().tracer.span(
+        "output.dependencies.reuse",
+        { outputCount: plan.reusableOutputs.length },
+        async () => reusableOutputChangeSet(plan.reusableOutputs ?? [])
+      );
+      return this.outputChangeSet;
+    }
+    await this.observability().tracer.span(
+      "output.dependencies.manifest",
+      {},
+      () => this.getManifest(options)
+    );
     if (!this.outputChangeSet) {
       const manifest = await this.getManifest();
       const contentIndex = await this.getContentIndex();
-      const pluginPageOutputs = await this.pluginRuntime.getPageOutputs(
-        manifest,
-        contentIndex
+      const pluginPageOutputs = await this.observability().tracer.span(
+        "output.dependencies.plugin",
+        {},
+        () => this.pluginRuntime.getPageOutputs(manifest, contentIndex)
+      );
+      return await this.observability().tracer.span(
+        "output.dependencies.resolve",
+        {},
+        () => determineOutputChanges({
+          manifest,
+          previousState: void 0,
+          changeSet: {
+            added: manifest.entries.map((entry) => `${entry.slug}.md`),
+            changed: [],
+            removed: [],
+            unchanged: []
+          },
+          affectedContent: {
+            direct: new Set(manifest.entries.map((entry) => entry.slug)),
+            dependent: /* @__PURE__ */ new Set()
+          },
+          pluginPageOutputs,
+          contentOutputDependencies: this.pluginRuntime.getContentOutputDependencies(),
+          externalDependencies: plan.externalDependencies,
+          externalDependencyFailures: plan.externalDependencyFailures
+        })
       );
-      return determineOutputChanges({
-        manifest,
-        previousState: void 0,
-        changeSet: {
-          added: manifest.entries.map((entry) => `${entry.slug}.md`),
-          changed: [],
-          removed: [],
-          unchanged: []
-        },
-        affectedContent: {
-          direct: new Set(manifest.entries.map((entry) => entry.slug)),
-          dependent: /* @__PURE__ */ new Set()
-        },
-        pluginPageOutputs,
-        contentOutputDependencies: this.pluginRuntime.getContentOutputDependencies()
-      });
     }
     return this.outputChangeSet;
   }
@@ -4769,29 +5612,113 @@ var ContentManager = class {
   publishStrategy() {
     return this.pipelineOptions.config?.content.filters.publishStrategy ?? "explicit";
   }
-  reuseManifestEntry(slug, preparation) {
-    if (!preparation?.previousState?.manifestEntries) return null;
-    if (preparation.previousState.pipelineFingerprint !== this.getPipelineFingerprint()) {
+  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(
+      slug,
+      source
+    );
+    if (!contentCacheFingerprint) return null;
+    if (plan.previousState.entries[`${slug}.md`]?.processedContentCacheFingerprint !== contentCacheFingerprint) {
       return null;
     }
-    if (preparation.affectedContent.direct.has(slug)) return null;
-    if (preparation.affectedContent.dependent.has(slug)) return null;
-    const entry = preparation.previousManifestEntriesBySlug.get(slug);
+    const entry = plan.previousManifestEntriesBySlug.get(slug);
     if (!entry) return null;
     this.reusedContentCount += 1;
+    this.processedContentCacheFingerprints.set(slug, contentCacheFingerprint);
     this.observability().tracer.event("content.reuse", { slug });
     return cloneManifestEntry(entry);
   }
   getPipelineFingerprint() {
     if (!this.pipelineOptions.config) return void 0;
-    this.pipelineFingerprint ??= computePipelineFingerprint(
-      this.pipelineOptions.config
-    );
+    this.pipelineFingerprint ??= this.computePipelineFingerprint();
     return this.pipelineFingerprint;
   }
+  requestBuildStateCommit(options) {
+    if (this.pipelineOptions.commitBuildState === false) return;
+    if (options?.incremental === true) this.buildStateCommitRequested = true;
+  }
+  async commitBuildState() {
+    if (this.buildStateCommitted || !this.buildStateCommitRequested || !this.manifest || !this.outputChangeSet) {
+      return;
+    }
+    const manifest = this.manifest;
+    const outputChangeSet = this.outputChangeSet;
+    const plan = await this.getBuildPlan();
+    if (!plan.incremental) return;
+    await this.observability().tracer.span(
+      "content.build-state.save",
+      {},
+      () => this.buildCoordinator.commit(
+        plan,
+        manifest,
+        this.getPipelineFingerprint(),
+        [...outputChangeSet.affected, ...outputChangeSet.unchanged],
+        this.cacheManifestEntries,
+        this.trackedContentDependencies,
+        plan.externalDependencies,
+        this.processedContentCacheFingerprints,
+        this.pluginRuntime.getManifestHookCache(),
+        this.publishingBuildTime
+      )
+    );
+    this.buildStateCommitted = true;
+  }
+  getBuildPlan(options) {
+    if (this.buildPlan) return this.buildPlan;
+    const plan = this.createBuildPlan(options);
+    this.buildPlan = plan;
+    void plan.catch(() => {
+      if (this.buildPlan === plan) this.buildPlan = null;
+    });
+    return plan;
+  }
+  async createBuildPlan(options) {
+    const config = this.pipelineOptions.config;
+    if (config && hasGlobalContentDependency(config)) {
+      this.pipelineFingerprint = this.computePipelineFingerprint(
+        await this.getContentLocations()
+      );
+    }
+    const contentIndex = await this.getContentIndex();
+    const external = await this.observability().tracer.span(
+      "external.dependencies.resolve",
+      {},
+      () => this.pluginRuntime.resolveExternalDependencies(contentIndex)
+    );
+    return this.buildCoordinator.getPlan(
+      options?.incremental !== false,
+      this.getPipelineFingerprint(),
+      this.requiresFullContentRegeneration(),
+      external.snapshots,
+      external.failures,
+      this.publishingBuildTime
+    );
+  }
+  computePipelineFingerprint(locations) {
+    const config = this.pipelineOptions.config;
+    if (!config) return "";
+    const contentScopeFingerprint = locations && hasGlobalContentDependency(config) ? computeContentScopeFingerprint(locations) : void 0;
+    return computePipelineFingerprint(config, contentScopeFingerprint);
+  }
   requiresFullContentRegeneration() {
     const config = this.pipelineOptions.config;
-    return config ? !isPersistentlyCacheable("", config).cacheable : false;
+    return config ? requiresFullContentRegeneration(config) : false;
+  }
+  getProcessedContentCacheFingerprint(slug, source) {
+    const config = this.pipelineOptions.config;
+    if (!config || !isPersistentlyCacheable(slug, config, source).cacheable) {
+      this.processedContentCacheFingerprints.set(slug, void 0);
+      return void 0;
+    }
+    const fingerprint = computeContentCacheFingerprint(slug, source, config);
+    this.processedContentCacheFingerprints.set(slug, fingerprint);
+    return fingerprint;
   }
   isRoutable(slug) {
     if (!this.routableSlugs) {
@@ -4834,6 +5761,21 @@ var ContentManager = class {
     this.isBuildTime = true;
     this.pluginRuntime.enableBuildTime();
   }
+  async emitPublicImageAssets(manifest) {
+    const imagePaths = new Set(
+      manifest.publicEntries.flatMap(
+        (entry) => entry.assets.map((asset) => normalizeContentPath(asset.path)).filter(isImagePath)
+      )
+    );
+    const entriesByPath = new Map(
+      (await this.source.scan()).map((entry) => [entry.path, entry])
+    );
+    for (const path6 of imagePaths) {
+      const entry = entriesByPath.get(path6);
+      if (entry)
+        this.pluginRuntime.emitCoreAsset(path6, await this.source.read(entry));
+    }
+  }
   observability() {
     return this.pipelineOptions.observability ?? noopObservability;
   }
@@ -4853,8 +5795,7 @@ function cloneManifestEntry(entry) {
     links: entry.links.map((link) => ({ ...link })),
     backlinks: [...entry.backlinks],
     assets: entry.assets.map((asset) => ({ ...asset })),
-    ...entry.headTags ? { headTags: [...entry.headTags] } : {},
-    ...entry.bodySlots ? { bodySlots: { ...entry.bodySlots } } : {}
+    ...entry.headTags ? { headTags: [...entry.headTags] } : {}
   };
 }
 async function mapConcurrent3(values, concurrency, map) {
@@ -4886,6 +5827,12 @@ async function getContentSourceEntry(source, logicalPath) {
   return (await source.scan()).find((candidate) => candidate.path === logicalPath) ?? null;
 }
 
+// src/content/external_fingerprint.ts
+import { createHash as createHash7 } from "node:crypto";
+function fingerprintExternalValue(value) {
+  return createHash7("sha256").update(stableStringify(value)).digest("hex");
+}
+
 // src/content/folder_entry.ts
 function resolveFolderEntry(manifest, folder, options = {}) {
   const base = normalizeFolder2(folder);
@@ -5151,6 +6098,105 @@ function clampFinite(value, min, max) {
   return clamp(value, min, max);
 }
 
+// src/content/public_content_view.ts
+var emptyEntries = Object.freeze([]);
+function createPublicContentView(manifest) {
+  const routableEntries = manifest.entries.filter(
+    (entry) => entry.publishing.routable
+  );
+  const discoverableEntries = routableEntries.filter(
+    (entry) => entry.publishing.discoverable
+  );
+  const routableSlugs = new Set(routableEntries.map((entry) => entry.slug));
+  const copiesBySlug = new Map(
+    routableEntries.map((entry) => [
+      entry.slug,
+      copyEntry(entry, routableSlugs)
+    ])
+  );
+  const discoverableSlugs = new Set(
+    discoverableEntries.map((entry) => entry.slug)
+  );
+  const routableCopies = routableEntries.map((entry) => copiesBySlug.get(entry.slug)).filter(isDefined);
+  const discoverableCopies = discoverableEntries.map((entry) => copiesBySlug.get(entry.slug)).filter(isDefined);
+  const aliases = createAliasIndex2(routableCopies);
+  const tags = createTagIndex(discoverableCopies);
+  const getDiscoverableRelated = (relatedSlugs) => Object.freeze(
+    relatedSlugs.filter((relatedSlug) => discoverableSlugs.has(relatedSlug)).map((relatedSlug) => copiesBySlug.get(relatedSlug)).filter(isDefined)
+  );
+  return Object.freeze({
+    routableEntries: Object.freeze(routableCopies),
+    discoverableEntries: Object.freeze(discoverableCopies),
+    findRoutableBySlug: (slug) => copiesBySlug.get(slug),
+    findDiscoverableBySlug: (slug) => discoverableSlugs.has(slug) ? copiesBySlug.get(slug) : void 0,
+    findRoutableByAlias: (alias) => aliases.get(alias.toLowerCase()) ?? emptyEntries,
+    getDiscoverableEntriesByTag: (tag) => tags.get(tag) ?? emptyEntries,
+    getDiscoverableOutgoing: (slug) => getDiscoverableRelated(manifest.graph.outgoingSlugs(slug)),
+    getDiscoverableIncoming: (slug) => getDiscoverableRelated(manifest.graph.incomingSlugs(slug)),
+    getDiscoverableNeighbors: (slug) => getDiscoverableRelated(manifest.graph.neighborSlugs(slug))
+  });
+}
+function copyEntry(entry, routableSlugs) {
+  return deepFreeze2(
+    structuredClone({
+      slug: entry.slug,
+      ...entry.contentId === void 0 ? {} : { contentId: entry.contentId },
+      permalink: entry.permalink,
+      publicLocation: entry.publicLocation,
+      title: entry.title,
+      ...entry.aliases === void 0 ? {} : { aliases: entry.aliases },
+      publishing: {
+        visibility: entry.publishing.visibility,
+        routable: entry.publishing.routable,
+        discoverable: entry.publishing.discoverable
+      },
+      tags: entry.tags,
+      links: entry.links.filter(
+        (link) => link.kind !== "note" || link.slug === null || routableSlugs.has(link.slug)
+      ),
+      assets: entry.assets
+    })
+  );
+}
+function createAliasIndex2(entries) {
+  const aliases = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const alias of entry.aliases ?? []) {
+      const matches = aliases.get(alias.toLowerCase()) ?? [];
+      matches.push(entry);
+      aliases.set(alias.toLowerCase(), matches);
+    }
+  }
+  return new Map(
+    [...aliases].map(([alias, entries2]) => [alias, Object.freeze(entries2)])
+  );
+}
+function createTagIndex(entries) {
+  const tags = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const tag of entry.tags) {
+      const taggedEntries = tags.get(tag) ?? [];
+      taggedEntries.push(entry);
+      tags.set(tag, taggedEntries);
+    }
+  }
+  return new Map(
+    [...tags].map(([tag, entries2]) => [tag, Object.freeze(entries2)])
+  );
+}
+function deepFreeze2(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  for (const child of Object.values(value)) {
+    deepFreeze2(child);
+  }
+  return Object.freeze(value);
+}
+function isDefined(value) {
+  return value !== void 0;
+}
+
 // src/content/read_only_content_graph.ts
 async function readOnlyContentGraph(source, locations) {
   const entries = await source.scan();
@@ -5214,25 +6260,6 @@ function resolveBuildOutputDirectory(config) {
   return directory ? path5.resolve(directory) : void 0;
 }
 
-// src/types/content_manifest.ts
-var ARTICLE_SLOT = {
-  header: "article.header",
-  metadata: "article.metadata",
-  aside: "article.aside",
-  beforeContent: "article.before-content",
-  afterContent: "article.after-content",
-  footer: "article.footer"
-};
-function appendContentBodySlot(entry, slot, html) {
-  if (!html.trim()) return;
-  const previous = entry.bodySlots?.[slot];
-  entry.bodySlots = {
-    ...entry.bodySlots,
-    [slot]: previous ? `${previous}
-${html}` : html
-  };
-}
-
 // src/types/plugin_endpoint.ts
 function defineEndpoint(path6, handler, options = {}) {
   if (options.cacheControl === void 0) {
@@ -5300,8 +6327,8 @@ function calculateReadingTime(html) {
   return Math.max(1, Math.ceil(cjkCharacters / 500 + latinWords / 220));
 }
 export {
-  ARTICLE_SLOT,
   ATTACHMENTS_BASE_PATH,
+  CONTENT_BUILD_STATE_VERSION,
   CompositeTraceSink,
   ConfigValidationError,
   ConsoleLogger,
@@ -5315,7 +6342,6 @@ export {
   PluginDependencyError,
   PluginHookError,
   SinkTracer,
-  appendContentBodySlot,
   attachErrorPath,
   attachmentUrl,
   buildContentCollections,
@@ -5326,6 +6352,7 @@ export {
   createClientEntry,
   createContentGraph,
   createPluginMemo,
+  createPublicContentView,
   createStyleAsset,
   createUnavailableGeneratedOutputSink,
   defineConfig,
@@ -5338,6 +6365,7 @@ export {
   escapeScriptJson,
   extractFrontmatterAliases,
   fingerprintContentEntries,
+  fingerprintExternalValue,
   getContentSourceEntry,
   getEntryLanguage,
   getExtension,