@riebeckite/core 0.0.15 → 0.0.17

package/README.md

@@ -32,7 +32,7 @@ import { defineConfig } from "@riebeckite/core";
 
 export default defineConfig({
   site: { title: "My notes", baseUrl: "https://example.com" },
-  content: { directory: "../../content" },
+  content: { directory: "content" },
 });
 ```
 

package/README_ja.md

@@ -25,7 +25,7 @@ import { defineConfig } from "@riebeckite/core";
 
 export default defineConfig({
   site: { title: "My notes", baseUrl: "https://example.com" },
-  content: { directory: "../../content" },
+  content: { directory: "content" },
 });
 ```
 

package/dist/index.d.ts

@@ -10,18 +10,21 @@ export { buildContentCollections } from "./src/content/content_collection.js";
 export { fingerprintContentEntries } from "./src/content/content_fingerprint.js";
 export type { ContentGraph, ContentGraphNeighbors, } from "./src/content/content_graph.js";
 export { createContentGraph } from "./src/content/content_graph.js";
+export { getEntryLanguage, selectEntriesByLanguage, } from "./src/content/content_language.js";
 export { resolveDefaultContentLocation } from "./src/content/content_location.js";
 export type { ContentBuildOptions, ContentInspection, } from "./src/content/content_manager.js";
 export { ContentManager } from "./src/content/content_manager.js";
 export { extractFrontmatterAliases } from "./src/content/content_metadata.js";
+export { computePipelineFingerprint, isPersistentlyCacheable, } from "./src/content/content_persistent_cache.js";
 export type { ContentQueryDateFilter, ContentQueryDateGranularity, ContentQueryFilter, ContentQueryFrontmatterFilter, ContentQueryGroup, ContentQueryGroupBy, ContentQueryGroupOptions, ContentQueryPage, ContentQueryPagination, ContentQueryScalar, ContentQuerySort, ContentQuerySortOrder, ContentQuerySpec, ContentQueryTagFilter, } from "./src/content/content_query.js";
 export { groupContentEntries, queryContentEntries, queryContentPage, resolveContentQueryPagination, } from "./src/content/content_query.js";
 export type { ContentSource, ContentSourceContent, ContentSourceEntry, ContentSourceMetadata, } from "./src/content/content_source.js";
 export { getContentSourceEntry, readContentSourceEntry, } from "./src/content/content_source.js";
 export { resolveContentStableId } from "./src/content/content_stable_id.js";
-export { FileSystemContentSource, INTERNAL_CONTENT_IGNORE_PATTERNS, isIgnoredContentPath, } from "./src/content/file_system_content_source.js";
+export type { ContentSourceExclusion, ContentSourceScan, } from "./src/content/file_system_content_source.js";
+export { FileSystemContentSource, INTERNAL_CONTENT_IGNORE_PATTERNS, isIgnoredContentPath, matchContentExcludePattern, } from "./src/content/file_system_content_source.js";
 export type { FolderEntryCandidate, FolderEntryKind, FolderEntryResolution, FolderEntryScope, FolderLocationResolution, ResolveFolderEntryOptions, } from "./src/content/folder_entry.js";
-export { resolveFolderEntry, resolveFolderLocation, resolveGeneratedFolderLocation, } from "./src/content/folder_entry.js";
+export { resolveFolderEntry, resolveFolderLocation, resolveGeneratedFolderLocation, resolvePublicFolderLocation, } from "./src/content/folder_entry.js";
 export type { ForceGraphLayoutOptions, GraphEdge, GraphLayoutNode, LinkableGraphNode, RadialGraphLayoutOptions, } from "./src/content/graph_layout.js";
 export { buildGraphEdges, layoutForceGraph, layoutRadialGraph, } from "./src/content/graph_layout.js";
 export { IMAGE_EXTENSIONS } from "./src/content/image_extensions.js";

package/dist/index.js

@@ -19,6 +19,7 @@ function validateConfigIssues(config) {
   }
   validateSite(value.site, issues);
   validateContent(value.content, issues);
+  validateCache(value.cache, issues);
   validateTheme(value.theme, issues);
   validatePlugins(value.plugins, issues);
   return issues;
@@ -93,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)) {
@@ -626,18 +636,13 @@ function resolveConfig(config) {
       }
     },
     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: {
@@ -805,7 +810,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 = 7;
 var CONTENT_BUILD_STATE_DIRECTORY = ".riebeckite";
 var CONTENT_BUILD_STATE_EXCLUDE = `${CONTENT_BUILD_STATE_DIRECTORY}/**`;
 
@@ -1322,6 +1327,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 {
@@ -1479,6 +1501,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) => {
@@ -1524,6 +1548,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";
@@ -1720,7 +1768,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
     }
@@ -1885,6 +1932,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");
 }
@@ -2153,6 +2201,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,
@@ -2202,6 +2253,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) {
@@ -2305,8 +2375,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)) ?? "";
@@ -2517,12 +2585,26 @@ var GeneratedOutputRegistry = class {
 };
 
 // src/plugin/plugin_lifecycle.ts
-var PluginLifecycleError = class extends Error {
+var PluginHookError = class extends Error {
   constructor(pluginName, hookName, cause) {
     super(`Plugin "${pluginName}" failed during "${hookName}"`, { cause });
-    this.name = "PluginLifecycleError";
+    this.name = "PluginHookError";
   }
 };
+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,
@@ -2559,19 +2641,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);
   }
 }
 
@@ -2589,6 +2659,7 @@ var PluginRuntime = class {
   generatedOutputs = new GeneratedOutputRegistry();
   isBuildTime = false;
   resolvedPlugins = null;
+  pageDeclarations = /* @__PURE__ */ new WeakMap();
   getDiagnostics() {
     return this.diagnostics;
   }
@@ -2599,7 +2670,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) {
@@ -2607,7 +2678,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
@@ -2619,22 +2690,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,
@@ -2642,16 +2721,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 = {
@@ -2662,10 +2749,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;
@@ -2747,63 +2830,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 ?? []);
@@ -2814,9 +2908,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,
@@ -2845,13 +2943,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) {
@@ -2896,18 +2994,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() {
@@ -2993,10 +3085,20 @@ function countSeverity(diagnostics, severity) {
 }
 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/content/affected_content.ts
@@ -3411,8 +3513,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, "/")
@@ -3426,6 +3528,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 [
@@ -3615,8 +3729,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);
@@ -3632,7 +3755,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
     });
@@ -3643,9 +3766,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;
@@ -3660,9 +3790,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);
@@ -3675,8 +3802,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);
@@ -3700,53 +3833,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;
@@ -3766,6 +3868,7 @@ var ManifestBuilder = class {
       permalink: location.permalink,
       publicLocation: location,
       title: getManifestTitle(slug, processed.frontmatter.title),
+      aliases: extractFrontmatterAliases(markdown),
       frontmatter: processed.frontmatter,
       publishing,
       html: processed.html,
@@ -3781,6 +3884,7 @@ var ManifestBuilder = class {
   build(entries, contentIndex) {
     const bySlug = new Map(entries.map((entry) => [entry.slug, entry]));
     const byContentId = createContentIdIndex(entries);
+    const byAlias = createAliasIndex(entries);
     const byPermalink = new Map(
       entries.map((entry) => [entry.permalink, entry])
     );
@@ -3808,6 +3912,7 @@ var ManifestBuilder = class {
       discoverableEntries: [...entries],
       bySlug,
       byContentId,
+      byAlias,
       byPermalink,
       byRoutablePermalink: new Map(byPermalink),
       redirects: /* @__PURE__ */ new Map(),
@@ -3828,6 +3933,14 @@ var ManifestBuilder = class {
     return { ...manifest, graph: createContentGraph(manifest) };
   }
 };
+function createAliasIndex(entries) {
+  const byAlias = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const alias of entry.aliases ?? [])
+      appendToMap(byAlias, alias.toLowerCase(), entry);
+  }
+  return byAlias;
+}
 function createContentIdIndex(entries) {
   const byContentId = /* @__PURE__ */ new Map();
   for (const entry of entries) {
@@ -4042,8 +4155,20 @@ 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(/\/$/, "");
@@ -4123,9 +4248,14 @@ 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(
@@ -4603,6 +4733,7 @@ function cloneManifestEntry(entry) {
     ...entry,
     publicLocation: { ...entry.publicLocation },
     frontmatter: { ...entry.frontmatter },
+    aliases: [...entry.aliases ?? []],
     tags: [...entry.tags],
     links: entry.links.map((link) => ({ ...link })),
     backlinks: [...entry.backlinks],
@@ -4669,6 +4800,17 @@ function resolveFolderLocation(manifest, folder) {
   const location = manifest.folderLocations.get(normalizeFolder2(folder));
   return location ? { type: "generated", pathname: location.pathname } : { type: "none" };
 }
+function resolvePublicFolderLocation(manifest, pathname) {
+  const normalizedPathname = normalizePathname(pathname);
+  const entry = manifest.publicEntries.find(
+    (candidate) => normalizePathname(candidate.publicLocation.permalink) === normalizedPathname
+  );
+  if (entry) return { type: "content", entry };
+  const location = [...manifest.folderLocations.values()].find(
+    (candidate) => normalizePathname(candidate.pathname) === normalizedPathname
+  );
+  return location ? { type: "generated", pathname: location.pathname } : { type: "none" };
+}
 function resolveGeneratedFolderLocation(manifest, folder) {
   const normalizedFolder = normalizeFolder2(folder);
   if (!normalizedFolder) return null;
@@ -4701,6 +4843,10 @@ function isInScope(entry, scope) {
 function normalizeFolder2(folder) {
   return folder.split("/").filter(Boolean).join("/");
 }
+function normalizePathname(pathname) {
+  const segments = pathname.split("/").filter(Boolean);
+  return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
 function parentPath(pathname, levels) {
   const segments = pathname.split("/").filter(Boolean);
   if (segments.length < levels) return null;
@@ -4909,6 +5055,7 @@ function createGraphEntry(entry, markdown, contentIndex, locations) {
     permalink: location.permalink,
     publicLocation: location,
     title: slug,
+    aliases: [],
     frontmatter: {},
     publishing: resolvePublishingState(
       {},
@@ -5001,6 +5148,7 @@ export {
   buildOutputInventory,
   calculateReadingTime,
   collectConfigDeprecationDiagnostics,
+  computePipelineFingerprint,
   createClientEntry,
   createContentGraph,
   createDeprecationDiagnostic,
@@ -5019,6 +5167,7 @@ export {
   fingerprintContentEntries,
   formatDeprecationMessage,
   getContentSourceEntry,
+  getEntryLanguage,
   getExtension,
   getResolvedPluginMetadata,
   groupContentEntries,
@@ -5028,11 +5177,13 @@ export {
   isIgnoredContentPath,
   isImagePath,
   isMarkdownPath,
+  isPersistentlyCacheable,
   isPublishable,
   isPublished,
   layoutForceGraph,
   layoutRadialGraph,
   loadContentBuildState,
+  matchContentExcludePattern,
   normalizeContentAssetOutputPath,
   normalizeContentPath,
   normalizeGeneratedOutputPath,
@@ -5052,8 +5203,10 @@ export {
   resolveFolderLocation,
   resolveGeneratedFolderLocation,
   resolvePlugins,
+  resolvePublicFolderLocation,
   resolvePublishingBuildTime,
   resolvePublishingState,
+  selectEntriesByLanguage,
   serializePublicClientConfig,
   stableStringify,
   stripHtml,

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

@@ -3,7 +3,7 @@ import type { ContentManifest, ContentManifestEntry } from "../types/content_man
 import { determineAffectedContent } from "./affected_content.js";
 import { type ContentBuildState, type FingerprintedContentEntry } from "./content_build_state.js";
 import { type ContentChangeSet } from "./content_change_set.js";
-import type { CachedContentDependency } from "./content_dependency_tracker.js";
+import { type CachedContentDependency } from "./content_dependency_tracker.js";
 import type { ContentSourceEntry } from "./content_source.js";
 import type { OutputDescriptor } from "./output_dependency.js";
 export type ContentBuildPreparation = {

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 = 6;
+export declare const CONTENT_BUILD_STATE_VERSION = 7;
 /**
  * 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_dependency_tracker.d.ts

@@ -1,4 +1,6 @@
 import type { ContentSource, ContentSourceContent } from "./content_source.js";
+export declare const LINK_INDEX_PREFIX = "index:";
+export declare const LINK_LOCATION_PREFIX = "location:";
 export type CachedContentDependency = {
     readonly kind: "content" | "file" | "link";
     readonly id: string;

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

@@ -0,0 +1,3 @@
+import type { ContentManifestEntry } from "../types/content_manifest.js";
+export declare function getEntryLanguage(entry: ContentManifestEntry): string | undefined;
+export declare function selectEntriesByLanguage(entries: readonly ContentManifestEntry[], language: string | undefined): readonly ContentManifestEntry[];

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

@@ -1,8 +1,5 @@
 import type { PostFrontmatter } from "../types/post_content.js";
 /**
- * Reads the optional, source-authored stable content ID.
- *
- * `id` is the canonical frontmatter field. `uid` is accepted only for
- * compatibility with existing content that used it before `id` was standard.
+ * Reads the optional, source-authored stable content ID from frontmatter.
  */
 export declare function resolveContentStableId(frontmatter: PostFrontmatter): string | undefined;

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

@@ -1,13 +1,22 @@
 import type { ContentSource, ContentSourceContent, ContentSourceEntry } from "./content_source.js";
 export declare const INTERNAL_CONTENT_IGNORE_PATTERNS: readonly [".git", ".git/**", ".github", ".github/**", ".obsidian", ".obsidian/**", "node_modules", "node_modules/**", "**/.DS_Store", "**/Thumbs.db", "**/desktop.ini"];
+export type ContentSourceExclusion = {
+    readonly path: string;
+    readonly pattern: string;
+};
+export type ContentSourceScan = {
+    readonly entries: readonly ContentSourceEntry[];
+    readonly exclusions: readonly ContentSourceExclusion[];
+};
 export declare class FileSystemContentSource implements ContentSource {
     private contentDirectory;
     private exclude;
     constructor(contentDirectory: string, exclude?: readonly string[]);
     scan(): Promise<readonly ContentSourceEntry[]>;
+    scanWithExclusions(): Promise<ContentSourceScan>;
     read(entry: ContentSourceEntry): Promise<ContentSourceContent>;
     private scanDirectory;
-    private isExcluded;
     private resolveFilePath;
 }
 export declare function isIgnoredContentPath(logicalPath: string, exclude?: readonly string[]): boolean;
+export declare function matchContentExcludePattern(logicalPath: string, exclude?: readonly string[]): string | undefined;

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

@@ -32,4 +32,5 @@ 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;

package/dist/src/pipeline.d.ts

@@ -29,6 +29,7 @@ export declare class Pipeline {
     private reportContentDependencies;
     private getPermalink;
     private resolveLinkDependency;
+    private recordNoteLinkDependencies;
     private use;
     private createNoteEmbedRenderer;
     private resolvePlugins;

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

@@ -1,11 +1,13 @@
+import type { Tracer } from "../observability.js";
 import type { RiebeckitePlugin } from "../types/plugin.js";
 import type { PluginLifecycleContext, PluginManifestContext } from "../types/plugin_context.js";
-type LifecycleHookName = "setup" | "buildStart" | "buildEnd" | "dispose";
-export declare class PluginLifecycleError extends Error {
-    constructor(pluginName: string, hookName: LifecycleHookName, cause: unknown);
+export declare class PluginHookError extends Error {
+    constructor(pluginName: string, hookName: string, cause: unknown);
 }
+export declare function runPluginHook<TContext extends {
+    tracer: Tracer;
+}, TResult>(plugin: RiebeckitePlugin, hookName: string, context: TContext, hook: (context: TContext) => TResult | Promise<TResult>): Promise<TResult>;
 export declare function runSetup(plugins: readonly RiebeckitePlugin[], createContext: (plugin: RiebeckitePlugin) => PluginLifecycleContext): Promise<void>;
 export declare function runBuildStart(plugins: readonly RiebeckitePlugin[], createContext: (plugin: RiebeckitePlugin) => PluginLifecycleContext): Promise<void>;
 export declare function runBuildEnd(plugins: readonly RiebeckitePlugin[], createContext: (plugin: RiebeckitePlugin) => PluginManifestContext): Promise<void>;
 export declare function runDispose(plugins: readonly RiebeckitePlugin[], createContext: (plugin: RiebeckitePlugin) => PluginLifecycleContext): Promise<void>;
-export {};

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

@@ -12,7 +12,7 @@ import type { PostContent } from "../types/post_content.js";
  * requested yet; the remaining values name the stage currently executing.
  * Once `started` is reached the lifecycle never runs again.
  */
-export type PluginBuildStage = "idle" | "setup" | "buildStart" | "onBuildStart" | "onConfigResolved" | "started";
+export type PluginBuildStage = "idle" | "setup" | "buildStart" | "onConfigResolved" | "started";
 export declare class PluginRuntime {
     private pipelineOptions;
     private buildLifecycle;
@@ -23,6 +23,7 @@ export declare class PluginRuntime {
     private generatedOutputs;
     private isBuildTime;
     private resolvedPlugins;
+    private pageDeclarations;
     constructor(pipelineOptions?: PipelineOptions);
     getDiagnostics(): Diagnostic[];
     getBuildStage(): PluginBuildStage;
@@ -30,7 +31,7 @@ export declare class PluginRuntime {
      * 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: Map<string, string>): Promise<void>;
@@ -61,6 +62,8 @@ export declare class PluginRuntime {
     getPagePaths(manifest: ContentManifest, contentIndex: Map<string, string>): Promise<readonly string[]>;
     getPageRoutes(manifest: ContentManifest, contentIndex: Map<string, string>): Promise<readonly PluginPageRoute[]>;
     getPageOutputs(manifest: ContentManifest, contentIndex: Map<string, string>): Promise<readonly OutputDescriptor[]>;
+    private getPageDeclarations;
+    private resolvePageDeclarations;
     getContentOutputDependencies(): readonly OutputDependency[];
     collectDiagnostics(contentIndex: Map<string, string>): Promise<Diagnostic[]>;
     private runBuildLifecycle;

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

@@ -24,7 +24,7 @@ export type ContentManifestPluginAsset = PluginAsset & {
  * The standard article consumer recognizes the `article.*` positions below.
  * Other names remain valid so a custom Site can define its own layout slots.
  */
-export type ContentBodySlot = "article.after-header" | "article.after-meta" | "article.aside" | "article.before-content" | "article.after-content" | "article.footer" | (string & {});
+export type ContentBodySlot = "article.header" | "article.metadata" | "article.aside" | "article.before-content" | "article.after-content" | "article.footer" | (string & {});
 /** Client entries and their explicitly public configuration. */
 export type ContentManifestPluginClientEntry = PluginClientEntry;
 export type ContentManifestEntry = {
@@ -37,6 +37,7 @@ export type ContentManifestEntry = {
     permalink: string;
     publicLocation: ContentPublicLocation;
     title: string;
+    aliases?: readonly string[];
     frontmatter: PostFrontmatter;
     publishing: ResolvedPublishingState;
     html: string;
@@ -70,6 +71,7 @@ export type ContentRedirect = {
 export type ContentPublicLocation = {
     slug: string;
     permalink: string;
+    language?: string;
     redirects?: readonly ContentRedirect[];
     metadata?: Readonly<Record<string, string>>;
 };
@@ -89,9 +91,10 @@ export type ContentLocationInput = {
 export type ContentManifest = {
     entries: ContentManifestEntry[];
     /**
-     * Entries that pass the configured publish strategy. `entries` keeps every
-     * scanned note for backward compatibility; publishing plugins should read
-     * this view so unpublished notes never reach generated output.
+     * Entries that are routable and therefore get a generated page: `public`
+     * and `unlisted` notes. `entries` keeps every scanned note for backward
+     * compatibility; plugins that emit generated output should read this view
+     * so drafts and scheduled notes never reach generated output.
      */
     publicEntries: ContentManifestEntry[];
     /** Entries that may appear on discovery surfaces such as navigation, search, feeds, taxonomy, and public graphs. */
@@ -99,6 +102,7 @@ export type ContentManifest = {
     bySlug: Map<string, ContentManifestEntry>;
     /** Contains only entries with an explicit source-authored content ID. */
     byContentId: Map<string, ContentManifestEntry>;
+    byAlias: Map<string, ContentManifestEntry[]>;
     byPermalink: Map<string, ContentManifestEntry>;
     /** Contains only routable entries: public and unlisted, excluding draft and scheduled-before entries. */
     byRoutablePermalink: Map<string, ContentManifestEntry>;

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

@@ -59,8 +59,6 @@ export type RiebeckitePlugin<TOptions = unknown> = {
     onPostParsed?(context: PluginPostContext): void | Promise<void>;
     onPostProcessed?(context: PluginPostContext): void | Promise<void>;
     onManifestCreated?(context: PluginManifestContext): void | Promise<void>;
-    onBuildStart?(context: PluginContext): void | Promise<void>;
-    onBuildEnd?(context: PluginManifestContext): void | Promise<void>;
     extendMarkdownPipeline?(pipeline: MarkdownPipeline, context: MarkdownPipelineContext): void;
     extendHtmlPipeline?(pipeline: HtmlPipeline): void;
     addDiagnostics?(context: PluginContext): Diagnostic[] | Promise<Diagnostic[]>;

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

@@ -14,6 +14,8 @@ export type PluginPage = {
     description?: string;
     /** Optional document metadata rendered by the site's document frame. */
     headTags?: readonly PluginHeadTag[];
+    /** Language of the page when the page type resolved one. */
+    language?: string;
 };
 export type PluginPageContext = PluginContext & {
     /** The public manifest. Unpublished content is not exposed through pages. */

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

@@ -1,4 +1,5 @@
 import type { ContentManifestEntry } from "./content_manifest.js";
+import type { PluginHeadTag } from "./plugin_head.js";
 import type { PostContent } from "./post_content.js";
 import type { ResolvedRiebeckiteConfig } from "./resolved_riebeckite_config.js";
 export type SeoMetadata = {
@@ -24,8 +25,8 @@ export type RenderableFeedEntry = ContentManifestEntry & {
     html?: string;
 };
 export type PluginSeoExtension = {
-    buildArticleSeo(config: ResolvedRiebeckiteConfig, permalink: string, post: PostContent): SeoMetadata;
-    buildWebsiteSeo(config: ResolvedRiebeckiteConfig, input: WebsiteSeoInput): SeoMetadata;
+    buildArticleSeo(config: ResolvedRiebeckiteConfig, permalink: string, post: PostContent, headTags?: readonly PluginHeadTag[]): SeoMetadata;
+    buildWebsiteSeo(config: ResolvedRiebeckiteConfig, input: WebsiteSeoInput, headTags?: readonly PluginHeadTag[]): SeoMetadata;
     buildAbsoluteUrl(config: ResolvedRiebeckiteConfig, pathOrUrl: string): string;
     buildPostUrl(config: ResolvedRiebeckiteConfig, permalink: string): string;
     getDescription(post: Pick<PostContent, "frontmatter" | "html">): string;

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

@@ -8,8 +8,6 @@ export type PostFrontmatter = Record<string, unknown> & {
      * this value survives a rename or public-location change.
      */
     id?: string;
-    /** @deprecated Use `id`. Read only as a compatibility fallback. */
-    uid?: string;
     title?: string;
     description?: string;
     date?: string | Date;

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

@@ -9,7 +9,13 @@ export type ResolvedRiebeckiteConfig = {
      * relative to their application root.
      */
     buildDirectory?: string;
-    site: Required<SiteConfig>;
+    site: Omit<Required<SiteConfig>, "feed"> & {
+        feed: {
+            title: string;
+            description: string;
+            language: string;
+        };
+    };
     content: {
         directory: string;
         source?: ContentSource;
@@ -18,11 +24,6 @@ export type ResolvedRiebeckiteConfig = {
             publishStrategy: PublishStrategy;
         };
     };
-    markdown: {
-        syntaxHighlight: {
-            theme: string;
-        };
-    };
     theme: Required<Omit<ThemeConfig, "tokens">> & {
         tokens: NonNullable<ThemeConfig["tokens"]>;
         styles: ThemeStyle[];

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

@@ -13,11 +13,6 @@ export interface RiebeckiteConfig {
             publishStrategy?: PublishStrategy;
         };
     };
-    markdown?: {
-        syntaxHighlight?: {
-            theme?: string;
-        };
-    };
     theme?: ThemeInput;
     plugins?: PluginInput[];
     cache?: {

package/package.json

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