@riebeckite/core 0.0.18 → 0.0.20

package/README.md

@@ -37,7 +37,7 @@ export default defineConfig({
 ```
 
 The content directory is resolved relative to the application root. See
-[Configuration](../../docs/docs/reference/configuration.en.md) for the full field list and the
+[Configuration](../../docs/docs/reference/configuration.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/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)
+- [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/README_ja.md

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

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 export { defineConfig, isExcluded, isPublished, resolveConfig, resolveConfigModule, } from "./src/config.js";
-export { type ConfigDeprecationNotice, collectConfigDeprecationDiagnostics, } from "./src/config_deprecations.js";
 export { ConfigValidationError } from "./src/config_validation.js";
 export { ATTACHMENTS_BASE_PATH, attachmentUrl, getExtension, isAttachmentPath, isImagePath, isMarkdownPath, normalizeContentPath, } from "./src/content/attachment.js";
 export type { ContentBuildState, FingerprintedContentEntry, } from "./src/content/content_build_state.js";
@@ -33,19 +32,19 @@ export { buildOutputInventory, determineOutputChanges, htmlOutputPath, } from ".
 export type { PublishingResolutionOptions, PublishingVisibility, ResolvedPublishingState, } from "./src/content/publishing.js";
 export { resolvePublishingBuildTime, resolvePublishingState, } from "./src/content/publishing.js";
 export { readOnlyContentGraph } from "./src/content/read_only_content_graph.js";
-export { createDeprecationDiagnostic, type DeprecationKind, type DeprecationNotice, formatDeprecationMessage, } from "./src/deprecation.js";
 export type { LogContext, Logger, LogLevel, Observability, ObservabilityValue, TraceAttributes, TraceEvent, Tracer, TraceSink, TraceSpan, } from "./src/observability.js";
 export { CompositeTraceSink, ConsoleLogger, NoopLogger, NoopTracer, SinkTracer, } from "./src/observability.js";
 export type { PipelineOptions } from "./src/pipeline.js";
 export { Pipeline } from "./src/pipeline.js";
 export type { PluginCache } from "./src/plugin/plugin_cache.js";
 export { PluginDependencyError, type PluginDependencyErrorKind, } from "./src/plugin/plugin_dependency_error.js";
+export { PluginHookError } from "./src/plugin/plugin_lifecycle.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";
+export type { ContentAsset, ContentBodySlot, ContentBodySlots, ContentLink, ContentLinkKind, ContentLocationInput, ContentManifest, ContentManifestEntry, ContentManifestPluginClientEntry, ContentPublicLocation, ContentRedirect, FolderLocation, PluginPageRoute, } from "./src/types/content_manifest.js";
+export { ARTICLE_SLOT, appendContentBodySlot, } from "./src/types/content_manifest.js";
 export type { Diagnostic, DiagnosticCode, DiagnosticSeverity, } from "./src/types/diagnostic.js";
 export type { ContentAssetOutputInput, GeneratedOutput, GeneratedOutputContent, GeneratedOutputInput, GeneratedOutputSink, } from "./src/types/generated_output.js";
 export { createUnavailableGeneratedOutputSink, normalizeContentAssetOutputPath, normalizeGeneratedOutputPath, } from "./src/types/generated_output.js";
@@ -74,5 +73,7 @@ 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 type { MarkdownFenceLine } from "./src/utils/markdown.js";
+export { scanMarkdownFenceLines } from "./src/utils/markdown.js";
 export { normalizeTag } from "./src/utils/tags.js";
 export { calculateReadingTime, stripHtml } from "./src/utils/text.js";

package/dist/index.js

@@ -778,46 +778,6 @@ function globToRegExp(glob) {
   return new RegExp(`^${re}$`);
 }
 
-// src/deprecation.ts
-function createDeprecationDiagnostic(notice) {
-  return {
-    code: `deprecated-${notice.kind}`,
-    severity: "warning",
-    message: formatDeprecationMessage(notice),
-    target: notice.target,
-    suggestion: notice.replacement ? `Use ${notice.replacement}. ${notice.action}` : notice.action,
-    meta: { deprecation: notice }
-  };
-}
-function formatDeprecationMessage(notice) {
-  const lines = [
-    `Deprecated: ${notice.target}`,
-    `Deprecated since: ${notice.deprecatedSince}`
-  ];
-  if (notice.replacement) lines.push(`Use: ${notice.replacement}`);
-  lines.push(`Migration: ${notice.action}`);
-  if (notice.documentationUrl) lines.push(`See: ${notice.documentationUrl}`);
-  if (notice.removedIn) lines.push(`Removal planned: ${notice.removedIn}`);
-  return lines.join("\n");
-}
-
-// src/config_deprecations.ts
-var configDeprecations = [];
-function collectConfigDeprecationDiagnostics(config, notices = configDeprecations) {
-  return notices.filter((notice) => hasConfigPath(config, notice.path)).map(createDeprecationDiagnostic);
-}
-function hasConfigPath(config, path6) {
-  let value = config;
-  for (const segment of path6.split(".")) {
-    if (!isRecord2(value) || !(segment in value)) return false;
-    value = value[segment];
-  }
-  return value !== void 0;
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 // src/content/image_extensions.ts
 var IMAGE_EXTENSIONS = [
   "png",
@@ -895,7 +855,7 @@ async function readContentBuildStateStatus(statePath) {
     }
     throw error;
   }
-  if (!isRecord3(parsed)) {
+  if (!isRecord2(parsed)) {
     return { kind: "invalid", path: statePath, reason: "invalid-shape" };
   }
   if (parsed.version !== CONTENT_BUILD_STATE_VERSION) {
@@ -935,15 +895,15 @@ function resolveContentBuildStatePath(config, contentDirectory) {
   );
 }
 function isContentBuildState(value) {
-  return isRecord3(value) && value.version === CONTENT_BUILD_STATE_VERSION && isContentBuildStateShape(value);
+  return isRecord2(value) && value.version === CONTENT_BUILD_STATE_VERSION && isContentBuildStateShape(value);
 }
 function isContentBuildStateShape(value) {
-  if (!isRecord3(value.entries) || !isRecord3(value.contentIndex) || value.outputs !== void 0 && !isOutputDescriptors(value.outputs)) {
+  if (!isRecord2(value.entries) || !isRecord2(value.contentIndex) || value.outputs !== void 0 && !isOutputDescriptors(value.outputs)) {
     return false;
   }
   return Object.values(value.entries).every(
-    (entry) => isRecord3(entry) && typeof entry.fingerprint === "string" && entry.fingerprint.length > 0 && Array.isArray(entry.aliases) && entry.aliases.every((alias) => typeof alias === "string") && Array.isArray(entry.dependencies) && entry.dependencies.every(
-      (dependency) => isRecord3(dependency) && (dependency.kind === "content" || dependency.kind === "file") && typeof dependency.id === "string"
+    (entry) => isRecord2(entry) && typeof entry.fingerprint === "string" && entry.fingerprint.length > 0 && Array.isArray(entry.aliases) && entry.aliases.every((alias) => typeof alias === "string") && Array.isArray(entry.dependencies) && entry.dependencies.every(
+      (dependency) => isRecord2(dependency) && (dependency.kind === "content" || dependency.kind === "file") && typeof dependency.id === "string"
     )
   ) && Object.values(value.contentIndex).every(
     (entry) => typeof entry === "string"
@@ -951,7 +911,7 @@ function isContentBuildStateShape(value) {
 }
 function isOutputDescriptors(value) {
   return Array.isArray(value) && value.every(
-    (output) => isRecord3(output) && (output.kind === "content" || output.kind === "redirect" || output.kind === "plugin-page" || output.kind === "generated") && isOutputPath(output.path) && typeof output.producer === "string" && Array.isArray(output.dependencies) && output.dependencies.every(isOutputDependency)
+    (output) => isRecord2(output) && (output.kind === "content" || output.kind === "redirect" || output.kind === "plugin-page" || output.kind === "generated") && isOutputPath(output.path) && typeof output.producer === "string" && Array.isArray(output.dependencies) && output.dependencies.every(isOutputDependency)
   );
 }
 function isOutputPath(value) {
@@ -961,11 +921,11 @@ function isOutputPath(value) {
   return value.split("/").every((segment) => segment !== "." && segment !== "..");
 }
 function isOutputDependency(value) {
-  if (!isRecord3(value) || typeof value.type !== "string") return false;
+  if (!isRecord2(value) || typeof value.type !== "string") return false;
   if (value.type === "global" || value.type === "unknown") return true;
   return value.type === "content" && typeof value.slug === "string" || value.type === "tag" && typeof value.tag === "string" || value.type === "folder" && typeof value.folder === "string";
 }
-function isRecord3(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNotFoundError(error) {
@@ -1727,47 +1687,65 @@ async function writeAtomically(targetPath, dir, serialized) {
     throw error;
   }
 }
+function isMissingFileError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
 function createPersistentContentCache(options) {
   const { config, logger, tracer } = options;
   const baseDir = cacheDirectory(config);
   const versionDir = versionDirectory(baseDir);
-  return {
-    async get(key) {
-      if (!config.cache?.enabled) return void 0;
+  const cache = {
+    async lookup(key) {
+      if (!config.cache?.enabled) {
+        return { status: "miss", reason: "disabled" };
+      }
       const filePath = cacheFilePath(baseDir, key);
+      let raw;
       try {
-        const raw = await fs2.readFile(filePath, "utf8");
-        const entry = JSON.parse(raw);
-        if (entry.schemaVersion !== CONTENT_CACHE_SCHEMA_VERSION) {
-          tracer?.event("persistentContentCache.schemaMismatch", { key });
-          return void 0;
-        }
-        if (entry.key !== key) {
-          tracer?.event("persistentContentCache.keyMismatch", { key });
-          return void 0;
-        }
-        if (!isValidCacheEntry(entry)) {
-          tracer?.event("persistentContentCache.invalidShape", { key });
-          return void 0;
-        }
-        tracer?.event("persistentContentCache.found", { key });
-        return entry;
+        raw = await fs2.readFile(filePath, "utf8");
       } catch (error) {
-        if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
-          tracer?.event("persistentContentCache.miss", { key });
-          return void 0;
+        if (isMissingFileError(error)) {
+          return { status: "miss", reason: "no-entry" };
         }
-        if (error instanceof SyntaxError) {
-          logger?.warn(
-            "Persistent content cache entry is corrupted and will be ignored.",
-            {
-              key
-            }
-          );
-          return void 0;
-        }
-        throw error;
+        logger?.warn(
+          "Persistent content cache entry could not be read and will be ignored.",
+          {
+            key,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        );
+        return { status: "miss", reason: "unreadable" };
       }
+      let entry;
+      try {
+        entry = JSON.parse(raw);
+      } catch (error) {
+        logger?.warn(
+          "Persistent content cache entry is corrupted and will be ignored.",
+          {
+            key,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        );
+        return { status: "miss", reason: "corrupted" };
+      }
+      if (typeof entry !== "object" || entry === null) {
+        return { status: "miss", reason: "invalid-entry" };
+      }
+      if (entry.schemaVersion !== CONTENT_CACHE_SCHEMA_VERSION) {
+        return { status: "miss", reason: "schema-mismatch" };
+      }
+      if (entry.key !== key) {
+        return { status: "miss", reason: "key-mismatch" };
+      }
+      if (!isValidCacheEntry(entry)) {
+        return { status: "miss", reason: "invalid-entry" };
+      }
+      return { status: "hit", entry };
+    },
+    async get(key) {
+      const result = await cache.lookup(key);
+      return result.status === "hit" ? result.entry : void 0;
     },
     async set(key, value) {
       if (!config.cache?.enabled) return;
@@ -1778,8 +1756,18 @@ function createPersistentContentCache(options) {
           "Persistent content cache values must be JSON serializable."
         );
       }
-      await writeAtomically(filePath, versionDir, serialized);
-      tracer?.event("persistentContentCache.write", { key });
+      try {
+        await writeAtomically(filePath, versionDir, serialized);
+        tracer?.event("persistentContentCache.write", { key });
+      } catch (error) {
+        logger?.warn(
+          "Persistent content cache entry could not be written and will be ignored.",
+          {
+            key,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        );
+      }
     },
     async clear() {
       try {
@@ -1788,6 +1776,7 @@ function createPersistentContentCache(options) {
       }
     }
   };
+  return cache;
 }
 function isValidCacheEntry(entry) {
   return typeof entry === "object" && entry !== null && typeof entry.key === "string" && typeof entry.schemaVersion === "number" && Array.isArray(entry.dependencies) && entry.dependencies.every(isValidDependency) && typeof entry.value === "object" && entry.value !== null && typeof entry.value.html === "string" && typeof entry.value.frontmatter === "object" && entry.value.frontmatter !== null && !Array.isArray(entry.value.frontmatter);
@@ -2136,41 +2125,15 @@ var Pipeline = class {
           frontmatter,
           pipelineFingerprint: this.pipelineFingerprint
         });
-        const cachedEntry = await this.persistentCache.get(cacheKey);
-        if (cachedEntry) {
-          const validationTracker = createContentDependencyTracker(
-            this.options.contentSource
+        const lookup = await this.persistentCache.lookup(cacheKey);
+        if (lookup.status === "hit") {
+          const invalidDependency = await this.findInvalidDependency(
+            lookup.entry.dependencies
           );
-          let valid = true;
-          for (const dep of cachedEntry.dependencies) {
-            if (dep.kind === "content") {
-              const content = await validationTracker.readContent(
-                dep.id,
-                async () => await this.getMarkdownBySlug?.(dep.id) ?? ""
-              );
-              if (fingerprintContent(content) !== dep.fingerprint) {
-                valid = false;
-                break;
-              }
-            } else if (dep.kind === "file") {
-              const fileContent = await validationTracker.contentSource.read({
-                path: dep.id
-              });
-              if (fingerprintContent(fileContent) !== dep.fingerprint) {
-                valid = false;
-                break;
-              }
-            } else if (dep.kind === "link") {
-              if (fingerprintContent(this.resolveLinkDependency(dep.id)) !== dep.fingerprint) {
-                valid = false;
-                break;
-              }
-            }
-          }
-          if (valid) {
+          if (!invalidDependency) {
             this.reportContentDependencies(
               sourceSlug,
-              cachedEntry.dependencies
+              lookup.entry.dependencies
             );
             this.options.observability?.tracer?.event(
               "persistentContentCache.hit",
@@ -2178,16 +2141,32 @@ var Pipeline = class {
             );
             this.options.onPersistentContentCacheResult?.("hit");
             return {
-              frontmatter: cachedEntry.value.frontmatter,
-              html: cachedEntry.value.html
+              frontmatter: lookup.entry.value.frontmatter,
+              html: lookup.entry.value.html
             };
           }
+          this.options.observability?.tracer?.event(
+            "persistentContentCache.miss",
+            {
+              key: cacheKey,
+              slug: sourceSlug,
+              reason: "dependency-changed",
+              dependencyKind: invalidDependency.kind,
+              dependencyId: invalidDependency.id
+            }
+          );
+          this.options.onPersistentContentCacheResult?.("miss");
+        } else {
+          this.options.observability?.tracer?.event(
+            "persistentContentCache.miss",
+            {
+              key: cacheKey,
+              slug: sourceSlug,
+              reason: lookup.reason
+            }
+          );
+          this.options.onPersistentContentCacheResult?.("miss");
         }
-        this.options.observability?.tracer?.event(
-          "persistentContentCache.miss",
-          { key: cacheKey, slug: sourceSlug }
-        );
-        this.options.onPersistentContentCacheResult?.("miss");
       } else {
         this.options.observability?.tracer?.event(
           "persistentContentCache.bypass",
@@ -2299,6 +2278,30 @@ var Pipeline = class {
   reportContentDependencies(slug, dependencies) {
     this.options.onContentDependencies?.(slug, dependencies);
   }
+  async findInvalidDependency(dependencies) {
+    const contentSource = this.options.contentSource;
+    if (!contentSource) return null;
+    const validationTracker = createContentDependencyTracker(contentSource);
+    for (const dep of dependencies) {
+      if (dep.kind === "content") {
+        const content = await validationTracker.readContent(
+          dep.id,
+          async () => await this.getMarkdownBySlug?.(dep.id) ?? ""
+        );
+        if (fingerprintContent(content) !== dep.fingerprint) return dep;
+      } else if (dep.kind === "file") {
+        const fileContent = await validationTracker.contentSource.read({
+          path: dep.id
+        });
+        if (fingerprintContent(fileContent) !== dep.fingerprint) return dep;
+      } else if (dep.kind === "link") {
+        if (fingerprintContent(this.resolveLinkDependency(dep.id)) !== dep.fingerprint) {
+          return dep;
+        }
+      }
+    }
+    return null;
+  }
   getPermalink(slug) {
     const permalink = this.permalinks.get(slug);
     if (!permalink) {
@@ -3680,9 +3683,14 @@ var ContentEntryReader = class {
     if (cached) return cached;
     const content = this.source.read(entry).then(
       (value) => typeof value === "string" ? value : new TextDecoder().decode(value)
-    ).finally(() => this.texts.delete(entry.path));
-    this.texts.set(entry.path, content);
-    return content;
+    );
+    const retain = entry.path.endsWith(".md");
+    const tracked = retain ? content : content.finally(() => this.texts.delete(entry.path));
+    this.texts.set(entry.path, tracked);
+    return tracked;
+  }
+  clearReadCache() {
+    this.texts.clear();
   }
 };
 
@@ -3826,10 +3834,12 @@ var FileSystemContentSource = class {
   async scanWithExclusions() {
     const exclusions = [];
     try {
+      const templaterTemplateFolder = await this.resolveTemplaterTemplateFolder();
       const entries = await this.scanDirectory(
         this.contentDirectory,
         "",
-        exclusions
+        exclusions,
+        templaterTemplateFolder
       );
       return { entries, exclusions };
     } catch (error) {
@@ -3847,7 +3857,7 @@ var FileSystemContentSource = class {
     }
     return await fs4.readFile(filePath);
   }
-  async scanDirectory(directory, parentPath2, exclusions) {
+  async scanDirectory(directory, parentPath2, exclusions, templaterTemplateFolder) {
     const directoryEntries = await fs4.readdir(directory, {
       withFileTypes: true
     });
@@ -3864,9 +3874,21 @@ var FileSystemContentSource = class {
         exclusions.push({ path: logicalPath, pattern });
         continue;
       }
+      if (templaterTemplateFolder && isTemplaterTemplatePath(logicalPath, templaterTemplateFolder)) {
+        exclusions.push({
+          path: logicalPath,
+          pattern: `Obsidian Templater templates_folder: ${templaterTemplateFolder}`
+        });
+        continue;
+      }
       if (directoryEntry.isDirectory()) {
         entries.push(
-          ...await this.scanDirectory(filePath, logicalPath, exclusions)
+          ...await this.scanDirectory(
+            filePath,
+            logicalPath,
+            exclusions,
+            templaterTemplateFolder
+          )
         );
         continue;
       }
@@ -3891,6 +3913,28 @@ var FileSystemContentSource = class {
     }
     return filePath;
   }
+  async resolveTemplaterTemplateFolder() {
+    const settingsPath = path4.join(
+      this.contentDirectory,
+      ".obsidian",
+      "plugins",
+      "templater-obsidian",
+      "data.json"
+    );
+    let raw;
+    try {
+      raw = await fs4.readFile(settingsPath, "utf8");
+    } catch (error) {
+      if (isFileNotFoundError(error)) return void 0;
+      throw error;
+    }
+    try {
+      const settings = JSON.parse(raw);
+      return normalizeTemplaterTemplateFolder(settings.templates_folder);
+    } catch {
+      return void 0;
+    }
+  }
 };
 function isIgnoredContentPath(logicalPath, exclude = []) {
   if (isExcluded(INTERNAL_CONTENT_IGNORE_PATTERNS, logicalPath)) return true;
@@ -3903,6 +3947,17 @@ function matchContentExcludePattern(logicalPath, exclude = []) {
   const withoutExtension = logicalPath.slice(0, -3);
   return exclude.find((pattern) => isExcluded([pattern], withoutExtension));
 }
+function isTemplaterTemplatePath(logicalPath, templateFolder) {
+  return logicalPath === templateFolder || logicalPath.startsWith(`${templateFolder}/`);
+}
+function normalizeTemplaterTemplateFolder(value) {
+  if (typeof value !== "string" || value.trim().length === 0) return void 0;
+  const normalized = normalizeContentPath(value.trim()).replace(/\/+$/, "");
+  if (normalized.length === 0 || normalized.startsWith("/") || path4.isAbsolute(normalized) || path4.win32.isAbsolute(normalized) || normalized.split("/").some((segment) => segment === "..")) {
+    return void 0;
+  }
+  return normalized;
+}
 function normalizeLogicalPath(logicalPath) {
   const normalizedPath = normalizeContentPath(logicalPath);
   if (normalizedPath.length === 0 || normalizedPath.startsWith("/") || path4.isAbsolute(normalizedPath) || path4.win32.isAbsolute(normalizedPath) || normalizedPath.split("/").some((segment) => segment === "..")) {
@@ -3913,6 +3968,9 @@ function normalizeLogicalPath(logicalPath) {
 function isMissingDirectoryError(error, directory) {
   return error instanceof Error && "code" in error && error.code === "ENOENT" && "path" in error && error.path === directory;
 }
+function isFileNotFoundError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
 function missingContentDirectoryError(directory) {
   const relative = path4.relative(process.cwd(), directory);
   const display = relative && !relative.startsWith("..") ? relative : directory;
@@ -4348,6 +4406,7 @@ var ContentManager = class {
   routableSlugs = null;
   routableSlugsPromise = null;
   processedContentCount = 0;
+  reusedContentCount = 0;
   outputChangeSet = null;
   trackedContentDependencies = /* @__PURE__ */ new Map();
   async getAllPosts() {
@@ -4575,6 +4634,12 @@ var ContentManager = class {
   async build(options = {}) {
     return await this.getManifest(options);
   }
+  getProcessedContentCount() {
+    return this.processedContentCount;
+  }
+  getReusedContentCount() {
+    return this.reusedContentCount;
+  }
   async getOutputChangeSet(options = {}) {
     await this.getManifest(options);
     if (!this.outputChangeSet) {
@@ -4650,6 +4715,7 @@ var ContentManager = class {
     return { entries, contentIndex, diagnostics };
   }
   async dispose() {
+    this.entryReader.clearReadCache();
     if (!this.contentIndex) return;
     await this.pluginRuntime.dispose(this.contentIndex);
   }
@@ -4712,6 +4778,7 @@ var ContentManager = class {
     if (preparation.affectedContent.dependent.has(slug)) return null;
     const entry = preparation.previousManifestEntriesBySlug.get(slug);
     if (!entry) return null;
+    this.reusedContentCount += 1;
     this.observability().tracer.event("content.reuse", { slug });
     return cloneManifestEntry(entry);
   }
@@ -5148,6 +5215,14 @@ function resolveBuildOutputDirectory(config) {
 }
 
 // src/types/content_manifest.ts
+var ARTICLE_SLOT = {
+  header: "article.header",
+  metadata: "article.metadata",
+  aside: "article.aside",
+  beforeContent: "article.before-content",
+  afterContent: "article.after-content",
+  footer: "article.footer"
+};
 function appendContentBodySlot(entry, slot, html) {
   if (!html.trim()) return;
   const previous = entry.bodySlots?.[slot];
@@ -5187,6 +5262,32 @@ function escapeScriptJson(value) {
   return value.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
 }
 
+// src/utils/markdown.ts
+var FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+var FENCE_CLOSE = /^ {0,3}(`{3,}|~{3,})\s*$/;
+function scanMarkdownFenceLines(source) {
+  const lines = [];
+  let fence = null;
+  for (const value of source.split("\n")) {
+    if (fence === null) {
+      const open = FENCE_OPEN.exec(value);
+      if (open && !(open[1][0] === "`" && open[2].includes("`"))) {
+        fence = { marker: open[1][0], length: open[1].length };
+      }
+      lines.push({ value, inFence: false });
+      continue;
+    }
+    const close = FENCE_CLOSE.exec(value);
+    if (close && close[1][0] === fence.marker && close[1].length >= fence.length) {
+      fence = null;
+      lines.push({ value, inFence: false });
+      continue;
+    }
+    lines.push({ value, inFence: true });
+  }
+  return lines;
+}
+
 // src/utils/text.ts
 function stripHtml(html) {
   return html.replace(/<script\b[\s\S]*?<\/script>/gi, " ").replace(/<style\b[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ");
@@ -5199,6 +5300,7 @@ function calculateReadingTime(html) {
   return Math.max(1, Math.ceil(cjkCharacters / 500 + latinWords / 220));
 }
 export {
+  ARTICLE_SLOT,
   ATTACHMENTS_BASE_PATH,
   CompositeTraceSink,
   ConfigValidationError,
@@ -5211,6 +5313,7 @@ export {
   NoopTracer,
   Pipeline,
   PluginDependencyError,
+  PluginHookError,
   SinkTracer,
   appendContentBodySlot,
   attachErrorPath,
@@ -5219,11 +5322,9 @@ export {
   buildGraphEdges,
   buildOutputInventory,
   calculateReadingTime,
-  collectConfigDeprecationDiagnostics,
   computePipelineFingerprint,
   createClientEntry,
   createContentGraph,
-  createDeprecationDiagnostic,
   createPluginMemo,
   createStyleAsset,
   createUnavailableGeneratedOutputSink,
@@ -5237,7 +5338,6 @@ export {
   escapeScriptJson,
   extractFrontmatterAliases,
   fingerprintContentEntries,
-  formatDeprecationMessage,
   getContentSourceEntry,
   getEntryLanguage,
   getExtension,
@@ -5280,6 +5380,7 @@ export {
   resolvePublicFolderLocation,
   resolvePublishingBuildTime,
   resolvePublishingState,
+  scanMarkdownFenceLines,
   selectEntriesByLanguage,
   serializePublicClientConfig,
   stableStringify,

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

@@ -11,4 +11,5 @@ export declare class ContentEntryReader {
     getEntries(): Promise<readonly ContentSourceEntry[]>;
     readText(logicalPath: string): Promise<string>;
     read(entry: ContentSourceEntry): Promise<string>;
+    clearReadCache(): void;
 }

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

@@ -44,6 +44,7 @@ export declare class ContentManager {
     private routableSlugs;
     private routableSlugsPromise;
     private processedContentCount;
+    private reusedContentCount;
     private outputChangeSet;
     private trackedContentDependencies;
     constructor(content: string | ContentSource, exclude?: string[], pipelineOptions?: PipelineOptions);
@@ -56,6 +57,8 @@ export declare class ContentManager {
     getManifest(options?: ContentBuildOptions): Promise<ContentManifest>;
     private buildManifest;
     build(options?: ContentBuildOptions): Promise<ContentManifest>;
+    getProcessedContentCount(): number;
+    getReusedContentCount(): number;
     getOutputChangeSet(options?: ContentBuildOptions): Promise<OutputChangeSet>;
     getBacklinks(targetSlug: string): Promise<Backlink[]>;
     getContentGraph(): Promise<ContentGraph>;

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

@@ -18,16 +18,21 @@ export type PersistentContentCacheOptions = {
 };
 export declare const CONTENT_CACHE_SCHEMA_VERSION = 3;
 export declare const CONTENT_CACHE_COMPATIBILITY_VERSION = 1;
-export type PersistentContentCache = {
-    get(key: string): Promise<PersistentContentCacheEntry | undefined>;
-    set(key: string, value: PersistentContentCacheEntry): Promise<void>;
-    clear(): Promise<void>;
+export type PersistentContentCacheMissReason = "disabled" | "no-entry" | "corrupted" | "unreadable" | "schema-mismatch" | "key-mismatch" | "invalid-entry";
+export type PersistentContentCacheLookup = {
+    status: "hit";
+    entry: PersistentContentCacheEntry;
+} | {
+    status: "miss";
+    reason: PersistentContentCacheMissReason;
 };
-export declare function createPersistentContentCache(options: PersistentContentCacheOptions): {
+export type PersistentContentCache = {
+    lookup(key: string): Promise<PersistentContentCacheLookup>;
     get(key: string): Promise<PersistentContentCacheEntry | undefined>;
     set(key: string, value: PersistentContentCacheEntry): Promise<void>;
     clear(): Promise<void>;
 };
+export declare function createPersistentContentCache(options: PersistentContentCacheOptions): PersistentContentCache;
 export type CacheKeyInputs = {
     slug: string;
     source: string;

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

@@ -17,6 +17,7 @@ export declare class FileSystemContentSource implements ContentSource {
     read(entry: ContentSourceEntry): Promise<ContentSourceContent>;
     private scanDirectory;
     private resolveFilePath;
+    private resolveTemplaterTemplateFolder;
 }
 export declare function isIgnoredContentPath(logicalPath: string, exclude?: readonly string[]): boolean;
 export declare function matchContentExcludePattern(logicalPath: string, exclude?: readonly string[]): string | undefined;

package/dist/src/pipeline.d.ts

@@ -27,6 +27,7 @@ export declare class Pipeline {
     execute(markDownContent: string, context?: MarkdownExecutionContext): Promise<PostContent>;
     private executeWithEmbedState;
     private reportContentDependencies;
+    private findInvalidDependency;
     private getPermalink;
     private resolveLinkDependency;
     private recordNoteLinkDependencies;

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

@@ -18,13 +18,36 @@ export type ContentAsset = {
 export type ContentManifestPluginAsset = PluginAsset & {
     path: string;
 };
+/**
+ * The standard `article.*` positions the article consumer recognizes.
+ *
+ * These constants are a convenience for Sites that prefer named references;
+ * writing the slot string inline (for example `name="article.metadata"`) stays
+ * the recommended, most readable form in TSX layouts.
+ */
+export declare const ARTICLE_SLOT: {
+    readonly header: "article.header";
+    readonly metadata: "article.metadata";
+    readonly aside: "article.aside";
+    readonly beforeContent: "article.before-content";
+    readonly afterContent: "article.after-content";
+    readonly footer: "article.footer";
+};
 /**
  * A semantic position in a Site-owned article layout.
  *
  * 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.header" | "article.metadata" | "article.aside" | "article.before-content" | "article.after-content" | "article.footer" | (string & {});
+export type ContentBodySlot = (typeof ARTICLE_SLOT)[keyof typeof ARTICLE_SLOT] | (string & {});
+/**
+ * A map of Plugin-provided HTML fragments keyed by slot name.
+ *
+ * The standard `article.*` names autocomplete while any custom slot name
+ * remains valid, so custom Plugins keep working. A slot is considered empty
+ * when its value is missing or whitespace-only.
+ */
+export type ContentBodySlots = Partial<Record<(typeof ARTICLE_SLOT)[keyof typeof ARTICLE_SLOT], string>> & Readonly<Record<string, string | undefined>>;
 /** Client entries and their explicitly public configuration. */
 export type ContentManifestPluginClientEntry = PluginClientEntry;
 export type ContentManifestEntry = {
@@ -91,15 +114,17 @@ export type ContentLocationInput = {
     markdown: string;
 };
 export type ContentManifest = {
+    /**
+     * Raw entries for every scanned content source, including drafts, scheduled,
+     * private, and otherwise nonpublic entries. This is not a publication view.
+     */
     entries: ContentManifestEntry[];
     /**
-     * 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.
+     * Routable entries for generated pages: `public` and `unlisted` notes.
+     * Plugins that emit public output must use this view rather than `entries`.
      */
     publicEntries: ContentManifestEntry[];
-    /** Entries that may appear on discovery surfaces such as navigation, search, feeds, taxonomy, and public graphs. */
+    /** Public entries allowed on discovery surfaces such as navigation, search, feeds, taxonomy, and public graphs. */
     discoverableEntries: ContentManifestEntry[];
     bySlug: Map<string, ContentManifestEntry>;
     /** Contains only entries with an explicit source-authored content ID. */

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

@@ -18,7 +18,11 @@ export type PluginPage = {
     language?: string;
 };
 export type PluginPageContext = PluginContext & {
-    /** The public manifest. Unpublished content is not exposed through pages. */
+    /**
+     * The resolved manifest. `manifest.entries` still contains `draft` and
+     * `scheduled` entries, so page output must read `publicEntries` (routable) or
+     * `discoverableEntries` (public only) instead of `entries`.
+     */
     manifest: ContentManifest;
     /** Request pathname, normalized to an absolute path. */
     pathname: string;

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

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

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

@@ -0,0 +1,5 @@
+export type MarkdownFenceLine = {
+    readonly value: string;
+    readonly inFence: boolean;
+};
+export declare function scanMarkdownFenceLines(source: string): MarkdownFenceLine[];

package/package.json

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

package/dist/src/config_deprecations.d.ts

@@ -1,8 +0,0 @@
-import { type DeprecationNotice } from "./deprecation.js";
-import type { Diagnostic } from "./types/diagnostic.js";
-import type { RiebeckiteConfig } from "./types/riebeckite_config.js";
-export type ConfigDeprecationNotice = DeprecationNotice & {
-    readonly kind: "config";
-    readonly path: string;
-};
-export declare function collectConfigDeprecationDiagnostics(config: RiebeckiteConfig, notices?: readonly ConfigDeprecationNotice[]): Diagnostic[];

package/dist/src/deprecation.d.ts

@@ -1,14 +0,0 @@
-import type { Diagnostic } from "./types/diagnostic.js";
-export type DeprecationKind = "config" | "plugin-api" | "theme-api" | "cli" | "scaffold" | "package";
-export type DeprecationNotice = {
-    readonly kind: DeprecationKind;
-    readonly id: string;
-    readonly target: string;
-    readonly deprecatedSince: string;
-    readonly action: string;
-    readonly replacement?: string;
-    readonly documentationUrl?: string;
-    readonly removedIn?: string;
-};
-export declare function createDeprecationDiagnostic(notice: DeprecationNotice): Diagnostic;
-export declare function formatDeprecationMessage(notice: DeprecationNotice): string;