@riebeckite/core 0.0.1

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

@@ -0,0 +1,20 @@
+import type { Logger } from "../observability.js";
+import type { JsonValue, PluginCache } from "./plugin_cache.js";
+/**
+ * Dependency-aware memoization on top of the existing `PluginCache`. The cache
+ * key is derived from the caller-supplied key plus a stable hash of the
+ * declared dependencies, so a cache hit only happens when everything the value
+ * depends on is unchanged. No separate cache backend is introduced.
+ */
+export type PluginMemo = {
+    memo<T extends JsonValue>(key: string, dependencies: JsonValue, compute: () => T | Promise<T>): Promise<T>;
+};
+export type CreatePluginMemoOptions = {
+    logger?: Logger;
+};
+export declare function createPluginMemo(cache: PluginCache, options?: CreatePluginMemoOptions): PluginMemo;
+/**
+ * Serializes JSON values with sorted object keys so that logically identical
+ * dependency sets hash identically regardless of key insertion order.
+ */
+export declare function stableStringify(value: JsonValue): string;

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

@@ -0,0 +1,59 @@
+import type { PipelineOptions } from "../pipeline.js";
+import type { ContentLocationInput, ContentManifest, ContentManifestEntry, ContentPublicLocation } from "../types/content_manifest.js";
+import type { Diagnostic } from "../types/diagnostic.js";
+import type { GeneratedOutput } from "../types/generated_output.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" | "onBuildStart" | "onConfigResolved" | "started";
+export declare class PluginRuntime {
+    private pipelineOptions;
+    private buildLifecycle;
+    private buildStage;
+    private disposed;
+    private diagnostics;
+    private pluginCaches;
+    private generatedOutputs;
+    private generatedOutputOwners;
+    private isBuildTime;
+    constructor(pipelineOptions?: PipelineOptions);
+    getDiagnostics(): Diagnostic[];
+    getBuildStage(): PluginBuildStage;
+    /**
+     * Starts the plugin build lifecycle exactly once, regardless of which public
+     * entry point (content processing or location resolution) reaches it first.
+     * Concurrent callers await the same run, so the ordered hooks
+     * (`setup` → `buildStart` → `onBuildStart` → `onConfigResolved`) are never
+     * duplicated and no caller proceeds before the lifecycle completes.
+     */
+    startBuild(contentIndex: Map<string, string>): Promise<void>;
+    runContentLoaded(slug: string, markdown: string, contentIndex: Map<string, string>): Promise<void>;
+    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>;
+    runBuildEnd(manifest: ContentManifest, contentIndex: Map<string, string>): Promise<void>;
+    enableBuildTime(): void;
+    dispose(contentIndex: Map<string, string>): Promise<void>;
+    collectAssets(): {
+        path: string;
+        pluginName: string;
+        kind: import("../types/plugin_asset.js").PluginAssetKind;
+        moduleSpecifier: string;
+    }[];
+    /** Returns registered outputs sorted by path for a deterministic build. */
+    collectGeneratedOutputs(): GeneratedOutput[];
+    collectDiagnostics(contentIndex: Map<string, string>): Promise<Diagnostic[]>;
+    private runBuildLifecycle;
+    private createContext;
+    private createPluginContext;
+    private generatedOutputSinkFor;
+    private cacheFor;
+    private runHook;
+    private observability;
+    private plugins;
+}

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

@@ -0,0 +1,7 @@
+export type ConfigValidationIssue = {
+    readonly path: string;
+    readonly message: string;
+};
+export type PluginOptionsValidator<TOptions = unknown> = {
+    validate(options: TOptions | undefined): readonly ConfigValidationIssue[] | undefined;
+}["validate"];

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

@@ -0,0 +1,87 @@
+import type { ContentGraph } from "../content/content_graph.js";
+import type { Diagnostic } from "./diagnostic.js";
+import type { GeneratedOutput } from "./generated_output.js";
+import type { PluginAsset } from "./plugin_asset.js";
+import type { PluginHeadTag } from "./plugin_head.js";
+import type { PostFrontmatter } from "./post_content.js";
+export type ContentLinkKind = "note" | "image" | "attachment" | "unresolved";
+export type ContentLink = {
+    raw: string;
+    slug: string | null;
+    kind: ContentLinkKind;
+    embed: boolean;
+};
+export type ContentAsset = {
+    path: string;
+};
+export type ContentManifestPluginAsset = PluginAsset & {
+    path: string;
+};
+export type ContentManifestEntry = {
+    slug: string;
+    permalink: string;
+    publicLocation: ContentPublicLocation;
+    title: string;
+    frontmatter: PostFrontmatter;
+    html: string;
+    /**
+     * Head tags a plugin wants the Site shell to render for this entry.
+     * 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[];
+};
+export type ContentRedirect = {
+    path: string;
+    status: 301 | 302 | 307 | 308;
+};
+export type ContentPublicLocation = {
+    slug: string;
+    permalink: string;
+    redirects?: readonly ContentRedirect[];
+    metadata?: Readonly<Record<string, string>>;
+};
+export type ContentLocationInput = {
+    slug: string;
+    path: string;
+    markdown: string;
+};
+export type ContentManifest = {
+    entries: ContentManifestEntry[];
+    /**
+     * Entries that pass the configured publish strategy. `entries` keeps every
+     * scanned note for backward compatibility; publishing plugins should read
+     * this view so unpublished notes never reach generated output.
+     */
+    publicEntries: ContentManifestEntry[];
+    bySlug: Map<string, ContentManifestEntry>;
+    byPermalink: Map<string, ContentManifestEntry>;
+    redirects: Map<string, ContentRedirect & {
+        slug: string;
+    }>;
+    /**
+     * Redirects whose owning entry is public. Prevents unpublished notes from
+     * leaking their previous paths into deploy files.
+     */
+    publicRedirects: Map<string, ContentRedirect & {
+        slug: string;
+    }>;
+    byTag: Map<string, ContentManifestEntry[]>;
+    byAsset: Map<string, ContentManifestEntry[]>;
+    outgoingLinks: Map<string, ContentLink[]>;
+    incomingLinks: Map<string, string[]>;
+    contentIndex: Map<string, string>;
+    graph: ContentGraph;
+    assets: ContentManifestPluginAsset[];
+    diagnostics: Diagnostic[];
+    generatedOutputs: GeneratedOutput[];
+};

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

@@ -0,0 +1,15 @@
+export type DiagnosticSeverity = "info" | "warning" | "error";
+export type DiagnosticCode = "broken-wikilink" | "broken-image" | "broken-link" | "unused-asset" | "orphan-note" | "missing-frontmatter" | "publish-conflict" | "duplicate-title" | "slug-collision" | "excluded-public" | "publish-boundary" | "internal-error" | (string & {});
+export type Diagnostic = {
+    code: DiagnosticCode;
+    severity: DiagnosticSeverity;
+    message: string;
+    pluginName?: string;
+    filePath?: string;
+    slug?: string;
+    line?: number;
+    column?: number;
+    target?: string;
+    suggestion?: string;
+    meta?: Record<string, unknown>;
+};

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

@@ -0,0 +1,28 @@
+export type GeneratedOutputContent = string | Uint8Array;
+/**
+ * A file a plugin wants written to the build output directory. Content is kept
+ * in memory until the integration layer forwards it to the build tool, so
+ * plugins never touch the filesystem themselves.
+ */
+export type GeneratedOutputInput = {
+    /**
+     * Output path relative to the build output directory, for example
+     * `_redirects`, `.nojekyll` or `daily/feed.xml`.
+     */
+    path: string;
+    content: GeneratedOutputContent;
+};
+export type GeneratedOutput = GeneratedOutputInput & {
+    /** Name of the plugin that registered the output. */
+    owner: string;
+};
+export type GeneratedOutputSink = {
+    emit(output: GeneratedOutputInput): void;
+};
+export declare function createUnavailableGeneratedOutputSink(): GeneratedOutputSink;
+/**
+ * Normalizes a plugin-provided output path and rejects anything that could
+ * escape the output directory or collide with reserved namespaces. Rejecting
+ * (rather than silently rewriting) keeps `..` traversal from being laundered.
+ */
+export declare function normalizeGeneratedOutputPath(input: string): string;

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

@@ -0,0 +1,71 @@
+import type { PluginOptionsValidator } from "./config_validation.js";
+import type { Diagnostic } from "./diagnostic.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";
+import type { HtmlPipeline, MarkdownPipeline, MarkdownPipelineContext, PipelinePlugin } from "./plugin_pipeline.js";
+import type { PluginSeoExtension } from "./plugin_seo.js";
+export type RiebeckitePlugin<TOptions = unknown> = {
+    name: string;
+    options?: TOptions;
+    order?: number;
+    enabled?: boolean;
+    /**
+     * Capabilities this plugin exposes to other plugins. A capability must have
+     * exactly one enabled provider; duplicate providers fail resolution.
+     */
+    provides?: string[];
+    /**
+     * Capabilities this plugin depends on. Resolution orders each provider
+     * before this plugin and fails with a diagnostic when none is available.
+     */
+    requires?: string[];
+    /**
+     * Capabilities this plugin uses when available. A missing capability is
+     * ignored, while a present provider is still ordered before this plugin.
+     */
+    optional?: string[];
+    cacheVersion?: string;
+    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>;
+    dispose?(context: PluginLifecycleContext): void | Promise<void>;
+    onConfigResolved?(context: PluginContext): void | Promise<void>;
+    onContentLoaded?(context: PluginContentContext): void | Promise<void>;
+    resolveContentLocations?: PluginContentLocationResolver;
+    extendContentLocations?(context: PluginContentLocationAugmentContext): void | Promise<void>;
+    onPostParsed?(context: PluginPostContext): void | Promise<void>;
+    onPostProcessed?(context: PluginPostContext): void | Promise<void>;
+    onManifestCreated?(context: PluginManifestContext): void | Promise<void>;
+    onBuildStart?(context: PluginContext): void | Promise<void>;
+    onBuildEnd?(context: PluginManifestContext): void | Promise<void>;
+    extendMarkdownPipeline?(pipeline: MarkdownPipeline, context: MarkdownPipelineContext): void;
+    extendHtmlPipeline?(pipeline: HtmlPipeline): void;
+    addDiagnostics?(context: PluginContext): Diagnostic[] | Promise<Diagnostic[]>;
+    /**
+     * Inspects final HTML pages after the SSG stage. Integrations that finish HTML
+     * generation call this for every emitted `.html` file. Prefer `addDiagnostics`
+     * for article-body rules; use this when the rule needs the whole document.
+     */
+    inspectGeneratedHtml?: PluginGeneratedHtmlInspector;
+    assets?: PluginAsset[];
+    clientEntries?: PluginClientEntry[];
+    endpoints?: PluginEndpoint[];
+    seo?: PluginSeoExtension;
+    extendContentGraph?(context: PluginGraphContext): void | Promise<void>;
+    renderers?: PluginContentRenderer[];
+};
+export type PluginInput = RiebeckitePlugin | false | null | undefined;
+export type ResolvedPluginMetadata = {
+    readonly name: string;
+    readonly enabled: boolean;
+    readonly provides: readonly string[];
+    readonly requires: readonly string[];
+    readonly optional: readonly string[];
+};
+export declare function definePlugin<TOptions>(plugin: RiebeckitePlugin<TOptions>): RiebeckitePlugin<TOptions>;
+export declare function resolvePlugins(plugins?: PluginInput[]): RiebeckitePlugin[];
+export declare function getResolvedPluginMetadata(plugins: readonly RiebeckitePlugin[]): readonly ResolvedPluginMetadata[];

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

@@ -0,0 +1,13 @@
+export type PluginAssetKind = "style" | "script";
+export type PluginAsset = {
+    pluginName: string;
+    kind: PluginAssetKind;
+    moduleSpecifier: string;
+};
+export type PluginClientEntry = {
+    pluginName: string;
+    moduleSpecifier: string;
+    exportName?: string;
+};
+export declare function createStyleAsset(pluginName: string): PluginAsset;
+export declare function createClientEntry(pluginName: string, exportName?: string): PluginClientEntry;

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

@@ -0,0 +1,85 @@
+import type { ContentSource } from "../content/content_source.js";
+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 { GeneratedOutputSink } from "./generated_output.js";
+import type { PostContent } from "./post_content.js";
+import type { ResolvedRiebeckiteConfig } from "./resolved_riebeckite_config.js";
+export type PluginContext = {
+    config?: ResolvedRiebeckiteConfig;
+    contentIndex: Map<string, string>;
+    diagnostics: Diagnostic[];
+    cache: PluginCache;
+    /**
+     * Registers a file to be written to the build output directory. Available
+     * during build lifecycle hooks; the integration layer forwards each entry to
+     * the build tool.
+     */
+    output: GeneratedOutputSink;
+    logger: Logger;
+    tracer: Tracer;
+    contentSource?: ContentSource;
+};
+export type PluginLifecycleContext = PluginContext;
+export type PluginContentContext = PluginContext & {
+    slug: string;
+    markdown: string;
+};
+export type PluginPostContext = PluginContentContext & {
+    content: PostContent;
+};
+export type PluginManifestContext = PluginContext & {
+    manifest: ContentManifest;
+};
+export type PluginGraphContext = PluginContext & {
+    entries: ContentManifestEntry[];
+};
+export type PluginContentLocationContext = PluginContext & {
+    entries: readonly ContentLocationInput[];
+};
+export type PluginContentLocationResolver = (context: PluginContentLocationContext) => readonly ContentPublicLocation[] | Promise<readonly ContentPublicLocation[]>;
+/**
+ * Context for augmenting already-resolved public locations.
+ *
+ * Runs after every `resolveContentLocations` resolver, so a plugin can add
+ * redirects or metadata without replacing (and therefore without needing to
+ * reproduce) the canonical permalink another plugin resolved.
+ */
+export type PluginContentLocationAugmentContext = PluginContext & {
+    entries: readonly ContentLocationInput[];
+    locations: Map<string, ContentPublicLocation>;
+};
+export type PluginRenderTarget = {
+    kind: string;
+    path: string;
+    raw: string;
+    label: string;
+    url: string;
+    embed: boolean;
+};
+export type PluginRenderContext = PluginContext & PluginRenderTarget;
+export type PluginContentRenderer = {
+    name?: string;
+    render(context: PluginRenderContext): string | null | Promise<string | null>;
+};
+export type PluginRenderInput = {
+    kind: string;
+    path: string;
+    raw: string;
+    label: string;
+    url: string;
+    embed: boolean;
+};
+export type PluginGeneratedHtml = {
+    /** Output-relative path of the generated HTML file (e.g. "index.html"). */
+    path: string;
+    /** Final page HTML produced by the SSG build. */
+    html: string;
+};
+/**
+ * Inspects a fully rendered HTML page after the SSG stage. Use this instead of
+ * `addDiagnostics` when the rule needs the final document (head, layout,
+ * navigation) rather than the article body HTML only.
+ */
+export type PluginGeneratedHtmlInspector = (page: PluginGeneratedHtml) => readonly Diagnostic[];

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

@@ -0,0 +1,5 @@
+import type { Diagnostic } from "./diagnostic.js";
+export type PluginDiagnosticLevel = Diagnostic["severity"];
+export type PluginDiagnostic = Diagnostic & {
+    pluginName: string;
+};

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

@@ -0,0 +1,22 @@
+import type { ContentManifest } from "./content_manifest.js";
+import type { ResolvedRiebeckiteConfig } from "./resolved_riebeckite_config.js";
+export type PluginEndpointMethod = "GET";
+export type PluginEndpointContext = {
+    config: ResolvedRiebeckiteConfig;
+    manifest: ContentManifest;
+};
+export type PluginEndpointResponse = {
+    status?: number;
+    headers?: Record<string, string>;
+    body?: string;
+    json?: unknown;
+};
+export type PluginEndpoint = {
+    path: string;
+    method?: PluginEndpointMethod;
+    handler(context: PluginEndpointContext): PluginEndpointResponse | Promise<PluginEndpointResponse>;
+};
+export type PluginEndpointOptions = {
+    cacheControl?: string;
+};
+export declare function defineEndpoint(path: string, handler: PluginEndpoint["handler"], options?: PluginEndpointOptions): PluginEndpoint;

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

@@ -0,0 +1,18 @@
+/**
+ * A document `<head>` element contributed by a plugin.
+ *
+ * A plugin provides these on a `ContentManifestEntry` (see
+ * `headTags`) and the Site shell decides whether and how to render them.
+ * Plugins still do not own the shell; they only describe tags.
+ */
+export type PluginHeadTag = {
+    tag: "meta";
+    attrs: Record<string, string>;
+} | {
+    tag: "link";
+    attrs: Record<string, string>;
+} | {
+    tag: "script";
+    attrs?: Record<string, string>;
+    children?: string;
+};

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

@@ -0,0 +1,20 @@
+import type { Plugin } from "unified";
+import type { Node } from "unist";
+import type { ContentSource } from "../content/content_source.js";
+import type { PluginRenderInput } from "./plugin_context.js";
+export type PipelinePlugin = Plugin<[unknown?], Node, Node>;
+export type MarkdownPipeline = {
+    use(plugin: PipelinePlugin, options?: unknown): void;
+};
+export type HtmlPipeline = MarkdownPipeline;
+export type MarkdownPipelineContext = {
+    contentIndex: Map<string, string>;
+    resolvePermalink: (slug: string) => string;
+    renderNoteEmbed?: (slug: string, fragment: MarkdownEmbedFragment | null) => Promise<string | null>;
+    renderContent?: (input: PluginRenderInput) => Promise<string | null>;
+    contentSource?: ContentSource;
+};
+export type MarkdownEmbedFragment = {
+    kind: "heading" | "block";
+    value: string;
+};

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

@@ -0,0 +1,40 @@
+import type { ContentManifestEntry } from "./content_manifest.js";
+import type { PostContent } from "./post_content.js";
+import type { ResolvedRiebeckiteConfig } from "./resolved_riebeckite_config.js";
+export type SeoMetadata = {
+    title: string;
+    description: string;
+    canonicalUrl: string;
+    imageUrl: string;
+    type: "website" | "article";
+    noindex: boolean;
+    publishedTime?: string;
+    modifiedTime?: string;
+    tags: string[];
+    readingTimeMinutes?: number;
+    jsonLd?: Record<string, unknown> | Record<string, unknown>[];
+};
+export type WebsiteSeoInput = {
+    title: string;
+    description?: string;
+    path: string;
+    kind?: "index" | "tag" | "article" | "website";
+};
+export type RenderableFeedEntry = ContentManifestEntry & {
+    html?: string;
+};
+export type PluginSeoExtension = {
+    buildArticleSeo(config: ResolvedRiebeckiteConfig, permalink: string, post: PostContent): SeoMetadata;
+    buildWebsiteSeo(config: ResolvedRiebeckiteConfig, input: WebsiteSeoInput): SeoMetadata;
+    buildAbsoluteUrl(config: ResolvedRiebeckiteConfig, pathOrUrl: string): string;
+    buildPostUrl(config: ResolvedRiebeckiteConfig, permalink: string): string;
+    getDescription(post: Pick<PostContent, "frontmatter" | "html">): string;
+    getEntryPublishedTime(entry: ContentManifestEntry): string | null;
+    getEntryUpdatedTime(entry: ContentManifestEntry): string | null;
+    getHtmlLanguage(config: ResolvedRiebeckiteConfig): string;
+    renderSitemap(config: ResolvedRiebeckiteConfig, entries: ContentManifestEntry[]): string;
+    renderRobots(config: ResolvedRiebeckiteConfig): string;
+    renderRssFeed(config: ResolvedRiebeckiteConfig, entries: RenderableFeedEntry[]): string;
+    renderAtomFeed(config: ResolvedRiebeckiteConfig, entries: RenderableFeedEntry[]): string;
+    renderJsonFeed(config: ResolvedRiebeckiteConfig, entries: RenderableFeedEntry[]): string;
+};

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

@@ -0,0 +1,20 @@
+export type PostContent = {
+    frontmatter: PostFrontmatter;
+    html: string;
+};
+export type PostFrontmatter = Record<string, unknown> & {
+    title?: string;
+    description?: string;
+    date?: string | Date;
+    created?: string | Date;
+    published?: string | Date;
+    updated?: string | Date;
+    publish?: boolean;
+    private?: boolean;
+    draft?: boolean;
+    tags?: string[];
+    image?: string;
+    ogImage?: string;
+    canonical?: string;
+    noindex?: boolean;
+};

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

@@ -0,0 +1,19 @@
+export type PublishStrategy = "explicit" | "selective";
+/**
+ * The frontmatter fields that decide publication. Notes, diagnostics, and
+ * build tooling all share this shape so the publish decision is applied
+ * consistently.
+ */
+export type PublishFrontmatter = {
+    readonly publish?: unknown;
+    readonly private?: unknown;
+    readonly draft?: unknown;
+};
+/**
+ * Single source of truth for the publish decision.
+ *
+ * - `explicit`: only notes opted in with `publish: true` are public.
+ * - `selective`: notes are public unless opted out with `private: true` or
+ *   `draft: true`.
+ */
+export declare function isPublishable(strategy: PublishStrategy, frontmatter: PublishFrontmatter | undefined): boolean;

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

@@ -0,0 +1,26 @@
+import type { ContentSource } from "../content/content_source.js";
+import type { RiebeckitePlugin } from "./plugin.js";
+import type { PublishStrategy } from "./publish_strategy.js";
+import type { SiteConfig } from "./site_config.js";
+import type { ThemeConfig, ThemeStyle } from "./theme_config.js";
+export type ResolvedRiebeckiteConfig = {
+    site: Required<SiteConfig>;
+    content: {
+        directory: string;
+        source?: ContentSource;
+        exclude: string[];
+        filters: {
+            publishStrategy: PublishStrategy;
+        };
+    };
+    markdown: {
+        syntaxHighlight: {
+            theme: string;
+        };
+    };
+    theme: Required<Omit<ThemeConfig, "tokens">> & {
+        tokens: NonNullable<ThemeConfig["tokens"]>;
+        styles: ThemeStyle[];
+    };
+    plugins: RiebeckitePlugin[];
+};

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

@@ -0,0 +1,23 @@
+import type { ContentSource } from "../content/content_source.js";
+import type { PluginInput } from "./plugin.js";
+import type { PublishStrategy } from "./publish_strategy.js";
+import type { SiteConfig } from "./site_config.js";
+import type { ThemeInput } from "./theme_config.js";
+export interface RiebeckiteConfig {
+    site: SiteConfig;
+    content?: {
+        directory?: string;
+        source?: ContentSource;
+        exclude?: string[];
+        filters?: {
+            publishStrategy?: PublishStrategy;
+        };
+    };
+    markdown?: {
+        syntaxHighlight?: {
+            theme?: string;
+        };
+    };
+    theme?: ThemeInput;
+    plugins?: PluginInput[];
+}

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

@@ -0,0 +1,14 @@
+export interface SiteConfig {
+    title: string;
+    description?: string;
+    author?: string;
+    baseUrl?: string;
+    locale?: string;
+    twitterSite?: string;
+    defaultOgImage?: string;
+    feed?: {
+        title?: string;
+        description?: string;
+        language?: string;
+    };
+}

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

@@ -0,0 +1,55 @@
+export type ThemeColorMode = "light" | "dark" | "system";
+export type ThemeTypographyPreset = "system" | "serif" | "sans";
+export type ThemeArticleLayoutPreset = "article" | "sidebar" | "full-width";
+export type ThemeDesignTokens = {
+    color?: {
+        paper?: string;
+        ink?: string;
+        muted?: string;
+        accent?: string;
+        border?: string;
+        borderStrong?: string;
+        surface?: string;
+        surfaceHover?: string;
+        overlay?: string;
+        danger?: string;
+        success?: string;
+        codeBackground?: string;
+    };
+    typography?: {
+        bodyFont?: string;
+        headingFont?: string;
+        monoFont?: string;
+    };
+    layout?: {
+        pageMaxWidth?: string;
+        articleMaxWidth?: string;
+        sidebarWidth?: string;
+        contentGap?: string;
+    };
+};
+export type ThemeStyle = {
+    moduleSpecifier: string;
+};
+export type ThemeAttributes = Record<`data-${string}`, string | undefined>;
+export type ThemeConfig = {
+    name?: string;
+    colorMode?: ThemeColorMode;
+    typography?: ThemeTypographyPreset;
+    articleLayout?: ThemeArticleLayoutPreset;
+    tokens?: ThemeDesignTokens;
+    attributes?: ThemeAttributes;
+    userCss?: string[];
+};
+export type RiebeckiteTheme<TOptions = unknown> = {
+    name: string;
+    options?: TOptions;
+    styles?: ThemeStyle[];
+    config?: Omit<ThemeConfig, "name" | "userCss"> & {
+        userCss?: string[];
+    };
+    attributes?: ThemeAttributes;
+};
+export type ThemeInput = ThemeConfig | RiebeckiteTheme;
+export declare function defineTheme<TOptions>(theme: RiebeckiteTheme<TOptions>): RiebeckiteTheme<TOptions>;
+export declare function isRiebeckiteTheme(theme: ThemeInput): theme is RiebeckiteTheme;