@riebeckite/core 0.0.16 → 0.0.18

package/dist/index.js

@@ -18,55 +18,12 @@ function validateConfigIssues(config) {
     return [{ path: "config", message: "Expected an object." }];
   }
   validateSite(value.site, issues);
-  validateNavigation(value.navigation, issues);
   validateContent(value.content, issues);
+  validateCache(value.cache, issues);
   validateTheme(value.theme, issues);
   validatePlugins(value.plugins, issues);
   return issues;
 }
-function validateNavigation(value, issues) {
-  if (value === void 0) return;
-  if (!isRecord(value)) {
-    issues.push({ path: "navigation", message: "Expected an object." });
-    return;
-  }
-  validateNavigationItems(value.header, "navigation.header", issues, /* @__PURE__ */ new Set());
-  validateNavigationItems(value.footer, "navigation.footer", issues, /* @__PURE__ */ new Set());
-}
-function validateNavigationItems(value, path5, issues, ancestors) {
-  if (value === void 0) return;
-  if (!Array.isArray(value)) {
-    issues.push({ path: path5, message: "Expected an array." });
-    return;
-  }
-  for (const [index, item] of value.entries()) {
-    const itemPath = `${path5}[${index}]`;
-    if (!isRecord(item)) {
-      issues.push({ path: itemPath, message: "Expected an object." });
-      continue;
-    }
-    if (ancestors.has(item)) {
-      issues.push({
-        path: itemPath,
-        message: "Navigation children must not be recursive."
-      });
-      continue;
-    }
-    validateRequiredString(item.label, `${itemPath}.label`, issues);
-    validateRequiredString(item.href, `${itemPath}.href`, issues);
-    validateOptionalBoolean(item.external, `${itemPath}.external`, issues);
-    if (item.children !== void 0) {
-      const nextAncestors = new Set(ancestors);
-      nextAncestors.add(item);
-      validateNavigationItems(
-        item.children,
-        `${itemPath}.children`,
-        issues,
-        nextAncestors
-      );
-    }
-  }
-}
 function validateSite(value, issues) {
   if (!isRecord(value)) {
     issues.push({ path: "site", message: "Expected an object." });
@@ -137,6 +94,15 @@ function validatePublishStrategy(value, issues) {
     });
   }
 }
+function validateCache(value, issues) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    issues.push({ path: "cache", message: "Expected an object." });
+    return;
+  }
+  validateOptionalBoolean(value.enabled, "cache.enabled", issues);
+  validateOptionalString(value.directory, "cache.directory", issues);
+}
 function validateTheme(value, issues) {
   if (value === void 0) return;
   if (!isRecord(value)) {
@@ -153,41 +119,41 @@ function validateTheme(value, issues) {
     }
   }
 }
-function validateThemeConfig(value, path5, issues) {
-  validateOptionalString(value.name, `${path5}.name`, issues);
+function validateThemeConfig(value, path6, issues) {
+  validateOptionalString(value.name, `${path6}.name`, issues);
   validateOneOf(
     value.colorMode,
-    `${path5}.colorMode`,
+    `${path6}.colorMode`,
     ["light", "dark", "system"],
     issues
   );
   validateOneOf(
     value.typography,
-    `${path5}.typography`,
+    `${path6}.typography`,
     ["system", "serif", "sans"],
     issues
   );
   validateOneOf(
     value.articleLayout,
-    `${path5}.articleLayout`,
+    `${path6}.articleLayout`,
     ["article", "sidebar", "full-width"],
     issues
   );
-  validateStringArray(value.userCss, `${path5}.userCss`, issues);
+  validateStringArray(value.userCss, `${path6}.userCss`, issues);
   if (value.attributes !== void 0 && !isRecord(value.attributes)) {
-    issues.push({ path: `${path5}.attributes`, message: "Expected an object." });
+    issues.push({ path: `${path6}.attributes`, message: "Expected an object." });
   }
 }
-function validateThemeStyles(value, path5, issues) {
+function validateThemeStyles(value, path6, issues) {
   if (value === void 0) return;
   if (!Array.isArray(value)) {
-    issues.push({ path: path5, message: "Expected an array." });
+    issues.push({ path: path6, message: "Expected an array." });
     return;
   }
   for (const [index, style] of value.entries()) {
     if (!isRecord(style) || !isNonEmptyString(style.moduleSpecifier)) {
       issues.push({
-        path: `${path5}[${index}].moduleSpecifier`,
+        path: `${path6}[${index}].moduleSpecifier`,
         message: "Expected a non-empty string."
       });
     }
@@ -207,69 +173,69 @@ function validatePlugins(value, issues) {
       continue;
     }
     const plugin = input;
-    const path5 = `plugins[${index}]`;
+    const path6 = `plugins[${index}]`;
     if (!isNonEmptyString(plugin.name)) {
       issues.push({
-        path: `${path5}.name`,
+        path: `${path6}.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: `${path5}.name`,
+          path: `${path6}.name`,
           message: `Duplicate plugin name "${plugin.name}" (also plugins[${duplicateIndex}]).`
         });
       } else {
         names.set(plugin.name, index);
       }
     }
-    validateOptionalBoolean(plugin.enabled, `${path5}.enabled`, issues);
-    validateCapabilityMetadata(plugin, path5, issues);
-    if (plugin.enabled !== false) validatePluginOptions(plugin, path5, issues);
+    validateOptionalBoolean(plugin.enabled, `${path6}.enabled`, issues);
+    validateCapabilityMetadata(plugin, path6, issues);
+    if (plugin.enabled !== false) validatePluginOptions(plugin, path6, issues);
   }
 }
-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 validateCapabilityMetadata(plugin, path6, issues) {
+  validateStringArray(plugin.provides, `${path6}.provides`, issues, true);
+  validateStringArray(plugin.requires, `${path6}.requires`, issues, true);
+  validateStringArray(plugin.optional, `${path6}.optional`, issues, true);
 }
-function validatePluginOptions(plugin, path5, issues) {
+function validatePluginOptions(plugin, path6, issues) {
   if (!plugin.validateOptions) return;
   try {
     const optionIssues = plugin.validateOptions(plugin.options) ?? [];
     for (const issue of optionIssues) {
       issues.push({
-        path: issue.path ? `${path5}.options.${issue.path}` : `${path5}.options`,
+        path: issue.path ? `${path6}.options.${issue.path}` : `${path6}.options`,
         message: issue.message
       });
     }
   } catch (error) {
     issues.push({
-      path: `${path5}.options`,
+      path: `${path6}.options`,
       message: `Validator failed: ${toErrorMessage(error)}`
     });
   }
 }
-function validateRequiredString(value, path5, issues) {
+function validateRequiredString(value, path6, issues) {
   if (!isNonEmptyString(value)) {
-    issues.push({ path: path5, message: "Expected a non-empty string." });
+    issues.push({ path: path6, message: "Expected a non-empty string." });
   }
 }
-function validateOptionalString(value, path5, issues) {
+function validateOptionalString(value, path6, issues) {
   if (value !== void 0 && typeof value !== "string") {
-    issues.push({ path: path5, message: "Expected a string." });
+    issues.push({ path: path6, message: "Expected a string." });
   }
 }
-function validateOptionalBoolean(value, path5, issues) {
+function validateOptionalBoolean(value, path6, issues) {
   if (value !== void 0 && typeof value !== "boolean") {
-    issues.push({ path: path5, message: "Expected a boolean." });
+    issues.push({ path: path6, message: "Expected a boolean." });
   }
 }
-function validateAbsoluteUrl(value, path5, issues) {
+function validateAbsoluteUrl(value, path6, issues) {
   if (value === void 0 || value === "") return;
   if (typeof value !== "string") {
-    issues.push({ path: path5, message: "Expected an absolute URL." });
+    issues.push({ path: path6, message: "Expected an absolute URL." });
     return;
   }
   try {
@@ -277,27 +243,27 @@ function validateAbsoluteUrl(value, path5, issues) {
     if (url.protocol !== "http:" && url.protocol !== "https:")
       throw new Error();
   } catch {
-    issues.push({ path: path5, message: "Expected an absolute HTTP(S) URL." });
+    issues.push({ path: path6, message: "Expected an absolute HTTP(S) URL." });
   }
 }
-function validateStringArray(value, path5, issues, nonEmpty = false) {
+function validateStringArray(value, path6, issues, nonEmpty = false) {
   if (value === void 0) return;
   if (!Array.isArray(value)) {
-    issues.push({ path: path5, message: "Expected an array." });
+    issues.push({ path: path6, message: "Expected an array." });
     return;
   }
   for (const [index, item] of value.entries()) {
     if (typeof item !== "string" || nonEmpty && !item.trim()) {
       issues.push({
-        path: `${path5}[${index}]`,
+        path: `${path6}[${index}]`,
         message: nonEmpty ? "Expected a non-empty string." : "Expected a string."
       });
     }
   }
 }
-function validateOneOf(value, path5, choices, issues) {
+function validateOneOf(value, path6, choices, issues) {
   if (value !== void 0 && (typeof value !== "string" || !choices.includes(value))) {
-    issues.push({ path: path5, message: `Expected one of: ${choices.join(", ")}.` });
+    issues.push({ path: path6, message: `Expected one of: ${choices.join(", ")}.` });
   }
 }
 function formatValidationIssues(issues) {
@@ -318,6 +284,74 @@ function toErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+// src/types/publish_strategy.ts
+function isPublishable(strategy, frontmatter) {
+  if (strategy === "explicit") {
+    return frontmatter?.publish === true;
+  }
+  return !(frontmatter?.private === true || frontmatter?.draft === true);
+}
+
+// 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/plugin/plugin_dependency_error.ts
 var PluginDependencyError = class extends Error {
   kind;
@@ -607,14 +641,6 @@ function getResolvedPluginMetadata(plugins) {
   }));
 }
 
-// src/types/publish_strategy.ts
-function isPublishable(strategy, frontmatter) {
-  if (strategy === "explicit") {
-    return frontmatter?.publish === true;
-  }
-  return !(frontmatter?.private === true || frontmatter?.draft === true);
-}
-
 // src/types/theme_config.ts
 function defineTheme(theme) {
   return theme;
@@ -669,23 +695,14 @@ function resolveConfig(config) {
         language: config.site?.feed?.language ?? config.site?.locale ?? "en"
       }
     },
-    navigation: {
-      header: config.navigation?.header ?? [],
-      footer: config.navigation?.footer ?? []
-    },
     content: {
-      directory: config.content?.directory ?? "../../content",
+      directory: config.content?.directory ?? "content",
       source: config.content?.source,
       exclude: config.content?.exclude ?? [],
       filters: {
         publishStrategy: config.content?.filters?.publishStrategy ?? "explicit"
       }
     },
-    markdown: {
-      syntaxHighlight: {
-        theme: config.markdown?.syntaxHighlight?.theme ?? ""
-      }
-    },
     theme,
     plugins: resolvePlugins(config.plugins),
     cache: {
@@ -723,10 +740,11 @@ function sanitizeThemeAttributes(attributes) {
     ).filter(([name]) => !reservedAttributes.has(name))
   );
 }
-function isPublished(config, frontmatter) {
-  if (frontmatter?.visibility === "unlisted") return true;
-  if (frontmatter?.visibility === "draft") return false;
-  return isPublishable(config.content.filters.publishStrategy, frontmatter);
+function isPublished(config, frontmatter, options = {}) {
+  return resolvePublishingState(frontmatter, {
+    strategy: config.content.filters.publishStrategy,
+    buildTime: resolvePublishingBuildTime(options.buildTime)
+  }).routable;
 }
 function isExcluded(patterns, relativePath) {
   const normalized = relativePath.replace(/\\/g, "/");
@@ -788,9 +806,9 @@ var configDeprecations = [];
 function collectConfigDeprecationDiagnostics(config, notices = configDeprecations) {
   return notices.filter((notice) => hasConfigPath(config, notice.path)).map(createDeprecationDiagnostic);
 }
-function hasConfigPath(config, path5) {
+function hasConfigPath(config, path6) {
   let value = config;
-  for (const segment of path5.split(".")) {
+  for (const segment of path6.split(".")) {
     if (!isRecord2(value) || !(segment in value)) return false;
     value = value[segment];
   }
@@ -853,7 +871,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 
 // src/content/content_build_state.ts
-var CONTENT_BUILD_STATE_VERSION = 6;
+var CONTENT_BUILD_STATE_VERSION = 8;
 var CONTENT_BUILD_STATE_DIRECTORY = ".riebeckite";
 var CONTENT_BUILD_STATE_EXCLUDE = `${CONTENT_BUILD_STATE_DIRECTORY}/**`;
 
@@ -1258,9 +1276,9 @@ function buildContentCollections(entries, definitions) {
 function normalizePageSize(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
 }
-function withPage(path5, index) {
-  if (index === 0) return path5;
-  const base = path5 === "/" ? "" : path5;
+function withPage(path6, index) {
+  if (index === 0) return path6;
+  const base = path6 === "/" ? "" : path6;
   return normalizePath(`${base}/page/${index + 1}`);
 }
 function defaultPath(context) {
@@ -1370,6 +1388,23 @@ function isResolvedNoteLink(link) {
   return link.kind === "note" && link.slug !== null;
 }
 
+// src/content/content_language.ts
+function getEntryLanguage(entry) {
+  return entry.publicLocation.language;
+}
+function selectEntriesByLanguage(entries, language) {
+  if (!language) {
+    return entries;
+  }
+  const localized = entries.filter(
+    (entry) => getEntryLanguage(entry) !== void 0
+  );
+  if (localized.length === 0) {
+    return entries;
+  }
+  return localized.filter((entry) => getEntryLanguage(entry) === language);
+}
+
 // src/content/content_location.ts
 function resolveDefaultContentLocation(content) {
   return {
@@ -1527,6 +1562,8 @@ import { matter as matter2 } from "vfile-matter";
 
 // src/content/content_dependency_tracker.ts
 import { createHash as createHash2 } from "node:crypto";
+var LINK_INDEX_PREFIX = "index:";
+var LINK_LOCATION_PREFIX = "location:";
 function createContentDependencyTracker(source) {
   const dependencies = /* @__PURE__ */ new Map();
   const record = (identity, content) => {
@@ -1572,6 +1609,30 @@ function dependencyKey(dependency) {
   return `${normalized.kind}:${normalized.id}`;
 }
 
+// src/content/content_links.ts
+var WIKILINK_PATTERN = /(!)?\[\[([^\]|#^]+)(?:[#^][^\]|]+)?(?:\|[^\]]+)?\]\]/g;
+function extractContentLinks(markdown, contentIndex) {
+  WIKILINK_PATTERN.lastIndex = 0;
+  const links = [];
+  for (let match = WIKILINK_PATTERN.exec(markdown); match !== null; match = WIKILINK_PATTERN.exec(markdown)) {
+    const rawTarget = match[2]?.trim();
+    if (!rawTarget) continue;
+    const resolved = contentIndex.get(rawTarget.toLowerCase()) ?? null;
+    links.push({
+      raw: rawTarget,
+      slug: resolved,
+      kind: resolved ? linkKind(resolved) : "unresolved",
+      embed: match[1] === "!"
+    });
+  }
+  return links;
+}
+function linkKind(value) {
+  if (isImagePath(value)) return "image";
+  if (isAttachmentPath(value)) return "attachment";
+  return "note";
+}
+
 // src/content/content_persistent_cache.ts
 import { createHash as createHash4 } from "node:crypto";
 import fs2 from "node:fs/promises";
@@ -1768,7 +1829,6 @@ function computePipelineFingerprint(config) {
   const fingerprintData = {
     compatibilityVersion: CONTENT_CACHE_COMPATIBILITY_VERSION,
     plugins: plugins.map((p) => pluginFingerprint(p)),
-    markdown: config.markdown,
     content: {
       filters: config.content.filters
     }
@@ -1933,6 +1993,7 @@ async function writeAtomically2(targetPath, versionDirectory2, serialized) {
 }
 function resolvePluginCacheDirectory(config) {
   if (!config) return path3.resolve(process.cwd(), ".riebeckite", "cache");
+  if (config.cache?.directory) return config.cache.directory;
   if (config.buildDirectory) return path3.join(config.buildDirectory, "cache");
   return path3.resolve(config.content.directory, "..", ".riebeckite", "cache");
 }
@@ -2201,6 +2262,9 @@ var Pipeline = class {
       frontmatter: file.data.matter || {},
       html: String(file.value)
     };
+    if (embedDepth === 0 && sourceSlug && dependencyTracker) {
+      this.recordNoteLinkDependencies(markDownContent, dependencyTracker);
+    }
     if (sourceSlug && dependencyTracker) {
       this.reportContentDependencies(
         sourceSlug,
@@ -2250,6 +2314,25 @@ var Pipeline = class {
       this.options.isRoutable
     );
   }
+  recordNoteLinkDependencies(markdown, dependencyTracker) {
+    for (const link of extractContentLinks(markdown, this.contentIndex)) {
+      if (link.slug !== null && link.kind === "note") {
+        const id = `${LINK_LOCATION_PREFIX}${link.slug}`;
+        dependencyTracker.recordLinkResolution(
+          id,
+          this.resolveLinkDependency(id)
+        );
+        continue;
+      }
+      if (link.kind === "unresolved") {
+        const id = `${LINK_INDEX_PREFIX}${link.raw.toLowerCase()}`;
+        dependencyTracker.recordLinkResolution(
+          id,
+          this.resolveLinkDependency(id)
+        );
+      }
+    }
+  }
   use(processor, plugin, options) {
     const register = processor.use.bind(processor);
     if (options === void 0) {
@@ -2353,8 +2436,6 @@ 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)) ?? "";
@@ -2443,9 +2524,9 @@ function resolveRelativeMarkdownSlug(sourceSlug, targetPath) {
   }
   return normalizedParts.join("/").replace(/\.md$/i, "");
 }
-function decodeUriPath(path5) {
+function decodeUriPath(path6) {
   try {
-    return decodeURI(path5);
+    return decodeURI(path6);
   } catch {
     return null;
   }
@@ -2533,16 +2614,16 @@ var GeneratedOutputRegistry = class {
   outputs = [];
   owners = /* @__PURE__ */ new Map();
   sinkFor(pluginName) {
-    const register = (path5, output) => {
-      const owner = this.owners.get(path5);
+    const register = (path6, output) => {
+      const owner = this.owners.get(path6);
       if (owner) {
         throw new Error(
-          `Duplicate generated output path "${path5}" declared by "${owner}" and "${pluginName}".`
+          `Duplicate generated output path "${path6}" declared by "${owner}" and "${pluginName}".`
         );
       }
-      this.owners.set(path5, pluginName);
+      this.owners.set(path6, pluginName);
       this.outputs.push({
-        path: path5,
+        path: path6,
         content: output.content,
         dependencies: output.dependencies,
         owner: pluginName
@@ -2565,12 +2646,29 @@ var GeneratedOutputRegistry = class {
 };
 
 // src/plugin/plugin_lifecycle.ts
-var PluginLifecycleError = class extends Error {
+var PluginHookError = class extends Error {
+  path;
   constructor(pluginName, hookName, cause) {
     super(`Plugin "${pluginName}" failed during "${hookName}"`, { cause });
-    this.name = "PluginLifecycleError";
+    this.name = "PluginHookError";
+    const path6 = cause?.path;
+    if (typeof path6 === "string") this.path = path6;
   }
 };
+async function runPluginHook(plugin, hookName, context, hook) {
+  try {
+    return await context.tracer.span(
+      `plugin.${hookName}`,
+      {
+        plugin: plugin.name,
+        hook: hookName
+      },
+      () => hook(context)
+    );
+  } catch (error) {
+    throw new PluginHookError(plugin.name, hookName, error);
+  }
+}
 async function runSetup(plugins, createContext) {
   await runLifecycleHook(
     plugins,
@@ -2607,19 +2705,7 @@ async function runLifecycleHook(plugins, hookName, getHook, createContext) {
   for (const plugin of plugins) {
     const hook = getHook(plugin);
     if (!hook) continue;
-    try {
-      const context = createContext(plugin);
-      await context.tracer.span(
-        `plugin.${hookName}`,
-        {
-          plugin: plugin.name,
-          hook: hookName
-        },
-        () => hook(context)
-      );
-    } catch (error) {
-      throw new PluginLifecycleError(plugin.name, hookName, error);
-    }
+    await runPluginHook(plugin, hookName, createContext(plugin), hook);
   }
 }
 
@@ -2637,6 +2723,7 @@ var PluginRuntime = class {
   generatedOutputs = new GeneratedOutputRegistry();
   isBuildTime = false;
   resolvedPlugins = null;
+  pageDeclarations = /* @__PURE__ */ new WeakMap();
   getDiagnostics() {
     return this.diagnostics;
   }
@@ -2647,7 +2734,7 @@ var PluginRuntime = class {
    * Starts the plugin build lifecycle exactly once, regardless of which public
    * entry point (content processing or location resolution) reaches it first.
    * Concurrent callers await the same run, so the ordered hooks
-   * (`setup` → `buildStart` → `onBuildStart` → `onConfigResolved`) are never
+   * (`setup` → `buildStart` → `onConfigResolved`) are never
    * duplicated and no caller proceeds before the lifecycle completes.
    */
   startBuild(contentIndex) {
@@ -2655,7 +2742,7 @@ var PluginRuntime = class {
     return this.buildLifecycle;
   }
   async runContentLoaded(slug, markdown, contentIndex) {
-    await this.runHook((plugin) => plugin.onContentLoaded, {
+    await this.runHook("onContentLoaded", (plugin) => plugin.onContentLoaded, {
       ...this.createContext(contentIndex),
       slug,
       markdown
@@ -2667,22 +2754,30 @@ var PluginRuntime = class {
     for (const plugin of this.plugins()) {
       const resolver = plugin.resolveContentLocations;
       if (!resolver) continue;
-      const resolved = await resolver(
-        this.createPluginContext(plugin, context)
+      const pluginContext = this.createPluginContext(plugin, context);
+      const resolved = await runPluginHook(
+        plugin,
+        "resolveContentLocations",
+        pluginContext,
+        resolver
       );
       locations.push(...resolved);
     }
     return locations;
   }
   async extendContentLocations(entries, locations, contentIndex) {
-    await this.runHook((plugin) => plugin.extendContentLocations, {
-      ...this.createContext(contentIndex),
-      entries,
-      locations
-    });
+    await this.runHook(
+      "extendContentLocations",
+      (plugin) => plugin.extendContentLocations,
+      {
+        ...this.createContext(contentIndex),
+        entries,
+        locations
+      }
+    );
   }
   async runPostHook(hookName, slug, markdown, content, contentIndex) {
-    await this.runHook((plugin) => plugin[hookName], {
+    await this.runHook(hookName, (plugin) => plugin[hookName], {
       ...this.createContext(contentIndex),
       slug,
       markdown,
@@ -2690,16 +2785,24 @@ var PluginRuntime = class {
     });
   }
   async runGraphHook(entries, contentIndex) {
-    await this.runHook((plugin) => plugin.extendContentGraph, {
-      ...this.createContext(contentIndex),
-      entries
-    });
+    await this.runHook(
+      "extendContentGraph",
+      (plugin) => plugin.extendContentGraph,
+      {
+        ...this.createContext(contentIndex),
+        entries
+      }
+    );
   }
   async runManifestCreated(manifest, contentIndex) {
-    await this.runHook((plugin) => plugin.onManifestCreated, {
-      ...this.createContext(contentIndex),
-      manifest
-    });
+    await this.runHook(
+      "onManifestCreated",
+      (plugin) => plugin.onManifestCreated,
+      {
+        ...this.createContext(contentIndex),
+        manifest
+      }
+    );
   }
   async runBuildEnd(manifest, contentIndex) {
     const context = {
@@ -2710,10 +2813,6 @@ var PluginRuntime = class {
       this.plugins(),
       (plugin) => this.createPluginContext(plugin, context)
     );
-    await this.runHook((plugin) => plugin.onBuildEnd, {
-      ...this.createContext(contentIndex),
-      manifest
-    });
   }
   enableBuildTime() {
     this.isBuildTime = true;
@@ -2795,63 +2894,74 @@ var PluginRuntime = class {
     return highest[0].page;
   }
   async getPagePaths(manifest, contentIndex) {
-    const paths = [];
-    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 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)];
+    return [
+      ...new Set(
+        (await this.getPageDeclarations(manifest, contentIndex)).map(
+          (declaration) => declaration.pathname
+        )
+      )
+    ];
   }
   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 routes;
+    return (await this.getPageDeclarations(manifest, contentIndex)).map(
+      ({ pathname, plugin, pageType }) => ({
+        pathname,
+        pluginName: plugin.name,
+        pageType: pageType.id
+      })
+    );
   }
   async getPageOutputs(manifest, contentIndex) {
-    const outputs = [];
+    const outputs = await Promise.all(
+      (await this.getPageDeclarations(manifest, contentIndex)).map(
+        async ({ pathname, plugin, pageType }) => {
+          const context = {
+            ...this.createContext(contentIndex),
+            manifest,
+            pathname
+          };
+          const dependencies = pageType.outputDependencies ? typeof pageType.outputDependencies === "function" ? await pageType.outputDependencies(
+            this.createPluginContext(plugin, context)
+          ) : pageType.outputDependencies : [{ type: "unknown" }];
+          return {
+            output: {
+              kind: "plugin-page",
+              path: pathname,
+              producer: `plugin:${plugin.name}:page:${pageType.id}`,
+              dependencies
+            },
+            priority: pageType.priority ?? 0
+          };
+        }
+      )
+    );
+    return uniqueOutputs(outputs);
+  }
+  async getPageDeclarations(manifest, contentIndex) {
+    const existing = this.pageDeclarations.get(manifest);
+    if (existing) return await existing;
+    const declarations = this.resolvePageDeclarations(manifest, contentIndex);
+    this.pageDeclarations.set(manifest, declarations);
+    return await declarations;
+  }
+  async resolvePageDeclarations(manifest, contentIndex) {
+    const declarations = [];
     const context = { ...this.createContext(contentIndex), manifest };
     for (const plugin of this.plugins()) {
       for (const pageType of plugin.pageTypes ?? []) {
-        const 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
+        const paths = pageType.paths;
+        if (!paths) continue;
+        const resolved = typeof paths === "function" ? await paths(this.createPluginContext(plugin, context)) : paths;
+        for (const pathname of resolved) {
+          declarations.push({
+            pathname: normalizePageTypePath(pathname, pageType),
+            plugin,
+            pageType
           });
         }
       }
     }
-    return uniqueOutputs(outputs);
+    return declarations;
   }
   getContentOutputDependencies() {
     return this.plugins().flatMap((plugin) => plugin.outputDependencies ?? []);
@@ -2862,9 +2972,13 @@ var PluginRuntime = class {
       const results = [];
       const context = this.createContext(contentIndex);
       for (const plugin of this.plugins()) {
-        const diagnostics = await plugin.addDiagnostics?.(
-          this.createPluginContext(plugin, context)
-        );
+        const hook = plugin.addDiagnostics;
+        const diagnostics = hook ? await runPluginHook(
+          plugin,
+          "addDiagnostics",
+          this.createPluginContext(plugin, context),
+          hook
+        ) : void 0;
         for (const diagnostic of diagnostics ?? []) {
           results.push({
             ...diagnostic,
@@ -2893,13 +3007,13 @@ var PluginRuntime = class {
         stage: "buildStart",
         run: () => runBuildStart(this.plugins(), createPluginContext)
       },
-      {
-        stage: "onBuildStart",
-        run: () => this.runHook((plugin) => plugin.onBuildStart, context)
-      },
       {
         stage: "onConfigResolved",
-        run: () => this.runHook((plugin) => plugin.onConfigResolved, context)
+        run: () => this.runHook(
+          "onConfigResolved",
+          (plugin) => plugin.onConfigResolved,
+          context
+        )
       }
     ];
     for (const { stage, run } of stages) {
@@ -2944,18 +3058,12 @@ var PluginRuntime = class {
     this.pluginCaches.set(plugin.name, cache);
     return cache;
   }
-  async runHook(hook, context) {
+  async runHook(hookName, hook, context) {
     for (const plugin of this.plugins()) {
       const pluginHook = hook(plugin);
       if (!pluginHook) continue;
       const pluginContext = this.createPluginContext(plugin, context);
-      await pluginContext.tracer.span(
-        "plugin.hook",
-        {
-          plugin: plugin.name
-        },
-        () => pluginHook(pluginContext)
-      );
+      await runPluginHook(plugin, hookName, pluginContext, pluginHook);
     }
   }
   observability() {
@@ -3029,22 +3137,40 @@ function normalizePageTypePath(pathname, pageType) {
   return pageType.directoryIndex ? normalizeDirectoryPagePath(pathname) : normalizePagePath(pathname);
 }
 function normalizeDirectoryPagePath(pathname) {
-  const path5 = normalizePagePath(pathname);
-  return path5 === "/" ? path5 : `${path5}/`;
+  const path6 = normalizePagePath(pathname);
+  return path6 === "/" ? path6 : `${path6}/`;
 }
 function normalizePagePath(pathname) {
-  const path5 = `/${pathname.split("/").filter(Boolean).join("/")}`;
-  return path5 === "/" ? path5 : path5.replace(/\/$/, "");
+  const path6 = `/${pathname.split("/").filter(Boolean).join("/")}`;
+  return path6 === "/" ? path6 : path6.replace(/\/$/, "");
 }
 function countSeverity(diagnostics, severity) {
   return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
 }
 function uniqueOutputs(outputs) {
   const byPath = /* @__PURE__ */ new Map();
-  for (const output of outputs) byPath.set(output.path, output);
-  return [...byPath.values()].sort(
-    (left, right) => left.path.localeCompare(right.path)
-  );
+  for (const output of outputs) {
+    const previous = byPath.get(output.output.path);
+    if (!previous || output.priority > previous.priority) {
+      byPath.set(output.output.path, output);
+      continue;
+    }
+    if (output.output.producer === previous.output.producer) continue;
+    if (output.priority === previous.priority) {
+      throw new Error(
+        `Multiple plugin page types declare ${output.output.path} at priority ${output.priority}: ${previous.output.producer}, ${output.output.producer}`
+      );
+    }
+  }
+  return [...byPath.values()].map(({ output }) => output).sort((left, right) => left.path.localeCompare(right.path));
+}
+
+// src/utils/error.ts
+function attachErrorPath(error, path6) {
+  if (error instanceof Error && error.path === void 0) {
+    error.path = path6;
+  }
+  return error;
 }
 
 // src/content/affected_content.ts
@@ -3067,9 +3193,9 @@ function determineAffectedContent(changeSet, previousState, currentPaths, curren
       previousState.contentIndex,
       currentContentIndex
     );
-    for (const [path5, entry] of Object.entries(previousState.entries)) {
-      if (!isMarkdownPath2(path5)) continue;
-      const slug = toDependencyId(path5);
+    for (const [path6, entry] of Object.entries(previousState.entries)) {
+      if (!isMarkdownPath2(path6)) continue;
+      const slug = toDependencyId(path6);
       if (direct.has(slug) || dependent.has(slug)) continue;
       if (!entry.linkTargets?.some((target) => changedIndexKeys.has(target))) {
         continue;
@@ -3106,27 +3232,27 @@ function findChangedIndexKeys(previousIndex, currentIndex) {
   return changed;
 }
 function addAllNotes(target, currentPaths, exclude) {
-  for (const path5 of currentPaths) {
-    if (!isMarkdownPath2(path5)) continue;
-    const slug = toDependencyId(path5);
+  for (const path6 of currentPaths) {
+    if (!isMarkdownPath2(path6)) continue;
+    const slug = toDependencyId(path6);
     if (exclude?.has(slug)) continue;
     target.add(slug);
   }
 }
-function isMarkdownPath2(path5) {
-  return path5.endsWith(".md");
+function isMarkdownPath2(path6) {
+  return path6.endsWith(".md");
 }
-function toDependencyId(path5) {
-  return path5.replace(/\.md$/, "");
+function toDependencyId(path6) {
+  return path6.replace(/\.md$/, "");
 }
-function toDependency(path5) {
-  return isMarkdownPath2(path5) ? { kind: "content", id: toDependencyId(path5) } : { kind: "file", id: path5.replace(/\\/g, "/") };
+function toDependency(path6) {
+  return isMarkdownPath2(path6) ? { kind: "content", id: toDependencyId(path6) } : { kind: "file", id: path6.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 [path6, entry] of Object.entries(state2.entries)) {
+    if (!isMarkdownPath2(path6)) continue;
+    const slug = toDependencyId(path6);
     for (const dependency of entry.dependencies) {
       const key = dependencyKey2(dependency);
       const values = dependents.get(key) ?? /* @__PURE__ */ new Set();
@@ -3148,18 +3274,18 @@ function diffContentEntries(previous, current) {
   const added = [];
   const changed = [];
   const unchanged = [];
-  for (const [path5, fingerprint] of currentFingerprints) {
-    const previousEntry = previous.entries[path5];
+  for (const [path6, fingerprint] of currentFingerprints) {
+    const previousEntry = previous.entries[path6];
     if (!previousEntry) {
-      added.push(path5);
+      added.push(path6);
     } else if (previousEntry.fingerprint !== fingerprint) {
-      changed.push(path5);
+      changed.push(path6);
     } else {
-      unchanged.push(path5);
+      unchanged.push(path6);
     }
   }
   const removed = Object.keys(previous.entries).filter(
-    (path5) => !currentFingerprints.has(path5)
+    (path6) => !currentFingerprints.has(path6)
   );
   return sortChangeSet({ added, changed, removed, unchanged });
 }
@@ -3171,9 +3297,6 @@ function allContentChanged(entries) {
     unchanged: []
   });
 }
-function hasContentChanges(changeSet) {
-  return changeSet.added.length > 0 || changeSet.changed.length > 0 || changeSet.removed.length > 0;
-}
 function sortChangeSet(changeSet) {
   return {
     added: [...changeSet.added].sort(),
@@ -3249,54 +3372,73 @@ var ContentIndexBuilder = class _ContentIndexBuilder {
   }
   source;
   async build(contentEntries, read = (entry) => this.source.read(entry)) {
-    const index = /* @__PURE__ */ new Map();
+    const candidates = /* @__PURE__ */ new Map();
     for (const contentEntry of contentEntries) {
-      await this.indexContentEntry(index, contentEntry, read);
+      await this.indexContentEntry(candidates, contentEntry, read);
     }
-    return index;
+    return resolveContentIndex(candidates);
   }
   static buildFromAliases(contentEntries, aliasesByPath) {
-    const index = /* @__PURE__ */ new Map();
+    const candidates = /* @__PURE__ */ new Map();
     for (const contentEntry of contentEntries) {
       _ContentIndexBuilder.indexContentEntryFromAliases(
-        index,
+        candidates,
         contentEntry,
         aliasesByPath.get(contentEntry.path) ?? []
       );
     }
-    return index;
+    return resolveContentIndex(candidates);
   }
-  async indexContentEntry(index, contentEntry, read) {
+  async indexContentEntry(candidates, contentEntry, read) {
     const aliases = contentEntry.path.toLowerCase().endsWith(".md") ? extractFrontmatterAliases(readText(await read(contentEntry))) : [];
     _ContentIndexBuilder.indexContentEntryFromAliases(
-      index,
+      candidates,
       contentEntry,
       aliases
     );
   }
-  static indexContentEntryFromAliases(index, contentEntry, aliases) {
+  static indexContentEntryFromAliases(candidates, contentEntry, aliases) {
     const contentPath = contentEntry.path;
     const ext = contentPath.split(".").pop()?.toLowerCase() ?? "";
     const value = ext === "md" ? contentPath.replace(/\.md$/, "") : contentPath;
     const parts = value.split("/");
     for (let i = parts.length - 1; i >= 0; i--) {
       const rawSuffix = parts.slice(i).join("/");
-      addIndexEntry(index, rawSuffix, value);
+      addCandidate(candidates, rawSuffix, value);
       if (ext !== "md") {
-        addIndexEntry(index, rawSuffix.replace(/\.[^/.]+$/, ""), value);
+        addCandidate(candidates, rawSuffix.replace(/\.[^/.]+$/, ""), value);
       }
     }
     if (ext === "md") {
-      for (const alias of aliases) addIndexEntry(index, alias, value);
+      for (const alias of aliases) addCandidate(candidates, alias, value);
     }
   }
 };
+function resolveContentIndex(candidates) {
+  const index = /* @__PURE__ */ new Map();
+  const ambiguities = /* @__PURE__ */ new Map();
+  for (const [key, values] of candidates) {
+    const list = [...values].sort(compareCandidates);
+    const [only] = list;
+    if (list.length === 1 && only !== void 0) {
+      index.set(key, only);
+      continue;
+    }
+    ambiguities.set(key, list);
+  }
+  return { index, ambiguities };
+}
+function compareCandidates(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
 function readText(content) {
   return typeof content === "string" ? content : new TextDecoder().decode(content);
 }
-function addIndexEntry(index, key, value) {
+function addCandidate(candidates, key, value) {
   const normalizedKey = key.toLowerCase();
-  if (!index.has(normalizedKey)) index.set(normalizedKey, value);
+  const values = candidates.get(normalizedKey) ?? /* @__PURE__ */ new Set();
+  values.add(value);
+  candidates.set(normalizedKey, values);
 }
 
 // src/content/content_build_coordinator.ts
@@ -3379,7 +3521,10 @@ var ContentBuildCoordinator = class {
       previousState,
       changeSet
     );
-    const currentContentIndex = await this.dependencies.observability.tracer.span(
+    const {
+      index: currentContentIndex,
+      ambiguities: currentContentIndexAmbiguities
+    } = await this.dependencies.observability.tracer.span(
       "content.index",
       {},
       () => ContentIndexBuilder.buildFromAliases(
@@ -3417,6 +3562,7 @@ var ContentBuildCoordinator = class {
       currentEntries,
       currentContentAliases,
       currentContentIndex,
+      currentContentIndexAmbiguities,
       changeSet,
       affectedContent: affected
     };
@@ -3444,8 +3590,8 @@ var ContentBuildCoordinator = class {
 function readText2(content) {
   return typeof content === "string" ? content : new TextDecoder().decode(content);
 }
-function toSlug(path5) {
-  return path5.replace(/\.md$/, "");
+function toSlug(path6) {
+  return path6.replace(/\.md$/, "");
 }
 function collectDependencies2(manifestEntry, trackedDependencies) {
   if (!manifestEntry) return [];
@@ -3459,8 +3605,8 @@ function collectDependencies2(manifestEntry, trackedDependencies) {
           kind: "file",
           id: asset.path.replace(/\\/g, "/")
         })),
-        ...trackedDependencies.filter(
-          (dependency) => dependency.kind === "content" || dependency.kind === "file"
+        ...trackedDependencies.map(toBuildDependency).filter(
+          (dependency) => dependency !== null
         ).map((dependency) => ({
           kind: dependency.kind,
           id: dependency.id.replace(/\\/g, "/")
@@ -3474,6 +3620,18 @@ function collectDependencies2(manifestEntry, trackedDependencies) {
     (left, right) => `${left.kind}:${left.id}`.localeCompare(`${right.kind}:${right.id}`)
   );
 }
+function toBuildDependency(dependency) {
+  if (dependency.kind === "content" || dependency.kind === "file") {
+    return { kind: dependency.kind, id: dependency.id };
+  }
+  if (dependency.id.startsWith(LINK_LOCATION_PREFIX)) {
+    return {
+      kind: "content",
+      id: dependency.id.slice(LINK_LOCATION_PREFIX.length)
+    };
+  }
+  return null;
+}
 function collectLinkTargets(manifestEntry) {
   if (!manifestEntry) return [];
   return [
@@ -3616,8 +3774,8 @@ var ContentLocationResolver = class {
     }
   }
 };
-function toSlug2(path5) {
-  return path5.replace(/\.md$/, "");
+function toSlug2(path6) {
+  return path6.replace(/\.md$/, "");
 }
 async function mapConcurrent2(values, concurrency, map) {
   const results = new Array(values.length);
@@ -3663,8 +3821,17 @@ var FileSystemContentSource = class {
   contentDirectory;
   exclude;
   async scan() {
+    return (await this.scanWithExclusions()).entries;
+  }
+  async scanWithExclusions() {
+    const exclusions = [];
     try {
-      return await this.scanDirectory(this.contentDirectory, "");
+      const entries = await this.scanDirectory(
+        this.contentDirectory,
+        "",
+        exclusions
+      );
+      return { entries, exclusions };
     } catch (error) {
       if (isMissingDirectoryError(error, this.contentDirectory)) {
         throw missingContentDirectoryError(this.contentDirectory);
@@ -3680,7 +3847,7 @@ var FileSystemContentSource = class {
     }
     return await fs4.readFile(filePath);
   }
-  async scanDirectory(directory, parentPath2) {
+  async scanDirectory(directory, parentPath2, exclusions) {
     const directoryEntries = await fs4.readdir(directory, {
       withFileTypes: true
     });
@@ -3691,9 +3858,16 @@ var FileSystemContentSource = class {
         parentPath2 ? `${parentPath2}/${directoryEntry.name}` : directoryEntry.name
       );
       const filePath = path4.join(directory, directoryEntry.name);
-      if (this.isExcluded(logicalPath)) continue;
+      if (isExcluded(INTERNAL_CONTENT_IGNORE_PATTERNS, logicalPath)) continue;
+      const pattern = matchContentExcludePattern(logicalPath, this.exclude);
+      if (pattern !== void 0) {
+        exclusions.push({ path: logicalPath, pattern });
+        continue;
+      }
       if (directoryEntry.isDirectory()) {
-        entries.push(...await this.scanDirectory(filePath, logicalPath));
+        entries.push(
+          ...await this.scanDirectory(filePath, logicalPath, exclusions)
+        );
         continue;
       }
       if (!directoryEntry.isFile()) continue;
@@ -3708,9 +3882,6 @@ var FileSystemContentSource = class {
     }
     return entries;
   }
-  isExcluded(logicalPath) {
-    return isIgnoredContentPath(logicalPath, this.exclude);
-  }
   resolveFilePath(logicalPath) {
     const normalizedPath = normalizeLogicalPath(logicalPath);
     const filePath = path4.resolve(this.contentDirectory, normalizedPath);
@@ -3723,8 +3894,14 @@ var FileSystemContentSource = class {
 };
 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));
+  return matchContentExcludePattern(logicalPath, exclude) !== void 0;
+}
+function matchContentExcludePattern(logicalPath, exclude = []) {
+  const direct = exclude.find((pattern) => isExcluded([pattern], logicalPath));
+  if (direct !== void 0) return direct;
+  if (!logicalPath.endsWith(".md")) return void 0;
+  const withoutExtension = logicalPath.slice(0, -3);
+  return exclude.find((pattern) => isExcluded([pattern], withoutExtension));
 }
 function normalizeLogicalPath(logicalPath) {
   const normalizedPath = normalizeContentPath(logicalPath);
@@ -3748,53 +3925,22 @@ function missingContentDirectoryError(directory) {
   return error;
 }
 
-// src/content/content_links.ts
-var WIKILINK_PATTERN = /(!)?\[\[([^\]|#^]+)(?:[#^][^\]|]+)?(?:\|[^\]]+)?\]\]/g;
-function extractContentLinks(markdown, contentIndex) {
-  WIKILINK_PATTERN.lastIndex = 0;
-  const links = [];
-  for (let match = WIKILINK_PATTERN.exec(markdown); match !== null; match = WIKILINK_PATTERN.exec(markdown)) {
-    const rawTarget = match[2]?.trim();
-    if (!rawTarget) continue;
-    const resolved = contentIndex.get(rawTarget.toLowerCase()) ?? null;
-    links.push({
-      raw: rawTarget,
-      slug: resolved,
-      kind: resolved ? linkKind(resolved) : "unresolved",
-      embed: match[1] === "!"
-    });
-  }
-  return links;
-}
-function linkKind(value) {
-  if (isImagePath(value)) return "image";
-  if (isAttachmentPath(value)) return "attachment";
-  return "note";
-}
-
 // src/content/content_stable_id.ts
 var MAX_STABLE_CONTENT_ID_LENGTH = 160;
 function resolveContentStableId(frontmatter) {
-  const id = readOptionalStableId(frontmatter.id, "id");
-  const uid = readOptionalStableId(frontmatter.uid, "uid");
-  if (id !== void 0 && uid !== void 0 && id !== uid) {
-    throw new Error(
-      'Content frontmatter fields "id" and "uid" must have the same value.'
-    );
-  }
-  return id ?? uid;
+  return readOptionalStableId(frontmatter.id);
 }
-function readOptionalStableId(value, field) {
+function readOptionalStableId(value) {
   if (value === void 0) return void 0;
   if (typeof value !== "string") {
-    throw new Error(`Content frontmatter field "${field}" must be a string.`);
+    throw new Error(`Content frontmatter field "id" must be a string.`);
   }
   if (value.length === 0 || value.length > MAX_STABLE_CONTENT_ID_LENGTH || value.trim() !== value || [...value].some((character) => {
     const code = character.codePointAt(0) ?? 0;
     return code <= 31 || code === 127;
   })) {
     throw new Error(
-      `Content frontmatter field "${field}" must be a non-empty, trimmed string of at most ${MAX_STABLE_CONTENT_ID_LENGTH} characters without control characters.`
+      `Content frontmatter field "id" must be a non-empty, trimmed string of at most ${MAX_STABLE_CONTENT_ID_LENGTH} characters without control characters.`
     );
   }
   return value;
@@ -3827,7 +3973,7 @@ var ManifestBuilder = class {
       assets: uniqueAssets(assets)
     };
   }
-  build(entries, contentIndex) {
+  build(entries, contentIndex, contentIndexAmbiguities = /* @__PURE__ */ new Map()) {
     const bySlug = new Map(entries.map((entry) => [entry.slug, entry]));
     const byContentId = createContentIdIndex(entries);
     const byAlias = createAliasIndex(entries);
@@ -3868,6 +4014,7 @@ var ManifestBuilder = class {
       outgoingLinks,
       incomingLinks,
       contentIndex,
+      contentIndexAmbiguities,
       assets: [],
       clientEntries: [],
       diagnostics: [],
@@ -3984,10 +4131,10 @@ function buildOutputInventory(manifest, pluginPageOutputs = [], contentOutputDep
   for (const entry of manifest.publicEntries) {
     addOutput(outputs, contentOutput(entry, contentOutputDependencies));
   }
-  for (const [path5, redirect] of manifest.publicRedirects) {
+  for (const [path6, redirect] of manifest.publicRedirects) {
     addOutput(outputs, {
       kind: "redirect",
-      path: htmlOutputPath(path5),
+      path: htmlOutputPath(path6),
       producer: `content:${redirect.slug}:redirect`,
       dependencies: [{ type: "content", slug: redirect.slug }]
     });
@@ -4101,90 +4248,47 @@ function linkTargets(entry) {
   ).map((link) => link.slug);
 }
 function addOutput(outputs, output) {
+  const existing = outputs.get(output.path);
+  if (existing) {
+    assertNoGeneratedOutputCollision(existing, output);
+  }
   outputs.set(output.path, output);
 }
+function assertNoGeneratedOutputCollision(existing, incoming) {
+  if (existing.kind !== "generated" && incoming.kind !== "generated") return;
+  if (existing.kind === incoming.kind && existing.producer === incoming.producer)
+    return;
+  throw new Error(
+    `Generated output path "${incoming.path}" collides with ${existing.kind} output owned by "${existing.producer}" and ${incoming.kind} output owned by "${incoming.producer}".`
+  );
+}
 function normalizePublicPath(pathname) {
-  const path5 = `/${pathname.split("/").filter(Boolean).join("/")}`;
-  return path5 === "/" ? path5 : path5.replace(/\/$/, "");
+  const path6 = `/${pathname.split("/").filter(Boolean).join("/")}`;
+  return path6 === "/" ? path6 : path6.replace(/\/$/, "");
 }
-function isMarkdownPath3(path5) {
-  return path5.endsWith(".md");
+function isMarkdownPath3(path6) {
+  return path6.endsWith(".md");
 }
-function toSlug3(path5) {
-  return path5.replace(/\.md$/, "");
+function toSlug3(path6) {
+  return path6.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;
+    const config = pipelineOptions.config ? {
+      ...pipelineOptions.config,
+      plugins: pipelineOptions.plugins ?? pipelineOptions.config.plugins
+    } : void 0;
     this.pipelineOptions = {
       ...pipelineOptions,
-      plugins: pipelineOptions.plugins ?? pipelineOptions.config?.plugins,
+      config,
+      plugins: pipelineOptions.plugins ?? config?.plugins,
       isRoutable: (slug) => this.isRoutable(slug)
     };
     this.publishingBuildTime = resolvePublishingBuildTime(
@@ -4229,6 +4333,7 @@ var ContentManager = class {
   manifestBuilder = new ManifestBuilder();
   pluginRuntime;
   contentIndex = null;
+  contentIndexAmbiguities = /* @__PURE__ */ new Map();
   contentIndexPromise = null;
   contentCache = /* @__PURE__ */ new Map();
   manifest = null;
@@ -4257,15 +4362,10 @@ 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;
-    }
+      return (await this.contentIndexPromise).index;
     if (preparation) {
       this.contentIndex = preparation.currentContentIndex;
+      this.contentIndexAmbiguities = preparation.currentContentIndexAmbiguities;
       return this.contentIndex;
     }
     const promise = this.observability().tracer.span(
@@ -4278,7 +4378,9 @@ var ContentManager = class {
     );
     if (!preparation) this.contentIndexPromise = promise;
     try {
-      this.contentIndex = await promise;
+      const built = await promise;
+      this.contentIndex = built.index;
+      this.contentIndexAmbiguities = built.ambiguities;
       return this.contentIndex;
     } finally {
       if (!preparation) this.contentIndexPromise = null;
@@ -4293,48 +4395,55 @@ var ContentManager = class {
         contentPath: `${slug}.md`
       },
       async () => {
-        const [contentIndex, rawPost] = await Promise.all([
-          this.getContentIndex(),
-          this.getPost(slug)
-        ]);
-        await this.pluginRuntime.startBuild(contentIndex);
-        await this.pluginRuntime.runContentLoaded(slug, rawPost, contentIndex);
-        await this.ensureRoutableSlugs();
-        this.pipeline ??= new Pipeline(
-          contentIndex,
-          await this.locationResolver.getPermalinks(),
-          (postSlug) => this.getPost(postSlug),
-          this.pipelineOptions,
-          this.isBuildTime
-        );
-        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
-          });
+        try {
+          return await this.processContent(slug);
+        } catch (error) {
+          throw attachErrorPath(error, `${slug}.md`);
         }
-        await this.pluginRuntime.runPostHook(
-          "onPostParsed",
-          slug,
-          rawPost,
-          content,
-          contentIndex
-        );
-        await this.pluginRuntime.runPostHook(
-          "onPostProcessed",
-          slug,
-          rawPost,
-          content,
-          contentIndex
-        );
-        this.contentCache.set(slug, content);
-        return content;
       }
     );
   }
+  async processContent(slug) {
+    const [contentIndex, rawPost] = await Promise.all([
+      this.getContentIndex(),
+      this.getPost(slug)
+    ]);
+    await this.pluginRuntime.startBuild(contentIndex);
+    await this.pluginRuntime.runContentLoaded(slug, rawPost, contentIndex);
+    await this.ensureRoutableSlugs();
+    this.pipeline ??= new Pipeline(
+      contentIndex,
+      await this.locationResolver.getPermalinks(),
+      (postSlug) => this.getPost(postSlug),
+      this.pipelineOptions,
+      this.isBuildTime
+    );
+    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,
+      rawPost,
+      content,
+      contentIndex
+    );
+    await this.pluginRuntime.runPostHook(
+      "onPostProcessed",
+      slug,
+      rawPost,
+      content,
+      contentIndex
+    );
+    this.contentCache.set(slug, content);
+    return content;
+  }
   async getManifest(options) {
     if (this.manifest) return this.manifest;
     if (this.manifestPromise) return await this.manifestPromise;
@@ -4400,7 +4509,11 @@ var ContentManager = class {
         const manifest = await this.observability().tracer.span(
           "content.graph",
           {},
-          () => this.manifestBuilder.build(entries, contentIndex)
+          () => this.manifestBuilder.build(
+            entries,
+            contentIndex,
+            this.contentIndexAmbiguities
+          )
         );
         const cacheManifestEntries = structuredClone(manifest.entries);
         this.locationResolver.populateRedirects(manifest, locations);
@@ -4636,7 +4749,13 @@ var ContentManager = class {
     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), {
+      let frontmatter;
+      try {
+        frontmatter = readFrontmatter(markdown);
+      } catch (error) {
+        throw attachErrorPath(error, `${post.slug}.md`);
+      }
+      const publishing = resolvePublishingState(frontmatter, {
         strategy,
         buildTime: this.publishingBuildTime
       });
@@ -4726,7 +4845,12 @@ function resolveFolderLocation(manifest, folder) {
     if (candidate) return { type: "content", entry: candidate.entry };
   }
   if (candidates.length > 1) return { type: "ambiguous", candidates };
-  const location = manifest.folderLocations.get(normalizeFolder2(folder));
+  const normalizedFolder = normalizeFolder2(folder);
+  const direct = manifest.folderLocations.get(normalizedFolder);
+  if (direct) return { type: "generated", pathname: direct.pathname };
+  const location = [...manifest.folderLocations.values()].find(
+    (candidate) => candidate.folder === normalizedFolder
+  );
   return location ? { type: "generated", pathname: location.pathname } : { type: "none" };
 }
 function resolvePublicFolderLocation(manifest, pathname) {
@@ -4740,12 +4864,15 @@ function resolvePublicFolderLocation(manifest, pathname) {
   );
   return location ? { type: "generated", pathname: location.pathname } : { type: "none" };
 }
-function resolveGeneratedFolderLocation(manifest, folder) {
+function resolveGeneratedFolderLocation(manifest, folder, language) {
   const normalizedFolder = normalizeFolder2(folder);
   if (!normalizedFolder) return null;
   const candidates = /* @__PURE__ */ new Set();
   const prefix = `${normalizedFolder}/`;
   for (const entry of manifest.publicEntries) {
+    if (language !== void 0 && entry.publicLocation.language !== language) {
+      continue;
+    }
     if (!entry.slug.startsWith(prefix)) continue;
     const remainder = entry.slug.slice(prefix.length).split("/").filter(Boolean);
     const pathname = parentPath(
@@ -4960,7 +5087,7 @@ function clampFinite(value, min, max) {
 // src/content/read_only_content_graph.ts
 async function readOnlyContentGraph(source, locations) {
   const entries = await source.scan();
-  const contentIndex = await new ContentIndexBuilder(source).build(entries);
+  const { index: contentIndex, ambiguities: contentIndexAmbiguities } = await new ContentIndexBuilder(source).build(entries);
   const markdownEntries = entries.filter((entry) => entry.path.endsWith(".md")).toSorted((left, right) => left.path.localeCompare(right.path));
   const markdownContents = await Promise.all(
     markdownEntries.map(async (entry) => ({
@@ -4971,7 +5098,11 @@ async function readOnlyContentGraph(source, locations) {
   const graphEntries = markdownContents.map(
     ({ entry, markdown }) => createGraphEntry(entry, markdown, contentIndex, locations)
   );
-  return new ManifestBuilder().build(graphEntries, contentIndex).graph;
+  return new ManifestBuilder().build(
+    graphEntries,
+    contentIndex,
+    contentIndexAmbiguities
+  ).graph;
 }
 function createGraphEntry(entry, markdown, contentIndex, locations) {
   const slug = entry.path.replace(/\.md$/, "");
@@ -5005,6 +5136,17 @@ async function readText3(source, entry) {
   return typeof content === "string" ? content : new TextDecoder().decode(content);
 }
 
+// src/project/project_layout.ts
+import path5 from "node:path";
+function resolveManagedStateRoot(config) {
+  const directory = config?.buildDirectory;
+  return directory ? path5.resolve(directory) : void 0;
+}
+function resolveBuildOutputDirectory(config) {
+  const directory = config?.outputDirectory;
+  return directory ? path5.resolve(directory) : void 0;
+}
+
 // src/types/content_manifest.ts
 function appendContentBodySlot(entry, slot, html) {
   if (!html.trim()) return;
@@ -5017,12 +5159,12 @@ ${html}` : html
 }
 
 // src/types/plugin_endpoint.ts
-function defineEndpoint(path5, handler, options = {}) {
+function defineEndpoint(path6, handler, options = {}) {
   if (options.cacheControl === void 0) {
-    return { path: path5, handler };
+    return { path: path6, handler };
   }
   return {
-    path: path5,
+    path: path6,
     handler: async (context) => {
       const response = await handler(context);
       const headers = { ...response.headers };
@@ -5071,12 +5213,14 @@ export {
   PluginDependencyError,
   SinkTracer,
   appendContentBodySlot,
+  attachErrorPath,
   attachmentUrl,
   buildContentCollections,
   buildGraphEdges,
   buildOutputInventory,
   calculateReadingTime,
   collectConfigDeprecationDiagnostics,
+  computePipelineFingerprint,
   createClientEntry,
   createContentGraph,
   createDeprecationDiagnostic,
@@ -5095,6 +5239,7 @@ export {
   fingerprintContentEntries,
   formatDeprecationMessage,
   getContentSourceEntry,
+  getEntryLanguage,
   getExtension,
   getResolvedPluginMetadata,
   groupContentEntries,
@@ -5104,11 +5249,13 @@ export {
   isIgnoredContentPath,
   isImagePath,
   isMarkdownPath,
+  isPersistentlyCacheable,
   isPublishable,
   isPublished,
   layoutForceGraph,
   layoutRadialGraph,
   loadContentBuildState,
+  matchContentExcludePattern,
   normalizeContentAssetOutputPath,
   normalizeContentPath,
   normalizeGeneratedOutputPath,
@@ -5118,6 +5265,7 @@ export {
   readContentBuildStateStatus,
   readContentSourceEntry,
   readOnlyContentGraph,
+  resolveBuildOutputDirectory,
   resolveConfig,
   resolveConfigModule,
   resolveContentBuildStatePath,
@@ -5127,10 +5275,12 @@ export {
   resolveFolderEntry,
   resolveFolderLocation,
   resolveGeneratedFolderLocation,
+  resolveManagedStateRoot,
   resolvePlugins,
   resolvePublicFolderLocation,
   resolvePublishingBuildTime,
   resolvePublishingState,
+  selectEntriesByLanguage,
   serializePublicClientConfig,
   stableStringify,
   stripHtml,