@riebeckite/core 0.0.1

package/dist/src/config.d.ts

@@ -0,0 +1,8 @@
+import type { PostFrontmatter } from "./types/post_content.js";
+import type { ResolvedRiebeckiteConfig } from "./types/resolved_riebeckite_config.js";
+import type { RiebeckiteConfig } from "./types/riebeckite_config.js";
+export declare function defineConfig(config: RiebeckiteConfig): RiebeckiteConfig;
+export declare function resolveConfigModule(configModule: unknown): ResolvedRiebeckiteConfig;
+export declare function resolveConfig(config: RiebeckiteConfig): ResolvedRiebeckiteConfig;
+export declare function isPublished(config: ResolvedRiebeckiteConfig, frontmatter: PostFrontmatter | undefined): boolean;
+export declare function isExcluded(patterns: readonly string[], relativePath: string): boolean;

package/dist/src/config_validation.d.ts

@@ -0,0 +1,7 @@
+import type { ConfigValidationIssue } from "./types/config_validation.js";
+import type { RiebeckiteConfig } from "./types/riebeckite_config.js";
+export declare class ConfigValidationError extends Error {
+    readonly issues: readonly ConfigValidationIssue[];
+    constructor(issues: readonly ConfigValidationIssue[]);
+}
+export declare function validateConfig(config: RiebeckiteConfig): void;

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

@@ -0,0 +1,7 @@
+import type { ContentBuildState } from "./content_build_state.js";
+import type { ContentChangeSet } from "./content_change_set.js";
+export type AffectedContent = {
+    readonly direct: ReadonlySet<string>;
+    readonly dependent: ReadonlySet<string>;
+};
+export declare function determineAffectedContent(changeSet: ContentChangeSet, previousState: ContentBuildState | undefined, currentPaths: readonly string[]): AffectedContent;

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

@@ -0,0 +1,7 @@
+export declare const ATTACHMENTS_BASE_PATH = "/assets/attachments";
+export declare function isMarkdownPath(filePath: string): boolean;
+export declare function isImagePath(filePath: string): boolean;
+export declare function isAttachmentPath(filePath: string): boolean;
+export declare function getExtension(filePath: string): string;
+export declare function attachmentUrl(filePath: string): string;
+export declare function normalizeContentPath(filePath: string): string;

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

@@ -0,0 +1,25 @@
+import type { Observability } from "../observability.js";
+import type { ContentManifest } from "../types/content_manifest.js";
+import { type ContentBuildState, type FingerprintedContentEntry } from "./content_build_state.js";
+import { type ContentChangeSet } from "./content_change_set.js";
+import type { ContentSourceEntry } from "./content_source.js";
+export type ContentBuildPreparation = {
+    readonly previousState: ContentBuildState | undefined;
+    readonly currentEntries: readonly FingerprintedContentEntry[];
+    readonly changeSet: ContentChangeSet;
+};
+type ContentBuildCoordinatorDependencies = {
+    readonly buildStatePath: string;
+    readonly getEntries: () => Promise<readonly ContentSourceEntry[]>;
+    readonly readEntry: (entry: ContentSourceEntry) => Promise<string>;
+    readonly observability: Observability;
+};
+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>;
+    private prepare;
+}
+export {};

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

@@ -0,0 +1,22 @@
+import type { ContentSourceEntry } from "./content_source.js";
+export declare const CONTENT_BUILD_STATE_VERSION = 2;
+/**
+ * Build state lives under `<content directory>/.riebeckite`. That directory is
+ * build-time state, not content, so content sources must exclude it from scans
+ * to avoid treating the state file itself as a changed content entry.
+ */
+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[];
+};
+export type ContentBuildState = {
+    readonly version: number;
+    readonly entries: Readonly<Record<string, ContentBuildEntry>>;
+    readonly contentIndex: Readonly<Record<string, string>>;
+};
+export type FingerprintedContentEntry = {
+    readonly entry: ContentSourceEntry;
+    readonly fingerprint: string;
+};

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

@@ -0,0 +1,20 @@
+import type { ResolvedRiebeckiteConfig } from "../types/resolved_riebeckite_config.js";
+import { type ContentBuildState } from "./content_build_state.js";
+export declare function loadContentBuildState(statePath: string): Promise<ContentBuildState | undefined>;
+export type ContentBuildStateInvalidReason = "malformed-json" | "unsupported-version" | "invalid-shape";
+export type ContentBuildStateStatus = {
+    kind: "missing";
+    path: string;
+} | {
+    kind: "valid";
+    path: string;
+    version: number;
+    entryCount: number;
+} | {
+    kind: "invalid";
+    path: string;
+    reason: ContentBuildStateInvalidReason;
+};
+export declare function readContentBuildStateStatus(statePath: string): Promise<ContentBuildStateStatus>;
+export declare function saveContentBuildState(statePath: string, state: ContentBuildState): Promise<void>;
+export declare function resolveContentBuildStatePath(config: ResolvedRiebeckiteConfig | undefined, contentDirectory: string | undefined): string;

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

@@ -0,0 +1,10 @@
+import type { ContentBuildState, FingerprintedContentEntry } from "./content_build_state.js";
+export type ContentChangeSet = {
+    readonly added: readonly string[];
+    readonly changed: readonly string[];
+    readonly removed: readonly string[];
+    readonly unchanged: readonly string[];
+};
+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_collection.d.ts

@@ -0,0 +1,78 @@
+import type { ContentManifestEntry } from "../types/content_manifest.js";
+import { type ContentQueryFilter, type ContentQueryGroupBy, type ContentQuerySort, type ContentQuerySortOrder } from "./content_query.js";
+/**
+ * Context passed to the optional title/path builders of a collection
+ * definition. `value` is the raw group key (for example `Log/Article` or
+ * `2025-12`), not a URL.
+ */
+export type ContentCollectionContext = {
+    kind: string;
+    value: string;
+    basePath: string;
+};
+/**
+ * Declarative definition of a taxonomy or archive. A definition groups
+ * resolved manifest entries, maps every group to a site-local listing path,
+ * and optionally names the collection.
+ */
+export type ContentCollectionDefinition = {
+    /** Stable identifier copied onto every generated collection. */
+    kind: string;
+    /** How entries are grouped (tags, folder, date, or a frontmatter field). */
+    groupBy: ContentQueryGroupBy;
+    /** Site-local path prefix for the listing pages, for example `/tags`. */
+    basePath: string;
+    /** Optional filter applied before grouping. */
+    filter?: ContentQueryFilter;
+    /** Optional sort applied before grouping and inside each listing. */
+    sort?: ContentQuerySort | readonly ContentQuerySort[];
+    /** Optional ordering of the generated group keys. Defaults to ascending. */
+    order?: ContentQuerySortOrder;
+    /** Entries per listing page. Omitted or `0` keeps a single page. */
+    pageSize?: number;
+    /**
+     * Optional display title. Defaults to the raw group value.
+     */
+    resolveTitle?: (context: ContentCollectionContext) => string;
+    /**
+     * Optional site-local path builder. Defaults to `basePath` plus a slugified
+     * group value, so `Log/Article` under `/tags` becomes `/tags/log/article`.
+     */
+    resolvePath?: (context: ContentCollectionContext) => string;
+};
+/**
+ * Pagination state of a generated listing page. When `size` is `0`,
+ * pagination is disabled and the single page contains every entry.
+ */
+export type ContentCollectionPage = {
+    /** 1-based page number. */
+    current: number;
+    /** Total number of pages in the collection. */
+    count: number;
+    /** Entries per page; `0` when pagination is disabled. */
+    size: number;
+    /** Total number of entries in the collection. */
+    total: number;
+    /** Site-local path of the previous page, or `null`. */
+    previousPath: string | null;
+    /** Site-local path of the next page, or `null`. */
+    nextPath: string | null;
+};
+/**
+ * A single generated listing page: one taxonomy value, archive period, or
+ * folder, together with the entries it lists in resolved query order.
+ */
+export type ContentCollection = {
+    kind: string;
+    value: string;
+    title: string;
+    path: string;
+    page: ContentCollectionPage;
+    entries: ContentManifestEntry[];
+};
+/**
+ * Builds listing collections from resolved manifest entries and declarative
+ * definitions. It applies the same query engine as `queryContentEntries`, so
+ * links inside a listing use the resolved `permalink`.
+ */
+export declare function buildContentCollections(entries: readonly ContentManifestEntry[], definitions: readonly ContentCollectionDefinition[]): ContentCollection[];

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

@@ -0,0 +1,12 @@
+import type { Observability } from "../observability.js";
+import type { ContentSource, ContentSourceEntry } from "./content_source.js";
+export declare class ContentEntryReader {
+    private readonly source;
+    private readonly observability;
+    private entries;
+    private texts;
+    constructor(source: ContentSource, observability: Observability);
+    getEntries(): Promise<readonly ContentSourceEntry[]>;
+    readText(logicalPath: string): Promise<string>;
+    read(entry: ContentSourceEntry): Promise<string>;
+}

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

@@ -0,0 +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[]>;

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

@@ -0,0 +1,23 @@
+import type { ContentLink, ContentManifestEntry } from "../types/content_manifest.js";
+export type ContentGraphSource = {
+    entries: ContentManifestEntry[];
+    bySlug: Map<string, ContentManifestEntry>;
+    outgoingLinks: Map<string, ContentLink[]>;
+    incomingLinks: Map<string, string[]>;
+};
+export type ContentGraph = {
+    nodes(): ContentManifestEntry[];
+    get(slug: string): ContentManifestEntry | null;
+    outgoing(slug: string): ContentManifestEntry[];
+    incoming(slug: string): ContentManifestEntry[];
+    neighbors(slug: string): ContentManifestEntry[];
+    outgoingSlugs(slug: string): string[];
+    incomingSlugs(slug: string): string[];
+    neighborSlugs(slug: string): string[];
+    filterNeighbors(slug: string, include: (neighborSlug: string) => boolean): ContentGraphNeighbors;
+};
+export type ContentGraphNeighbors = {
+    outgoingSlugs: string[];
+    incomingSlugs: string[];
+};
+export declare function createContentGraph(manifest: ContentGraphSource): ContentGraph;

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

@@ -0,0 +1,7 @@
+import type { ContentSource, ContentSourceEntry } from "./content_source.js";
+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>>;
+    private indexContentEntry;
+}

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

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

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

@@ -0,0 +1,2 @@
+import type { ContentLocationInput, ContentPublicLocation } from "../types/content_manifest.js";
+export declare function resolveDefaultContentLocation(content: ContentLocationInput): ContentPublicLocation;

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

@@ -0,0 +1,18 @@
+import type { PluginRuntime } from "../plugin/plugin_runtime.js";
+import type { ContentManifest, ContentPublicLocation } from "../types/content_manifest.js";
+import type { ContentSourceEntry } from "./content_source.js";
+type ContentLocationResolverDependencies = {
+    readonly getEntries: () => Promise<readonly ContentSourceEntry[]>;
+    readonly readEntry: (entry: ContentSourceEntry) => Promise<string>;
+    readonly getContentIndex: () => Promise<Map<string, string>>;
+    readonly pluginRuntime: PluginRuntime;
+};
+export declare class ContentLocationResolver {
+    private readonly dependencies;
+    private locations;
+    constructor(dependencies: ContentLocationResolverDependencies);
+    getLocations(): Promise<ReadonlyMap<string, ContentPublicLocation>>;
+    getPermalinks(): Promise<Map<string, string>>;
+    populateRedirects(manifest: ContentManifest, locations: ReadonlyMap<string, ContentPublicLocation>): void;
+}
+export {};

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

@@ -0,0 +1,59 @@
+import type { PipelineOptions } from "../pipeline.js";
+import type { ContentManifest, ContentPublicLocation } from "../types/content_manifest.js";
+import type { Diagnostic } from "../types/diagnostic.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 { ContentGraph } from "./content_graph.js";
+import type { ContentSource, ContentSourceEntry } from "./content_source.js";
+export type Backlink = {
+    slug: string;
+};
+export type ContentPostReference = {
+    slug: string;
+};
+export type ContentBuildOptions = {
+    incremental?: boolean;
+};
+export type ContentInspection = {
+    readonly entries: readonly ContentSourceEntry[];
+    readonly contentIndex: ReadonlyMap<string, string>;
+    readonly diagnostics: readonly Diagnostic[];
+};
+export declare class ContentManager {
+    private pipelineOptions;
+    private source;
+    private contentIndexBuilder;
+    private manifestBuilder;
+    private pluginRuntime;
+    private contentIndex;
+    private contentCache;
+    private manifest;
+    private pipeline;
+    private entryReader;
+    private locationResolver;
+    private buildCoordinator;
+    private isBuildTime;
+    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>>;
+    getProcessedContent(slug: string): Promise<PostContent>;
+    getManifest(options?: ContentBuildOptions): Promise<ContentManifest>;
+    build(options?: ContentBuildOptions): Promise<ContentManifest>;
+    getBacklinks(targetSlug: string): Promise<Backlink[]>;
+    getContentGraph(): Promise<ContentGraph>;
+    getDiagnostics(): Promise<Diagnostic[]>;
+    inspect(): Promise<ContentInspection>;
+    dispose(): Promise<void>;
+    getContentLocations(): Promise<ReadonlyMap<string, ContentPublicLocation>>;
+    private applyPublicView;
+    private enableBuildTime;
+    private observability;
+}
+declare module "../pipeline" {
+    interface PipelineOptions {
+        config?: ResolvedRiebeckiteConfig;
+    }
+}

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

@@ -0,0 +1,3 @@
+export declare function extractContentTags(markdown: string): string[];
+export declare function normalizeFrontmatterTags(tags: unknown): string[];
+export declare function extractFrontmatterAliases(markdown: string): string[];

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

@@ -0,0 +1,76 @@
+import type { ContentManifestEntry } from "../types/content_manifest.js";
+export type ContentQueryScalar = string | number | boolean;
+export type ContentQueryTagFilter = {
+    any?: readonly string[];
+    all?: readonly string[];
+    none?: readonly string[];
+};
+export type ContentQueryFrontmatterFilter = Record<string, ContentQueryScalar | readonly ContentQueryScalar[]>;
+export type ContentQueryDateFilter = {
+    field?: string;
+    from?: string;
+    to?: string;
+};
+export type ContentQueryFilter = {
+    tags?: ContentQueryTagFilter;
+    folder?: string | readonly string[];
+    frontmatter?: ContentQueryFrontmatterFilter;
+    date?: ContentQueryDateFilter;
+};
+export type ContentQuerySortOrder = "asc" | "desc";
+export type ContentQuerySort = {
+    field?: string;
+    order?: ContentQuerySortOrder;
+};
+export type ContentQuerySpec = {
+    filter?: ContentQueryFilter;
+    sort?: ContentQuerySort | readonly ContentQuerySort[];
+    limit?: number;
+    offset?: number;
+};
+export type ContentQueryPagination = {
+    /** Number of entries skipped from the start. */
+    offset: number;
+    /** Entries per page; `0` means pagination is disabled. */
+    limit: number;
+    /** Total number of entries before pagination. */
+    total: number;
+    /** 1-based page number for the resolved offset. */
+    page: number;
+    /** Total number of pages (`0` when there are no entries). */
+    pageCount: number;
+    hasPrevious: boolean;
+    hasNext: boolean;
+};
+export type ContentQueryPage = {
+    entries: ContentManifestEntry[];
+    page: ContentQueryPagination;
+};
+export type ContentQueryDateGranularity = "year" | "month" | "day";
+export type ContentQueryGroupBy = {
+    by: "tags";
+} | {
+    by: "folder";
+    depth?: number;
+} | {
+    by: "date";
+    field?: string;
+    fields?: readonly string[];
+    granularity?: ContentQueryDateGranularity;
+} | {
+    by: "frontmatter";
+    field: string;
+};
+export type ContentQueryGroup = {
+    key: string;
+    entries: ContentManifestEntry[];
+};
+export type ContentQueryGroupOptions = {
+    filter?: ContentQueryFilter;
+    sort?: ContentQuerySort | readonly ContentQuerySort[];
+    order?: ContentQuerySortOrder;
+};
+export declare function queryContentEntries(entries: readonly ContentManifestEntry[], spec?: ContentQuerySpec): ContentManifestEntry[];
+export declare function queryContentPage(entries: readonly ContentManifestEntry[], spec?: ContentQuerySpec): ContentQueryPage;
+export declare function resolveContentQueryPagination(total: number, spec?: Pick<ContentQuerySpec, "offset" | "limit">): ContentQueryPagination;
+export declare function groupContentEntries(entries: readonly ContentManifestEntry[], groupBy: ContentQueryGroupBy, options?: ContentQueryGroupOptions): ContentQueryGroup[];

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

@@ -0,0 +1,17 @@
+export type ContentSourceMetadata = {
+    readonly modifiedAt?: number;
+    readonly size?: number;
+    readonly etag?: string;
+    readonly hash?: string;
+};
+export type ContentSourceEntry = {
+    readonly path: string;
+    readonly metadata?: ContentSourceMetadata;
+};
+export type ContentSourceContent = string | Uint8Array;
+export interface ContentSource {
+    scan(): Promise<readonly ContentSourceEntry[]>;
+    read(entry: ContentSourceEntry): Promise<ContentSourceContent>;
+}
+export declare function readContentSourceEntry(source: ContentSource, logicalPath: string): Promise<ContentSourceContent | null>;
+export declare function getContentSourceEntry(source: ContentSource, logicalPath: string): Promise<ContentSourceEntry | null>;

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

@@ -0,0 +1,11 @@
+import type { ContentSource, ContentSourceContent, ContentSourceEntry } from "./content_source.js";
+export declare class FileSystemContentSource implements ContentSource {
+    private contentDirectory;
+    private exclude;
+    constructor(contentDirectory: string, exclude?: readonly string[]);
+    scan(): Promise<readonly ContentSourceEntry[]>;
+    read(entry: ContentSourceEntry): Promise<ContentSourceContent>;
+    private scanDirectory;
+    private isExcluded;
+    private resolveFilePath;
+}

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

@@ -0,0 +1,24 @@
+export type GraphEdge = {
+    source: string;
+    target: string;
+};
+export type LinkableGraphNode = {
+    slug: string;
+    outgoing: string[];
+    backlinks: string[];
+};
+export type GraphLayoutNode = {
+    x: number;
+    y: number;
+    radius: number;
+};
+export type RadialGraphLayoutOptions = {
+    width: number;
+    height: number;
+    centerSlug: string;
+    radiusRatio?: number;
+    minNodeRadius?: number;
+    maxNodeRadius?: number;
+};
+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>;

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

@@ -0,0 +1 @@
+export declare const IMAGE_EXTENSIONS: string[];

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

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

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

@@ -0,0 +1,4 @@
+import type { ContentPublicLocation } from "../types/content_manifest.js";
+import type { ContentGraph } from "./content_graph.js";
+import type { ContentSource } from "./content_source.js";
+export declare function readOnlyContentGraph(source: ContentSource, locations: ReadonlyMap<string, ContentPublicLocation>): Promise<ContentGraph>;

package/dist/src/observability.d.ts

@@ -0,0 +1,70 @@
+export type ObservabilityValue = string | number | boolean | null;
+export type LogContext = Readonly<Record<string, ObservabilityValue>>;
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export interface Logger {
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext, cause?: Error): void;
+    child(context: LogContext): Logger;
+}
+export type TraceAttributes = Readonly<Record<string, ObservabilityValue>>;
+export type TraceSpan = Readonly<{
+    name: string;
+    startTime: number;
+    durationMs: number;
+    status: "ok" | "error";
+    attributes: TraceAttributes;
+}>;
+export type TraceEvent = Readonly<{
+    name: string;
+    time: number;
+    attributes: TraceAttributes;
+}>;
+export interface TraceSink {
+    onSpan(span: TraceSpan): void;
+    onEvent(event: TraceEvent): void;
+}
+export interface Tracer {
+    span<T>(name: string, attributes: TraceAttributes, fn: () => T | Promise<T>): Promise<T>;
+    event(name: string, attributes?: TraceAttributes): void;
+}
+export type Observability = Readonly<{
+    logger: Logger;
+    tracer: Tracer;
+}>;
+export declare class NoopLogger implements Logger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+    child(): Logger;
+}
+export declare class ConsoleLogger implements Logger {
+    private readonly context;
+    constructor(context?: LogContext);
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext, cause?: Error): void;
+    child(context: LogContext): Logger;
+    private write;
+}
+export declare class NoopTracer implements Tracer {
+    span<T>(_name: string, _attributes: TraceAttributes, fn: () => T | Promise<T>): Promise<T>;
+    event(): void;
+}
+export declare class SinkTracer implements Tracer {
+    private readonly sink;
+    constructor(sink: TraceSink);
+    span<T>(name: string, attributes: TraceAttributes, fn: () => T | Promise<T>): Promise<T>;
+    event(name: string, attributes?: TraceAttributes): void;
+    private emitSpan;
+}
+export declare class CompositeTraceSink implements TraceSink {
+    private readonly sinks;
+    constructor(sinks: readonly TraceSink[]);
+    onSpan(span: TraceSpan): void;
+    onEvent(event: TraceEvent): void;
+}
+export declare const noopObservability: Observability;

package/dist/src/pipeline.d.ts

@@ -0,0 +1,25 @@
+import type { ContentSource } from "./content/content_source.js";
+import type { Observability } from "./observability.js";
+import type { RiebeckitePlugin } from "./types/plugin.js";
+import type { PostContent } from "./types/post_content.js";
+export interface PipelineOptions {
+    plugins?: RiebeckitePlugin[];
+    observability?: Observability;
+    config?: import("./types/resolved_riebeckite_config.js").ResolvedRiebeckiteConfig;
+    contentSource?: ContentSource;
+}
+export declare class Pipeline {
+    private contentIndex;
+    private permalinks;
+    private getMarkdownBySlug?;
+    private options;
+    private isBuildTime;
+    private pluginCaches;
+    constructor(contentIndex: Map<string, string>, permalinks: ReadonlyMap<string, string>, getMarkdownBySlug?: (slug: string) => Promise<string>, options?: PipelineOptions, isBuildTime?: boolean);
+    execute(markDownContent: string, embedDepth?: number, embedTrail?: Set<string>): Promise<PostContent>;
+    private getPermalink;
+    private use;
+    private createNoteEmbedRenderer;
+    private createContentRenderer;
+    private cacheFor;
+}

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

@@ -0,0 +1,22 @@
+import type { Logger, Tracer } from "../observability.js";
+import type { ResolvedRiebeckiteConfig } from "../types/resolved_riebeckite_config.js";
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type PluginCache = {
+    get<T extends JsonValue>(key: string): Promise<T | undefined>;
+    set<T extends JsonValue>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+};
+export declare function createUnavailablePluginCache(): PluginCache;
+type CreatePluginCacheOptions = {
+    pluginName: string;
+    cacheVersion?: string;
+    cacheDirectory: string;
+    logger?: Logger;
+    tracer?: Tracer;
+};
+export declare function createPluginCache(options: CreatePluginCacheOptions): PluginCache;
+export declare function resolvePluginCacheDirectory(config: ResolvedRiebeckiteConfig | undefined): string;
+export {};

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

@@ -0,0 +1,2 @@
+import type { RiebeckitePlugin } from "../types/plugin.js";
+export declare function resolvePluginDependencies(plugins: readonly RiebeckitePlugin[]): RiebeckitePlugin[];

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

@@ -0,0 +1,20 @@
+export type PluginDependencyErrorKind = "missing-capability" | "duplicate-provider" | "self-dependency" | "invalid-capability" | "cycle";
+export type CapabilityDeclaration = "provides" | "requires" | "optional";
+export declare class PluginDependencyError extends Error {
+    readonly kind: PluginDependencyErrorKind;
+    readonly pluginName?: string;
+    readonly capability?: string;
+    readonly declaration?: CapabilityDeclaration;
+    readonly pluginNames: readonly string[];
+    readonly chain: readonly string[];
+    readonly availableCapabilities: readonly string[];
+    constructor(input: {
+        kind: PluginDependencyErrorKind;
+        pluginName?: string;
+        capability?: string;
+        declaration?: CapabilityDeclaration;
+        pluginNames?: readonly string[];
+        chain?: readonly string[];
+        availableCapabilities?: readonly string[];
+    });
+}

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

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