@riebeckite/core 0.0.22 → 0.0.24

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

@@ -1,21 +1,11 @@
 import type { Observability } from "../observability.js";
 import type { ContentManifest, ContentManifestEntry } from "../types/content_manifest.js";
-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 { ExternalDependencyFailure, ExternalDependencySnapshot } from "../types/external_dependency.js";
+import type { ContentBuildPlan } from "./content_build_plan.js";
+import { type ManifestHookCacheEntry } from "./content_build_state.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 = {
-    readonly previousState: ContentBuildState | undefined;
-    readonly previousManifestEntriesBySlug: ReadonlyMap<string, ContentManifestEntry>;
-    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>;
-};
 type ContentBuildCoordinatorDependencies = {
     readonly buildStatePath: string;
     readonly getEntries: () => Promise<readonly ContentSourceEntry[]>;
@@ -24,10 +14,10 @@ type ContentBuildCoordinatorDependencies = {
 };
 export declare class ContentBuildCoordinator {
     private readonly dependencies;
-    private preparation;
+    private plan;
     constructor(dependencies: ContentBuildCoordinatorDependencies);
-    getPreparation(incremental: boolean | undefined, pipelineFingerprint: string | undefined, fullContentRegenerationRequired?: boolean): Promise<ContentBuildPreparation>;
-    commit(preparation: ContentBuildPreparation, manifest: ContentManifest, pipelineFingerprint: string | undefined, outputs?: readonly OutputDescriptor[], manifestEntries?: readonly ContentManifestEntry[], trackedDependencies?: ReadonlyMap<string, readonly CachedContentDependency[]>): Promise<void>;
+    getPlan(incremental: boolean, pipelineFingerprint: string | undefined, fullContentRegenerationRequired?: boolean, externalDependencies?: readonly ExternalDependencySnapshot[], externalDependencyFailures?: readonly ExternalDependencyFailure[], publishingBuildTime?: Date): Promise<ContentBuildPlan>;
+    commit(plan: ContentBuildPlan, manifest: ContentManifest, pipelineFingerprint: string | undefined, outputs: readonly OutputDescriptor[], manifestEntries: readonly ContentManifestEntry[], trackedDependencies: ReadonlyMap<string, readonly CachedContentDependency[]>, externalDependencies: readonly ExternalDependencySnapshot[], processedContentCacheFingerprints: ReadonlyMap<string, string | undefined>, manifestHookCache: readonly ManifestHookCacheEntry[], publishingBuildTime: Date): Promise<void>;
     private prepare;
     private getContentAliases;
 }

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

@@ -0,0 +1,24 @@
+import type { ContentManifestEntry } from "../types/content_manifest.js";
+import type { ExternalDependencyFailure, ExternalDependencySnapshot } from "../types/external_dependency.js";
+import type { determineAffectedContent } from "./affected_content.js";
+import type { ContentBuildState, FingerprintedContentEntry } from "./content_build_state.js";
+import type { ContentChangeSet } from "./content_change_set.js";
+import type { OutputChangeSet, OutputDescriptor } from "./output_dependency.js";
+export type FullRegenerationReason = "incremental-disabled" | "cache-missing-or-invalid" | "pipeline-fingerprint-changed" | "content-plugin-uncacheable" | "external-dependency-unavailable" | "publishing-state-expired";
+export type ContentBuildPlan = {
+    readonly incremental: boolean;
+    readonly previousState: ContentBuildState | undefined;
+    readonly previousManifestEntriesBySlug: ReadonlyMap<string, ContentManifestEntry>;
+    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>;
+    readonly cacheValid: boolean;
+    readonly fullRegenerationReasons: readonly FullRegenerationReason[];
+    readonly reusableOutputs: readonly OutputDescriptor[] | undefined;
+    readonly externalDependencies: readonly ExternalDependencySnapshot[];
+    readonly externalDependencyFailures: readonly ExternalDependencyFailure[];
+};
+export declare function reusableOutputChangeSet(outputs: readonly OutputDescriptor[]): OutputChangeSet;

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 = 8;
+export declare const CONTENT_BUILD_STATE_VERSION = 16;
 /**
  * Build state lives under `<content directory>/.riebeckite`. That directory is
  * build-time state, not content, so content sources must exclude it from scans
@@ -14,6 +14,7 @@ export type ContentBuildEntry = {
     readonly aliases: readonly string[];
     readonly dependencies: readonly ContentBuildDependency[];
     readonly linkTargets?: readonly string[];
+    readonly processedContentCacheFingerprint?: string;
 };
 export type ContentBuildDependency = {
     readonly kind: "content" | "file";
@@ -26,6 +27,26 @@ export type ContentBuildState = {
     readonly pipelineFingerprint?: string;
     readonly manifestEntries?: readonly ContentManifestEntry[];
     readonly outputs?: readonly OutputDescriptor[];
+    readonly externalDependencies?: readonly PersistedExternalDependency[];
+    readonly manifestHookCache?: readonly ManifestHookCacheEntry[];
+    readonly nextPublishingChangeAt?: string;
+};
+export type ManifestHookCacheEntry = {
+    readonly pluginName: string;
+    readonly cacheable: boolean;
+    readonly pipelineFingerprint: string | undefined;
+    readonly inputFingerprint: string;
+    readonly outputFingerprint: string;
+    readonly snapshot: ManifestHookSnapshot;
+};
+export type ManifestHookSnapshot = {
+    readonly entries: readonly ContentManifestEntry[];
+};
+export type PersistedExternalDependency = {
+    readonly id: string;
+    readonly fingerprint: string;
+    readonly scope: import("../types/external_dependency.js").ExternalDependencyScope;
+    readonly expiresAt?: string;
 };
 export type FingerprintedContentEntry = {
     readonly entry: ContentSourceEntry;

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

@@ -1,10 +1,11 @@
 import type { PipelineOptions } from "../pipeline.js";
+import type { ManifestHookMetrics } from "../plugin/plugin_runtime.js";
 import type { ContentManifest, ContentPublicLocation } from "../types/content_manifest.js";
 import type { Diagnostic } from "../types/diagnostic.js";
 import type { ResolvedPluginPage } from "../types/plugin_page.js";
 import type { PostContent } from "../types/post_content.js";
 import type { ResolvedRiebeckiteConfig } from "../types/resolved_riebeckite_config.js";
-import { type ContentBuildPreparation } from "./content_build_coordinator.js";
+import { type ContentBuildPlan } from "./content_build_plan.js";
 import type { ContentGraph } from "./content_graph.js";
 import type { ContentSource, ContentSourceEntry } from "./content_source.js";
 import { type OutputChangeSet } from "./output_dependency.js";
@@ -46,12 +47,17 @@ export declare class ContentManager {
     private processedContentCount;
     private reusedContentCount;
     private outputChangeSet;
+    private buildPlan;
+    private buildStateCommitRequested;
+    private buildStateCommitted;
+    private cacheManifestEntries;
     private trackedContentDependencies;
+    private processedContentCacheFingerprints;
     constructor(content: string | ContentSource, exclude?: string[], pipelineOptions?: PipelineOptions);
     getAllPosts(): Promise<ContentPostReference[]>;
     scan(): Promise<readonly ContentSourceEntry[]>;
     getPost(slug: string): Promise<string>;
-    getContentIndex(preparation?: ContentBuildPreparation): Promise<Map<string, string>>;
+    getContentIndex(plan?: ContentBuildPlan): Promise<Map<string, string>>;
     getProcessedContent(slug: string): Promise<PostContent>;
     private processContent;
     getManifest(options?: ContentBuildOptions): Promise<ContentManifest>;
@@ -59,6 +65,8 @@ export declare class ContentManager {
     build(options?: ContentBuildOptions): Promise<ContentManifest>;
     getProcessedContentCount(): number;
     getReusedContentCount(): number;
+    getManifestHookMetrics(): ManifestHookMetrics;
+    getNoChangeFastPathBlockReason(options?: ContentBuildOptions): Promise<string | undefined>;
     getOutputChangeSet(options?: ContentBuildOptions): Promise<OutputChangeSet>;
     getBacklinks(targetSlug: string): Promise<Backlink[]>;
     getContentGraph(): Promise<ContentGraph>;
@@ -75,7 +83,13 @@ export declare class ContentManager {
     private publishStrategy;
     private reuseManifestEntry;
     private getPipelineFingerprint;
+    private requestBuildStateCommit;
+    private commitBuildState;
+    private getBuildPlan;
+    private createBuildPlan;
+    private computePipelineFingerprint;
     private requiresFullContentRegeneration;
+    private getProcessedContentCacheFingerprint;
     private isRoutable;
     private ensureRoutableSlugs;
     private resolveRoutableSlugs;
@@ -87,5 +101,6 @@ declare module "../pipeline" {
     interface PipelineOptions {
         config?: ResolvedRiebeckiteConfig;
         publishingBuildTime?: Date | string;
+        commitBuildState?: boolean;
     }
 }

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

@@ -1,4 +1,5 @@
 import type { Logger, Tracer } from "../observability.js";
+import type { ContentPublicLocation } from "../types/content_manifest.js";
 import type { PostContent } from "../types/post_content.js";
 import type { ResolvedRiebeckiteConfig } from "../types/resolved_riebeckite_config.js";
 import type { CachedContentDependency } from "./content_dependency_tracker.js";
@@ -16,8 +17,8 @@ export type PersistentContentCacheOptions = {
     logger?: Logger;
     tracer?: Tracer;
 };
-export declare const CONTENT_CACHE_SCHEMA_VERSION = 3;
-export declare const CONTENT_CACHE_COMPATIBILITY_VERSION = 1;
+export declare const CONTENT_CACHE_SCHEMA_VERSION = 5;
+export declare const CONTENT_CACHE_COMPATIBILITY_VERSION = 3;
 export type PersistentContentCacheMissReason = "disabled" | "no-entry" | "corrupted" | "unreadable" | "schema-mismatch" | "key-mismatch" | "invalid-entry";
 export type PersistentContentCacheLookup = {
     status: "hit";
@@ -40,9 +41,13 @@ export type CacheKeyInputs = {
     pipelineFingerprint: string;
 };
 export declare function computeContentCacheKey(inputs: CacheKeyInputs): string;
-export declare function computePipelineFingerprint(config: ResolvedRiebeckiteConfig): string;
-export declare function isPersistentlyCacheable(_slug: string, config: ResolvedRiebeckiteConfig): {
+export declare function computePipelineFingerprint(config: ResolvedRiebeckiteConfig, contentScopeFingerprint?: string): string;
+export declare function computeContentScopeFingerprint(locations: ReadonlyMap<string, ContentPublicLocation>): string;
+export declare function isPersistentlyCacheable(slug: string, config: ResolvedRiebeckiteConfig, source?: string): {
     cacheable: boolean;
     reason?: string;
 };
+export declare function computeContentCacheFingerprint(slug: string, source: string, config: ResolvedRiebeckiteConfig): string;
+export declare function hasGlobalContentDependency(config: ResolvedRiebeckiteConfig): boolean;
+export declare function requiresFullContentRegeneration(config: ResolvedRiebeckiteConfig): boolean;
 export declare function extractFrontmatter(markdown: string): PostContent["frontmatter"];

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

@@ -0,0 +1 @@
+export declare function fingerprintExternalValue(value: unknown): string;

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

@@ -1,5 +1,5 @@
 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 declare const INTERNAL_CONTENT_IGNORE_PATTERNS: readonly [".riebeckite", ".riebeckite/**", ".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;

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

@@ -0,0 +1,7 @@
+import type { ContentManifest } from "../types/content_manifest.js";
+import type { ManifestHookCacheEntry, ManifestHookSnapshot } from "./content_build_state.js";
+export declare function fingerprintManifestHookInput(manifest: ContentManifest): string;
+export declare function createManifestHookCacheEntry(pluginName: string, cacheable: boolean, pipelineFingerprint: string | undefined, inputFingerprint: string, manifest: ContentManifest): ManifestHookCacheEntry;
+export declare function fingerprintManifestHookSideEffects(manifest: ContentManifest): string;
+export declare function fingerprintManifestHookSnapshot(snapshot: ManifestHookSnapshot, manifest: ContentManifest): string;
+export declare function applyManifestHookSnapshot(manifest: ContentManifest, snapshot: ManifestHookSnapshot): boolean;

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

@@ -1,4 +1,5 @@
 import type { ContentManifest } from "../types/content_manifest.js";
+import type { ExternalDependencyFailure, ExternalDependencySnapshot } from "../types/external_dependency.js";
 import type { OutputDependency } from "../types/output_dependency.js";
 import type { ContentBuildState } from "./content_build_state.js";
 import type { ContentChangeSet } from "./content_change_set.js";
@@ -29,6 +30,8 @@ export declare function determineOutputChanges(input: {
     };
     readonly pluginPageOutputs?: readonly OutputDescriptor[];
     readonly contentOutputDependencies?: readonly OutputDependency[];
+    readonly externalDependencies?: readonly ExternalDependencySnapshot[];
+    readonly externalDependencyFailures?: readonly ExternalDependencyFailure[];
 }): OutputChangeSet;
 export declare function buildOutputInventory(manifest: ContentManifest, pluginPageOutputs?: readonly OutputDescriptor[], contentOutputDependencies?: readonly OutputDependency[]): readonly OutputDescriptor[];
 export declare function htmlOutputPath(pathname: string): string;

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

@@ -0,0 +1,30 @@
+import type { ContentLink, ContentManifest, ContentManifestEntry, ContentPublicLocation } from "../types/content_manifest.js";
+import type { ResolvedPublishingState } from "./publishing.js";
+type DeepReadonly<Value> = Value extends (...args: never[]) => unknown ? Value : Value extends readonly (infer Item)[] ? readonly DeepReadonly<Item>[] : Value extends object ? {
+    readonly [Key in keyof Value]: DeepReadonly<Value[Key]>;
+} : Value;
+export type PublicContentEntry = DeepReadonly<{
+    slug: string;
+    contentId?: string;
+    permalink: string;
+    publicLocation: ContentPublicLocation;
+    title: string;
+    aliases?: readonly string[];
+    publishing: ResolvedPublishingState;
+    tags: string[];
+    links: ContentLink[];
+    assets: ContentManifestEntry["assets"];
+}>;
+export type PublicContentView = {
+    readonly routableEntries: readonly PublicContentEntry[];
+    readonly discoverableEntries: readonly PublicContentEntry[];
+    findRoutableBySlug(slug: string): PublicContentEntry | undefined;
+    findDiscoverableBySlug(slug: string): PublicContentEntry | undefined;
+    findRoutableByAlias(alias: string): readonly PublicContentEntry[];
+    getDiscoverableEntriesByTag(tag: string): readonly PublicContentEntry[];
+    getDiscoverableOutgoing(slug: string): readonly PublicContentEntry[];
+    getDiscoverableIncoming(slug: string): readonly PublicContentEntry[];
+    getDiscoverableNeighbors(slug: string): readonly PublicContentEntry[];
+};
+export declare function createPublicContentView(manifest: ContentManifest): PublicContentView;
+export {};

package/dist/src/pipeline.d.ts

@@ -12,6 +12,7 @@ export interface PipelineOptions {
     isRoutable?: (slug: string) => boolean;
     onContentDependencies?(slug: string, dependencies: readonly CachedContentDependency[]): void;
     onPersistentContentCacheResult?(result: "hit" | "miss" | "bypass"): void;
+    contentScopeFingerprint?: string;
 }
 export declare class Pipeline {
     private contentIndex;
@@ -27,6 +28,7 @@ export declare class Pipeline {
     execute(markDownContent: string, context?: MarkdownExecutionContext): Promise<PostContent>;
     private executeWithEmbedState;
     private reportContentDependencies;
+    private contentPipelineFingerprint;
     private findInvalidDependency;
     private getPermalink;
     private resolveLinkDependency;

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

@@ -5,4 +5,5 @@ export declare class GeneratedOutputRegistry {
     private readonly owners;
     sinkFor(pluginName: string): GeneratedOutputSink;
     all(): GeneratedOutput[];
+    count(): number;
 }

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

@@ -1,7 +1,9 @@
+import type { ManifestHookCacheEntry } from "../content/content_build_state.js";
 import type { OutputDescriptor } from "../content/output_dependency.js";
 import type { PipelineOptions } from "../pipeline.js";
 import type { ContentLocationInput, ContentManifest, ContentManifestEntry, ContentPublicLocation, PluginPageRoute } from "../types/content_manifest.js";
 import type { Diagnostic } from "../types/diagnostic.js";
+import type { ExternalDependencyFailure, ExternalDependencySnapshot } from "../types/external_dependency.js";
 import type { GeneratedOutput, GeneratedOutputContent } from "../types/generated_output.js";
 import type { OutputDependency } from "../types/output_dependency.js";
 import { type PluginClientEntry } from "../types/plugin_asset.js";
@@ -13,6 +15,22 @@ import type { PostContent } from "../types/post_content.js";
  * Once `started` is reached the lifecycle never runs again.
  */
 export type PluginBuildStage = "idle" | "setup" | "buildStart" | "onConfigResolved" | "started";
+export type ManifestHookMetrics = Readonly<{
+    manifestHooksExecuted: number;
+    manifestHooksReused: number;
+    manifestHookCacheHit: number;
+    manifestHookCacheMiss: number;
+    manifestHookDurationMs: number;
+    byPlugin: Readonly<Record<string, ManifestHookPluginMetrics>>;
+}>;
+export type ManifestHookPluginMetrics = Readonly<{
+    executed: number;
+    reused: number;
+    cacheHit: number;
+    cacheMiss: number;
+    durationMs: number;
+    reason: string;
+}>;
 export declare class PluginRuntime {
     private pipelineOptions;
     private buildLifecycle;
@@ -24,9 +42,20 @@ export declare class PluginRuntime {
     private isBuildTime;
     private resolvedPlugins;
     private pageDeclarations;
+    private externalDependencies;
+    private externalDependencyFailures;
+    private externalDependenciesResolved;
+    private manifestHooksExecuted;
+    private manifestHookDurationMs;
+    private manifestHooksReused;
+    private manifestHookCache;
+    private manifestHookMetricsByPlugin;
     constructor(pipelineOptions?: PipelineOptions);
     getDiagnostics(): Diagnostic[];
     getBuildStage(): PluginBuildStage;
+    getManifestHookMetrics(): ManifestHookMetrics;
+    getNoChangeFastPathBlockReason(previousCache: readonly ManifestHookCacheEntry[], pipelineFingerprint: string | undefined): string | undefined;
+    getManifestHookCache(): readonly ManifestHookCacheEntry[];
     /**
      * Starts the plugin build lifecycle exactly once, regardless of which public
      * entry point (content processing or location resolution) reaches it first.
@@ -36,12 +65,18 @@ export declare class PluginRuntime {
      */
     startBuild(contentIndex: Map<string, string>): Promise<void>;
     runContentLoaded(slug: string, markdown: string, contentIndex: Map<string, string>): Promise<void>;
+    resolveExternalDependencies(contentIndex: Map<string, string>): Promise<{
+        readonly snapshots: readonly ExternalDependencySnapshot[];
+        readonly failures: readonly ExternalDependencyFailure[];
+    }>;
     resolveContentLocations(entries: readonly ContentLocationInput[], contentIndex: Map<string, string>): Promise<readonly ContentPublicLocation[]>;
     extendContentLocations(entries: readonly ContentLocationInput[], locations: Map<string, ContentPublicLocation>, contentIndex: Map<string, string>): Promise<void>;
     runPostHook(hookName: "onPostParsed" | "onPostProcessed", slug: string, markdown: string, content: PostContent, contentIndex: Map<string, string>): Promise<void>;
     runGraphHook(entries: ContentManifestEntry[], contentIndex: Map<string, string>): Promise<void>;
-    runManifestCreated(manifest: ContentManifest, contentIndex: Map<string, string>): Promise<void>;
+    runManifestCreated(manifest: ContentManifest, contentIndex: Map<string, string>, previousCache: readonly ManifestHookCacheEntry[], pipelineFingerprint: string | undefined): Promise<void>;
+    private recordManifestHookMetric;
     runBuildEnd(manifest: ContentManifest, contentIndex: Map<string, string>): Promise<void>;
+    runGeneratedOutputPlans(manifest: ContentManifest): Promise<void>;
     enableBuildTime(): void;
     dispose(contentIndex: Map<string, string>): Promise<void>;
     collectAssets(): {

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

@@ -25,29 +25,6 @@ export type ContentManifestPluginAsset = PluginAsset & {
  * 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 = (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 = {
@@ -69,24 +46,11 @@ export type ContentManifestEntry = {
      * The Site owns the shell, so it decides whether to render them.
      */
     headTags?: readonly PluginHeadTag[];
-    /**
-     * Plugin-provided HTML fragments the Site renders in named body slots.
-     * The Site owns its layout, so it decides where (and whether) each slot is
-     * rendered; a plugin only supplies the fragment, keyed by slot name.
-     */
-    bodySlots?: Readonly<Record<string, string>>;
     tags: string[];
     links: ContentLink[];
     backlinks: string[];
     assets: ContentAsset[];
 };
-/**
- * Appends a Plugin-provided HTML fragment to a named Site layout slot.
- *
- * Plugins publish fragments; the Site chooses which slots to render and where.
- * Appending preserves contributions from earlier plugins in resolved order.
- */
-export declare function appendContentBodySlot(entry: ContentManifestEntry, slot: ContentBodySlot, html: string): void;
 export type ContentRedirect = {
     path: string;
     status: 301 | 302 | 307 | 308;

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

@@ -0,0 +1,31 @@
+export type ExternalDependencyScope = {
+    readonly type: "content";
+} | {
+    readonly type: "output";
+    readonly paths: readonly string[];
+} | {
+    readonly type: "all";
+};
+export type ExternalDependencySnapshot<T = unknown> = {
+    readonly id: string;
+    readonly fingerprint: string;
+    readonly scope: ExternalDependencyScope;
+    readonly expiresAt?: string;
+    readonly value: T;
+};
+export type ExternalDependencyFailure = {
+    readonly id: string;
+    readonly reason: string;
+};
+export type ExternalDependencyResolution<T = unknown> = {
+    readonly kind: "resolved";
+    readonly snapshot: ExternalDependencySnapshot<T>;
+} | {
+    readonly kind: "unavailable";
+    readonly failure: ExternalDependencyFailure;
+};
+export type ExternalDependencyContext = {
+    readonly config?: import("./resolved_riebeckite_config.js").ResolvedRiebeckiteConfig;
+    readonly contentIndex: Map<string, string>;
+    readonly cache: import("../plugin/plugin_cache.js").PluginCache;
+};

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

@@ -10,6 +10,12 @@ export type OutputDependency = {
 } | {
     readonly type: "file";
     readonly path: string;
+} | {
+    readonly type: "projection";
+    readonly projection: "navigation" | "recent-posts" | "taxonomy-tags" | "taxonomy-folders";
+} | {
+    readonly type: "external";
+    readonly id: string;
 } | {
     readonly type: "global";
 } | {

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

@@ -1,5 +1,8 @@
 import type { PluginOptionsValidator } from "./config_validation.js";
+import type { ContentManifestEntry } from "./content_manifest.js";
 import type { Diagnostic } from "./diagnostic.js";
+import type { ExternalDependencyContext, ExternalDependencyResolution } from "./external_dependency.js";
+import type { GeneratedOutputContent } from "./generated_output.js";
 import type { OutputDependency } from "./output_dependency.js";
 import type { PluginAsset, PluginClientEntry } from "./plugin_asset.js";
 import type { PluginContentContext, PluginContentLocationAugmentContext, PluginContentLocationResolver, PluginContentRenderer, PluginContext, PluginGeneratedHtmlInspector, PluginGraphContext, PluginLifecycleContext, PluginManifestContext, PluginPostContext } from "./plugin_context.js";
@@ -7,6 +10,7 @@ import type { PluginEndpoint } from "./plugin_endpoint.js";
 import type { PluginPageType } from "./plugin_page.js";
 import type { HtmlPipeline, MarkdownPipeline, MarkdownPipelineContext, PipelinePlugin } from "./plugin_pipeline.js";
 import type { PluginSeoExtension } from "./plugin_seo.js";
+import type { ResolvedRiebeckiteConfig } from "./resolved_riebeckite_config.js";
 export type RiebeckitePlugin<TOptions = unknown> = {
     name: string;
     options?: TOptions;
@@ -39,18 +43,29 @@ export type RiebeckitePlugin<TOptions = unknown> = {
      *   frontmatter, plugin options, and this contract version.
      * - `tracked`: external content/file inputs are read only through
      *   framework-owned APIs that record dependency fingerprints.
+     * - `global`: processed HTML depends on the resolved content-location set.
      * - `unsafe`: persistent processed-content cache must bypass this plugin.
+     *
+     * `appliesToContent` may narrow an unsafe contract to raw Markdown sources
+     * it can affect. It must return `unknown` when it cannot prove the result;
+     * unknown falls back to bypassing the cache. Content and environment
+     * fingerprints must be stable whenever they are supplied.
      */
     processedContentCache?: {
         version: string;
-        dependencyMode: "none" | "tracked" | "unsafe";
+        dependencyMode: "none" | "tracked" | "global" | "unsafe";
+        appliesToContent?: (context: ProcessedContentCacheContext) => ProcessedContentCacheApplicability;
+        contentDependencyFingerprint?: (context: ProcessedContentCacheContext) => string | undefined;
+        environmentFingerprint?: () => string | undefined;
     };
+    resolveExternalDependencies?(context: ExternalDependencyContext): Promise<readonly ExternalDependencyResolution[]>;
     validateOptions?: PluginOptionsValidator<TOptions>;
     remarkPlugins?: PipelinePlugin[];
     rehypePlugins?: PipelinePlugin[];
     setup?(context: PluginLifecycleContext): void | Promise<void>;
     buildStart?(context: PluginLifecycleContext): void | Promise<void>;
     buildEnd?(context: PluginManifestContext): void | Promise<void>;
+    planGeneratedOutputs?(context: PluginGeneratedOutputPlanContext): readonly PlannedGeneratedOutput[] | Promise<readonly PlannedGeneratedOutput[]>;
     dispose?(context: PluginLifecycleContext): void | Promise<void>;
     onConfigResolved?(context: PluginContext): void | Promise<void>;
     onContentLoaded?(context: PluginContentContext): void | Promise<void>;
@@ -74,10 +89,27 @@ export type RiebeckitePlugin<TOptions = unknown> = {
     seo?: PluginSeoExtension;
     extendContentGraph?(context: PluginGraphContext): void | Promise<void>;
     renderers?: PluginContentRenderer[];
-    outputDependencies?: readonly OutputDependency[];
+    contentOutputDependencies?: readonly OutputDependency[];
     /** Framework-independent page types contributed by this plugin. */
     pageTypes?: PluginPageType[];
 };
+export type PlannedGeneratedOutput = {
+    readonly path: string;
+    readonly content: GeneratedOutputContent;
+    readonly dependencies: readonly OutputDependency[];
+};
+export type PluginGeneratedOutputPlanContext = {
+    readonly manifest: Readonly<{
+        readonly discoverableEntries: readonly ContentManifestEntry[];
+        readonly routableEntries: readonly ContentManifestEntry[];
+    }>;
+    readonly site: Readonly<ResolvedRiebeckiteConfig["site"]> | undefined;
+};
+export type ProcessedContentCacheContext = {
+    readonly slug: string;
+    readonly source: string;
+};
+export type ProcessedContentCacheApplicability = "applies" | "does-not-apply" | "unknown";
 export type PluginInput = RiebeckitePlugin | false | null | undefined;
 export type ResolvedPluginMetadata = {
     readonly name: string;

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

@@ -18,8 +18,8 @@ export type PluginClientEntry<TPublicConfig extends JsonValue = JsonValue> = {
      */
     publicConfig?: TPublicConfig;
 };
-export declare function createStyleAsset(pluginName: string): PluginAsset;
-export declare function createClientEntry<TPublicConfig extends JsonValue>(pluginName: string, exportName?: string, publicConfig?: TPublicConfig): PluginClientEntry<TPublicConfig>;
+export declare function createStyleAsset(pluginName: string, moduleSpecifier: string): PluginAsset;
+export declare function createClientEntry<TPublicConfig extends JsonValue>(pluginName: string, moduleSpecifier: string, exportName?: string, publicConfig?: TPublicConfig): PluginClientEntry<TPublicConfig>;
 /**
  * Serializes explicitly registered client configuration for code generation.
  * Rejecting non-JSON values prevents generated client modules from silently

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

@@ -0,0 +1,2 @@
+export type PluginDataHelper<Input, Model> = (input: Readonly<Input>) => Model | Promise<Model>;
+export type PluginComponent<Props> = (props: Readonly<Props>) => unknown;

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

@@ -3,6 +3,7 @@ import type { Logger, Tracer } from "../observability.js";
 import type { PluginCache } from "../plugin/plugin_cache.js";
 import type { ContentLocationInput, ContentManifest, ContentManifestEntry, ContentPublicLocation } from "./content_manifest.js";
 import type { Diagnostic } from "./diagnostic.js";
+import type { ExternalDependencySnapshot } from "./external_dependency.js";
 import type { GeneratedOutputSink } from "./generated_output.js";
 import type { PostContent } from "./post_content.js";
 import type { ResolvedRiebeckiteConfig } from "./resolved_riebeckite_config.js";
@@ -20,6 +21,7 @@ export type PluginContext = {
     logger: Logger;
     tracer: Tracer;
     contentSource?: ContentSource;
+    externalDependencies?: ReadonlyMap<string, ExternalDependencySnapshot>;
 };
 export type PluginLifecycleContext = PluginContext;
 export type PluginContentContext = PluginContext & {

package/package.json

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