@riebeckite/core 0.0.17 → 0.0.19

package/dist/index.js

@@ -119,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."
       });
     }
@@ -173,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 {
@@ -243,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) {
@@ -284,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;
@@ -573,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;
@@ -680,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, "/");
@@ -745,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];
   }
@@ -810,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 = 7;
+var CONTENT_BUILD_STATE_VERSION = 8;
 var CONTENT_BUILD_STATE_DIRECTORY = ".riebeckite";
 var CONTENT_BUILD_STATE_EXCLUDE = `${CONTENT_BUILD_STATE_DIRECTORY}/**`;
 
@@ -1215,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) {
@@ -1705,7 +1766,14 @@ function createPersistentContentCache(options) {
           );
           return void 0;
         }
-        throw error;
+        logger?.warn(
+          "Persistent content cache entry could not be read and will be ignored.",
+          {
+            key,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        );
+        return void 0;
       }
     },
     async set(key, value) {
@@ -1717,8 +1785,18 @@ function createPersistentContentCache(options) {
           "Persistent content cache values must be JSON serializable."
         );
       }
-      await writeAtomically(filePath, versionDir, serialized);
-      tracer?.event("persistentContentCache.write", { key });
+      try {
+        await writeAtomically(filePath, versionDir, serialized);
+        tracer?.event("persistentContentCache.write", { key });
+      } catch (error) {
+        logger?.warn(
+          "Persistent content cache entry could not be written and will be ignored.",
+          {
+            key,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        );
+      }
     },
     async clear() {
       try {
@@ -2463,9 +2541,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;
   }
@@ -2553,16 +2631,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
@@ -2586,9 +2664,12 @@ var GeneratedOutputRegistry = class {
 
 // src/plugin/plugin_lifecycle.ts
 var PluginHookError = class extends Error {
+  path;
   constructor(pluginName, hookName, cause) {
     super(`Plugin "${pluginName}" failed during "${hookName}"`, { cause });
     this.name = "PluginHookError";
+    const path6 = cause?.path;
+    if (typeof path6 === "string") this.path = path6;
   }
 };
 async function runPluginHook(plugin, hookName, context, hook) {
@@ -3073,12 +3154,12 @@ 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;
@@ -3101,6 +3182,14 @@ function uniqueOutputs(outputs) {
   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
 function determineAffectedContent(changeSet, previousState, currentPaths, currentContentIndex) {
   const changedPaths = [
@@ -3121,9 +3210,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;
@@ -3160,27 +3249,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();
@@ -3202,18 +3291,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 });
 }
@@ -3225,9 +3314,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(),
@@ -3303,54 +3389,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
@@ -3433,7 +3538,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(
@@ -3471,6 +3579,7 @@ var ContentBuildCoordinator = class {
       currentEntries,
       currentContentAliases,
       currentContentIndex,
+      currentContentIndexAmbiguities,
       changeSet,
       affectedContent: affected
     };
@@ -3498,8 +3607,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 [];
@@ -3588,9 +3697,14 @@ var ContentEntryReader = class {
     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;
+    );
+    const retain = entry.path.endsWith(".md");
+    const tracked = retain ? content : content.finally(() => this.texts.delete(entry.path));
+    this.texts.set(entry.path, tracked);
+    return tracked;
+  }
+  clearReadCache() {
+    this.texts.clear();
   }
 };
 
@@ -3682,8 +3796,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);
@@ -3881,7 +3995,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);
@@ -3922,6 +4036,7 @@ var ManifestBuilder = class {
       outgoingLinks,
       incomingLinks,
       contentIndex,
+      contentIndexAmbiguities,
       assets: [],
       clientEntries: [],
       diagnostics: [],
@@ -4038,10 +4153,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 }]
     });
@@ -4170,79 +4285,19 @@ function assertNoGeneratedOutputCollision(existing, incoming) {
   );
 }
 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 {
@@ -4300,6 +4355,7 @@ var ContentManager = class {
   manifestBuilder = new ManifestBuilder();
   pluginRuntime;
   contentIndex = null;
+  contentIndexAmbiguities = /* @__PURE__ */ new Map();
   contentIndexPromise = null;
   contentCache = /* @__PURE__ */ new Map();
   manifest = null;
@@ -4328,15 +4384,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(
@@ -4349,7 +4400,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;
@@ -4364,48 +4417,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;
@@ -4471,7 +4531,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);
@@ -4608,6 +4672,7 @@ var ContentManager = class {
     return { entries, contentIndex, diagnostics };
   }
   async dispose() {
+    this.entryReader.clearReadCache();
     if (!this.contentIndex) return;
     await this.pluginRuntime.dispose(this.contentIndex);
   }
@@ -4707,7 +4772,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
       });
@@ -4797,7 +4868,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) {
@@ -4811,12 +4887,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(
@@ -5031,7 +5110,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) => ({
@@ -5042,7 +5121,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$/, "");
@@ -5076,7 +5159,26 @@ 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
+var ARTICLE_SLOT = {
+  header: "article.header",
+  metadata: "article.metadata",
+  aside: "article.aside",
+  beforeContent: "article.before-content",
+  afterContent: "article.after-content",
+  footer: "article.footer"
+};
 function appendContentBodySlot(entry, slot, html) {
   if (!html.trim()) return;
   const previous = entry.bodySlots?.[slot];
@@ -5088,12 +5190,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 };
@@ -5128,6 +5230,7 @@ function calculateReadingTime(html) {
   return Math.max(1, Math.ceil(cjkCharacters / 500 + latinWords / 220));
 }
 export {
+  ARTICLE_SLOT,
   ATTACHMENTS_BASE_PATH,
   CompositeTraceSink,
   ConfigValidationError,
@@ -5142,6 +5245,7 @@ export {
   PluginDependencyError,
   SinkTracer,
   appendContentBodySlot,
+  attachErrorPath,
   attachmentUrl,
   buildContentCollections,
   buildGraphEdges,
@@ -5193,6 +5297,7 @@ export {
   readContentBuildStateStatus,
   readContentSourceEntry,
   readOnlyContentGraph,
+  resolveBuildOutputDirectory,
   resolveConfig,
   resolveConfigModule,
   resolveContentBuildStatePath,
@@ -5202,6 +5307,7 @@ export {
   resolveFolderEntry,
   resolveFolderLocation,
   resolveGeneratedFolderLocation,
+  resolveManagedStateRoot,
   resolvePlugins,
   resolvePublicFolderLocation,
   resolvePublishingBuildTime,