@riebeckite/core 0.0.27 → 0.0.28

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

@@ -11,6 +11,7 @@ type ContentBuildCoordinatorDependencies = {
     readonly getEntries: () => Promise<readonly ContentSourceEntry[]>;
     readonly readEntry: (entry: ContentSourceEntry) => Promise<string>;
     readonly observability: Observability;
+    readonly includeFileMetadata: boolean;
 };
 export declare class ContentBuildCoordinator {
     private readonly dependencies;

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 = 16;
+export declare const CONTENT_BUILD_STATE_VERSION = 19;
 /**
  * Build state lives under `<content directory>/.riebeckite`. That directory is
  * build-time state, not content, so content sources must exclude it from scans
@@ -36,11 +36,12 @@ export type ManifestHookCacheEntry = {
     readonly cacheable: boolean;
     readonly pipelineFingerprint: string | undefined;
     readonly inputFingerprint: string;
-    readonly outputFingerprint: string;
-    readonly snapshot: ManifestHookSnapshot;
+    readonly outputFingerprint?: string;
+    readonly snapshot?: ManifestHookSnapshot;
 };
 export type ManifestHookSnapshot = {
     readonly entries: readonly ContentManifestEntry[];
+    readonly order?: readonly string[];
 };
 export type PersistedExternalDependency = {
     readonly id: string;

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

@@ -7,4 +7,3 @@ export type ContentChangeSet = {
 };
 export declare function diffContentEntries(previous: ContentBuildState, current: readonly FingerprintedContentEntry[]): ContentChangeSet;
 export declare function allContentChanged(entries: readonly FingerprintedContentEntry[]): ContentChangeSet;
-export declare function hasContentChanges(changeSet: ContentChangeSet): boolean;

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

@@ -1,3 +1,3 @@
 import type { FingerprintedContentEntry } from "./content_build_state.js";
 import type { ContentSourceContent, ContentSourceEntry } from "./content_source.js";
-export declare function fingerprintContentEntries(entries: readonly ContentSourceEntry[], read: (entry: ContentSourceEntry) => Promise<ContentSourceContent>): Promise<readonly FingerprintedContentEntry[]>;
+export declare function fingerprintContentEntries(entries: readonly ContentSourceEntry[], read: (entry: ContentSourceEntry) => Promise<ContentSourceContent>, includeMetadata?: boolean): Promise<readonly FingerprintedContentEntry[]>;

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

@@ -1,2 +1,3 @@
 import type { ContentLink } from "../types/content_manifest.js";
 export declare function extractContentLinks(markdown: string, contentIndex: Map<string, string>): ContentLink[];
+export declare function extractMarkdownLinkUrls(markdown: string): string[];

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

@@ -27,7 +27,7 @@ export declare class ContentManager {
     private pipelineOptions;
     private source;
     private contentIndexBuilder;
-    private manifestBuilder;
+    private manifestAssembler;
     private pluginRuntime;
     private contentIndex;
     private contentIndexAmbiguities;
@@ -78,8 +78,6 @@ export declare class ContentManager {
     inspect(): Promise<ContentInspection>;
     dispose(): Promise<void>;
     getContentLocations(): Promise<ReadonlyMap<string, ContentPublicLocation>>;
-    private applyPublicView;
-    private synchronizeManifestHtml;
     private publishStrategy;
     private reuseManifestEntry;
     private getPipelineFingerprint;

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

@@ -0,0 +1,14 @@
+import type { ContentManifestEntry } from "../types/content_manifest.js";
+import type { ContentBuildPlan } from "./content_build_plan.js";
+type ReuseManifestEntryInput = {
+    readonly slug: string;
+    readonly plan: ContentBuildPlan;
+    readonly pipelineFingerprint: string | undefined;
+    readonly getContentCacheFingerprint: () => string | undefined;
+};
+type ReusedManifestEntry = {
+    readonly entry: ContentManifestEntry;
+    readonly contentCacheFingerprint: string;
+};
+export declare function reuseManifestEntry(input: ReuseManifestEntryInput): ReusedManifestEntry | null;
+export {};

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

@@ -1,4 +1,5 @@
 export type ContentSourceMetadata = {
+    readonly createdAt?: number;
     readonly modifiedAt?: number;
     readonly size?: number;
     readonly etag?: string;

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

@@ -0,0 +1,13 @@
+import type { ContentManifest, ContentManifestEntry } from "../types/content_manifest.js";
+import type { PostContent } from "../types/post_content.js";
+import type { PublishStrategy } from "../types/publish_strategy.js";
+import { ManifestBuilder } from "./manifest_builder.js";
+export declare class ManifestAssembler {
+    private readonly contentCache;
+    private readonly builder;
+    constructor(contentCache: Map<string, PostContent>);
+    createEntry(...args: Parameters<ManifestBuilder["createEntry"]>): ContentManifestEntry;
+    build(...args: Parameters<ManifestBuilder["build"]>): ContentManifest;
+    applyPublicView(manifest: ContentManifest, strategy: PublishStrategy, publishingBuildTime: Date): void;
+    synchronizeHtml(manifest: ContentManifest, preHookEntries: readonly ContentManifestEntry[]): void;
+}

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

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

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

@@ -1,7 +1,15 @@
-import type { ContentManifest } from "../types/content_manifest.js";
+import type { ContentManifest, ContentManifestEntry } 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 serializeManifestEntries(entries: readonly ContentManifestEntry[]): Map<string, string>;
+export declare function createManifestHookCacheEntry(pluginName: string, cacheable: boolean, pipelineFingerprint: string | undefined, inputFingerprint: string, manifest: ContentManifest, beforeEntries: ReadonlyMap<string, string>, afterEntries: ReadonlyMap<string, string>): ManifestHookCacheEntry;
 export declare function fingerprintManifestHookSideEffects(manifest: ContentManifest): string;
-export declare function fingerprintManifestHookSnapshot(snapshot: ManifestHookSnapshot, manifest: ContentManifest): string;
+export declare function fingerprintManifestHookSnapshot(manifest: ContentManifest): string;
+export type ManifestHookRestorePoint = {
+    readonly entries: readonly ContentManifestEntry[];
+    readonly publicEntries: ContentManifest["publicEntries"];
+    readonly discoverableEntries: ContentManifest["discoverableEntries"];
+};
+export declare function captureManifestHookRestorePoint(manifest: ContentManifest): ManifestHookRestorePoint;
+export declare function restoreManifestHookEntries(manifest: ContentManifest, point: ManifestHookRestorePoint): boolean;
 export declare function applyManifestHookSnapshot(manifest: ContentManifest, snapshot: ManifestHookSnapshot): boolean;

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

@@ -1,6 +1,7 @@
 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 { ContentOutputDependencyResolver } from "../types/plugin.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";
@@ -29,9 +30,10 @@ export declare function determineOutputChanges(input: {
         readonly dependent: ReadonlySet<string>;
     };
     readonly pluginPageOutputs?: readonly OutputDescriptor[];
-    readonly contentOutputDependencies?: readonly OutputDependency[];
+    readonly contentOutputDependencies?: readonly OutputDependency[] | ContentOutputDependencyResolver;
     readonly externalDependencies?: readonly ExternalDependencySnapshot[];
     readonly externalDependencyFailures?: readonly ExternalDependencyFailure[];
+    readonly contentFingerprints?: ReadonlyMap<string, string | undefined>;
 }): OutputChangeSet;
-export declare function buildOutputInventory(manifest: ContentManifest, pluginPageOutputs?: readonly OutputDescriptor[], contentOutputDependencies?: readonly OutputDependency[]): readonly OutputDescriptor[];
+export declare function buildOutputInventory(manifest: ContentManifest, pluginPageOutputs?: readonly OutputDescriptor[], contentOutputDependencies?: readonly OutputDependency[] | ContentOutputDependencyResolver): readonly OutputDescriptor[];
 export declare function htmlOutputPath(pathname: string): string;

package/dist/src/markdown_fragments.d.ts

@@ -0,0 +1,2 @@
+import type { MarkdownEmbedFragment } from "./types/plugin_pipeline.js";
+export declare function selectEmbedMarkdownFragment(markdown: string, fragment: MarkdownEmbedFragment | null): string | null;

package/dist/src/markdown_links.d.ts

@@ -0,0 +1,8 @@
+import type { Node } from "unist";
+import type { MarkdownPipelineContext } from "./types/plugin_pipeline.js";
+type LinkNormalizationContext = MarkdownPipelineContext & {
+    recordLinkResolution?: (id: string, value: string) => void;
+};
+export declare function normalizeMarkdownLinks(context: LinkNormalizationContext): (tree: Node) => void;
+export declare function resolveLinkDependencyValue(id: string, contentIndex: ReadonlyMap<string, string>, lookupPermalink: (slug: string) => string | undefined, isRoutable: ((slug: string) => boolean) | undefined): string;
+export {};

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

@@ -0,0 +1,42 @@
+import type { ManifestHookCacheEntry } from "../content/content_build_state.js";
+import type { ContentManifest } from "../types/content_manifest.js";
+import type { RiebeckitePlugin } from "../types/plugin.js";
+import type { PluginContextBase, PluginContextWithCache } from "./plugin_runtime_context.js";
+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;
+}>;
+type ManifestHookRunnerOptions = {
+    readonly plugins: () => readonly RiebeckitePlugin[];
+    readonly createContext: (contentIndex: Map<string, string>) => PluginContextBase;
+    readonly createPluginContext: <TContext extends PluginContextBase>(plugin: RiebeckitePlugin, context: TContext) => PluginContextWithCache<TContext>;
+    readonly generatedOutputCount: () => number;
+    readonly diagnosticCount: () => number;
+};
+export declare class ManifestHookRunner {
+    private readonly options;
+    private manifestHooksExecuted;
+    private manifestHookDurationMs;
+    private manifestHooksReused;
+    private manifestHookCache;
+    private manifestHookMetricsByPlugin;
+    constructor(options: ManifestHookRunnerOptions);
+    getMetrics(): ManifestHookMetrics;
+    getNoChangeFastPathBlockReason(previousCache: readonly ManifestHookCacheEntry[], pipelineFingerprint: string | undefined): string | undefined;
+    getCache(): readonly ManifestHookCacheEntry[];
+    runManifestCreated(manifest: ContentManifest, contentIndex: Map<string, string>, previousCache: readonly ManifestHookCacheEntry[], pipelineFingerprint: string | undefined): Promise<void>;
+    private recordManifestHookMetric;
+}
+export {};

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

@@ -0,0 +1,23 @@
+import type { OutputDescriptor } from "../content/output_dependency.js";
+import type { ContentManifest, PluginPageRoute } from "../types/content_manifest.js";
+import type { RiebeckitePlugin } from "../types/plugin.js";
+import type { ResolvedPluginPage } from "../types/plugin_page.js";
+import type { PluginContextBase, PluginContextWithCache } from "./plugin_runtime_context.js";
+type PluginPageResolverOptions = {
+    readonly plugins: () => readonly RiebeckitePlugin[];
+    readonly createContext: (contentIndex: Map<string, string>) => PluginContextBase;
+    readonly createPluginContext: <TContext extends PluginContextBase>(plugin: RiebeckitePlugin, context: TContext) => PluginContextWithCache<TContext>;
+};
+export declare class PluginPageResolver {
+    private readonly options;
+    private pageDeclarations;
+    constructor(options: PluginPageResolverOptions);
+    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[]>;
+    private getPageDeclarations;
+    private resolvePageDeclarations;
+}
+export declare function collectPageTypeOwners(plugins: readonly RiebeckitePlugin[]): void;
+export {};

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

@@ -5,54 +5,28 @@ import type { ContentLocationInput, ContentManifest, ContentManifestEntry, Conte
 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 { ContentOutputDependencyResolver } from "../types/plugin.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";
-/**
- * Explicit build lifecycle stages. `idle` means no build lifecycle has been
- * requested yet; the remaining values name the stage currently executing.
- * Once `started` is reached the lifecycle never runs again.
- */
-export type PluginBuildStage = "idle" | "setup" | "buildStart" | "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;
-}>;
+import { type ManifestHookMetrics } from "./manifest_hooks.js";
+export type { ManifestHookMetrics, ManifestHookPluginMetrics, } from "./manifest_hooks.js";
 export declare class PluginRuntime {
     private pipelineOptions;
     private buildLifecycle;
-    private buildStage;
     private disposed;
     private diagnostics;
     private pluginCaches;
     private generatedOutputs;
     private isBuildTime;
     private resolvedPlugins;
-    private pageDeclarations;
     private externalDependencies;
     private externalDependencyFailures;
     private externalDependenciesResolved;
-    private manifestHooksExecuted;
-    private manifestHookDurationMs;
-    private manifestHooksReused;
-    private manifestHookCache;
-    private manifestHookMetricsByPlugin;
+    private readonly pageResolver;
+    private readonly manifestHooks;
     constructor(pipelineOptions?: PipelineOptions);
     getDiagnostics(): Diagnostic[];
-    getBuildStage(): PluginBuildStage;
     getManifestHookMetrics(): ManifestHookMetrics;
     getNoChangeFastPathBlockReason(previousCache: readonly ManifestHookCacheEntry[], pipelineFingerprint: string | undefined): string | undefined;
     getManifestHookCache(): readonly ManifestHookCacheEntry[];
@@ -74,7 +48,6 @@ export declare class PluginRuntime {
     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>, 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;
@@ -98,9 +71,7 @@ export declare class PluginRuntime {
     getPagePaths(manifest: ContentManifest, contentIndex: Map<string, string>): Promise<readonly string[]>;
     getPageRoutes(manifest: ContentManifest, contentIndex: Map<string, string>): Promise<readonly PluginPageRoute[]>;
     getPageOutputs(manifest: ContentManifest, contentIndex: Map<string, string>): Promise<readonly OutputDescriptor[]>;
-    private getPageDeclarations;
-    private resolvePageDeclarations;
-    getContentOutputDependencies(): readonly OutputDependency[];
+    getContentOutputDependencies(): ContentOutputDependencyResolver;
     collectDiagnostics(contentIndex: Map<string, string>): Promise<Diagnostic[]>;
     private runBuildLifecycle;
     private createContext;

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

@@ -0,0 +1,3 @@
+import type { PluginContext } from "../types/plugin_context.js";
+export type PluginContextBase = Omit<PluginContext, "cache" | "logger" | "tracer" | "output">;
+export type PluginContextWithCache<TContext extends PluginContextBase> = TContext & Pick<PluginContext, "cache" | "logger" | "tracer" | "output">;

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

@@ -5,6 +5,11 @@ import type { GeneratedOutput } from "./generated_output.js";
 import type { PluginAsset, PluginClientEntry } from "./plugin_asset.js";
 import type { PluginHeadTag } from "./plugin_head.js";
 import type { PostFrontmatter } from "./post_content.js";
+export type ContentFileMetadata = {
+    readonly size?: number;
+    readonly ctime?: Date;
+    readonly mtime?: Date;
+};
 export type ContentLinkKind = "note" | "image" | "attachment" | "unresolved";
 export type ContentLink = {
     raw: string;
@@ -37,6 +42,7 @@ export type ContentManifestEntry = {
     permalink: string;
     publicLocation: ContentPublicLocation;
     title: string;
+    file?: ContentFileMetadata;
     aliases?: readonly string[];
     frontmatter: PostFrontmatter;
     publishing: ResolvedPublishingState;

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

@@ -10,12 +10,19 @@ export type OutputDependency = {
 } | {
     readonly type: "file";
     readonly path: string;
+} | {
+    readonly type: "public-location";
+    readonly pathname: string;
 } | {
     readonly type: "projection";
     readonly projection: "navigation" | "recent-posts" | "taxonomy-tags" | "taxonomy-folders";
 } | {
     readonly type: "external";
     readonly id: string;
+} | {
+    readonly type: "content-query";
+    readonly properties: readonly string[];
+    readonly unknown?: boolean;
 } | {
     readonly type: "global";
 } | {

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

@@ -1,5 +1,5 @@
 import type { PluginOptionsValidator } from "./config_validation.js";
-import type { ContentManifestEntry } from "./content_manifest.js";
+import type { ContentManifest, 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";
@@ -32,6 +32,7 @@ export type RiebeckitePlugin<TOptions = unknown> = {
      */
     optional?: string[];
     cacheVersion?: string;
+    contentFileMetadata?: boolean;
     /**
      * Explicit contract for the persistent processed-content cache.
      *
@@ -90,9 +91,14 @@ export type RiebeckitePlugin<TOptions = unknown> = {
     extendContentGraph?(context: PluginGraphContext): void | Promise<void>;
     renderers?: PluginContentRenderer[];
     contentOutputDependencies?: readonly OutputDependency[];
+    resolveContentOutputDependencies?: ContentOutputDependencyResolver;
     /** Framework-independent page types contributed by this plugin. */
     pageTypes?: PluginPageType[];
 };
+export type ContentOutputDependencyResolver = (context: {
+    readonly entry: ContentManifestEntry;
+    readonly manifest: ContentManifest;
+}) => readonly OutputDependency[];
 export type PlannedGeneratedOutput = {
     readonly path: string;
     readonly content: GeneratedOutputContent;

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

@@ -0,0 +1 @@
+export declare function mapConcurrent<T, U>(values: readonly T[], concurrency: number, map: (value: T) => Promise<U>): Promise<U[]>;

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

@@ -2,4 +2,5 @@ export type MarkdownFenceLine = {
     readonly value: string;
     readonly inFence: boolean;
 };
+export declare function splitOnce(value: string, separator: string): [string, string?];
 export declare function scanMarkdownFenceLines(source: string): MarkdownFenceLine[];

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

@@ -1,2 +1,3 @@
+export declare function escapeRegExp(value: string): string;
 export declare function stripHtml(html: string): string;
 export declare function calculateReadingTime(html: string): number;

package/package.json

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