@riebeckite/core 0.0.17 → 0.0.18

package/README.md

@@ -37,7 +37,7 @@ export default defineConfig({
 ```
 
 The content directory is resolved relative to the application root. See
-[Configuration](../../docs/en/docs/reference/configuration.md) for the full field list and the
+[Configuration](../../docs/docs/reference/configuration.en.md) for the full field list and the
 `projectRoot` / `appRoot` / `configRoot` / `contentRoot` resolution rules.
 
 ## Public API
@@ -88,8 +88,8 @@ The content directory is resolved relative to the application root. See
 
 ## See also
 
-- [Framework Reference](../../docs/en/docs/reference/README.md)
-- [Content System](../../docs/en/docs/framework/content-system.md)
-- [Plugin System](../../docs/en/docs/reference/plugin-api.md) / [Theme System](../../docs/en/docs/reference/theme-api.md)
-- [Architecture](../../docs/en/docs/framework/architecture.md)
+- [Framework Reference](../../docs/docs/reference/README.en.md)
+- [Content System](../../docs/docs/framework/content-system.en.md)
+- [Plugin System](../../docs/docs/reference/plugin-api.en.md) / [Theme System](../../docs/docs/reference/theme-api.en.md)
+- [Architecture](../../docs/docs/framework/architecture.en.md)
 

package/README_ja.md

@@ -29,7 +29,7 @@ export default defineConfig({
 });
 ```
 
-コンテンツディレクトリはアプリケーションルート基準で解決します。設定項目の全体と `projectRoot` / `appRoot` / `configRoot` / `contentRoot` の解決規則は [Configuration](../../docs/ja/docs/reference/configuration.md) を参照してください。
+コンテンツディレクトリはアプリケーションルート基準で解決します。設定項目の全体と `projectRoot` / `appRoot` / `configRoot` / `contentRoot` の解決規則は [Configuration](../../docs/docs/reference/configuration.md) を参照してください。
 
 ## 公開 API
 
@@ -69,8 +69,8 @@ export default defineConfig({
 
 ## 関連資料
 
-- [Framework Reference](../../docs/ja/docs/reference/README.md)
-- [Content System](../../docs/ja/docs/framework/content-system.md)
-- [Plugin System](../../docs/ja/docs/reference/plugin-api.md) / [Theme System](../../docs/ja/docs/reference/theme-api.md)
-- [Architecture](../../docs/ja/docs/framework/architecture.md)
+- [Framework Reference](../../docs/docs/reference/README.md)
+- [Content System](../../docs/docs/framework/content-system.md)
+- [Plugin System](../../docs/docs/reference/plugin-api.md) / [Theme System](../../docs/docs/reference/theme-api.md)
+- [Architecture](../../docs/docs/framework/architecture.md)
 

package/dist/index.d.ts

@@ -42,6 +42,7 @@ export type { PluginCache } from "./src/plugin/plugin_cache.js";
 export { PluginDependencyError, type PluginDependencyErrorKind, } from "./src/plugin/plugin_dependency_error.js";
 export type { CreatePluginMemoOptions, PluginMemo, } from "./src/plugin/plugin_memo.js";
 export { createPluginMemo, stableStringify, } from "./src/plugin/plugin_memo.js";
+export { resolveBuildOutputDirectory, resolveManagedStateRoot, } from "./src/project/project_layout.js";
 export type { ConfigValidationIssue, PluginOptionsValidator, } from "./src/types/config_validation.js";
 export type { ContentAsset, ContentBodySlot, ContentLink, ContentLinkKind, ContentLocationInput, ContentManifest, ContentManifestEntry, ContentManifestPluginClientEntry, ContentPublicLocation, ContentRedirect, FolderLocation, PluginPageRoute, } from "./src/types/content_manifest.js";
 export { appendContentBodySlot } from "./src/types/content_manifest.js";
@@ -71,6 +72,7 @@ export type { SiteConfig } from "./src/types/site_config.js";
 export type { RiebeckiteTheme, ThemeArticleLayoutPreset, ThemeAttributes, ThemeColorMode, ThemeConfig, ThemeDesignTokens, ThemeInput, ThemeStyle, ThemeTypographyPreset, } from "./src/types/theme_config.js";
 export { defineTheme } from "./src/types/theme_config.js";
 export { uniqueStrings } from "./src/utils/collections.js";
+export { attachErrorPath } from "./src/utils/error.js";
 export { escapeHtml, escapeHtmlAttribute, escapeScriptJson, } from "./src/utils/html.js";
 export { normalizeTag } from "./src/utils/tags.js";
 export { calculateReadingTime, stripHtml } from "./src/utils/text.js";

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) {
@@ -2463,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;
   }
@@ -2553,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
@@ -2586,9 +2647,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 +3137,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 +3165,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 +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;
@@ -3160,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();
@@ -3202,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 });
 }
@@ -3225,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(),
@@ -3303,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
@@ -3433,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(
@@ -3471,6 +3562,7 @@ var ContentBuildCoordinator = class {
       currentEntries,
       currentContentAliases,
       currentContentIndex,
+      currentContentIndexAmbiguities,
       changeSet,
       affectedContent: affected
     };
@@ -3498,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 [];
@@ -3682,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);
@@ -3881,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);
@@ -3922,6 +4014,7 @@ var ManifestBuilder = class {
       outgoingLinks,
       incomingLinks,
       contentIndex,
+      contentIndexAmbiguities,
       assets: [],
       clientEntries: [],
       diagnostics: [],
@@ -4038,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 }]
     });
@@ -4170,79 +4263,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 +4333,7 @@ var ContentManager = class {
   manifestBuilder = new ManifestBuilder();
   pluginRuntime;
   contentIndex = null;
+  contentIndexAmbiguities = /* @__PURE__ */ new Map();
   contentIndexPromise = null;
   contentCache = /* @__PURE__ */ new Map();
   manifest = null;
@@ -4328,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(
@@ -4349,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;
@@ -4364,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;
@@ -4471,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);
@@ -4707,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
       });
@@ -4797,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) {
@@ -4811,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(
@@ -5031,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) => ({
@@ -5042,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$/, "");
@@ -5076,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;
@@ -5088,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 };
@@ -5142,6 +5213,7 @@ export {
   PluginDependencyError,
   SinkTracer,
   appendContentBodySlot,
+  attachErrorPath,
   attachmentUrl,
   buildContentCollections,
   buildGraphEdges,
@@ -5193,6 +5265,7 @@ export {
   readContentBuildStateStatus,
   readContentSourceEntry,
   readOnlyContentGraph,
+  resolveBuildOutputDirectory,
   resolveConfig,
   resolveConfigModule,
   resolveContentBuildStatePath,
@@ -5202,6 +5275,7 @@ export {
   resolveFolderEntry,
   resolveFolderLocation,
   resolveGeneratedFolderLocation,
+  resolveManagedStateRoot,
   resolvePlugins,
   resolvePublicFolderLocation,
   resolvePublishingBuildTime,

package/dist/src/config.d.ts

@@ -4,5 +4,7 @@ import type { RiebeckiteConfig } from "./types/riebeckite_config.js";
 export declare function defineConfig(config: RiebeckiteConfig): RiebeckiteConfig;
 export declare function resolveConfigModule(configModule: unknown): ResolvedRiebeckiteConfig;
 export declare function resolveConfig(config: RiebeckiteConfig): ResolvedRiebeckiteConfig;
-export declare function isPublished(config: ResolvedRiebeckiteConfig, frontmatter: PostFrontmatter | undefined): boolean;
+export declare function isPublished(config: ResolvedRiebeckiteConfig, frontmatter: PostFrontmatter | undefined, options?: {
+    buildTime?: Date | string;
+}): boolean;
 export declare function isExcluded(patterns: readonly string[], relativePath: string): boolean;

package/dist/src/content/content_build_coordinator.d.ts

@@ -12,6 +12,7 @@ export type ContentBuildPreparation = {
     readonly currentEntries: readonly FingerprintedContentEntry[];
     readonly currentContentAliases: ReadonlyMap<string, readonly string[]>;
     readonly currentContentIndex: Map<string, string>;
+    readonly currentContentIndexAmbiguities: ReadonlyMap<string, readonly string[]>;
     readonly changeSet: ContentChangeSet;
     readonly affectedContent: ReturnType<typeof determineAffectedContent>;
 };

package/dist/src/content/content_build_state.d.ts

@@ -1,7 +1,7 @@
 import type { ContentManifestEntry } from "../types/content_manifest.js";
 import type { ContentSourceEntry } from "./content_source.js";
 import type { OutputDescriptor } from "./output_dependency.js";
-export declare const CONTENT_BUILD_STATE_VERSION = 7;
+export declare const CONTENT_BUILD_STATE_VERSION = 8;
 /**
  * Build state lives under `<content directory>/.riebeckite`. That directory is
  * build-time state, not content, so content sources must exclude it from scans

package/dist/src/content/content_index_builder.d.ts

@@ -1,9 +1,13 @@
 import type { ContentSource, ContentSourceEntry } from "./content_source.js";
+export type ContentIndexBuild = {
+    readonly index: Map<string, string>;
+    readonly ambiguities: ReadonlyMap<string, readonly string[]>;
+};
 export declare class ContentIndexBuilder {
     private source;
     constructor(source: ContentSource);
-    build(contentEntries: readonly ContentSourceEntry[], read?: (entry: ContentSourceEntry) => Promise<import("./content_source.js").ContentSourceContent>): Promise<Map<string, string>>;
-    static buildFromAliases(contentEntries: readonly ContentSourceEntry[], aliasesByPath: ReadonlyMap<string, readonly string[]>): Map<string, string>;
+    build(contentEntries: readonly ContentSourceEntry[], read?: (entry: ContentSourceEntry) => Promise<import("./content_source.js").ContentSourceContent>): Promise<ContentIndexBuild>;
+    static buildFromAliases(contentEntries: readonly ContentSourceEntry[], aliasesByPath: ReadonlyMap<string, readonly string[]>): ContentIndexBuild;
     private indexContentEntry;
     private static indexContentEntryFromAliases;
 }

package/dist/src/content/content_manager.d.ts

@@ -29,6 +29,7 @@ export declare class ContentManager {
     private manifestBuilder;
     private pluginRuntime;
     private contentIndex;
+    private contentIndexAmbiguities;
     private contentIndexPromise;
     private contentCache;
     private manifest;
@@ -51,6 +52,7 @@ export declare class ContentManager {
     getPost(slug: string): Promise<string>;
     getContentIndex(preparation?: ContentBuildPreparation): Promise<Map<string, string>>;
     getProcessedContent(slug: string): Promise<PostContent>;
+    private processContent;
     getManifest(options?: ContentBuildOptions): Promise<ContentManifest>;
     private buildManifest;
     build(options?: ContentBuildOptions): Promise<ContentManifest>;

package/dist/src/content/folder_entry.d.ts

@@ -33,4 +33,4 @@ export type FolderLocationResolution = {
 export declare function resolveFolderEntry(manifest: ContentManifest, folder: string, options?: ResolveFolderEntryOptions): FolderEntryResolution;
 export declare function resolveFolderLocation(manifest: ContentManifest, folder: string): FolderLocationResolution;
 export declare function resolvePublicFolderLocation(manifest: ContentManifest, pathname: string): FolderLocationResolution;
-export declare function resolveGeneratedFolderLocation(manifest: ContentManifest, folder: string): string | null;
+export declare function resolveGeneratedFolderLocation(manifest: ContentManifest, folder: string, language?: string): string | null;

package/dist/src/content/manifest_builder.d.ts

@@ -3,5 +3,5 @@ import type { PostContent } from "../types/post_content.js";
 import type { ResolvedPublishingState } from "./publishing.js";
 export declare class ManifestBuilder {
     createEntry(slug: string, markdown: string, processed: PostContent, contentIndex: Map<string, string>, location: ContentPublicLocation, publishing: ResolvedPublishingState): ContentManifestEntry;
-    build(entries: ContentManifestEntry[], contentIndex: Map<string, string>): ContentManifest;
+    build(entries: ContentManifestEntry[], contentIndex: Map<string, string>, contentIndexAmbiguities?: ReadonlyMap<string, readonly string[]>): ContentManifest;
 }

package/dist/src/plugin/plugin_lifecycle.d.ts

@@ -2,6 +2,7 @@ import type { Tracer } from "../observability.js";
 import type { RiebeckitePlugin } from "../types/plugin.js";
 import type { PluginLifecycleContext, PluginManifestContext } from "../types/plugin_context.js";
 export declare class PluginHookError extends Error {
+    readonly path?: string;
     constructor(pluginName: string, hookName: string, cause: unknown);
 }
 export declare function runPluginHook<TContext extends {

package/dist/src/project/project_layout.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedRiebeckiteConfig } from "../types/resolved_riebeckite_config.js";
+/**
+ * Root directory for Riebeckite-managed persistent state: content build state,
+ * plugin cache, persistent content cache, and the SSG output cache. The root is
+ * reproducible and safe to remove; missing paths are not an error.
+ */
+export declare function resolveManagedStateRoot(config: ResolvedRiebeckiteConfig | undefined): string | undefined;
+/**
+ * Directory for the built site. Missing paths are not an error.
+ */
+export declare function resolveBuildOutputDirectory(config: ResolvedRiebeckiteConfig | undefined): string | undefined;

package/dist/src/types/content_manifest.d.ts

@@ -77,6 +77,8 @@ export type ContentPublicLocation = {
 };
 export type FolderLocation = {
     pathname: string;
+    folder?: string;
+    language?: string;
 };
 export type PluginPageRoute = {
     pathname: string;
@@ -121,6 +123,13 @@ export type ContentManifest = {
     outgoingLinks: Map<string, ContentLink[]>;
     incomingLinks: Map<string, string[]>;
     contentIndex: Map<string, string>;
+    /**
+     * Lookup keys that matched more than one candidate, mapped to their
+     * candidates (sorted). These keys are intentionally absent from
+     * `contentIndex` so links stay unresolved instead of picking a target by
+     * discovery order. Used to report actionable ambiguity diagnostics.
+     */
+    contentIndexAmbiguities?: ReadonlyMap<string, readonly string[]>;
     graph: ContentGraph;
     assets: ContentManifestPluginAsset[];
     /**

package/dist/src/types/plugin_seo.d.ts

@@ -25,7 +25,7 @@ export type RenderableFeedEntry = ContentManifestEntry & {
     html?: string;
 };
 export type PluginSeoExtension = {
-    buildArticleSeo(config: ResolvedRiebeckiteConfig, permalink: string, post: PostContent, headTags?: readonly PluginHeadTag[]): SeoMetadata;
+    buildArticleSeo(config: ResolvedRiebeckiteConfig, permalink: string, post: PostContent, headTags?: readonly PluginHeadTag[], language?: string): SeoMetadata;
     buildWebsiteSeo(config: ResolvedRiebeckiteConfig, input: WebsiteSeoInput, headTags?: readonly PluginHeadTag[]): SeoMetadata;
     buildAbsoluteUrl(config: ResolvedRiebeckiteConfig, pathOrUrl: string): string;
     buildPostUrl(config: ResolvedRiebeckiteConfig, permalink: string): string;

package/dist/src/types/resolved_riebeckite_config.d.ts

@@ -9,6 +9,11 @@ export type ResolvedRiebeckiteConfig = {
      * relative to their application root.
      */
     buildDirectory?: string;
+    /**
+     * Directory for the built site. Host integrations resolve this relative to
+     * their application root.
+     */
+    outputDirectory?: string;
     site: Omit<Required<SiteConfig>, "feed"> & {
         feed: {
             title: string;

package/dist/src/utils/error.d.ts

@@ -0,0 +1 @@
+export declare function attachErrorPath<T>(error: T, path: string): T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riebeckite/core",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
   },
   "devDependencies": {
     "tsx": "^4.22.4",
-    "@riebeckite/test": "0.0.17"
+    "@riebeckite/test": "0.0.18"
   },
   "repository": {
     "type": "git",