@riebeckite/core 0.0.13 → 0.0.15

package/dist/index.js

@@ -109,41 +109,41 @@ function validateTheme(value, issues) {
     }
   }
 }
-function validateThemeConfig(value, path4, issues) {
-  validateOptionalString(value.name, `${path4}.name`, issues);
+function validateThemeConfig(value, path5, issues) {
+  validateOptionalString(value.name, `${path5}.name`, issues);
   validateOneOf(
     value.colorMode,
-    `${path4}.colorMode`,
+    `${path5}.colorMode`,
     ["light", "dark", "system"],
     issues
   );
   validateOneOf(
     value.typography,
-    `${path4}.typography`,
+    `${path5}.typography`,
     ["system", "serif", "sans"],
     issues
   );
   validateOneOf(
     value.articleLayout,
-    `${path4}.articleLayout`,
+    `${path5}.articleLayout`,
     ["article", "sidebar", "full-width"],
     issues
   );
-  validateStringArray(value.userCss, `${path4}.userCss`, issues);
+  validateStringArray(value.userCss, `${path5}.userCss`, issues);
   if (value.attributes !== void 0 && !isRecord(value.attributes)) {
-    issues.push({ path: `${path4}.attributes`, message: "Expected an object." });
+    issues.push({ path: `${path5}.attributes`, message: "Expected an object." });
   }
 }
-function validateThemeStyles(value, path4, issues) {
+function validateThemeStyles(value, path5, issues) {
   if (value === void 0) return;
   if (!Array.isArray(value)) {
-    issues.push({ path: path4, message: "Expected an array." });
+    issues.push({ path: path5, message: "Expected an array." });
     return;
   }
   for (const [index, style] of value.entries()) {
     if (!isRecord(style) || !isNonEmptyString(style.moduleSpecifier)) {
       issues.push({
-        path: `${path4}[${index}].moduleSpecifier`,
+        path: `${path5}[${index}].moduleSpecifier`,
         message: "Expected a non-empty string."
       });
     }
@@ -163,69 +163,69 @@ function validatePlugins(value, issues) {
       continue;
     }
     const plugin = input;
-    const path4 = `plugins[${index}]`;
+    const path5 = `plugins[${index}]`;
     if (!isNonEmptyString(plugin.name)) {
       issues.push({
-        path: `${path4}.name`,
+        path: `${path5}.name`,
         message: "Expected a non-empty string."
       });
     } else if (plugin.enabled !== false) {
       const duplicateIndex = names.get(plugin.name);
       if (duplicateIndex !== void 0) {
         issues.push({
-          path: `${path4}.name`,
+          path: `${path5}.name`,
           message: `Duplicate plugin name "${plugin.name}" (also plugins[${duplicateIndex}]).`
         });
       } else {
         names.set(plugin.name, index);
       }
     }
-    validateOptionalBoolean(plugin.enabled, `${path4}.enabled`, issues);
-    validateCapabilityMetadata(plugin, path4, issues);
-    if (plugin.enabled !== false) validatePluginOptions(plugin, path4, issues);
+    validateOptionalBoolean(plugin.enabled, `${path5}.enabled`, issues);
+    validateCapabilityMetadata(plugin, path5, issues);
+    if (plugin.enabled !== false) validatePluginOptions(plugin, path5, issues);
   }
 }
-function validateCapabilityMetadata(plugin, path4, issues) {
-  validateStringArray(plugin.provides, `${path4}.provides`, issues, true);
-  validateStringArray(plugin.requires, `${path4}.requires`, issues, true);
-  validateStringArray(plugin.optional, `${path4}.optional`, issues, true);
+function validateCapabilityMetadata(plugin, path5, issues) {
+  validateStringArray(plugin.provides, `${path5}.provides`, issues, true);
+  validateStringArray(plugin.requires, `${path5}.requires`, issues, true);
+  validateStringArray(plugin.optional, `${path5}.optional`, issues, true);
 }
-function validatePluginOptions(plugin, path4, issues) {
+function validatePluginOptions(plugin, path5, issues) {
   if (!plugin.validateOptions) return;
   try {
     const optionIssues = plugin.validateOptions(plugin.options) ?? [];
     for (const issue of optionIssues) {
       issues.push({
-        path: issue.path ? `${path4}.options.${issue.path}` : `${path4}.options`,
+        path: issue.path ? `${path5}.options.${issue.path}` : `${path5}.options`,
         message: issue.message
       });
     }
   } catch (error) {
     issues.push({
-      path: `${path4}.options`,
+      path: `${path5}.options`,
       message: `Validator failed: ${toErrorMessage(error)}`
     });
   }
 }
-function validateRequiredString(value, path4, issues) {
+function validateRequiredString(value, path5, issues) {
   if (!isNonEmptyString(value)) {
-    issues.push({ path: path4, message: "Expected a non-empty string." });
+    issues.push({ path: path5, message: "Expected a non-empty string." });
   }
 }
-function validateOptionalString(value, path4, issues) {
+function validateOptionalString(value, path5, issues) {
   if (value !== void 0 && typeof value !== "string") {
-    issues.push({ path: path4, message: "Expected a string." });
+    issues.push({ path: path5, message: "Expected a string." });
   }
 }
-function validateOptionalBoolean(value, path4, issues) {
+function validateOptionalBoolean(value, path5, issues) {
   if (value !== void 0 && typeof value !== "boolean") {
-    issues.push({ path: path4, message: "Expected a boolean." });
+    issues.push({ path: path5, message: "Expected a boolean." });
   }
 }
-function validateAbsoluteUrl(value, path4, issues) {
+function validateAbsoluteUrl(value, path5, issues) {
   if (value === void 0 || value === "") return;
   if (typeof value !== "string") {
-    issues.push({ path: path4, message: "Expected an absolute URL." });
+    issues.push({ path: path5, message: "Expected an absolute URL." });
     return;
   }
   try {
@@ -233,27 +233,27 @@ function validateAbsoluteUrl(value, path4, issues) {
     if (url.protocol !== "http:" && url.protocol !== "https:")
       throw new Error();
   } catch {
-    issues.push({ path: path4, message: "Expected an absolute HTTP(S) URL." });
+    issues.push({ path: path5, message: "Expected an absolute HTTP(S) URL." });
   }
 }
-function validateStringArray(value, path4, issues, nonEmpty = false) {
+function validateStringArray(value, path5, issues, nonEmpty = false) {
   if (value === void 0) return;
   if (!Array.isArray(value)) {
-    issues.push({ path: path4, message: "Expected an array." });
+    issues.push({ path: path5, message: "Expected an array." });
     return;
   }
   for (const [index, item] of value.entries()) {
     if (typeof item !== "string" || nonEmpty && !item.trim()) {
       issues.push({
-        path: `${path4}[${index}]`,
+        path: `${path5}[${index}]`,
         message: nonEmpty ? "Expected a non-empty string." : "Expected a string."
       });
     }
   }
 }
-function validateOneOf(value, path4, choices, issues) {
+function validateOneOf(value, path5, choices, issues) {
   if (value !== void 0 && (typeof value !== "string" || !choices.includes(value))) {
-    issues.push({ path: path4, message: `Expected one of: ${choices.join(", ")}.` });
+    issues.push({ path: path5, message: `Expected one of: ${choices.join(", ")}.` });
   }
 }
 function formatValidationIssues(issues) {
@@ -538,8 +538,21 @@ function definePlugin(plugin) {
 }
 function resolvePlugins(plugins = []) {
   const orderedPlugins = plugins.filter((plugin) => Boolean(plugin)).filter((plugin) => plugin.enabled !== false).toSorted((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  assertUniquePluginNames(orderedPlugins);
   return resolvePluginDependencies(orderedPlugins);
 }
+function assertUniquePluginNames(plugins) {
+  const owners = /* @__PURE__ */ new Map();
+  plugins.forEach((plugin, index) => {
+    const previous = owners.get(plugin.name);
+    if (previous !== void 0) {
+      throw new Error(
+        `Plugin name "${plugin.name}" is used by both plugins[${previous}] and plugins[${index}]`
+      );
+    }
+    owners.set(plugin.name, index);
+  });
+}
 function getResolvedPluginMetadata(plugins) {
   return plugins.map((plugin) => ({
     name: plugin.name,
@@ -626,7 +639,11 @@ function resolveConfig(config) {
       }
     },
     theme,
-    plugins: resolvePlugins(config.plugins)
+    plugins: resolvePlugins(config.plugins),
+    cache: {
+      enabled: config.cache?.enabled ?? true,
+      directory: config.cache?.directory ?? ""
+    }
   };
 }
 function resolveThemeConfig(themeInput) {
@@ -659,6 +676,8 @@ function sanitizeThemeAttributes(attributes) {
   );
 }
 function isPublished(config, frontmatter) {
+  if (frontmatter?.visibility === "unlisted") return true;
+  if (frontmatter?.visibility === "draft") return false;
   return isPublishable(config.content.filters.publishStrategy, frontmatter);
 }
 function isExcluded(patterns, relativePath) {
@@ -693,6 +712,46 @@ function globToRegExp(glob) {
   return new RegExp(`^${re}$`);
 }
 
+// src/deprecation.ts
+function createDeprecationDiagnostic(notice) {
+  return {
+    code: `deprecated-${notice.kind}`,
+    severity: "warning",
+    message: formatDeprecationMessage(notice),
+    target: notice.target,
+    suggestion: notice.replacement ? `Use ${notice.replacement}. ${notice.action}` : notice.action,
+    meta: { deprecation: notice }
+  };
+}
+function formatDeprecationMessage(notice) {
+  const lines = [
+    `Deprecated: ${notice.target}`,
+    `Deprecated since: ${notice.deprecatedSince}`
+  ];
+  if (notice.replacement) lines.push(`Use: ${notice.replacement}`);
+  lines.push(`Migration: ${notice.action}`);
+  if (notice.documentationUrl) lines.push(`See: ${notice.documentationUrl}`);
+  if (notice.removedIn) lines.push(`Removal planned: ${notice.removedIn}`);
+  return lines.join("\n");
+}
+
+// src/config_deprecations.ts
+var configDeprecations = [];
+function collectConfigDeprecationDiagnostics(config, notices = configDeprecations) {
+  return notices.filter((notice) => hasConfigPath(config, notice.path)).map(createDeprecationDiagnostic);
+}
+function hasConfigPath(config, path5) {
+  let value = config;
+  for (const segment of path5.split(".")) {
+    if (!isRecord2(value) || !(segment in value)) return false;
+    value = value[segment];
+  }
+  return value !== void 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/content/image_extensions.ts
 var IMAGE_EXTENSIONS = [
   "png",
@@ -746,7 +805,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 
 // src/content/content_build_state.ts
-var CONTENT_BUILD_STATE_VERSION = 2;
+var CONTENT_BUILD_STATE_VERSION = 6;
 var CONTENT_BUILD_STATE_DIRECTORY = ".riebeckite";
 var CONTENT_BUILD_STATE_EXCLUDE = `${CONTENT_BUILD_STATE_DIRECTORY}/**`;
 
@@ -770,7 +829,7 @@ async function readContentBuildStateStatus(statePath) {
     }
     throw error;
   }
-  if (!isRecord2(parsed)) {
+  if (!isRecord3(parsed)) {
     return { kind: "invalid", path: statePath, reason: "invalid-shape" };
   }
   if (parsed.version !== CONTENT_BUILD_STATE_VERSION) {
@@ -786,12 +845,12 @@ async function readContentBuildStateStatus(statePath) {
     entryCount: Object.keys(parsed.entries).length
   };
 }
-async function saveContentBuildState(statePath, state) {
+async function saveContentBuildState(statePath, state2) {
   const directory = path.dirname(statePath);
   const temporaryPath = `${statePath}.${randomUUID()}.tmp`;
   await fs.mkdir(directory, { recursive: true });
   try {
-    await fs.writeFile(temporaryPath, JSON.stringify(state), "utf8");
+    await fs.writeFile(temporaryPath, JSON.stringify(state2), "utf8");
     await fs.rename(temporaryPath, statePath);
   } catch (error) {
     await fs.rm(temporaryPath, { force: true }).catch(() => void 0);
@@ -810,19 +869,37 @@ function resolveContentBuildStatePath(config, contentDirectory) {
   );
 }
 function isContentBuildState(value) {
-  return isRecord2(value) && value.version === CONTENT_BUILD_STATE_VERSION && isContentBuildStateShape(value);
+  return isRecord3(value) && value.version === CONTENT_BUILD_STATE_VERSION && isContentBuildStateShape(value);
 }
 function isContentBuildStateShape(value) {
-  if (!isRecord2(value.entries) || !isRecord2(value.contentIndex)) return false;
+  if (!isRecord3(value.entries) || !isRecord3(value.contentIndex) || value.outputs !== void 0 && !isOutputDescriptors(value.outputs)) {
+    return false;
+  }
   return Object.values(value.entries).every(
-    (entry) => isRecord2(entry) && typeof entry.fingerprint === "string" && entry.fingerprint.length > 0 && Array.isArray(entry.dependencies) && entry.dependencies.every(
-      (dependency) => typeof dependency === "string"
+    (entry) => isRecord3(entry) && typeof entry.fingerprint === "string" && entry.fingerprint.length > 0 && Array.isArray(entry.aliases) && entry.aliases.every((alias) => typeof alias === "string") && Array.isArray(entry.dependencies) && entry.dependencies.every(
+      (dependency) => isRecord3(dependency) && (dependency.kind === "content" || dependency.kind === "file") && typeof dependency.id === "string"
     )
   ) && Object.values(value.contentIndex).every(
     (entry) => typeof entry === "string"
   );
 }
-function isRecord2(value) {
+function isOutputDescriptors(value) {
+  return Array.isArray(value) && value.every(
+    (output) => isRecord3(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)
+  );
+}
+function isOutputPath(value) {
+  if (typeof value !== "string" || value.length === 0 || value.includes("\\") || value.includes("\0") || value.startsWith("/")) {
+    return false;
+  }
+  return value.split("/").every((segment) => segment !== "." && segment !== "..");
+}
+function isOutputDependency(value) {
+  if (!isRecord3(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";
+}
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNotFoundError(error) {
@@ -1133,9 +1210,9 @@ function buildContentCollections(entries, definitions) {
 function normalizePageSize(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
 }
-function withPage(path4, index) {
-  if (index === 0) return path4;
-  const base = path4 === "/" ? "" : path4;
+function withPage(path5, index) {
+  if (index === 0) return path5;
+  const base = path5 === "/" ? "" : path5;
   return normalizePath(`${base}/page/${index + 1}`);
 }
 function defaultPath(context) {
@@ -1163,12 +1240,32 @@ function normalizePath(value) {
 // src/content/content_fingerprint.ts
 import { createHash } from "node:crypto";
 async function fingerprintContentEntries(entries, read) {
-  return await Promise.all(
-    [...entries].sort((left, right) => left.path.localeCompare(right.path)).map(async (entry) => ({
-      entry,
-      fingerprint: await fingerprintContentEntry(entry, 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)
+  }));
+}
+async function mapConcurrent(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;
 }
 async function fingerprintContentEntry(entry, read) {
   if (entry.metadata?.hash) return `hash:${entry.metadata.hash}`;
@@ -1233,6 +1330,10 @@ function resolveDefaultContentLocation(content) {
   };
 }
 
+// src/content/content_manager.ts
+import { VFile as VFile2 } from "vfile";
+import { matter as matter3 } from "vfile-matter";
+
 // src/observability.ts
 var NoopLogger = class {
   debug() {
@@ -1374,12 +1475,334 @@ import remarkMath from "remark-math";
 import remarkParse from "remark-parse";
 import remarkRehype from "remark-rehype";
 import { unified } from "unified";
-import { matter } from "vfile-matter";
+import { matter as matter2 } from "vfile-matter";
 
-// src/plugin/plugin_cache.ts
-import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+// src/content/content_dependency_tracker.ts
+import { createHash as createHash2 } from "node:crypto";
+function createContentDependencyTracker(source) {
+  const dependencies = /* @__PURE__ */ new Map();
+  const record = (identity, content) => {
+    const normalized = normalizeDependencyIdentity(identity);
+    dependencies.set(dependencyKey(normalized), {
+      ...normalized,
+      fingerprint: fingerprintContent(content)
+    });
+  };
+  return {
+    contentSource: {
+      scan: () => source.scan(),
+      async read(entry) {
+        const content = await source.read(entry);
+        record({ kind: "file", id: entry.path }, content);
+        return content;
+      }
+    },
+    async readContent(slug, read) {
+      const content = await read();
+      record({ kind: "content", id: slug }, content);
+      return content;
+    },
+    recordLinkResolution(id, value) {
+      record({ kind: "link", id }, value);
+    },
+    dependencies: () => [...dependencies.values()].toSorted(
+      (left, right) => dependencyKey(left).localeCompare(dependencyKey(right))
+    )
+  };
+}
+function fingerprintContent(content) {
+  return `sha256:${createHash2("sha256").update(typeof content === "string" ? content : content).digest("hex")}`;
+}
+function normalizeDependencyIdentity(dependency) {
+  return {
+    ...dependency,
+    id: dependency.kind === "file" ? dependency.id.replace(/\\/g, "/") : dependency.id
+  };
+}
+function dependencyKey(dependency) {
+  const normalized = normalizeDependencyIdentity(dependency);
+  return `${normalized.kind}:${normalized.id}`;
+}
+
+// src/content/content_persistent_cache.ts
+import { createHash as createHash4 } from "node:crypto";
 import fs2 from "node:fs/promises";
+import os from "node:os";
 import path2 from "node:path";
+import { VFile } from "vfile";
+import { matter } from "vfile-matter";
+
+// src/plugin/plugin_memo.ts
+import { createHash as createHash3 } from "node:crypto";
+function createPluginMemo(cache, options = {}) {
+  return {
+    async memo(key, dependencies, compute) {
+      const memoKey = `${key}:${hash(stableStringify(dependencies))}`;
+      try {
+        const cached = await cache.get(memoKey);
+        if (cached !== void 0) return cached;
+      } catch (error) {
+        warn(
+          options.logger,
+          "Plugin cache read failed; recomputing.",
+          key,
+          error
+        );
+      }
+      const value = await compute();
+      try {
+        await cache.set(memoKey, value);
+      } catch (error) {
+        warn(
+          options.logger,
+          "Plugin cache write failed; result not cached.",
+          key,
+          error
+        );
+      }
+      return value;
+    }
+  };
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const keys = Object.keys(value).sort();
+  const body = keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",");
+  return `{${body}}`;
+}
+function hash(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
+function warn(logger, message, key, error) {
+  logger?.warn(message, {
+    memoKey: key,
+    error: error instanceof Error ? error.message : String(error)
+  });
+}
+
+// src/content/content_persistent_cache.ts
+var CONTENT_CACHE_NAMESPACE = "content";
+var CONTENT_CACHE_SCHEMA_VERSION = 3;
+var CONTENT_CACHE_COMPATIBILITY_VERSION = 1;
+function hash2(value) {
+  return createHash4("sha256").update(value).digest("hex");
+}
+function cacheDirectory(config) {
+  if (config.cache?.directory) {
+    return path2.join(config.cache.directory, CONTENT_CACHE_NAMESPACE);
+  }
+  if (config.buildDirectory) {
+    return path2.join(config.buildDirectory, "cache", CONTENT_CACHE_NAMESPACE);
+  }
+  return path2.join(
+    os.tmpdir(),
+    "riebeckite-content-cache",
+    CONTENT_CACHE_NAMESPACE
+  );
+}
+function versionDirectory(baseDir) {
+  return path2.join(baseDir, `v${CONTENT_CACHE_SCHEMA_VERSION}`);
+}
+function cacheFilePath(baseDir, key) {
+  return path2.join(versionDirectory(baseDir), `${hash2(key)}.json`);
+}
+async function writeAtomically(targetPath, dir, serialized) {
+  await fs2.mkdir(dir, { recursive: true });
+  const temporaryPath = `${targetPath}.${createHash4("sha256").update(`${Date.now()}-${Math.random()}`).digest("hex").slice(0, 12)}.tmp`;
+  try {
+    await fs2.writeFile(temporaryPath, serialized, "utf8");
+    await fs2.rename(temporaryPath, targetPath);
+  } catch (error) {
+    await fs2.rm(temporaryPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+function createPersistentContentCache(options) {
+  const { config, logger, tracer } = options;
+  const baseDir = cacheDirectory(config);
+  const versionDir = versionDirectory(baseDir);
+  return {
+    async get(key) {
+      if (!config.cache?.enabled) return void 0;
+      const filePath = cacheFilePath(baseDir, key);
+      try {
+        const raw = await fs2.readFile(filePath, "utf8");
+        const entry = JSON.parse(raw);
+        if (entry.schemaVersion !== CONTENT_CACHE_SCHEMA_VERSION) {
+          tracer?.event("persistentContentCache.schemaMismatch", { key });
+          return void 0;
+        }
+        if (entry.key !== key) {
+          tracer?.event("persistentContentCache.keyMismatch", { key });
+          return void 0;
+        }
+        if (!isValidCacheEntry(entry)) {
+          tracer?.event("persistentContentCache.invalidShape", { key });
+          return void 0;
+        }
+        tracer?.event("persistentContentCache.found", { key });
+        return entry;
+      } catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+          tracer?.event("persistentContentCache.miss", { key });
+          return void 0;
+        }
+        if (error instanceof SyntaxError) {
+          logger?.warn(
+            "Persistent content cache entry is corrupted and will be ignored.",
+            {
+              key
+            }
+          );
+          return void 0;
+        }
+        throw error;
+      }
+    },
+    async set(key, value) {
+      if (!config.cache?.enabled) return;
+      const filePath = cacheFilePath(baseDir, key);
+      const serialized = JSON.stringify(value);
+      if (serialized === void 0) {
+        throw new TypeError(
+          "Persistent content cache values must be JSON serializable."
+        );
+      }
+      await writeAtomically(filePath, versionDir, serialized);
+      tracer?.event("persistentContentCache.write", { key });
+    },
+    async clear() {
+      try {
+        await fs2.rm(baseDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+}
+function isValidCacheEntry(entry) {
+  return typeof entry === "object" && entry !== null && typeof entry.key === "string" && typeof entry.schemaVersion === "number" && Array.isArray(entry.dependencies) && entry.dependencies.every(isValidDependency) && typeof entry.value === "object" && entry.value !== null && typeof entry.value.html === "string" && typeof entry.value.frontmatter === "object" && entry.value.frontmatter !== null && !Array.isArray(entry.value.frontmatter);
+}
+function isValidDependency(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return (candidate.kind === "content" || candidate.kind === "file" || candidate.kind === "link") && typeof candidate.id === "string" && typeof candidate.fingerprint === "string";
+}
+function computeContentCacheKey(inputs) {
+  const { slug, source, frontmatter, pipelineFingerprint } = inputs;
+  const normalizedFrontmatter = normalizeFrontmatterForCache(frontmatter);
+  const keyData = {
+    schemaVersion: CONTENT_CACHE_SCHEMA_VERSION,
+    slug,
+    source,
+    frontmatter: normalizedFrontmatter,
+    pipelineFingerprint
+  };
+  return hash2(stableStringify(keyData));
+}
+function normalizeFrontmatterForCache(frontmatter) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (value instanceof Date) {
+      normalized[key] = value.toISOString();
+    } else if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      normalized[key] = normalizeFrontmatterForCache(
+        value
+      );
+    } else {
+      normalized[key] = value;
+    }
+  }
+  return normalized;
+}
+function computePipelineFingerprint(config) {
+  const plugins = config.plugins;
+  const fingerprintData = {
+    compatibilityVersion: CONTENT_CACHE_COMPATIBILITY_VERSION,
+    plugins: plugins.map((p) => pluginFingerprint(p)),
+    markdown: config.markdown,
+    content: {
+      filters: config.content.filters
+    }
+  };
+  return hash2(stableStringify(fingerprintData));
+}
+var pluginFingerprints = /* @__PURE__ */ new WeakMap();
+function pluginFingerprint(plugin) {
+  const cached = pluginFingerprints.get(plugin);
+  if (cached !== void 0) return cached;
+  const fingerprint = sanitizeForFingerprint(plugin);
+  pluginFingerprints.set(plugin, fingerprint);
+  return fingerprint;
+}
+var functionSourceFingerprints = /* @__PURE__ */ new Map();
+function fingerprintFunctionSource(value) {
+  const source = Function.prototype.toString.call(value);
+  const cached = functionSourceFingerprints.get(source);
+  if (cached !== void 0) return cached;
+  const fingerprint = `fn:${hash2(source)}`;
+  functionSourceFingerprints.set(source, fingerprint);
+  return fingerprint;
+}
+function sanitizeForFingerprint(value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "function") {
+    return fingerprintFunctionSource(value);
+  }
+  if (typeof value === "symbol") return "[Symbol]";
+  if (Array.isArray(value)) return value.map(sanitizeForFingerprint);
+  if (value instanceof Map || value instanceof Set)
+    return `[${value.constructor.name}]`;
+  if (typeof value === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = sanitizeForFingerprint(val);
+    }
+    return result;
+  }
+  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" };
+  }
+  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";
+  });
+  if (unsafePlugin) {
+    if (unsafePlugin.processedContentCache?.dependencyMode === "unsafe") {
+      return {
+        cacheable: false,
+        reason: `plugin ${unsafePlugin.name} explicitly marks processed content cache as unsafe`
+      };
+    }
+    return {
+      cacheable: false,
+      reason: `plugin ${unsafePlugin.name} can affect processed content without a processedContentCache contract`
+    };
+  }
+  return { cacheable: true };
+}
+function canAffectProcessedContent(plugin) {
+  return Boolean(
+    plugin.remarkPlugins?.length || plugin.rehypePlugins?.length || plugin.extendMarkdownPipeline || plugin.extendHtmlPipeline || plugin.renderers?.length || plugin.onContentLoaded || plugin.onPostParsed || plugin.onPostProcessed
+  );
+}
+function extractFrontmatter(markdown) {
+  const vfile = new VFile({ value: markdown });
+  matter(vfile);
+  return vfile.data.matter ?? {};
+}
+
+// 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,
@@ -1389,20 +1812,20 @@ function createUnavailablePluginCache() {
   };
 }
 function createPluginCache(options) {
-  const pluginDirectory = path2.join(
+  const pluginDirectory = path3.join(
     options.cacheDirectory,
     pluginNamespace(options.pluginName)
   );
-  const versionDirectory = path2.join(
+  const versionDirectory2 = path3.join(
     pluginDirectory,
-    hash(options.cacheVersion ?? "1")
+    hash3(options.cacheVersion ?? "1")
   );
   const writes = /* @__PURE__ */ new Map();
   return {
     async get(key) {
       let raw;
       try {
-        raw = await fs2.readFile(cachePath(versionDirectory, key), "utf8");
+        raw = await fs3.readFile(cachePath(versionDirectory2, key), "utf8");
       } catch (error) {
         if (isNotFoundError2(error)) {
           options.tracer?.event("cache.miss", { plugin: options.pluginName });
@@ -1425,13 +1848,13 @@ function createPluginCache(options) {
       }
     },
     async set(key, value) {
-      const targetPath = cachePath(versionDirectory, key);
+      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(() => writeAtomically(targetPath, versionDirectory, serialized));
+      const write = previousWrite.catch(() => void 0).then(() => writeAtomically2(targetPath, versionDirectory2, serialized));
       writes.set(targetPath, write);
       try {
         await write;
@@ -1442,37 +1865,37 @@ function createPluginCache(options) {
       }
     },
     async delete(key) {
-      await fs2.rm(cachePath(versionDirectory, key), { force: true });
+      await fs3.rm(cachePath(versionDirectory2, key), { force: true });
     },
     async clear() {
-      await fs2.rm(pluginDirectory, { recursive: true, force: true });
+      await fs3.rm(pluginDirectory, { recursive: true, force: true });
     }
   };
 }
-async function writeAtomically(targetPath, versionDirectory, serialized) {
-  await fs2.mkdir(versionDirectory, { recursive: true });
+async function writeAtomically2(targetPath, versionDirectory2, serialized) {
+  await fs3.mkdir(versionDirectory2, { recursive: true });
   const temporaryPath = `${targetPath}.${randomUUID2()}.tmp`;
   try {
-    await fs2.writeFile(temporaryPath, serialized, "utf8");
-    await fs2.rename(temporaryPath, targetPath);
+    await fs3.writeFile(temporaryPath, serialized, "utf8");
+    await fs3.rename(temporaryPath, targetPath);
   } catch (error) {
-    await fs2.rm(temporaryPath, { force: true }).catch(() => void 0);
+    await fs3.rm(temporaryPath, { force: true }).catch(() => void 0);
     throw error;
   }
 }
 function resolvePluginCacheDirectory(config) {
-  if (!config) return path2.resolve(process.cwd(), ".riebeckite", "cache");
-  if (config.buildDirectory) return path2.join(config.buildDirectory, "cache");
-  return path2.resolve(config.content.directory, "..", ".riebeckite", "cache");
+  if (!config) return path3.resolve(process.cwd(), ".riebeckite", "cache");
+  if (config.buildDirectory) return path3.join(config.buildDirectory, "cache");
+  return path3.resolve(config.content.directory, "..", ".riebeckite", "cache");
 }
-function cachePath(versionDirectory, key) {
-  return path2.join(versionDirectory, `${hash(key)}.json`);
+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 : hash(pluginName);
+  return /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(pluginName) ? pluginName : hash3(pluginName);
 }
-function hash(value) {
-  return createHash2("sha256").update(value).digest("hex");
+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";
@@ -1484,16 +1907,20 @@ async function unavailableAtRuntime() {
 }
 
 // src/types/generated_output.ts
+var ATTACHMENTS_NAMESPACE = ATTACHMENTS_BASE_PATH.replace(/^\/+/, "");
+var STATIC_ASSETS_DIR = "assets";
 function createUnavailableGeneratedOutputSink() {
+  const unavailable = () => {
+    throw new Error(
+      "Generated output is available only during a build lifecycle."
+    );
+  };
   return {
-    emit() {
-      throw new Error(
-        "Generated output is available only during a build lifecycle."
-      );
-    }
+    emit: unavailable,
+    emitAsset: unavailable
   };
 }
-function normalizeGeneratedOutputPath(input) {
+function normalizeOutputPathSegments(input) {
   if (typeof input !== "string" || input.length === 0) {
     throw new Error("Generated output path must be a non-empty string.");
   }
@@ -1517,12 +1944,27 @@ function normalizeGeneratedOutputPath(input) {
       );
     }
   }
-  const normalized = segments.join("/");
-  if (normalized === "assets" || normalized.startsWith("assets/")) {
+  return segments.join("/");
+}
+function normalizeGeneratedOutputPath(input) {
+  const normalized = normalizeOutputPathSegments(input);
+  if (normalized === STATIC_ASSETS_DIR || normalized.startsWith(`${STATIC_ASSETS_DIR}/`)) {
     throw new Error(
       `Generated output path must not conflict with the static assets namespace: "${input}".`
     );
   }
+  return rejectInternalRiebeckitePath(normalized, input);
+}
+function normalizeContentAssetOutputPath(input) {
+  const normalized = normalizeOutputPathSegments(input);
+  if (normalized === ATTACHMENTS_NAMESPACE || normalized.startsWith(`${ATTACHMENTS_NAMESPACE}/`)) {
+    throw new Error(
+      `Generated output path must not conflict with the attachment namespace: "${input}".`
+    );
+  }
+  return rejectInternalRiebeckitePath(normalized, input);
+}
+function rejectInternalRiebeckitePath(normalized, input) {
   if (normalized === ".riebeckite" || normalized.startsWith(".riebeckite/")) {
     throw new Error(
       `Generated output path must not target internal Riebeckite files: "${input}".`
@@ -1539,6 +1981,16 @@ var Pipeline = class {
     this.getMarkdownBySlug = getMarkdownBySlug;
     this.options = options;
     this.isBuildTime = isBuildTime;
+    if (this.options.config && this.options.config.cache?.enabled !== false) {
+      this.persistentCache = createPersistentContentCache({
+        config: this.options.config,
+        logger: this.options.observability?.logger,
+        tracer: this.options.observability?.tracer
+      });
+      this.pipelineFingerprint = computePipelineFingerprint(
+        this.options.config
+      );
+    }
   }
   contentIndex;
   permalinks;
@@ -1546,23 +1998,106 @@ var Pipeline = class {
   options;
   isBuildTime;
   pluginCaches = /* @__PURE__ */ new Map();
+  persistentCache = null;
+  pipelineFingerprint = null;
+  resolvedPlugins = null;
   async execute(markDownContent, context = {}) {
     return await this.executeWithEmbedState(
       markDownContent,
       context,
       0,
-      new Set(context.sourceSlug ? [context.sourceSlug] : [])
+      new Set(context.sourceSlug ? [context.sourceSlug] : []),
+      this.options.contentSource ? createContentDependencyTracker(this.options.contentSource) : null
     );
   }
-  async executeWithEmbedState(markDownContent, context, embedDepth, embedTrail) {
+  async executeWithEmbedState(markDownContent, context, embedDepth, embedTrail, rootDependencyTracker) {
+    const dependencyTracker = rootDependencyTracker;
+    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 cacheable = isPersistentlyCacheable(
+        sourceSlug,
+        this.options.config
+      );
+      if (cacheable.cacheable) {
+        const frontmatter = extractFrontmatter(markDownContent);
+        const cacheKey = computeContentCacheKey({
+          slug: sourceSlug,
+          source: markDownContent,
+          frontmatter,
+          pipelineFingerprint: this.pipelineFingerprint
+        });
+        const cachedEntry = await this.persistentCache.get(cacheKey);
+        if (cachedEntry) {
+          const validationTracker = createContentDependencyTracker(
+            this.options.contentSource
+          );
+          let valid = true;
+          for (const dep of cachedEntry.dependencies) {
+            if (dep.kind === "content") {
+              const content = await validationTracker.readContent(
+                dep.id,
+                async () => await this.getMarkdownBySlug?.(dep.id) ?? ""
+              );
+              if (fingerprintContent(content) !== dep.fingerprint) {
+                valid = false;
+                break;
+              }
+            } else if (dep.kind === "file") {
+              const fileContent = await validationTracker.contentSource.read({
+                path: dep.id
+              });
+              if (fingerprintContent(fileContent) !== dep.fingerprint) {
+                valid = false;
+                break;
+              }
+            } else if (dep.kind === "link") {
+              if (fingerprintContent(this.resolveLinkDependency(dep.id)) !== dep.fingerprint) {
+                valid = false;
+                break;
+              }
+            }
+          }
+          if (valid) {
+            this.reportContentDependencies(
+              sourceSlug,
+              cachedEntry.dependencies
+            );
+            this.options.observability?.tracer?.event(
+              "persistentContentCache.hit",
+              { key: cacheKey, slug: sourceSlug }
+            );
+            this.options.onPersistentContentCacheResult?.("hit");
+            return {
+              frontmatter: cachedEntry.value.frontmatter,
+              html: cachedEntry.value.html
+            };
+          }
+        }
+        this.options.observability?.tracer?.event(
+          "persistentContentCache.miss",
+          { key: cacheKey, slug: sourceSlug }
+        );
+        this.options.onPersistentContentCacheResult?.("miss");
+      } else {
+        this.options.observability?.tracer?.event(
+          "persistentContentCache.bypass",
+          {
+            slug: sourceSlug,
+            ...cacheable.reason ? { reason: cacheable.reason } : {}
+          }
+        );
+        this.options.onPersistentContentCacheResult?.("bypass");
+      }
+    }
     const processor = unified();
-    const plugins = resolvePlugins(this.options.plugins);
+    const plugins = this.resolvePlugins();
     this.use(processor, remarkParse);
     this.use(processor, remarkDirective);
     this.use(processor, remarkFrontmatter, ["yaml", "toml"]);
     this.use(processor, function loadFrontmatter() {
       return (_tree, file2) => {
-        matter(file2);
+        matter2(file2);
       };
     });
     this.use(processor, remarkMath);
@@ -1571,9 +2106,14 @@ var Pipeline = class {
       sourceSlug: context.sourceSlug,
       contentIndex: this.contentIndex,
       resolvePermalink: (slug) => this.getPermalink(slug),
-      renderNoteEmbed: this.createNoteEmbedRenderer(embedDepth, embedTrail),
-      renderContent: this.createContentRenderer(),
-      contentSource: this.options.contentSource
+      isRoutable: this.options.isRoutable,
+      renderNoteEmbed: this.createNoteEmbedRenderer(
+        embedDepth,
+        embedTrail,
+        dependencyTracker
+      ),
+      renderContent: this.createContentRenderer(effectiveContentSource),
+      contentSource: effectiveContentSource
     };
     for (const plugin of plugins) {
       for (const remarkPlugin of plugin.remarkPlugins ?? []) {
@@ -1588,7 +2128,10 @@ var Pipeline = class {
         markdownPipelineContext
       );
     }
-    this.use(processor, normalizeMarkdownLinks, markdownPipelineContext);
+    this.use(processor, normalizeMarkdownLinks, {
+      ...markdownPipelineContext,
+      recordLinkResolution: dependencyTracker ? (id, value) => dependencyTracker.recordLinkResolution(id, value) : void 0
+    });
     this.use(processor, remarkRehype, { allowDangerousHtml: true });
     this.use(processor, rehypeRaw);
     for (const plugin of plugins) {
@@ -1606,10 +2149,43 @@ var Pipeline = class {
     this.use(processor, rehypeFormat);
     this.use(processor, rehypeStringify, { allowDangerousHtml: true });
     const file = await processor.process(markDownContent.trim());
-    return {
+    const result = {
       frontmatter: file.data.matter || {},
       html: String(file.value)
     };
+    if (sourceSlug && dependencyTracker) {
+      this.reportContentDependencies(
+        sourceSlug,
+        dependencyTracker.dependencies()
+      );
+    }
+    if (embedDepth === 0 && this.persistentCache && this.pipelineFingerprint && sourceSlug && dependencyTracker && this.options.config) {
+      const cacheable = isPersistentlyCacheable(
+        sourceSlug,
+        this.options.config
+      );
+      if (cacheable.cacheable) {
+        const frontmatter = extractFrontmatter(markDownContent);
+        const cacheKey = computeContentCacheKey({
+          slug: sourceSlug,
+          source: markDownContent,
+          frontmatter,
+          pipelineFingerprint: this.pipelineFingerprint
+        });
+        const dependencies = dependencyTracker.dependencies();
+        const entry = {
+          schemaVersion: CONTENT_CACHE_SCHEMA_VERSION,
+          key: cacheKey,
+          dependencies,
+          value: result
+        };
+        await this.persistentCache.set(cacheKey, entry);
+      }
+    }
+    return result;
+  }
+  reportContentDependencies(slug, dependencies) {
+    this.options.onContentDependencies?.(slug, dependencies);
   }
   getPermalink(slug) {
     const permalink = this.permalinks.get(slug);
@@ -1618,6 +2194,14 @@ var Pipeline = class {
     }
     return permalink;
   }
+  resolveLinkDependency(id) {
+    return resolveLinkDependencyValue(
+      id,
+      this.contentIndex,
+      (slug) => this.permalinks.get(slug),
+      this.options.isRoutable
+    );
+  }
   use(processor, plugin, options) {
     const register = processor.use.bind(processor);
     if (options === void 0) {
@@ -1626,26 +2210,37 @@ var Pipeline = class {
       register(plugin, options);
     }
   }
-  createNoteEmbedRenderer(embedDepth, embedTrail) {
+  createNoteEmbedRenderer(embedDepth, embedTrail, dependencyTracker) {
     if (!this.getMarkdownBySlug || embedDepth >= 3) return void 0;
     return async (slug, fragment) => {
+      if (this.options.isRoutable && !this.options.isRoutable(slug)) {
+        return null;
+      }
       if (embedTrail.has(slug)) return null;
       const sourceMarkdown = await this.getMarkdownBySlug?.(slug);
       const markdown = sourceMarkdown ? selectEmbedMarkdownFragment(sourceMarkdown, fragment) : null;
       if (!markdown) return null;
       const nextEmbedTrail = new Set(embedTrail);
       nextEmbedTrail.add(slug);
+      if (dependencyTracker) {
+        await dependencyTracker.readContent(slug, async () => markdown);
+      }
       const content = await this.executeWithEmbedState(
         markdown,
         { sourceSlug: slug },
         embedDepth + 1,
-        nextEmbedTrail
+        nextEmbedTrail,
+        dependencyTracker
       );
       return content.html;
     };
   }
-  createContentRenderer() {
-    const renderers = resolvePlugins(this.options.plugins).flatMap(
+  resolvePlugins() {
+    this.resolvedPlugins ??= resolvePlugins(this.options.plugins);
+    return this.resolvedPlugins;
+  }
+  createContentRenderer(contentSource) {
+    const renderers = this.resolvePlugins().flatMap(
       (plugin) => (plugin.renderers ?? []).map((renderer) => ({ plugin, renderer }))
     );
     if (renderers.length === 0) return void 0;
@@ -1667,7 +2262,7 @@ var Pipeline = class {
             output: createUnavailableGeneratedOutputSink(),
             logger: observability.logger.child({ plugin: plugin.name }),
             tracer: observability.tracer,
-            contentSource: this.options.contentSource,
+            contentSource,
             ...input
           })
         );
@@ -1710,6 +2305,21 @@ function normalizeMarkdownLinks(context) {
     });
   };
 }
+var LINK_INDEX_PREFIX = "index:";
+var LINK_LOCATION_PREFIX = "location:";
+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") {
@@ -1722,7 +2332,7 @@ function visitMarkdownLinkNodes(node, visitor) {
 function normalizeMarkdownLinkUrl(url, context) {
   if (!context.sourceSlug) return null;
   if (!isMarkdownContentLink(url)) return null;
-  const [pathAndQuery, hash3 = ""] = splitOnce(url, "#");
+  const [pathAndQuery, hash4 = ""] = splitOnce(url, "#");
   const [rawPath, query = ""] = splitOnce(pathAndQuery, "?");
   const decodedPath = decodeUriPath(rawPath);
   if (!decodedPath?.toLowerCase().endsWith(".md")) return null;
@@ -1733,15 +2343,35 @@ function normalizeMarkdownLinkUrl(url, context) {
   if (!resolvedSlug) return null;
   const indexedSlug = getExactContentSlug(context, resolvedSlug);
   if (!indexedSlug) return null;
-  const suffix = `${query ? `?${query}` : ""}${hash3 ? `#${hash3}` : ""}`;
+  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 {
-    return context.contentIndex.get(slug.toLowerCase()) ?? null;
+    const indexKey = slug.toLowerCase();
+    recordLinkResolution(context, LINK_INDEX_PREFIX, indexKey);
+    return context.contentIndex.get(indexKey) ?? null;
   }
 }
 function isMarkdownContentLink(url) {
@@ -1765,9 +2395,9 @@ function resolveRelativeMarkdownSlug(sourceSlug, targetPath) {
   }
   return normalizedParts.join("/").replace(/\.md$/i, "");
 }
-function decodeUriPath(path4) {
+function decodeUriPath(path5) {
   try {
-    return decodeURI(path4);
+    return decodeURI(path5);
   } catch {
     return null;
   }
@@ -1855,17 +2485,27 @@ var GeneratedOutputRegistry = class {
   outputs = [];
   owners = /* @__PURE__ */ new Map();
   sinkFor(pluginName) {
-    return {
-      emit: (output) => {
-        const path4 = normalizeGeneratedOutputPath(output.path);
-        const owner = this.owners.get(path4);
-        if (owner) {
-          throw new Error(
-            `Duplicate generated output path "${path4}" declared by "${owner}" and "${pluginName}".`
-          );
-        }
-        this.owners.set(path4, pluginName);
-        this.outputs.push({ path: path4, content: output.content, owner: pluginName });
+    const register = (path5, output) => {
+      const owner = this.owners.get(path5);
+      if (owner) {
+        throw new Error(
+          `Duplicate generated output path "${path5}" declared by "${owner}" and "${pluginName}".`
+        );
+      }
+      this.owners.set(path5, pluginName);
+      this.outputs.push({
+        path: path5,
+        content: output.content,
+        dependencies: output.dependencies,
+        owner: pluginName
+      });
+    };
+    return {
+      emit: (output) => {
+        register(normalizeGeneratedOutputPath(output.path), output);
+      },
+      emitAsset: (output) => {
+        register(normalizeContentAssetOutputPath(output.path), output);
       }
     };
   }
@@ -1948,6 +2588,7 @@ var PluginRuntime = class {
   pluginCaches = /* @__PURE__ */ new Map();
   generatedOutputs = new GeneratedOutputRegistry();
   isBuildTime = false;
+  resolvedPlugins = null;
   getDiagnostics() {
     return this.diagnostics;
   }
@@ -2068,20 +2709,26 @@ var PluginRuntime = class {
   }
   async resolvePage(pathname, manifest, contentIndex) {
     const matches = [];
-    const normalizedPathname = normalizePagePath(pathname);
-    const context = {
-      ...this.createContext(contentIndex),
-      manifest,
-      pathname: normalizedPathname
-    };
+    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, type: pageType.id, pluginName: plugin.name },
+            page: {
+              ...page,
+              pathname: pageType.directoryIndex ? normalizeDirectoryPagePath(page.pathname) : page.pathname,
+              type: pageType.id,
+              pluginName: plugin.name
+            },
             priority: pageType.priority ?? 0
           });
         }
@@ -2094,7 +2741,7 @@ var PluginRuntime = class {
     );
     if (highest.length !== 1) {
       throw new Error(
-        `Multiple plugin page types match ${normalizedPathname} at priority ${highestPriority}: ${highest.map((match) => match.page.type).join(", ")}`
+        `Multiple plugin page types match ${requestedPathname} at priority ${highestPriority}: ${highest.map((match) => match.page.type).join(", ")}`
       );
     }
     return highest[0].page;
@@ -2106,12 +2753,60 @@ var PluginRuntime = class {
       for (const pageType of plugin.pageTypes ?? []) {
         const declared = pageType.paths;
         if (!declared) continue;
-        paths.push(
-          ...typeof declared === "function" ? await declared(this.createPluginContext(plugin, context)) : declared
-        );
+        const resolved = typeof declared === "function" ? await declared(this.createPluginContext(plugin, context)) : declared;
+        for (const rawPath of resolved) {
+          paths.push(normalizePageTypePath(rawPath, pageType));
+        }
+      }
+    }
+    return [...new Set(paths)];
+  }
+  async getPageRoutes(manifest, contentIndex) {
+    const routes = [];
+    const context = { ...this.createContext(contentIndex), manifest };
+    for (const plugin of this.plugins()) {
+      for (const pageType of plugin.pageTypes ?? []) {
+        const declared = pageType.paths;
+        if (!declared) continue;
+        const paths = typeof declared === "function" ? await declared(this.createPluginContext(plugin, context)) : declared;
+        for (const pathname of paths) {
+          routes.push({
+            pathname: normalizePageTypePath(pathname, pageType),
+            pluginName: plugin.name,
+            pageType: pageType.id
+          });
+        }
       }
     }
-    return [...new Set(paths.map(normalizePagePath))];
+    return routes;
+  }
+  async getPageOutputs(manifest, contentIndex) {
+    const outputs = [];
+    const context = { ...this.createContext(contentIndex), manifest };
+    for (const plugin of this.plugins()) {
+      for (const pageType of plugin.pageTypes ?? []) {
+        const declared = pageType.paths;
+        if (!declared) continue;
+        const paths = typeof declared === "function" ? await declared(this.createPluginContext(plugin, context)) : declared;
+        for (const rawPath of paths) {
+          const pathname = normalizePageTypePath(rawPath, pageType);
+          const dependencyContext = { ...context, pathname };
+          const dependencies = pageType.outputDependencies ? typeof pageType.outputDependencies === "function" ? await pageType.outputDependencies(
+            this.createPluginContext(plugin, dependencyContext)
+          ) : pageType.outputDependencies : [{ type: "unknown" }];
+          outputs.push({
+            kind: "plugin-page",
+            path: pathname,
+            producer: `plugin:${plugin.name}:page:${pageType.id}`,
+            dependencies
+          });
+        }
+      }
+    }
+    return uniqueOutputs(outputs);
+  }
+  getContentOutputDependencies() {
+    return this.plugins().flatMap((plugin) => plugin.outputDependencies ?? []);
   }
   async collectDiagnostics(contentIndex) {
     const tracer = this.observability().tracer;
@@ -2169,6 +2864,7 @@ var PluginRuntime = class {
     return {
       config: this.pipelineOptions.config,
       contentIndex,
+      contentSource: this.pipelineOptions.contentSource,
       diagnostics: this.diagnostics
     };
   }
@@ -2218,27 +2914,33 @@ var PluginRuntime = class {
     return this.pipelineOptions.observability ?? noopObservability;
   }
   plugins() {
-    const plugins = resolvePlugins(this.pipelineOptions.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);
-      }
+    if (this.resolvedPlugins === null) {
+      const resolved = resolvePlugins(this.pipelineOptions.plugins);
+      collectPageTypeOwners(resolved);
+      this.resolvedPlugins = resolved;
     }
-    return plugins;
+    return this.resolvedPlugins;
   }
 };
+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`);
@@ -2264,24 +2966,48 @@ function validatePageType(pluginName, pageType) {
       `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 path5 = normalizePagePath(pathname);
+  return path5 === "/" ? path5 : `${path5}/`;
 }
 function normalizePagePath(pathname) {
-  const path4 = `/${pathname.split("/").filter(Boolean).join("/")}`;
-  return path4 === "/" ? path4 : path4.replace(/\/$/, "");
+  const path5 = `/${pathname.split("/").filter(Boolean).join("/")}`;
+  return path5 === "/" ? path5 : path5.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) byPath.set(output.path, output);
+  return [...byPath.values()].sort(
+    (left, right) => left.path.localeCompare(right.path)
+  );
+}
 
 // src/content/affected_content.ts
-function determineAffectedContent(changeSet, previousState, currentPaths) {
+function determineAffectedContent(changeSet, previousState, currentPaths, currentContentIndex) {
   const changedPaths = [
     ...changeSet.added,
     ...changeSet.changed,
     ...changeSet.removed
   ];
   const direct = new Set(
-    changedPaths.filter(isMarkdownPath2).map(toDependencyKey)
+    changedPaths.filter(isMarkdownPath2).map(toDependencyId)
   );
   const dependent = /* @__PURE__ */ new Set();
   if (!previousState) {
@@ -2289,40 +3015,81 @@ function determineAffectedContent(changeSet, previousState, currentPaths) {
     return { direct, dependent };
   }
   if (changeSet.added.length > 0 || changeSet.removed.length > 0) {
-    addAllNotes(dependent, currentPaths, direct);
+    const changedIndexKeys = findChangedIndexKeys(
+      previousState.contentIndex,
+      currentContentIndex
+    );
+    for (const [path5, entry] of Object.entries(previousState.entries)) {
+      if (!isMarkdownPath2(path5)) continue;
+      const slug = toDependencyId(path5);
+      if (direct.has(slug) || dependent.has(slug)) continue;
+      if (!entry.linkTargets?.some((target) => changedIndexKeys.has(target))) {
+        continue;
+      }
+      dependent.add(slug);
+    }
   }
-  const pending = changedPaths.map(toDependencyKey);
-  const seen = new Set(pending);
+  const dependentsByDependency = buildDependentsByDependency(previousState);
+  const pending = changedPaths.map(toDependency);
+  const seen = new Set(pending.map(dependencyKey2));
   while (pending.length > 0) {
     const changed = pending.pop();
     if (changed === void 0) continue;
-    for (const [path4, entry] of Object.entries(previousState.entries)) {
-      if (!isMarkdownPath2(path4)) continue;
-      const slug = toDependencyKey(path4);
+    for (const slug of dependentsByDependency.get(dependencyKey2(changed)) ?? []) {
       if (direct.has(slug) || dependent.has(slug)) continue;
-      if (!entry.dependencies.includes(changed)) continue;
       dependent.add(slug);
-      if (!seen.has(slug)) {
-        seen.add(slug);
-        pending.push(slug);
+      const dependency = { kind: "content", id: slug };
+      if (!seen.has(dependencyKey2(dependency))) {
+        seen.add(dependencyKey2(dependency));
+        pending.push(dependency);
       }
     }
   }
   return { direct, dependent };
 }
+function findChangedIndexKeys(previousIndex, currentIndex) {
+  const changed = /* @__PURE__ */ new Set();
+  for (const [key, previousValue] of Object.entries(previousIndex)) {
+    if (currentIndex.get(key) !== previousValue) changed.add(key);
+  }
+  for (const key of currentIndex.keys()) {
+    if (!(key in previousIndex)) changed.add(key);
+  }
+  return changed;
+}
 function addAllNotes(target, currentPaths, exclude) {
-  for (const path4 of currentPaths) {
-    if (!isMarkdownPath2(path4)) continue;
-    const slug = toDependencyKey(path4);
+  for (const path5 of currentPaths) {
+    if (!isMarkdownPath2(path5)) continue;
+    const slug = toDependencyId(path5);
     if (exclude?.has(slug)) continue;
     target.add(slug);
   }
 }
-function isMarkdownPath2(path4) {
-  return path4.endsWith(".md");
+function isMarkdownPath2(path5) {
+  return path5.endsWith(".md");
+}
+function toDependencyId(path5) {
+  return path5.replace(/\.md$/, "");
+}
+function toDependency(path5) {
+  return isMarkdownPath2(path5) ? { kind: "content", id: toDependencyId(path5) } : { kind: "file", id: path5.replace(/\\/g, "/") };
+}
+function buildDependentsByDependency(state2) {
+  const dependents = /* @__PURE__ */ new Map();
+  for (const [path5, entry] of Object.entries(state2.entries)) {
+    if (!isMarkdownPath2(path5)) continue;
+    const slug = toDependencyId(path5);
+    for (const dependency of entry.dependencies) {
+      const key = dependencyKey2(dependency);
+      const values = dependents.get(key) ?? /* @__PURE__ */ new Set();
+      values.add(slug);
+      dependents.set(key, values);
+    }
+  }
+  return dependents;
 }
-function toDependencyKey(path4) {
-  return path4.replace(/\.md$/, "");
+function dependencyKey2(dependency) {
+  return `${dependency.kind}:${dependency.id}`;
 }
 
 // src/content/content_change_set.ts
@@ -2333,18 +3100,18 @@ function diffContentEntries(previous, current) {
   const added = [];
   const changed = [];
   const unchanged = [];
-  for (const [path4, fingerprint] of currentFingerprints) {
-    const previousEntry = previous.entries[path4];
+  for (const [path5, fingerprint] of currentFingerprints) {
+    const previousEntry = previous.entries[path5];
     if (!previousEntry) {
-      added.push(path4);
+      added.push(path5);
     } else if (previousEntry.fingerprint !== fingerprint) {
-      changed.push(path4);
+      changed.push(path5);
     } else {
-      unchanged.push(path4);
+      unchanged.push(path5);
     }
   }
   const removed = Object.keys(previous.entries).filter(
-    (path4) => !currentFingerprints.has(path4)
+    (path5) => !currentFingerprints.has(path5)
   );
   return sortChangeSet({ added, changed, removed, unchanged });
 }
@@ -2368,119 +3135,6 @@ function sortChangeSet(changeSet) {
   };
 }
 
-// src/content/content_build_coordinator.ts
-var ContentBuildCoordinator = class {
-  constructor(dependencies) {
-    this.dependencies = dependencies;
-  }
-  dependencies;
-  preparation = null;
-  getPreparation(incremental) {
-    this.preparation ??= this.prepare(incremental);
-    return this.preparation;
-  }
-  async commit(preparation, manifest) {
-    const entriesBySlug = new Map(
-      manifest.entries.map((entry) => [entry.slug, entry])
-    );
-    const state = {
-      version: CONTENT_BUILD_STATE_VERSION,
-      entries: Object.fromEntries(
-        preparation.currentEntries.map(({ entry, fingerprint }) => {
-          const manifestEntry = entriesBySlug.get(toSlug(entry.path));
-          return [
-            entry.path,
-            {
-              fingerprint,
-              dependencies: collectDependencies2(manifestEntry)
-            }
-          ];
-        })
-      ),
-      contentIndex: Object.fromEntries(
-        [...manifest.contentIndex.entries()].sort(
-          ([left], [right]) => left.localeCompare(right)
-        )
-      )
-    };
-    try {
-      await saveContentBuildState(this.dependencies.buildStatePath, state);
-    } catch {
-    }
-  }
-  async prepare(incremental) {
-    const currentEntries = await fingerprintContentEntries(
-      await this.dependencies.getEntries(),
-      (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 affected = determineAffectedContent(
-      changeSet,
-      previousState,
-      currentEntries.map(({ entry }) => entry.path)
-    );
-    this.dependencies.observability.tracer.event("build.incremental", {
-      incremental: incremental !== false,
-      added: changeSet.added.length,
-      changed: changeSet.changed.length,
-      removed: changeSet.removed.length,
-      unchanged: changeSet.unchanged.length,
-      affected: affected.direct.size + affected.dependent.size
-    });
-    return { previousState, currentEntries, changeSet };
-  }
-};
-function toSlug(path4) {
-  return path4.replace(/\.md$/, "");
-}
-function collectDependencies2(manifestEntry) {
-  if (!manifestEntry) return [];
-  return [
-    ...new Set(
-      manifestEntry.links.filter(
-        (link) => link.slug !== null
-      ).map((link) => link.slug)
-    )
-  ].sort();
-}
-
-// src/content/content_entry_reader.ts
-var ContentEntryReader = class {
-  constructor(source, observability) {
-    this.source = source;
-    this.observability = observability;
-  }
-  source;
-  observability;
-  entries = null;
-  texts = /* @__PURE__ */ new Map();
-  async getEntries() {
-    this.entries ??= await this.observability.tracer.span(
-      "content.scan",
-      {},
-      () => this.source.scan()
-    );
-    return this.entries;
-  }
-  async readText(logicalPath) {
-    const entry = (await this.getEntries()).find(
-      (current) => current.path === logicalPath
-    );
-    if (!entry) throw new Error(`Content entry was not found: ${logicalPath}`);
-    return await this.read(entry);
-  }
-  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)
-    );
-    this.texts.set(entry.path, content);
-    return content;
-  }
-};
-
 // src/utils/tags.ts
 function normalizeTag(raw) {
   const cleaned = raw.replace(/[/-]+$/, "");
@@ -2541,7 +3195,7 @@ function stripYamlQuotes(value) {
 }
 
 // src/content/content_index_builder.ts
-var ContentIndexBuilder = class {
+var ContentIndexBuilder = class _ContentIndexBuilder {
   constructor(source) {
     this.source = source;
   }
@@ -2553,7 +3207,26 @@ var ContentIndexBuilder = class {
     }
     return index;
   }
+  static buildFromAliases(contentEntries, aliasesByPath) {
+    const index = /* @__PURE__ */ new Map();
+    for (const contentEntry of contentEntries) {
+      _ContentIndexBuilder.indexContentEntryFromAliases(
+        index,
+        contentEntry,
+        aliasesByPath.get(contentEntry.path) ?? []
+      );
+    }
+    return index;
+  }
   async indexContentEntry(index, contentEntry, read) {
+    const aliases = contentEntry.path.toLowerCase().endsWith(".md") ? extractFrontmatterAliases(readText(await read(contentEntry))) : [];
+    _ContentIndexBuilder.indexContentEntryFromAliases(
+      index,
+      contentEntry,
+      aliases
+    );
+  }
+  static indexContentEntryFromAliases(index, contentEntry, aliases) {
     const contentPath = contentEntry.path;
     const ext = contentPath.split(".").pop()?.toLowerCase() ?? "";
     const value = ext === "md" ? contentPath.replace(/\.md$/, "") : contentPath;
@@ -2566,20 +3239,246 @@ var ContentIndexBuilder = class {
       }
     }
     if (ext === "md") {
-      const markdown = readText(await read(contentEntry));
-      for (const alias of extractFrontmatterAliases(markdown)) {
-        addIndexEntry(index, alias, value);
+      for (const alias of aliases) addIndexEntry(index, alias, value);
+    }
+  }
+};
+function readText(content) {
+  return typeof content === "string" ? content : new TextDecoder().decode(content);
+}
+function addIndexEntry(index, key, value) {
+  const normalizedKey = key.toLowerCase();
+  if (!index.has(normalizedKey)) index.set(normalizedKey, value);
+}
+
+// src/content/content_build_coordinator.ts
+var ContentBuildCoordinator = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  dependencies;
+  preparation = null;
+  getPreparation(incremental, pipelineFingerprint, fullContentRegenerationRequired = false) {
+    this.preparation ??= this.prepare(
+      incremental,
+      pipelineFingerprint,
+      fullContentRegenerationRequired
+    );
+    return this.preparation;
+  }
+  async commit(preparation, manifest, pipelineFingerprint, outputs = [], manifestEntries = manifest.entries, trackedDependencies = /* @__PURE__ */ new Map()) {
+    const entriesBySlug = new Map(
+      manifest.entries.map((entry) => [entry.slug, entry])
+    );
+    const state2 = {
+      version: CONTENT_BUILD_STATE_VERSION,
+      entries: Object.fromEntries(
+        preparation.currentEntries.map(({ entry, fingerprint }) => {
+          const manifestEntry = entriesBySlug.get(toSlug(entry.path));
+          return [
+            entry.path,
+            {
+              fingerprint,
+              aliases: preparation.currentContentAliases.get(entry.path) ?? [],
+              dependencies: collectDependencies2(
+                manifestEntry,
+                trackedDependencies.get(toSlug(entry.path)) ?? preparation.previousState?.entries[entry.path]?.dependencies ?? []
+              ),
+              linkTargets: collectLinkTargets(manifestEntry)
+            }
+          ];
+        })
+      ),
+      contentIndex: Object.fromEntries(
+        [...manifest.contentIndex.entries()].sort(
+          ([left], [right]) => left.localeCompare(right)
+        )
+      ),
+      pipelineFingerprint,
+      manifestEntries,
+      outputs
+    };
+    try {
+      await saveContentBuildState(this.dependencies.buildStatePath, state2);
+    } catch (error) {
+      this.dependencies.observability.logger.warn(
+        "Incremental build state could not be persisted; the next build regenerates every note instead of reusing stale output.",
+        {
+          path: this.dependencies.buildStatePath,
+          reason: error instanceof Error ? error.message : String(error)
+        }
+      );
+    }
+  }
+  async prepare(incremental, pipelineFingerprint, fullContentRegenerationRequired) {
+    const entries = await this.dependencies.observability.tracer.span(
+      "content.discovery",
+      {},
+      () => this.dependencies.getEntries()
+    );
+    const currentEntries = await this.dependencies.observability.tracer.span(
+      "content.fingerprint",
+      {},
+      () => fingerprintContentEntries(
+        entries,
+        (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 currentContentIndex = await this.dependencies.observability.tracer.span(
+      "content.index",
+      {},
+      () => ContentIndexBuilder.buildFromAliases(
+        currentEntries.map(({ entry }) => entry),
+        currentContentAliases
+      )
+    );
+    const affected = !fullContentRegenerationRequired && previousState?.pipelineFingerprint === pipelineFingerprint ? determineAffectedContent(
+      changeSet,
+      previousState,
+      currentEntries.map(({ entry }) => entry.path),
+      currentContentIndex
+    ) : determineAffectedContent(
+      allContentChanged(currentEntries),
+      void 0,
+      currentEntries.map(({ entry }) => entry.path),
+      currentContentIndex
+    );
+    this.dependencies.observability.tracer.event("build.incremental", {
+      incremental: incremental !== false,
+      added: changeSet.added.length,
+      changed: changeSet.changed.length,
+      removed: changeSet.removed.length,
+      unchanged: changeSet.unchanged.length,
+      affected: affected.direct.size + affected.dependent.size
+    });
+    return {
+      previousState,
+      previousManifestEntriesBySlug: new Map(
+        (previousState?.manifestEntries ?? []).map((entry) => [
+          entry.slug,
+          entry
+        ])
+      ),
+      currentEntries,
+      currentContentAliases,
+      currentContentIndex,
+      changeSet,
+      affectedContent: affected
+    };
+  }
+  async getContentAliases(currentEntries, previousState, changeSet) {
+    const changedPaths = /* @__PURE__ */ new Set([...changeSet.added, ...changeSet.changed]);
+    const aliases = /* @__PURE__ */ new Map();
+    for (const { entry } of currentEntries) {
+      if (!entry.path.toLowerCase().endsWith(".md")) continue;
+      const previousAliases = previousState?.entries[entry.path]?.aliases;
+      if (!changedPaths.has(entry.path) && previousAliases) {
+        aliases.set(entry.path, previousAliases);
+        continue;
       }
+      aliases.set(
+        entry.path,
+        extractFrontmatterAliases(
+          readText2(await this.dependencies.readEntry(entry))
+        )
+      );
+    }
+    return aliases;
+  }
+};
+function readText2(content) {
+  return typeof content === "string" ? content : new TextDecoder().decode(content);
+}
+function toSlug(path5) {
+  return path5.replace(/\.md$/, "");
+}
+function collectDependencies2(manifestEntry, trackedDependencies) {
+  if (!manifestEntry) return [];
+  return [
+    ...new Map(
+      [
+        ...manifestEntry.links.filter(
+          (link) => link.slug !== null
+        ).map((link) => ({ kind: "content", id: link.slug })),
+        ...manifestEntry.assets.map((asset) => ({
+          kind: "file",
+          id: asset.path.replace(/\\/g, "/")
+        })),
+        ...trackedDependencies.filter(
+          (dependency) => dependency.kind === "content" || dependency.kind === "file"
+        ).map((dependency) => ({
+          kind: dependency.kind,
+          id: dependency.id.replace(/\\/g, "/")
+        }))
+      ].map((dependency) => [
+        `${dependency.kind}:${dependency.id}`,
+        dependency
+      ])
+    ).values()
+  ].toSorted(
+    (left, right) => `${left.kind}:${left.id}`.localeCompare(`${right.kind}:${right.id}`)
+  );
+}
+function collectLinkTargets(manifestEntry) {
+  if (!manifestEntry) return [];
+  return [
+    ...new Set(manifestEntry.links.map((link) => link.raw.toLowerCase()))
+  ].sort();
+}
+
+// src/content/content_entry_reader.ts
+var ContentEntryReader = class {
+  constructor(source, observability) {
+    this.source = source;
+    this.observability = observability;
+  }
+  source;
+  observability;
+  entries = null;
+  entriesPromise = null;
+  entriesByPath = null;
+  texts = /* @__PURE__ */ new Map();
+  async getEntries() {
+    if (this.entries) return this.entries;
+    if (this.entriesPromise) return await this.entriesPromise;
+    this.entriesPromise = this.observability.tracer.span(
+      "content.scan",
+      {},
+      () => this.source.scan()
+    );
+    try {
+      this.entries = await this.entriesPromise;
+      this.entriesByPath = new Map(
+        this.entries.map((entry) => [entry.path, entry])
+      );
+      return this.entries;
+    } finally {
+      this.entriesPromise = null;
     }
   }
+  async readText(logicalPath) {
+    await this.getEntries();
+    const entry = this.entriesByPath?.get(logicalPath);
+    if (!entry) throw new Error(`Content entry was not found: ${logicalPath}`);
+    return await this.read(entry);
+  }
+  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)
+    ).finally(() => this.texts.delete(entry.path));
+    this.texts.set(entry.path, content);
+    return content;
+  }
 };
-function readText(content) {
-  return typeof content === "string" ? content : new TextDecoder().decode(content);
-}
-function addIndexEntry(index, key, value) {
-  const normalizedKey = key.toLowerCase();
-  if (!index.has(normalizedKey)) index.set(normalizedKey, value);
-}
 
 // src/content/content_location_resolver.ts
 var ContentLocationResolver = class {
@@ -2588,19 +3487,37 @@ var ContentLocationResolver = class {
   }
   dependencies;
   locations = null;
+  locationsPromise = null;
+  permalinks = null;
+  permalinksPromise = null;
   async getLocations() {
     if (this.locations) return this.locations;
+    if (this.locationsPromise) return await this.locationsPromise;
+    this.locationsPromise = this.dependencies.observability.tracer.span(
+      "content.locations",
+      {},
+      () => this.resolveLocations()
+    );
+    try {
+      return await this.locationsPromise;
+    } finally {
+      this.locationsPromise = null;
+    }
+  }
+  async resolveLocations() {
     const [entries, contentIndex] = await Promise.all([
       this.dependencies.getEntries(),
       this.dependencies.getContentIndex()
     ]);
     await this.dependencies.pluginRuntime.startBuild(contentIndex);
-    const inputs = await Promise.all(
-      entries.filter((entry) => entry.path.endsWith(".md")).map(async (entry) => ({
+    const inputs = await mapConcurrent2(
+      entries.filter((entry) => entry.path.endsWith(".md")),
+      64,
+      async (entry) => ({
         slug: toSlug2(entry.path),
         path: entry.path,
         markdown: await this.dependencies.readEntry(entry)
-      }))
+      })
     );
     const locations = new Map(
       inputs.map((input) => [input.slug, resolveDefaultContentLocation(input)])
@@ -2625,6 +3542,17 @@ var ContentLocationResolver = class {
     return locations;
   }
   async getPermalinks() {
+    if (this.permalinks) return this.permalinks;
+    if (this.permalinksPromise) return await this.permalinksPromise;
+    this.permalinksPromise = this.createPermalinks();
+    try {
+      this.permalinks = await this.permalinksPromise;
+      return this.permalinks;
+    } finally {
+      this.permalinksPromise = null;
+    }
+  }
+  async createPermalinks() {
     return new Map(
       Array.from(
         (await this.getLocations()).entries(),
@@ -2640,13 +3568,45 @@ var ContentLocationResolver = class {
     }
   }
 };
-function toSlug2(path4) {
-  return path4.replace(/\.md$/, "");
+function toSlug2(path5) {
+  return path5.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);
+    }
+  }
+  await Promise.all(
+    Array.from(
+      { length: Math.min(concurrency, values.length) },
+      () => worker()
+    )
+  );
+  return results;
 }
 
 // src/content/file_system_content_source.ts
-import fs3 from "node:fs/promises";
-import path3 from "node:path";
+import fs4 from "node:fs/promises";
+import path4 from "node:path";
+var INTERNAL_CONTENT_IGNORE_PATTERNS = [
+  ".git",
+  ".git/**",
+  ".github",
+  ".github/**",
+  ".obsidian",
+  ".obsidian/**",
+  "node_modules",
+  "node_modules/**",
+  "**/.DS_Store",
+  "**/Thumbs.db",
+  "**/desktop.ini"
+];
 var FileSystemContentSource = class {
   constructor(contentDirectory, exclude = []) {
     this.contentDirectory = contentDirectory;
@@ -2655,33 +3615,41 @@ var FileSystemContentSource = class {
   contentDirectory;
   exclude;
   async scan() {
-    return await this.scanDirectory(this.contentDirectory, "");
+    try {
+      return await this.scanDirectory(this.contentDirectory, "");
+    } catch (error) {
+      if (isMissingDirectoryError(error, this.contentDirectory)) {
+        throw missingContentDirectoryError(this.contentDirectory);
+      }
+      throw error;
+    }
   }
   async read(entry) {
     const filePath = this.resolveFilePath(entry.path);
-    const stats = await fs3.lstat(filePath);
+    const stats = await fs4.lstat(filePath);
     if (!stats.isFile() || stats.isSymbolicLink()) {
       throw new Error(`Content entry is not a regular file: ${entry.path}`);
     }
-    return await fs3.readFile(filePath);
+    return await fs4.readFile(filePath);
   }
-  async scanDirectory(directory, parentPath) {
-    const directoryEntries = await fs3.readdir(directory, {
+  async scanDirectory(directory, parentPath2) {
+    const directoryEntries = await fs4.readdir(directory, {
       withFileTypes: true
     });
     const entries = [];
     for (const directoryEntry of directoryEntries) {
       if (directoryEntry.isSymbolicLink()) continue;
       const logicalPath = normalizeContentPath(
-        parentPath ? `${parentPath}/${directoryEntry.name}` : directoryEntry.name
+        parentPath2 ? `${parentPath2}/${directoryEntry.name}` : directoryEntry.name
       );
-      const filePath = path3.join(directory, directoryEntry.name);
+      const filePath = path4.join(directory, directoryEntry.name);
+      if (this.isExcluded(logicalPath)) continue;
       if (directoryEntry.isDirectory()) {
         entries.push(...await this.scanDirectory(filePath, logicalPath));
         continue;
       }
-      if (!directoryEntry.isFile() || this.isExcluded(logicalPath)) continue;
-      const stats = await fs3.stat(filePath);
+      if (!directoryEntry.isFile()) continue;
+      const stats = await fs4.stat(filePath);
       entries.push({
         path: logicalPath,
         metadata: {
@@ -2693,26 +3661,44 @@ var FileSystemContentSource = class {
     return entries;
   }
   isExcluded(logicalPath) {
-    if (isExcluded(this.exclude, logicalPath)) return true;
-    return logicalPath.endsWith(".md") && isExcluded(this.exclude, logicalPath.slice(0, -3));
+    return isIgnoredContentPath(logicalPath, this.exclude);
   }
   resolveFilePath(logicalPath) {
     const normalizedPath = normalizeLogicalPath(logicalPath);
-    const filePath = path3.resolve(this.contentDirectory, normalizedPath);
-    const relativePath = path3.relative(this.contentDirectory, filePath);
-    if (relativePath.startsWith("..") || path3.isAbsolute(relativePath)) {
+    const filePath = path4.resolve(this.contentDirectory, normalizedPath);
+    const relativePath = path4.relative(this.contentDirectory, filePath);
+    if (relativePath.startsWith("..") || path4.isAbsolute(relativePath)) {
       throw new Error(`Invalid content path: ${logicalPath}`);
     }
     return filePath;
   }
 };
+function isIgnoredContentPath(logicalPath, exclude = []) {
+  if (isExcluded(INTERNAL_CONTENT_IGNORE_PATTERNS, logicalPath)) return true;
+  if (isExcluded(exclude, logicalPath)) return true;
+  return logicalPath.endsWith(".md") && isExcluded(exclude, logicalPath.slice(0, -3));
+}
 function normalizeLogicalPath(logicalPath) {
   const normalizedPath = normalizeContentPath(logicalPath);
-  if (normalizedPath.length === 0 || normalizedPath.startsWith("/") || path3.isAbsolute(normalizedPath) || path3.win32.isAbsolute(normalizedPath) || normalizedPath.split("/").some((segment) => segment === "..")) {
+  if (normalizedPath.length === 0 || normalizedPath.startsWith("/") || path4.isAbsolute(normalizedPath) || path4.win32.isAbsolute(normalizedPath) || normalizedPath.split("/").some((segment) => segment === "..")) {
     throw new Error(`Invalid content path: ${logicalPath}`);
   }
   return normalizedPath;
 }
+function isMissingDirectoryError(error, directory) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT" && "path" in error && error.path === directory;
+}
+function missingContentDirectoryError(directory) {
+  const relative = path4.relative(process.cwd(), directory);
+  const display = relative && !relative.startsWith("..") ? relative : directory;
+  const error = new Error(
+    `Could not find the content directory:
+
+  ${display}`
+  );
+  error.hint = "Check `content.directory` in your Riebeckite configuration.";
+  return error;
+}
 
 // src/content/content_links.ts
 var WIKILINK_PATTERN = /(!)?\[\[([^\]|#^]+)(?:[#^][^\]|]+)?(?:\|[^\]]+)?\]\]/g;
@@ -2768,7 +3754,7 @@ function readOptionalStableId(value, field) {
 
 // src/content/manifest_builder.ts
 var ManifestBuilder = class {
-  createEntry(slug, markdown, processed, contentIndex, location) {
+  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
@@ -2781,6 +3767,7 @@ var ManifestBuilder = class {
       publicLocation: location,
       title: getManifestTitle(slug, processed.frontmatter.title),
       frontmatter: processed.frontmatter,
+      publishing,
       html: processed.html,
       tags: uniqueStrings([
         ...normalizeFrontmatterTags(processed.frontmatter.tags),
@@ -2818,9 +3805,11 @@ var ManifestBuilder = class {
     const manifest = {
       entries,
       publicEntries: [...entries],
+      discoverableEntries: [...entries],
       bySlug,
       byContentId,
       byPermalink,
+      byRoutablePermalink: new Map(byPermalink),
       redirects: /* @__PURE__ */ new Map(),
       publicRedirects: /* @__PURE__ */ new Map(),
       byTag,
@@ -2831,7 +3820,10 @@ var ManifestBuilder = class {
       assets: [],
       clientEntries: [],
       diagnostics: [],
-      generatedOutputs: []
+      generatedOutputs: [],
+      folderLocations: /* @__PURE__ */ new Map(),
+      pageRoutes: [],
+      pagePaths: []
     };
     return { ...manifest, graph: createContentGraph(manifest) };
   }
@@ -2872,21 +3864,283 @@ function appendUniqueToMap(map, key, value) {
   map.set(key, values);
 }
 
+// src/content/output_dependency.ts
+function determineOutputChanges(input) {
+  const current = buildOutputInventory(
+    input.manifest,
+    input.pluginPageOutputs,
+    input.contentOutputDependencies
+  );
+  const previous = new Map(
+    (input.previousState?.outputs ?? []).map((output) => [output.path, output])
+  );
+  const changedContent = collectChangedContent(input);
+  const changedTags = collectChangedTags(
+    input.previousState,
+    input.manifest,
+    changedContent
+  );
+  const changedFolders = collectChangedFolders(
+    input.previousState,
+    input.manifest,
+    changedContent
+  );
+  const affected = /* @__PURE__ */ new Map();
+  const unchanged = [];
+  for (const output of current) {
+    if (isOutputAffected(output, changedContent, changedTags, changedFolders)) {
+      affected.set(output.path, output);
+    } else {
+      unchanged.push(output);
+    }
+  }
+  for (const output of current) {
+    const previousOutput = previous.get(output.path);
+    if (!previousOutput || output.kind !== previousOutput.kind) {
+      affected.set(output.path, output);
+    }
+  }
+  const currentPaths = new Set(current.map((output) => output.path));
+  const removed = [...previous.values()].filter(
+    (output) => !currentPaths.has(output.path)
+  );
+  const fullRegenerationRequired = current.some(
+    (output) => output.dependencies.some((dependency) => dependency.type === "unknown")
+  );
+  const affectedValues = [...affected.values()].sort(compareOutput);
+  const unchangedValues = unchanged.filter((output) => !affected.has(output.path)).sort(compareOutput);
+  return {
+    affected: affectedValues,
+    removed: removed.sort(compareOutput),
+    unchanged: unchangedValues,
+    fullRegenerationRequired,
+    candidateOutputCount: current.length,
+    affectedOutputCount: affectedValues.length,
+    removedOutputCount: removed.length,
+    unchangedOutputCount: unchangedValues.length
+  };
+}
+function buildOutputInventory(manifest, pluginPageOutputs = [], contentOutputDependencies = []) {
+  const outputs = /* @__PURE__ */ new Map();
+  for (const entry of manifest.publicEntries) {
+    addOutput(outputs, contentOutput(entry, contentOutputDependencies));
+  }
+  for (const [path5, redirect] of manifest.publicRedirects) {
+    addOutput(outputs, {
+      kind: "redirect",
+      path: htmlOutputPath(path5),
+      producer: `content:${redirect.slug}:redirect`,
+      dependencies: [{ type: "content", slug: redirect.slug }]
+    });
+  }
+  for (const output of pluginPageOutputs) {
+    addOutput(outputs, { ...output, path: htmlOutputPath(output.path) });
+  }
+  for (const output of manifest.generatedOutputs) {
+    addOutput(outputs, {
+      kind: "generated",
+      path: output.path,
+      producer: `plugin:${output.owner}`,
+      dependencies: output.dependencies ?? [{ type: "unknown" }]
+    });
+  }
+  return [...outputs.values()].sort(compareOutput);
+}
+function htmlOutputPath(pathname) {
+  const normalized = normalizePublicPath(pathname);
+  if (normalized === "/") return "index.html";
+  const withoutSlash = normalized.replace(/^\//, "");
+  if (pathname.endsWith("/")) return `${withoutSlash}/index.html`;
+  return `${withoutSlash}.html`;
+}
+function contentOutput(entry, dependencies) {
+  return {
+    kind: "content",
+    path: htmlOutputPath(entry.permalink),
+    producer: `content:${entry.slug}`,
+    dependencies: [{ type: "content", slug: entry.slug }, ...dependencies]
+  };
+}
+function isOutputAffected(output, changedContent, changedTags, changedFolders) {
+  for (const dependency of output.dependencies) {
+    if (dependency.type === "unknown") return true;
+    if (dependency.type === "global") return changedContent.size > 0;
+    if (dependency.type === "content" && changedContent.has(dependency.slug)) {
+      return true;
+    }
+    if (dependency.type === "tag" && changedTags.has(dependency.tag))
+      return true;
+    if (dependency.type === "folder" && changedFolders.has(dependency.folder)) {
+      return true;
+    }
+  }
+  return false;
+}
+function collectChangedContent(input) {
+  const changed = /* @__PURE__ */ new Set([
+    ...input.affectedContent.direct,
+    ...input.affectedContent.dependent,
+    ...input.changeSet.removed.filter(isMarkdownPath3).map(toSlug3)
+  ]);
+  const previousEntries = input.previousState?.manifestEntries ?? [];
+  const currentEntries = input.manifest.entries;
+  const previousBySlug = new Map(
+    previousEntries.map((entry) => [entry.slug, entry])
+  );
+  const currentBySlug = new Map(
+    currentEntries.map((entry) => [entry.slug, entry])
+  );
+  for (const slug of changed) {
+    for (const target of linkTargets(previousBySlug.get(slug)))
+      changed.add(target);
+    for (const target of linkTargets(currentBySlug.get(slug)))
+      changed.add(target);
+  }
+  return changed;
+}
+function collectChangedTags(previousState, manifest, changedContent) {
+  const previousBySlug = new Map(
+    (previousState?.manifestEntries ?? []).map((entry) => [entry.slug, entry])
+  );
+  const currentBySlug = new Map(
+    manifest.entries.map((entry) => [entry.slug, entry])
+  );
+  const tags = /* @__PURE__ */ new Set();
+  for (const slug of changedContent) {
+    for (const tag of previousBySlug.get(slug)?.tags ?? []) tags.add(tag);
+    for (const tag of currentBySlug.get(slug)?.tags ?? []) tags.add(tag);
+  }
+  return tags;
+}
+function collectChangedFolders(previousState, manifest, changedContent) {
+  const previousBySlug = new Map(
+    (previousState?.manifestEntries ?? []).map((entry) => [entry.slug, entry])
+  );
+  const currentBySlug = new Map(
+    manifest.entries.map((entry) => [entry.slug, entry])
+  );
+  const folders = /* @__PURE__ */ new Set();
+  for (const slug of changedContent) {
+    addFolderAncestors(folders, previousBySlug.get(slug)?.slug ?? slug);
+    addFolderAncestors(folders, currentBySlug.get(slug)?.slug ?? slug);
+  }
+  return folders;
+}
+function addFolderAncestors(folders, slug) {
+  const segments = slug.split("/");
+  segments.pop();
+  while (true) {
+    folders.add(segments.join("/"));
+    if (segments.length === 0) return;
+    segments.pop();
+  }
+}
+function linkTargets(entry) {
+  if (!entry) return [];
+  return entry.links.filter(
+    (link) => link.slug !== null
+  ).map((link) => link.slug);
+}
+function addOutput(outputs, output) {
+  outputs.set(output.path, output);
+}
+function normalizePublicPath(pathname) {
+  const path5 = `/${pathname.split("/").filter(Boolean).join("/")}`;
+  return path5 === "/" ? path5 : path5.replace(/\/$/, "");
+}
+function isMarkdownPath3(path5) {
+  return path5.endsWith(".md");
+}
+function toSlug3(path5) {
+  return path5.replace(/\.md$/, "");
+}
+function compareOutput(left, right) {
+  return left.path.localeCompare(right.path) || left.kind.localeCompare(right.kind);
+}
+
+// src/content/publishing.ts
+function resolvePublishingState(frontmatter, options) {
+  const explicitVisibility = resolveExplicitVisibility(frontmatter?.visibility);
+  const publishAt = resolvePublishAt(frontmatter?.publishAt);
+  if (explicitVisibility === "draft")
+    return state("draft", false, false, publishAt);
+  if (publishAt && publishAt.getTime() > options.buildTime.getTime()) {
+    return state("scheduled", false, false, publishAt);
+  }
+  if (explicitVisibility === "unlisted") {
+    return state("unlisted", true, false, publishAt);
+  }
+  if (explicitVisibility === "public" || publishAt) {
+    return state("public", true, true, publishAt);
+  }
+  const routable = isPublishable(options.strategy, frontmatter);
+  return state(routable ? "public" : "draft", routable, routable, publishAt);
+}
+function resolvePublishingBuildTime(input) {
+  if (input === void 0) return /* @__PURE__ */ new Date();
+  if (input instanceof Date) {
+    if (Number.isNaN(input.getTime()))
+      throw new Error("Invalid publishing build time.");
+    return new Date(input.getTime());
+  }
+  const parsed = new Date(input);
+  if (Number.isNaN(parsed.getTime()))
+    throw new Error("Invalid publishing build time.");
+  return parsed;
+}
+function resolveExplicitVisibility(value) {
+  if (value === void 0) return void 0;
+  if (value === "public" || value === "unlisted" || value === "draft")
+    return value;
+  throw new Error(
+    `Invalid content visibility "${String(value)}". Expected public, unlisted, or draft.`
+  );
+}
+function resolvePublishAt(value) {
+  if (value === void 0) return void 0;
+  if (!(typeof value === "string" || value instanceof Date)) {
+    throw new Error("Invalid publishAt. Expected an ISO 8601 date string.");
+  }
+  const parsed = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error(
+      `Invalid publishAt "${String(value)}". Expected an ISO 8601 date string.`
+    );
+  }
+  return new Date(parsed.getTime());
+}
+function state(visibility, routable, discoverable, publishAt) {
+  return {
+    visibility,
+    routable,
+    discoverable,
+    ...publishAt ? { publishAt } : {}
+  };
+}
+
 // src/content/content_manager.ts
+var CONTENT_PROCESSING_CONCURRENCY = 16;
 var ContentManager = class {
   constructor(content, exclude = [], pipelineOptions = {}) {
     this.pipelineOptions = pipelineOptions;
     this.pipelineOptions = {
       ...pipelineOptions,
-      plugins: pipelineOptions.plugins ?? pipelineOptions.config?.plugins
+      plugins: pipelineOptions.plugins ?? pipelineOptions.config?.plugins,
+      isRoutable: (slug) => this.isRoutable(slug)
     };
+    this.publishingBuildTime = resolvePublishingBuildTime(
+      pipelineOptions.publishingBuildTime
+    );
     this.source = typeof content === "string" ? pipelineOptions.config?.content.source ?? new FileSystemContentSource(content, [
       ...exclude,
       CONTENT_BUILD_STATE_EXCLUDE
     ]) : content;
     this.pipelineOptions = {
       ...this.pipelineOptions,
-      contentSource: this.source
+      contentSource: this.source,
+      onContentDependencies: (slug, dependencies) => {
+        this.trackedContentDependencies.set(slug, dependencies);
+      }
     };
     this.contentIndexBuilder = new ContentIndexBuilder(this.source);
     this.pluginRuntime = new PluginRuntime(this.pipelineOptions);
@@ -2900,7 +4154,8 @@ var ContentManager = class {
       getEntries: () => this.entryReader.getEntries(),
       readEntry: (entry) => this.entryReader.read(entry),
       getContentIndex: () => this.getContentIndex(),
-      pluginRuntime: this.pluginRuntime
+      pluginRuntime: this.pluginRuntime,
+      observability
     });
     this.buildCoordinator = new ContentBuildCoordinator({
       buildStatePath,
@@ -2915,13 +4170,22 @@ var ContentManager = class {
   manifestBuilder = new ManifestBuilder();
   pluginRuntime;
   contentIndex = null;
+  contentIndexPromise = null;
   contentCache = /* @__PURE__ */ new Map();
   manifest = null;
+  manifestPromise = null;
+  pipelineFingerprint = null;
   pipeline = null;
   entryReader;
   locationResolver;
   buildCoordinator;
   isBuildTime = false;
+  publishingBuildTime;
+  routableSlugs = null;
+  routableSlugsPromise = null;
+  processedContentCount = 0;
+  outputChangeSet = null;
+  trackedContentDependencies = /* @__PURE__ */ new Map();
   async getAllPosts() {
     return (await this.scan()).filter((entry) => entry.path.endsWith(".md")).map((entry) => ({ slug: entry.path.replace(/\.md$/, "") }));
   }
@@ -2933,17 +4197,33 @@ var ContentManager = class {
   }
   async getContentIndex(preparation) {
     if (this.contentIndex) return this.contentIndex;
+    if (!preparation && this.contentIndexPromise)
+      return await this.contentIndexPromise;
     if (preparation?.previousState && !hasContentChanges(preparation.changeSet)) {
       this.contentIndex = new Map(
         Object.entries(preparation.previousState.contentIndex)
       );
       return this.contentIndex;
     }
-    this.contentIndex = await this.contentIndexBuilder.build(
-      await this.entryReader.getEntries(),
-      (entry) => this.entryReader.read(entry)
+    if (preparation) {
+      this.contentIndex = preparation.currentContentIndex;
+      return this.contentIndex;
+    }
+    const promise = this.observability().tracer.span(
+      "content.index",
+      {},
+      async () => await this.contentIndexBuilder.build(
+        await this.entryReader.getEntries(),
+        (entry) => this.entryReader.read(entry)
+      )
     );
-    return this.contentIndex;
+    if (!preparation) this.contentIndexPromise = promise;
+    try {
+      this.contentIndex = await promise;
+      return this.contentIndex;
+    } finally {
+      if (!preparation) this.contentIndexPromise = null;
+    }
   }
   async getProcessedContent(slug) {
     const cached = this.contentCache.get(slug);
@@ -2960,6 +4240,7 @@ var ContentManager = class {
         ]);
         await this.pluginRuntime.startBuild(contentIndex);
         await this.pluginRuntime.runContentLoaded(slug, rawPost, contentIndex);
+        await this.ensureRoutableSlugs();
         this.pipeline ??= new Pipeline(
           contentIndex,
           await this.locationResolver.getPermalinks(),
@@ -2970,6 +4251,12 @@ var ContentManager = class {
         const content = await this.pipeline.execute(rawPost, {
           sourceSlug: slug
         });
+        this.processedContentCount += 1;
+        if (this.processedContentCount % 100 === 0) {
+          this.observability().tracer.event("content.process.sample", {
+            processed: this.processedContentCount
+          });
+        }
         await this.pluginRuntime.runPostHook(
           "onPostParsed",
           slug,
@@ -2990,9 +4277,24 @@ var ContentManager = class {
     );
   }
   async getManifest(options) {
+    if (this.manifest) return this.manifest;
+    if (this.manifestPromise) return await this.manifestPromise;
+    this.manifestPromise = this.buildManifest(options);
+    try {
+      return await this.manifestPromise;
+    } catch (error) {
+      this.manifestPromise = null;
+      throw error;
+    }
+  }
+  async buildManifest(options) {
     if (this.manifest) return this.manifest;
     this.enableBuildTime();
-    const preparation = options ? await this.buildCoordinator.getPreparation(options.incremental) : void 0;
+    const preparation = options ? await this.buildCoordinator.getPreparation(
+      options.incremental,
+      this.getPipelineFingerprint(),
+      this.requiresFullContentRegeneration()
+    ) : void 0;
     return await this.observability().tracer.span(
       "content.manifest",
       {},
@@ -3002,26 +4304,38 @@ var ContentManager = class {
           this.getContentIndex(preparation),
           this.getContentLocations()
         ]);
-        const entries = await Promise.all(
-          posts.map(async (post) => {
-            const [rawPost, processed] = await Promise.all([
-              this.getPost(post.slug),
-              this.getProcessedContent(post.slug)
-            ]);
-            const location = locations.get(post.slug);
-            if (!location) {
-              throw new Error(
-                `Content public location was not resolved: ${post.slug}`
+        const entries = await this.observability().tracer.span(
+          "content.manifest.entries",
+          {},
+          () => mapConcurrent3(
+            posts,
+            CONTENT_PROCESSING_CONCURRENCY,
+            async (post) => {
+              const reused = this.reuseManifestEntry(post.slug, preparation);
+              if (reused) return reused;
+              const [rawPost, processed] = await Promise.all([
+                this.getPost(post.slug),
+                this.getProcessedContent(post.slug)
+              ]);
+              const location = locations.get(post.slug);
+              if (!location) {
+                throw new Error(
+                  `Content public location was not resolved: ${post.slug}`
+                );
+              }
+              return this.manifestBuilder.createEntry(
+                post.slug,
+                rawPost,
+                processed,
+                contentIndex,
+                location,
+                resolvePublishingState(processed.frontmatter, {
+                  strategy: this.publishStrategy(),
+                  buildTime: this.publishingBuildTime
+                })
               );
             }
-            return this.manifestBuilder.createEntry(
-              post.slug,
-              rawPost,
-              processed,
-              contentIndex,
-              location
-            );
-          })
+          )
         );
         await this.pluginRuntime.runGraphHook(entries, contentIndex);
         const manifest = await this.observability().tracer.span(
@@ -3029,9 +4343,17 @@ var ContentManager = class {
           {},
           () => this.manifestBuilder.build(entries, contentIndex)
         );
+        const cacheManifestEntries = structuredClone(manifest.entries);
         this.locationResolver.populateRedirects(manifest, locations);
-        await this.pluginRuntime.runManifestCreated(manifest, contentIndex);
         this.applyPublicView(manifest);
+        manifest.pagePaths = [
+          ...await this.pluginRuntime.getPagePaths(manifest, contentIndex)
+        ];
+        manifest.pageRoutes = [
+          ...await this.pluginRuntime.getPageRoutes(manifest, contentIndex)
+        ];
+        await this.pluginRuntime.runManifestCreated(manifest, contentIndex);
+        this.synchronizeManifestHtml(manifest, cacheManifestEntries);
         manifest.assets = this.pluginRuntime.collectAssets();
         manifest.clientEntries = this.pluginRuntime.collectClientEntries();
         manifest.diagnostics = [
@@ -3040,8 +4362,39 @@ var ContentManager = class {
         ];
         await this.pluginRuntime.runBuildEnd(manifest, contentIndex);
         manifest.generatedOutputs = this.pluginRuntime.collectGeneratedOutputs();
+        const pluginPageOutputs = await this.pluginRuntime.getPageOutputs(
+          manifest,
+          contentIndex
+        );
+        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,
+            affectedOutputCount: this.outputChangeSet.affectedOutputCount,
+            removedOutputCount: this.outputChangeSet.removedOutputCount,
+            unchangedOutputCount: this.outputChangeSet.unchangedOutputCount,
+            fullRegenerationRequired: this.outputChangeSet.fullRegenerationRequired
+          });
+        }
         if (preparation)
-          await this.buildCoordinator.commit(preparation, manifest);
+          await this.buildCoordinator.commit(
+            preparation,
+            manifest,
+            this.getPipelineFingerprint(),
+            this.outputChangeSet ? [
+              ...this.outputChangeSet.affected,
+              ...this.outputChangeSet.unchanged
+            ] : [],
+            cacheManifestEntries,
+            this.trackedContentDependencies
+          );
         this.manifest = manifest;
         return manifest;
       }
@@ -3050,6 +4403,34 @@ var ContentManager = class {
   async build(options = {}) {
     return await this.getManifest(options);
   }
+  async getOutputChangeSet(options = {}) {
+    await this.getManifest(options);
+    if (!this.outputChangeSet) {
+      const manifest = await this.getManifest();
+      const contentIndex = await this.getContentIndex();
+      const pluginPageOutputs = await this.pluginRuntime.getPageOutputs(
+        manifest,
+        contentIndex
+      );
+      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;
+  }
   async getBacklinks(targetSlug) {
     const graph = await this.getContentGraph();
     return graph.incomingSlugs(targetSlug).map((slug) => ({
@@ -3104,19 +4485,106 @@ var ContentManager = class {
     return await this.locationResolver.getLocations();
   }
   applyPublicView(manifest) {
-    const strategy = this.pipelineOptions.config?.content.filters.publishStrategy ?? "explicit";
+    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) => isPublishable(strategy, entry.frontmatter)
+      (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, preparation) {
+    if (!preparation?.previousState?.manifestEntries) return null;
+    if (preparation.previousState.pipelineFingerprint !== this.getPipelineFingerprint()) {
+      return null;
+    }
+    if (preparation.affectedContent.direct.has(slug)) return null;
+    if (preparation.affectedContent.dependent.has(slug)) return null;
+    const entry = preparation.previousManifestEntriesBySlug.get(slug);
+    if (!entry) return null;
+    this.observability().tracer.event("content.reuse", { slug });
+    return cloneManifestEntry(entry);
+  }
+  getPipelineFingerprint() {
+    if (!this.pipelineOptions.config) return void 0;
+    this.pipelineFingerprint ??= computePipelineFingerprint(
+      this.pipelineOptions.config
+    );
+    return this.pipelineFingerprint;
+  }
+  requiresFullContentRegeneration() {
+    const config = this.pipelineOptions.config;
+    return config ? !isPersistentlyCacheable("", config).cacheable : false;
+  }
+  isRoutable(slug) {
+    if (!this.routableSlugs) {
+      throw new Error(`Publishing state was not resolved: ${slug}`);
+    }
+    return this.routableSlugs.has(slug);
+  }
+  async ensureRoutableSlugs() {
+    if (this.routableSlugs) return this.routableSlugs;
+    if (this.routableSlugsPromise) return await this.routableSlugsPromise;
+    this.routableSlugsPromise = this.resolveRoutableSlugs();
+    try {
+      this.routableSlugs = await this.routableSlugsPromise;
+      return this.routableSlugs;
+    } finally {
+      this.routableSlugsPromise = null;
+    }
+  }
+  async resolveRoutableSlugs() {
+    const strategy = this.publishStrategy();
+    const posts = await this.getAllPosts();
+    const routableSlugs = /* @__PURE__ */ new Set();
+    await mapConcurrent3(posts, CONTENT_PROCESSING_CONCURRENCY, async (post) => {
+      const markdown = await this.getPost(post.slug);
+      const publishing = resolvePublishingState(readFrontmatter(markdown), {
+        strategy,
+        buildTime: this.publishingBuildTime
+      });
+      if (publishing.routable) routableSlugs.add(post.slug);
+    });
+    return routableSlugs;
+  }
   enableBuildTime() {
     this.isBuildTime = true;
     this.pluginRuntime.enableBuildTime();
@@ -3125,6 +4593,43 @@ var ContentManager = class {
     return this.pipelineOptions.observability ?? noopObservability;
   }
 };
+function readFrontmatter(markdown) {
+  const file = new VFile2({ value: markdown });
+  matter3(file);
+  return file.data.matter ?? {};
+}
+function cloneManifestEntry(entry) {
+  return {
+    ...entry,
+    publicLocation: { ...entry.publicLocation },
+    frontmatter: { ...entry.frontmatter },
+    tags: [...entry.tags],
+    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 } } : {}
+  };
+}
+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) {
@@ -3135,6 +4640,74 @@ async function getContentSourceEntry(source, logicalPath) {
   return (await source.scan()).find((candidate) => candidate.path === logicalPath) ?? null;
 }
 
+// src/content/folder_entry.ts
+function resolveFolderEntry(manifest, folder, options = {}) {
+  const base = normalizeFolder2(folder);
+  const scope = options.scope ?? "routable";
+  const candidates = [];
+  for (const [kind, slug] of folderEntrySlugs(base)) {
+    if (slug === null) continue;
+    const entry = manifest.bySlug.get(slug);
+    if (!entry || !isInScope(entry, scope)) continue;
+    candidates.push({ kind, entry });
+  }
+  if (candidates.length === 0) return { type: "none" };
+  const candidate = candidates[0];
+  if (candidates.length === 1 && candidate) {
+    return { type: "resolved", kind: candidate.kind, entry: candidate.entry };
+  }
+  return { type: "ambiguous", candidates };
+}
+function resolveFolderLocation(manifest, folder) {
+  const resolution = resolveFolderEntry(manifest, folder);
+  const candidates = resolution.type === "ambiguous" ? resolution.candidates.filter((candidate) => candidate.kind !== "folder") : resolution.type === "resolved" && resolution.kind !== "folder" ? [{ kind: resolution.kind, entry: resolution.entry }] : [];
+  if (candidates.length === 1) {
+    const candidate = candidates[0];
+    if (candidate) return { type: "content", entry: candidate.entry };
+  }
+  if (candidates.length > 1) return { type: "ambiguous", candidates };
+  const location = manifest.folderLocations.get(normalizeFolder2(folder));
+  return location ? { type: "generated", pathname: location.pathname } : { type: "none" };
+}
+function resolveGeneratedFolderLocation(manifest, folder) {
+  const normalizedFolder = normalizeFolder2(folder);
+  if (!normalizedFolder) return null;
+  const candidates = /* @__PURE__ */ new Set();
+  const prefix = `${normalizedFolder}/`;
+  for (const entry of manifest.publicEntries) {
+    if (!entry.slug.startsWith(prefix)) continue;
+    const remainder = entry.slug.slice(prefix.length).split("/").filter(Boolean);
+    const pathname = parentPath(
+      entry.publicLocation.permalink,
+      remainder.length
+    );
+    if (pathname) candidates.add(pathname);
+  }
+  return candidates.size === 1 ? [...candidates][0] ?? null : null;
+}
+function folderEntrySlugs(base) {
+  const prefix = base === "" ? "" : `${base}/`;
+  return [
+    ["readme", `${prefix}README`],
+    ["index", `${prefix}index`],
+    ["folder", base === "" ? null : base]
+  ];
+}
+function isInScope(entry, scope) {
+  if (scope === "all") return true;
+  if (scope === "discoverable") return entry.publishing.discoverable;
+  return entry.publishing.routable;
+}
+function normalizeFolder2(folder) {
+  return folder.split("/").filter(Boolean).join("/");
+}
+function parentPath(pathname, levels) {
+  const segments = pathname.split("/").filter(Boolean);
+  if (segments.length < levels) return null;
+  const parent = segments.slice(0, -levels);
+  return parent.length === 0 ? "/" : `/${parent.join("/")}/`;
+}
+
 // src/content/graph_layout.ts
 function buildGraphEdges(nodes, visibleSlugs = new Set(nodes.map((node) => node.slug))) {
   const edges = /* @__PURE__ */ new Map();
@@ -3171,9 +4744,143 @@ function layoutRadialGraph(nodes, options) {
   });
   return layout;
 }
+function layoutForceGraph(nodes, options) {
+  const safeOptions = resolveForceGraphLayoutOptions(options);
+  const layoutNodes = [...nodes].sort((a, b) => a.slug.localeCompare(b.slug));
+  const layout = createInitialLayout(layoutNodes, safeOptions);
+  const visibleSlugs = new Set(layoutNodes.map((node) => node.slug));
+  const edges = buildGraphEdges(layoutNodes, visibleSlugs).filter(
+    (edge) => edge.source !== edge.target
+  );
+  const velocities = new Map(
+    layoutNodes.map((node) => [node.slug, { x: 0, y: 0 }])
+  );
+  const centerX = safeOptions.width / 2;
+  const centerY = safeOptions.height / 2;
+  for (let iteration = 0; iteration < safeOptions.iterations; iteration++) {
+    const alpha = 1 - iteration / safeOptions.iterations;
+    applyRepulsion(
+      layoutNodes,
+      layout,
+      velocities,
+      safeOptions.repulsion * alpha
+    );
+    applyLinks(edges, layout, velocities, safeOptions.linkDistance, alpha);
+    applyCentering(layoutNodes, layout, velocities, centerX, centerY, alpha);
+    integrate(
+      layoutNodes,
+      layout,
+      velocities,
+      safeOptions,
+      safeOptions.damping
+    );
+  }
+  return layout;
+}
+function resolveForceGraphLayoutOptions(options) {
+  const minNodeRadius = clampFinite(options.minNodeRadius ?? 8, 1, 64);
+  const maxNodeRadius = Math.max(
+    minNodeRadius,
+    clampFinite(options.maxNodeRadius ?? 14, minNodeRadius, 96)
+  );
+  return {
+    width: clampFinite(options.width, maxNodeRadius * 2, 2e4),
+    height: clampFinite(options.height, maxNodeRadius * 2, 2e4),
+    centerSlug: options.centerSlug,
+    linkDistance: clampFinite(options.linkDistance ?? 84, 1, 2e3),
+    repulsion: clampFinite(options.repulsion ?? 1800, 0, 1e5),
+    iterations: Math.round(clampFinite(options.iterations ?? 160, 0, 1e3)),
+    damping: clampFinite(options.damping ?? 0.82, 0, 1),
+    minNodeRadius,
+    maxNodeRadius
+  };
+}
+function createInitialLayout(nodes, options) {
+  return layoutRadialGraph(nodes, {
+    width: options.width,
+    height: options.height,
+    centerSlug: options.centerSlug ?? nodes[0]?.slug ?? "",
+    radiusRatio: 0.28,
+    minNodeRadius: options.minNodeRadius,
+    maxNodeRadius: options.maxNodeRadius
+  });
+}
+function applyRepulsion(nodes, layout, velocities, strength) {
+  for (let sourceIndex = 0; sourceIndex < nodes.length; sourceIndex++) {
+    for (let targetIndex = sourceIndex + 1; targetIndex < nodes.length; targetIndex++) {
+      const source = layout.get(nodes[sourceIndex]?.slug ?? "");
+      const target = layout.get(nodes[targetIndex]?.slug ?? "");
+      const sourceVelocity = velocities.get(nodes[sourceIndex]?.slug ?? "");
+      const targetVelocity = velocities.get(nodes[targetIndex]?.slug ?? "");
+      if (!source || !target || !sourceVelocity || !targetVelocity) continue;
+      const dx = target.x - source.x || 0.01;
+      const dy = target.y - source.y || 0.01;
+      const distanceSquared = Math.max(dx * dx + dy * dy, 64);
+      const force = strength / distanceSquared;
+      const distance = Math.sqrt(distanceSquared);
+      const fx = dx / distance * force;
+      const fy = dy / distance * force;
+      sourceVelocity.x -= fx;
+      sourceVelocity.y -= fy;
+      targetVelocity.x += fx;
+      targetVelocity.y += fy;
+    }
+  }
+}
+function applyLinks(edges, layout, velocities, linkDistance, alpha) {
+  for (const edge of edges) {
+    const source = layout.get(edge.source);
+    const target = layout.get(edge.target);
+    const sourceVelocity = velocities.get(edge.source);
+    const targetVelocity = velocities.get(edge.target);
+    if (!source || !target || !sourceVelocity || !targetVelocity) continue;
+    const dx = target.x - source.x || 0.01;
+    const dy = target.y - source.y || 0.01;
+    const distance = Math.max(Math.sqrt(dx * dx + dy * dy), 1);
+    const force = (distance - linkDistance) * 0.018 * alpha;
+    const fx = dx / distance * force;
+    const fy = dy / distance * force;
+    sourceVelocity.x += fx;
+    sourceVelocity.y += fy;
+    targetVelocity.x -= fx;
+    targetVelocity.y -= fy;
+  }
+}
+function applyCentering(nodes, layout, velocities, centerX, centerY, alpha) {
+  for (const node of nodes) {
+    const point = layout.get(node.slug);
+    const velocity = velocities.get(node.slug);
+    if (!point || !velocity) continue;
+    velocity.x += (centerX - point.x) * 4e-3 * alpha;
+    velocity.y += (centerY - point.y) * 4e-3 * alpha;
+  }
+}
+function integrate(nodes, layout, velocities, options, damping) {
+  for (const node of nodes) {
+    const point = layout.get(node.slug);
+    const velocity = velocities.get(node.slug);
+    if (!point || !velocity) continue;
+    velocity.x *= damping;
+    velocity.y *= damping;
+    point.x = clamp(
+      point.x + velocity.x,
+      point.radius,
+      options.width - point.radius
+    );
+    point.y = clamp(
+      point.y + velocity.y,
+      point.radius,
+      options.height - point.radius
+    );
+  }
+}
 function clamp(value, min, max) {
   return Math.min(Math.max(value, min), max);
 }
+function clampFinite(value, min, max) {
+  if (!Number.isFinite(value)) return min;
+  return clamp(value, min, max);
+}
 
 // src/content/read_only_content_graph.ts
 async function readOnlyContentGraph(source, locations) {
@@ -3183,7 +4890,7 @@ async function readOnlyContentGraph(source, locations) {
   const markdownContents = await Promise.all(
     markdownEntries.map(async (entry) => ({
       entry,
-      markdown: await readText2(source, entry)
+      markdown: await readText3(source, entry)
     }))
   );
   const graphEntries = markdownContents.map(
@@ -3203,6 +4910,13 @@ function createGraphEntry(entry, markdown, contentIndex, locations) {
     publicLocation: location,
     title: slug,
     frontmatter: {},
+    publishing: resolvePublishingState(
+      {},
+      {
+        strategy: "selective",
+        buildTime: /* @__PURE__ */ new Date(0)
+      }
+    ),
     html: "",
     tags: [],
     links: extractContentLinks(markdown, contentIndex),
@@ -3210,60 +4924,11 @@ function createGraphEntry(entry, markdown, contentIndex, locations) {
     assets: []
   };
 }
-async function readText2(source, entry) {
+async function readText3(source, entry) {
   const content = await source.read(entry);
   return typeof content === "string" ? content : new TextDecoder().decode(content);
 }
 
-// src/plugin/plugin_memo.ts
-import { createHash as createHash3 } from "node:crypto";
-function createPluginMemo(cache, options = {}) {
-  return {
-    async memo(key, dependencies, compute) {
-      const memoKey = `${key}:${hash2(stableStringify(dependencies))}`;
-      try {
-        const cached = await cache.get(memoKey);
-        if (cached !== void 0) return cached;
-      } catch (error) {
-        warn(
-          options.logger,
-          "Plugin cache read failed; recomputing.",
-          key,
-          error
-        );
-      }
-      const value = await compute();
-      try {
-        await cache.set(memoKey, value);
-      } catch (error) {
-        warn(
-          options.logger,
-          "Plugin cache write failed; result not cached.",
-          key,
-          error
-        );
-      }
-      return value;
-    }
-  };
-}
-function stableStringify(value) {
-  if (value === null || typeof value !== "object") return JSON.stringify(value);
-  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-  const keys = Object.keys(value).sort();
-  const body = keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",");
-  return `{${body}}`;
-}
-function hash2(value) {
-  return createHash3("sha256").update(value).digest("hex");
-}
-function warn(logger, message, key, error) {
-  logger?.warn(message, {
-    memoKey: key,
-    error: error instanceof Error ? error.message : String(error)
-  });
-}
-
 // src/types/content_manifest.ts
 function appendContentBodySlot(entry, slot, html) {
   if (!html.trim()) return;
@@ -3276,12 +4941,12 @@ ${html}` : html
 }
 
 // src/types/plugin_endpoint.ts
-function defineEndpoint(path4, handler, options = {}) {
+function defineEndpoint(path5, handler, options = {}) {
   if (options.cacheControl === void 0) {
-    return { path: path4, handler };
+    return { path: path5, handler };
   }
   return {
-    path: path4,
+    path: path5,
     handler: async (context) => {
       const response = await handler(context);
       const headers = { ...response.headers };
@@ -3323,6 +4988,7 @@ export {
   ContentManager,
   FileSystemContentSource,
   IMAGE_EXTENSIONS,
+  INTERNAL_CONTENT_IGNORE_PATTERNS,
   NoopLogger,
   NoopTracer,
   Pipeline,
@@ -3332,9 +4998,12 @@ export {
   attachmentUrl,
   buildContentCollections,
   buildGraphEdges,
+  buildOutputInventory,
   calculateReadingTime,
+  collectConfigDeprecationDiagnostics,
   createClientEntry,
   createContentGraph,
+  createDeprecationDiagnostic,
   createPluginMemo,
   createStyleAsset,
   createUnavailableGeneratedOutputSink,
@@ -3342,23 +5011,29 @@ export {
   defineEndpoint,
   definePlugin,
   defineTheme,
+  determineOutputChanges,
   escapeHtml,
   escapeHtmlAttribute,
   escapeScriptJson,
   extractFrontmatterAliases,
   fingerprintContentEntries,
+  formatDeprecationMessage,
   getContentSourceEntry,
   getExtension,
   getResolvedPluginMetadata,
   groupContentEntries,
+  htmlOutputPath,
   isAttachmentPath,
   isExcluded,
+  isIgnoredContentPath,
   isImagePath,
   isMarkdownPath,
   isPublishable,
   isPublished,
+  layoutForceGraph,
   layoutRadialGraph,
   loadContentBuildState,
+  normalizeContentAssetOutputPath,
   normalizeContentPath,
   normalizeGeneratedOutputPath,
   normalizeTag,
@@ -3373,7 +5048,12 @@ export {
   resolveContentQueryPagination,
   resolveContentStableId,
   resolveDefaultContentLocation,
+  resolveFolderEntry,
+  resolveFolderLocation,
+  resolveGeneratedFolderLocation,
   resolvePlugins,
+  resolvePublishingBuildTime,
+  resolvePublishingState,
   serializePublicClientConfig,
   stableStringify,
   stripHtml,