@riebeckite/core 0.0.13 → 0.0.15

package/dist/src/config_deprecations.d.ts

@@ -0,0 +1,8 @@
+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/content/affected_content.d.ts

@@ -4,4 +4,4 @@ export type AffectedContent = {
     readonly direct: ReadonlySet<string>;
     readonly dependent: ReadonlySet<string>;
 };
-export declare function determineAffectedContent(changeSet: ContentChangeSet, previousState: ContentBuildState | undefined, currentPaths: readonly string[]): AffectedContent;
+export declare function determineAffectedContent(changeSet: ContentChangeSet, previousState: ContentBuildState | undefined, currentPaths: readonly string[], currentContentIndex: ReadonlyMap<string, string>): AffectedContent;

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

@@ -1,12 +1,19 @@
 import type { Observability } from "../observability.js";
-import type { ContentManifest } from "../types/content_manifest.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 { 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 changeSet: ContentChangeSet;
+    readonly affectedContent: ReturnType<typeof determineAffectedContent>;
 };
 type ContentBuildCoordinatorDependencies = {
     readonly buildStatePath: string;
@@ -18,8 +25,9 @@ export declare class ContentBuildCoordinator {
     private readonly dependencies;
     private preparation;
     constructor(dependencies: ContentBuildCoordinatorDependencies);
-    getPreparation(incremental: boolean | undefined): Promise<ContentBuildPreparation>;
-    commit(preparation: ContentBuildPreparation, manifest: ContentManifest): Promise<void>;
+    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>;
     private prepare;
+    private getContentAliases;
 }
 export {};

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

@@ -1,5 +1,7 @@
+import type { ContentManifestEntry } from "../types/content_manifest.js";
 import type { ContentSourceEntry } from "./content_source.js";
-export declare const CONTENT_BUILD_STATE_VERSION = 2;
+import type { OutputDescriptor } from "./output_dependency.js";
+export declare const CONTENT_BUILD_STATE_VERSION = 6;
 /**
  * Build state lives under `<content directory>/.riebeckite`. That directory is
  * build-time state, not content, so content sources must exclude it from scans
@@ -9,12 +11,21 @@ export declare const CONTENT_BUILD_STATE_DIRECTORY = ".riebeckite";
 export declare const CONTENT_BUILD_STATE_EXCLUDE = ".riebeckite/**";
 export type ContentBuildEntry = {
     readonly fingerprint: string;
-    readonly dependencies: readonly string[];
+    readonly aliases: readonly string[];
+    readonly dependencies: readonly ContentBuildDependency[];
+    readonly linkTargets?: readonly string[];
+};
+export type ContentBuildDependency = {
+    readonly kind: "content" | "file";
+    readonly id: string;
 };
 export type ContentBuildState = {
     readonly version: number;
     readonly entries: Readonly<Record<string, ContentBuildEntry>>;
     readonly contentIndex: Readonly<Record<string, string>>;
+    readonly pipelineFingerprint?: string;
+    readonly manifestEntries?: readonly ContentManifestEntry[];
+    readonly outputs?: readonly OutputDescriptor[];
 };
 export type FingerprintedContentEntry = {
     readonly entry: ContentSourceEntry;

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

@@ -0,0 +1,18 @@
+import type { ContentSource, ContentSourceContent } from "./content_source.js";
+export type CachedContentDependency = {
+    readonly kind: "content" | "file" | "link";
+    readonly id: string;
+    readonly fingerprint: string;
+};
+type DependencyIdentity = Pick<CachedContentDependency, "kind" | "id">;
+export type ContentDependencyTracker = {
+    readonly contentSource: ContentSource;
+    readContent(slug: string, read: () => Promise<string>): Promise<string>;
+    recordLinkResolution(id: string, value: string): void;
+    dependencies(): readonly CachedContentDependency[];
+};
+export declare function createContentDependencyTracker(source: ContentSource): ContentDependencyTracker;
+export declare function fingerprintContent(content: ContentSourceContent): string;
+export declare function normalizeDependencyIdentity<T extends DependencyIdentity>(dependency: T): T;
+export declare function dependencyKey(dependency: DependencyIdentity): string;
+export {};

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

@@ -4,6 +4,8 @@ export declare class ContentEntryReader {
     private readonly source;
     private readonly observability;
     private entries;
+    private entriesPromise;
+    private entriesByPath;
     private texts;
     constructor(source: ContentSource, observability: Observability);
     getEntries(): Promise<readonly ContentSourceEntry[]>;

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

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

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

@@ -1,3 +1,4 @@
+import type { Observability } from "../observability.js";
 import type { PluginRuntime } from "../plugin/plugin_runtime.js";
 import type { ContentManifest, ContentPublicLocation } from "../types/content_manifest.js";
 import type { ContentSourceEntry } from "./content_source.js";
@@ -6,13 +7,19 @@ type ContentLocationResolverDependencies = {
     readonly readEntry: (entry: ContentSourceEntry) => Promise<string>;
     readonly getContentIndex: () => Promise<Map<string, string>>;
     readonly pluginRuntime: PluginRuntime;
+    readonly observability: Observability;
 };
 export declare class ContentLocationResolver {
     private readonly dependencies;
     private locations;
+    private locationsPromise;
+    private permalinks;
+    private permalinksPromise;
     constructor(dependencies: ContentLocationResolverDependencies);
     getLocations(): Promise<ReadonlyMap<string, ContentPublicLocation>>;
+    private resolveLocations;
     getPermalinks(): Promise<Map<string, string>>;
+    private createPermalinks;
     populateRedirects(manifest: ContentManifest, locations: ReadonlyMap<string, ContentPublicLocation>): void;
 }
 export {};

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

@@ -7,6 +7,7 @@ import type { ResolvedRiebeckiteConfig } from "../types/resolved_riebeckite_conf
 import { type ContentBuildPreparation } from "./content_build_coordinator.js";
 import type { ContentGraph } from "./content_graph.js";
 import type { ContentSource, ContentSourceEntry } from "./content_source.js";
+import { type OutputChangeSet } from "./output_dependency.js";
 export type Backlink = {
     slug: string;
 };
@@ -28,13 +29,22 @@ export declare class ContentManager {
     private manifestBuilder;
     private pluginRuntime;
     private contentIndex;
+    private contentIndexPromise;
     private contentCache;
     private manifest;
+    private manifestPromise;
+    private pipelineFingerprint;
     private pipeline;
     private entryReader;
     private locationResolver;
     private buildCoordinator;
     private isBuildTime;
+    private publishingBuildTime;
+    private routableSlugs;
+    private routableSlugsPromise;
+    private processedContentCount;
+    private outputChangeSet;
+    private trackedContentDependencies;
     constructor(content: string | ContentSource, exclude?: string[], pipelineOptions?: PipelineOptions);
     getAllPosts(): Promise<ContentPostReference[]>;
     scan(): Promise<readonly ContentSourceEntry[]>;
@@ -42,7 +52,9 @@ export declare class ContentManager {
     getContentIndex(preparation?: ContentBuildPreparation): Promise<Map<string, string>>;
     getProcessedContent(slug: string): Promise<PostContent>;
     getManifest(options?: ContentBuildOptions): Promise<ContentManifest>;
+    private buildManifest;
     build(options?: ContentBuildOptions): Promise<ContentManifest>;
+    getOutputChangeSet(options?: ContentBuildOptions): Promise<OutputChangeSet>;
     getBacklinks(targetSlug: string): Promise<Backlink[]>;
     getContentGraph(): Promise<ContentGraph>;
     getDiagnostics(): Promise<Diagnostic[]>;
@@ -54,11 +66,20 @@ export declare class ContentManager {
     dispose(): Promise<void>;
     getContentLocations(): Promise<ReadonlyMap<string, ContentPublicLocation>>;
     private applyPublicView;
+    private synchronizeManifestHtml;
+    private publishStrategy;
+    private reuseManifestEntry;
+    private getPipelineFingerprint;
+    private requiresFullContentRegeneration;
+    private isRoutable;
+    private ensureRoutableSlugs;
+    private resolveRoutableSlugs;
     private enableBuildTime;
     private observability;
 }
 declare module "../pipeline" {
     interface PipelineOptions {
         config?: ResolvedRiebeckiteConfig;
+        publishingBuildTime?: Date | string;
     }
 }

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

@@ -0,0 +1,43 @@
+import type { Logger, Tracer } from "../observability.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";
+export type PersistentContentCacheEntry = {
+    schemaVersion: number;
+    key: string;
+    dependencies: readonly CachedContentDependency[];
+    value: {
+        frontmatter: PostContent["frontmatter"];
+        html: string;
+    };
+};
+export type PersistentContentCacheOptions = {
+    config: ResolvedRiebeckiteConfig;
+    logger?: Logger;
+    tracer?: Tracer;
+};
+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 declare function createPersistentContentCache(options: PersistentContentCacheOptions): {
+    get(key: string): Promise<PersistentContentCacheEntry | undefined>;
+    set(key: string, value: PersistentContentCacheEntry): Promise<void>;
+    clear(): Promise<void>;
+};
+export type CacheKeyInputs = {
+    slug: string;
+    source: string;
+    frontmatter: PostContent["frontmatter"];
+    pipelineFingerprint: string;
+};
+export declare function computeContentCacheKey(inputs: CacheKeyInputs): string;
+export declare function computePipelineFingerprint(config: ResolvedRiebeckiteConfig): string;
+export declare function isPersistentlyCacheable(_slug: string, config: ResolvedRiebeckiteConfig): {
+    cacheable: boolean;
+    reason?: string;
+};
+export declare function extractFrontmatter(markdown: string): PostContent["frontmatter"];

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

@@ -1,4 +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 class FileSystemContentSource implements ContentSource {
     private contentDirectory;
     private exclude;
@@ -9,3 +10,4 @@ export declare class FileSystemContentSource implements ContentSource {
     private isExcluded;
     private resolveFilePath;
 }
+export declare function isIgnoredContentPath(logicalPath: string, exclude?: readonly string[]): boolean;

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

@@ -0,0 +1,35 @@
+import type { ContentManifest, ContentManifestEntry } from "../types/content_manifest.js";
+export type FolderEntryKind = "readme" | "index" | "folder";
+export type FolderEntryScope = "routable" | "discoverable" | "all";
+export type FolderEntryCandidate = {
+    readonly kind: FolderEntryKind;
+    readonly entry: ContentManifestEntry;
+};
+export type FolderEntryResolution = {
+    readonly type: "none";
+} | {
+    readonly type: "resolved";
+    readonly kind: FolderEntryKind;
+    readonly entry: ContentManifestEntry;
+} | {
+    readonly type: "ambiguous";
+    readonly candidates: readonly FolderEntryCandidate[];
+};
+export type ResolveFolderEntryOptions = {
+    readonly scope?: FolderEntryScope;
+};
+export type FolderLocationResolution = {
+    readonly type: "none";
+} | {
+    readonly type: "content";
+    readonly entry: ContentManifestEntry;
+} | {
+    readonly type: "generated";
+    readonly pathname: string;
+} | {
+    readonly type: "ambiguous";
+    readonly candidates: readonly FolderEntryCandidate[];
+};
+export declare function resolveFolderEntry(manifest: ContentManifest, folder: string, options?: ResolveFolderEntryOptions): FolderEntryResolution;
+export declare function resolveFolderLocation(manifest: ContentManifest, folder: string): FolderLocationResolution;
+export declare function resolveGeneratedFolderLocation(manifest: ContentManifest, folder: string): string | null;

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

@@ -12,6 +12,25 @@ export type GraphLayoutNode = {
     y: number;
     radius: number;
 };
+export type ForceGraphLayoutOptions = {
+    width: number;
+    height: number;
+    centerSlug?: string;
+    linkDistance?: number;
+    repulsion?: number;
+    iterations?: number;
+    damping?: number;
+    minNodeRadius?: number;
+    maxNodeRadius?: number;
+};
+export type ForceLayoutGuardOptions = {
+    layout: "force" | "radial";
+    mode: "local" | "global";
+    nodeCount: number;
+    approved: boolean;
+};
+export declare const FORCE_LAYOUT_CONFIRM_NODE_COUNT = 500;
+export declare function shouldGuardForceLayout(options: ForceLayoutGuardOptions): boolean;
 export type RadialGraphLayoutOptions = {
     width: number;
     height: number;
@@ -22,3 +41,4 @@ export type RadialGraphLayoutOptions = {
 };
 export declare function buildGraphEdges<T extends LinkableGraphNode>(nodes: T[], visibleSlugs?: Set<string>): GraphEdge[];
 export declare function layoutRadialGraph<T extends LinkableGraphNode>(nodes: T[], options: RadialGraphLayoutOptions): Map<string, GraphLayoutNode>;
+export declare function layoutForceGraph<T extends LinkableGraphNode>(nodes: T[], options: ForceGraphLayoutOptions): Map<string, GraphLayoutNode>;

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

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

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

@@ -0,0 +1,34 @@
+import type { ContentManifest } from "../types/content_manifest.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";
+export type OutputKind = "content" | "redirect" | "plugin-page" | "generated";
+export type OutputDescriptor = {
+    readonly kind: OutputKind;
+    readonly path: string;
+    readonly producer: string;
+    readonly dependencies: readonly OutputDependency[];
+};
+export type OutputChangeSet = {
+    readonly affected: readonly OutputDescriptor[];
+    readonly removed: readonly OutputDescriptor[];
+    readonly unchanged: readonly OutputDescriptor[];
+    readonly fullRegenerationRequired: boolean;
+    readonly candidateOutputCount: number;
+    readonly affectedOutputCount: number;
+    readonly removedOutputCount: number;
+    readonly unchangedOutputCount: number;
+};
+export declare function determineOutputChanges(input: {
+    readonly manifest: ContentManifest;
+    readonly previousState: ContentBuildState | undefined;
+    readonly changeSet: ContentChangeSet;
+    readonly affectedContent: {
+        readonly direct: ReadonlySet<string>;
+        readonly dependent: ReadonlySet<string>;
+    };
+    readonly pluginPageOutputs?: readonly OutputDescriptor[];
+    readonly contentOutputDependencies?: readonly OutputDependency[];
+}): 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/publishing.d.ts

@@ -0,0 +1,15 @@
+import type { PostFrontmatter } from "../types/post_content.js";
+import { type PublishStrategy } from "../types/publish_strategy.js";
+export type PublishingVisibility = "public" | "unlisted" | "draft" | "scheduled";
+export type ResolvedPublishingState = {
+    visibility: PublishingVisibility;
+    routable: boolean;
+    discoverable: boolean;
+    publishAt?: Date;
+};
+export type PublishingResolutionOptions = {
+    strategy: PublishStrategy;
+    buildTime: Date;
+};
+export declare function resolvePublishingState(frontmatter: PostFrontmatter | undefined, options: PublishingResolutionOptions): ResolvedPublishingState;
+export declare function resolvePublishingBuildTime(input: Date | string | undefined): Date;

package/dist/src/deprecation.d.ts

@@ -0,0 +1,14 @@
+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;

package/dist/src/pipeline.d.ts

@@ -1,3 +1,4 @@
+import { type CachedContentDependency } from "./content/content_dependency_tracker.js";
 import type { ContentSource } from "./content/content_source.js";
 import type { Observability } from "./observability.js";
 import type { RiebeckitePlugin } from "./types/plugin.js";
@@ -8,6 +9,9 @@ export interface PipelineOptions {
     observability?: Observability;
     config?: import("./types/resolved_riebeckite_config.js").ResolvedRiebeckiteConfig;
     contentSource?: ContentSource;
+    isRoutable?: (slug: string) => boolean;
+    onContentDependencies?(slug: string, dependencies: readonly CachedContentDependency[]): void;
+    onPersistentContentCacheResult?(result: "hit" | "miss" | "bypass"): void;
 }
 export declare class Pipeline {
     private contentIndex;
@@ -16,12 +20,18 @@ export declare class Pipeline {
     private options;
     private isBuildTime;
     private pluginCaches;
+    private persistentCache;
+    private pipelineFingerprint;
+    private resolvedPlugins;
     constructor(contentIndex: Map<string, string>, permalinks: ReadonlyMap<string, string>, getMarkdownBySlug?: (slug: string) => Promise<string>, options?: PipelineOptions, isBuildTime?: boolean);
     execute(markDownContent: string, context?: MarkdownExecutionContext): Promise<PostContent>;
     private executeWithEmbedState;
+    private reportContentDependencies;
     private getPermalink;
+    private resolveLinkDependency;
     private use;
     private createNoteEmbedRenderer;
+    private resolvePlugins;
     private createContentRenderer;
     private cacheFor;
 }

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

@@ -1,7 +1,9 @@
+import type { OutputDescriptor } from "../content/output_dependency.js";
 import type { PipelineOptions } from "../pipeline.js";
-import type { ContentLocationInput, ContentManifest, ContentManifestEntry, ContentPublicLocation } from "../types/content_manifest.js";
+import type { ContentLocationInput, ContentManifest, ContentManifestEntry, ContentPublicLocation, PluginPageRoute } from "../types/content_manifest.js";
 import type { Diagnostic } from "../types/diagnostic.js";
 import type { GeneratedOutput } from "../types/generated_output.js";
+import type { OutputDependency } from "../types/output_dependency.js";
 import { type PluginClientEntry } from "../types/plugin_asset.js";
 import type { ResolvedPluginPage } from "../types/plugin_page.js";
 import type { PostContent } from "../types/post_content.js";
@@ -20,6 +22,7 @@ export declare class PluginRuntime {
     private pluginCaches;
     private generatedOutputs;
     private isBuildTime;
+    private resolvedPlugins;
     constructor(pipelineOptions?: PipelineOptions);
     getDiagnostics(): Diagnostic[];
     getBuildStage(): PluginBuildStage;
@@ -56,6 +59,9 @@ export declare class PluginRuntime {
     collectGeneratedOutputs(): GeneratedOutput[];
     resolvePage(pathname: string, manifest: ContentManifest, contentIndex: Map<string, string>): Promise<ResolvedPluginPage | null>;
     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[]>;
+    getContentOutputDependencies(): readonly OutputDependency[];
     collectDiagnostics(contentIndex: Map<string, string>): Promise<Diagnostic[]>;
     private runBuildLifecycle;
     private createContext;

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

@@ -1,4 +1,5 @@
 import type { ContentGraph } from "../content/content_graph.js";
+import type { ResolvedPublishingState } from "../content/publishing.js";
 import type { Diagnostic } from "./diagnostic.js";
 import type { GeneratedOutput } from "./generated_output.js";
 import type { PluginAsset, PluginClientEntry } from "./plugin_asset.js";
@@ -23,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.before-content" | "article.after-content" | "article.footer" | (string & {});
+export type ContentBodySlot = "article.after-header" | "article.after-meta" | "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 +38,7 @@ export type ContentManifestEntry = {
     publicLocation: ContentPublicLocation;
     title: string;
     frontmatter: PostFrontmatter;
+    publishing: ResolvedPublishingState;
     html: string;
     /**
      * Head tags a plugin wants the Site shell to render for this entry.
@@ -71,6 +73,14 @@ export type ContentPublicLocation = {
     redirects?: readonly ContentRedirect[];
     metadata?: Readonly<Record<string, string>>;
 };
+export type FolderLocation = {
+    pathname: string;
+};
+export type PluginPageRoute = {
+    pathname: string;
+    pluginName: string;
+    pageType: string;
+};
 export type ContentLocationInput = {
     slug: string;
     path: string;
@@ -84,10 +94,14 @@ export type ContentManifest = {
      * this view so unpublished notes never reach generated output.
      */
     publicEntries: ContentManifestEntry[];
+    /** Entries that may appear 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. */
     byContentId: Map<string, ContentManifestEntry>;
     byPermalink: Map<string, ContentManifestEntry>;
+    /** Contains only routable entries: public and unlisted, excluding draft and scheduled-before entries. */
+    byRoutablePermalink: Map<string, ContentManifestEntry>;
     redirects: Map<string, ContentRedirect & {
         slug: string;
     }>;
@@ -112,4 +126,7 @@ export type ContentManifest = {
     clientEntries: ContentManifestPluginClientEntry[];
     diagnostics: Diagnostic[];
     generatedOutputs: GeneratedOutput[];
+    folderLocations: Map<string, FolderLocation>;
+    pageRoutes: PluginPageRoute[];
+    pagePaths: string[];
 };

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

@@ -1,3 +1,4 @@
+import type { OutputDependency } from "./output_dependency.js";
 export type GeneratedOutputContent = string | Uint8Array;
 /**
  * A file a plugin wants written to the build output directory. Content is kept
@@ -11,13 +12,20 @@ export type GeneratedOutputInput = {
      */
     path: string;
     content: GeneratedOutputContent;
+    dependencies?: readonly OutputDependency[];
 };
 export type GeneratedOutput = GeneratedOutputInput & {
     /** Name of the plugin that registered the output. */
     owner: string;
 };
+export type ContentAssetOutputInput = {
+    path: string;
+    content: GeneratedOutputContent;
+    dependencies?: readonly OutputDependency[];
+};
 export type GeneratedOutputSink = {
     emit(output: GeneratedOutputInput): void;
+    emitAsset(output: ContentAssetOutputInput): void;
 };
 export declare function createUnavailableGeneratedOutputSink(): GeneratedOutputSink;
 /**
@@ -26,3 +34,4 @@ export declare function createUnavailableGeneratedOutputSink(): GeneratedOutputS
  * (rather than silently rewriting) keeps `..` traversal from being laundered.
  */
 export declare function normalizeGeneratedOutputPath(input: string): string;
+export declare function normalizeContentAssetOutputPath(input: string): string;

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

@@ -0,0 +1,14 @@
+export type OutputDependency = {
+    readonly type: "content";
+    readonly slug: string;
+} | {
+    readonly type: "tag";
+    readonly tag: string;
+} | {
+    readonly type: "folder";
+    readonly folder: string;
+} | {
+    readonly type: "global";
+} | {
+    readonly type: "unknown";
+};

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

@@ -1,5 +1,6 @@
 import type { PluginOptionsValidator } from "./config_validation.js";
 import type { Diagnostic } from "./diagnostic.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";
 import type { PluginEndpoint } from "./plugin_endpoint.js";
@@ -27,6 +28,23 @@ export type RiebeckitePlugin<TOptions = unknown> = {
      */
     optional?: string[];
     cacheVersion?: string;
+    /**
+     * Explicit contract for the persistent processed-content cache.
+     *
+     * This is intentionally separate from `cacheVersion`, which versions the
+     * plugin-local cache storage. Content-transforming plugins without this
+     * contract are treated as unsafe for persistent `PostContent` reuse.
+     *
+     * - `none`: processed HTML depends only on the current content source,
+     *   frontmatter, plugin options, and this contract version.
+     * - `tracked`: external content/file inputs are read only through
+     *   framework-owned APIs that record dependency fingerprints.
+     * - `unsafe`: persistent processed-content cache must bypass this plugin.
+     */
+    processedContentCache?: {
+        version: string;
+        dependencyMode: "none" | "tracked" | "unsafe";
+    };
     validateOptions?: PluginOptionsValidator<TOptions>;
     remarkPlugins?: PipelinePlugin[];
     rehypePlugins?: PipelinePlugin[];
@@ -58,6 +76,7 @@ export type RiebeckitePlugin<TOptions = unknown> = {
     seo?: PluginSeoExtension;
     extendContentGraph?(context: PluginGraphContext): void | Promise<void>;
     renderers?: PluginContentRenderer[];
+    outputDependencies?: readonly OutputDependency[];
     /** Framework-independent page types contributed by this plugin. */
     pageTypes?: PluginPageType[];
 };

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

@@ -1,4 +1,5 @@
 import type { ContentManifest } from "./content_manifest.js";
+import type { OutputDependency } from "./output_dependency.js";
 import type { PluginContext } from "./plugin_context.js";
 import type { PluginHeadTag } from "./plugin_head.js";
 /** A framework-independent page supplied by a Riebeckite plugin. */
@@ -29,6 +30,11 @@ export type PluginPageType = {
     }) => readonly string[] | Promise<readonly string[]>);
     /** Higher values win when more than one type matches a request. */
     priority?: number;
+    directoryIndex?: boolean;
+    outputDependencies?: readonly OutputDependency[] | ((context: PluginContext & {
+        manifest: ContentManifest;
+        pathname: string;
+    }) => readonly OutputDependency[] | Promise<readonly OutputDependency[]>);
     resolve(context: PluginPageContext): PluginPage | null | Promise<PluginPage | null>;
 };
 export type ResolvedPluginPage = PluginPage & {

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

@@ -16,6 +16,7 @@ export type MarkdownPipelineContext = {
     sourceSlug?: MarkdownExecutionContext["sourceSlug"];
     contentIndex: Map<string, string>;
     resolvePermalink: (slug: string) => string;
+    isRoutable?: (slug: string) => boolean;
     renderNoteEmbed?: (slug: string, fragment: MarkdownEmbedFragment | null) => Promise<string | null>;
     renderContent?: (input: PluginRenderInput) => Promise<string | null>;
     contentSource?: ContentSource;