@michaelthielemann/kestrel-delivery-static 0.1.0 → 5.0.2

package/README.md

@@ -0,0 +1,39 @@
+# delivery/static
+Static delivery with a publish status per document and locale. Requires `content@1`, `site@1`,
+`renderer@1` (the site's own renderer, e.g. the Nuxt layer), `blobstore@1` (filesystem or S3) and
+`persistence@1`. `delivery.publish:<type>` after `content.create/update`: for every locale whose
+own `statusField` equals `publishedValue` the document (fields with fallback, internal links
+resolved to public paths via `site.resolveLinks`, `_links` attached) is rendered in each
+configured format and stored under the path `site.pathOf` returns (default locale
+unprefixed unless `prefixPrimary`, `home` slug → `/`); other locales are removed. Outcome per
+locale in `delivery_publish_status` (`live` | `error` | `draft`, `path`, `error`, `publishedAt`); a failed
+render keeps the previous live output. `delivery.unpublish:<type>` after remove, `delivery.readStatus:<type>`
+for the editor's second lamp, `delivery.publishAll:<type>` to re-render everything.
+Formats come from the renderer (`html`, `pdf`, …) – `formats: ["html", "pdf"]` writes both.
+Assets the renderer returns (`assets: [{ path: "/_nuxt/app.js", … }]` – hydration bundles, CSS)
+are stored under `<prefix><path>` once per process; they are never removed on unpublish.
+With `media` configured, text output is scanned for `<publicPath>/<id>/file` and `<publicPath>/<id>/variants/<size>.<ext>` (HTML-escaped slashes, e.g. `&#x2F;`, are not matched) and copied to
+`<prefix><target><folder>/<filename>[.<size>.<ext>]`, rewritten in place; each target is copied once per process, so a file re-uploaded under the same name is refreshed in the export only by `publishAll`.
+Unresolved references are logged and left untouched.
+`delivery.exportLlms` (always on; `llms` defaults to paths instead of URLs and no full file) (no argument; append it after `delivery.publish`/`unpublish`/`publishAll`
+and after saving the settings) writes `<prefix>llms.txt` per [llmstxt.org](https://llmstxt.org) from the `live` status rows
+of every delivered type: `# <settings title>`, `> <settings description>`, one `## <headings[type] ?? type>` section with
+`- [<seo.title || title>](<siteUrl><path>): <seo.description>` per page; `seo.noindex === true` excludes a page. `full: true`
+also writes `<prefix>llms-full.txt` – the stored HTML of every page, restricted to `<main>`, converted with turndown
+(headings shifted three levels, root-relative links and images made absolute with `siteUrl`) – and needs `"html"` in
+`formats`; `full: false` removes a stale `llms-full.txt`. The result gains `llms: { entries, full }`.
+Every `Delivery` method returns a `Result`; a failure is an `Err(KestrelError)`, never an exception.
+A render failure (`RENDER_FAILED` or `TRANSIENT` from `renderer@1`) is not a step failure: it is
+recorded on the status row as `state: "error"` with the message and the remaining locales are still
+published. Only wiring bugs throw (unknown type, unconfigured type, unsafe media/asset path, a media
+row whose blob is gone).
+
+| Step | reads | writes | codes |
+|---|---|---|---|
+| `delivery.publish:<type>` | `result.id` | `result` (`document`, `delivery`) | TRANSIENT |
+| `delivery.unpublish:<type>` | `params.id` | – | VALIDATION (missing id), TRANSIENT |
+| `delivery.readStatus:<type>` | `params.id` | `result` | VALIDATION (missing id), TRANSIENT |
+| `delivery.publishAll:<type>` | – | `result` | TRANSIENT |
+| `delivery.exportLlms` | – | `result.llms` | TRANSIENT |
+
+Not included: sitemap, CDN invalidation.

package/dist/impl.d.ts

@@ -0,0 +1,54 @@
+import type { z } from "zod";
+import type { Blobstore } from "@michaelthielemann/kestrel-contracts/blobstore";
+import type { Content } from "@michaelthielemann/kestrel-contracts/content";
+import { type KestrelError, type Result } from "@michaelthielemann/kestrel-contracts/errors";
+import type { Document, Persistence } from "@michaelthielemann/kestrel-contracts/persistence";
+import type { Renderer } from "@michaelthielemann/kestrel-contracts/renderer";
+import type { Site } from "@michaelthielemann/kestrel-contracts/site";
+import type { Logger } from "@michaelthielemann/kestrel/logger";
+import type { configSchema } from "./module.ts";
+export declare const STATUS = "delivery_publish_status";
+export type Config = z.output<typeof configSchema>;
+export type TypeConfig = Config["types"][string];
+export type MediaConfig = NonNullable<Config["media"]>;
+export type State = "live" | "error" | "draft";
+export type DeliveryError = KestrelError<"TRANSIENT">;
+export interface PublishStatus extends Document {
+    type: string;
+    docId: string;
+    locale: string;
+    state: State;
+    path: string | null;
+    error: string | null;
+    publishedAt: number | null;
+    updatedAt: number;
+}
+export interface Delivery {
+    publish(type: string, id: string): Promise<Result<PublishStatus[], DeliveryError>>;
+    unpublish(type: string, id: string): Promise<Result<number, DeliveryError>>;
+    status(type: string, id: string): Promise<Result<PublishStatus[], DeliveryError>>;
+    publishAll(type: string): Promise<Result<{
+        documents: number;
+        live: number;
+        errors: number;
+    }, DeliveryError>>;
+    exportLlms(): Promise<Result<{
+        entries: number;
+        full: boolean;
+    }, DeliveryError>>;
+}
+export declare function keyFor(prefix: string, path: string, extension: string): string;
+export interface MediaMatch {
+    raw: string;
+    id: string;
+    size?: string;
+}
+export declare function rewriteMedia(html: string, publicPath: string, resolve: (match: MediaMatch) => string | undefined): string;
+export declare function createDeliveryStatic(config: Config, deps: {
+    content: Content;
+    site: Site;
+    renderer: Renderer;
+    blobs: Blobstore;
+    db: Persistence;
+    logger: Logger;
+}, now?: () => number): Promise<Delivery>;

package/dist/impl.js

@@ -0,0 +1,377 @@
+import { extname } from "node:path";
+import { err, isErr, ok } from "@michaelthielemann/kestrel-contracts/errors";
+import { exportLlms, validateLlmsConfig } from "./llms.js";
+export const STATUS = "delivery_publish_status";
+const PAGE = 100;
+// Collections are addressed by generated id or by delivery's own filters and every locale comes from
+// the content model, so only a transient failure of a dependency is expected here.
+function transientOnly(error, source) {
+    if (error.code !== "TRANSIENT")
+        throw new Error(`delivery/static: unexpected ${source} failure ${error.code}: ${error.message}`);
+    return error;
+}
+function bytes(data) {
+    return typeof data === "string" ? new TextEncoder().encode(data) : data;
+}
+export function keyFor(prefix, path, extension) {
+    const dir = path === "/" ? "" : `${path.slice(1)}/`;
+    return `${prefix}${dir}index.${extension}`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// The negative lookaheads pin the match to a segment boundary: "/file-x" or "/fileabc" must not
+// match "/file", and "thumb.webp.bak" must not match "thumb.webp" — but "?" and "/" (query strings,
+// trailing path segments) are not in the class, so those still terminate a match correctly.
+function mediaPattern(publicPath) {
+    return new RegExp(`${escapeRegExp(publicPath)}/([0-9a-f-]{36})/(?:file(?![A-Za-z0-9._-])|variants/([a-z][a-z0-9-]*)\\.([a-z0-9]+)(?![A-Za-z0-9._-]))`, "g");
+}
+function mediaKey(id, size) {
+    return size === undefined ? `${id}|file` : `${id}|${size}`;
+}
+function mediaMatches(html, publicPath) {
+    const re = mediaPattern(publicPath);
+    const out = [];
+    let m;
+    while ((m = re.exec(html)) !== null)
+        out.push({ raw: m[0], id: m[1], ...(m[2] === undefined ? {} : { size: m[2] }) });
+    return out;
+}
+// Pure so it can be unit-tested without a Persistence/Blobstore fake: resolution of ids and copying
+// of blobs happens beforehand, this only substitutes text it already has the answer for.
+export function rewriteMedia(html, publicPath, resolve) {
+    return html.replace(mediaPattern(publicPath), (raw, id, size) => resolve({ raw, id, ...(size === undefined ? {} : { size }) }) ?? raw);
+}
+// Mirrors the check the renderer-asset branch already applies to asset.path: media rows are normally
+// sanitized by media-default, but delivery-static must not trust that blindly when building blob keys.
+function assertSafeMediaSegment(value, label, id) {
+    if (value.startsWith("/") || value.split("/").some((p) => p === ".."))
+        throw new Error(`delivery/static: invalid media ${label} ${JSON.stringify(value)} for ${id}`);
+}
+async function findManyIn(db, collection, field, values) {
+    const out = [];
+    for (let i = 0; i < values.length; i += 200) {
+        const chunk = values.slice(i, i + 200);
+        for (let offset = 0;; offset += 500) {
+            const page = await db.findMany(collection, { [field]: { in: chunk } }, { limit: 500, offset });
+            if (isErr(page))
+                return err(transientOnly(page.error, "persistence@1"));
+            out.push(...page.value.items);
+            if (page.value.items.length < 500)
+                break;
+        }
+    }
+    return ok(out);
+}
+export async function createDeliveryStatic(config, deps, now = Date.now) {
+    const { content, site, renderer, blobs, db, logger } = deps;
+    const model = content.model();
+    const locales = model.locales ?? [];
+    for (const [type, tc] of Object.entries(config.types)) {
+        const fields = model.types[type]?.fields;
+        if (!fields)
+            throw new Error(`delivery/static: unknown content type "${type}"`);
+        for (const f of [tc.slugField, tc.statusField])
+            if (!(f in fields))
+                throw new Error(`delivery/static: field "${f}" does not exist on "${type}"`);
+    }
+    const supported = new Set(renderer.formats());
+    for (const f of config.formats)
+        if (!supported.has(f))
+            throw new Error(`delivery/static: renderer does not support format "${f}" (has ${[...supported].join(", ") || "none"})`);
+    validateLlmsConfig(config.llms, model, config.formats);
+    const prepared = await db.ensureCollection(STATUS, { type: "string", docId: "string", locale: "string", state: "string", path: "string", error: "string", publishedAt: "number", updatedAt: "number" });
+    if (isErr(prepared))
+        throw new Error(`delivery/static: cannot prepare "${STATUS}": ${prepared.error.message}`);
+    const uploadedAssets = new Set();
+    const typeConfig = (type) => {
+        const tc = config.types[type];
+        if (!tc)
+            throw new Error(`delivery/static: type "${type}" is not configured for delivery`);
+        return tc;
+    };
+    const statusRows = async (type, id) => {
+        const page = await db.findMany(STATUS, { type, docId: id }, { sort: { locale: "asc" } });
+        if (isErr(page))
+            return err(transientOnly(page.error, "persistence@1"));
+        return ok(page.value.items);
+    };
+    const liveSources = async (type) => {
+        const out = [];
+        for (let offset = 0;; offset += 500) {
+            const page = await db.findMany(STATUS, { type, state: "live" }, { sort: { path: "asc" }, limit: 500, offset });
+            if (isErr(page))
+                return err(transientOnly(page.error, "persistence@1"));
+            for (const row of page.value.items) {
+                if (row.path === null)
+                    continue;
+                const path = row.path;
+                out.push({
+                    type,
+                    path,
+                    locale: row.locale,
+                    docId: row.docId,
+                    html: async () => {
+                        const blob = await blobs.get(keyFor(config.prefix, path, "html"));
+                        if (isErr(blob))
+                            return err(transientOnly(blob.error, "blobstore@1"));
+                        return ok(blob.value ? new TextDecoder().decode(blob.value.data) : null);
+                    },
+                });
+            }
+            if (page.value.items.length < 500)
+                break;
+        }
+        return ok(out);
+    };
+    const setStatus = async (type, id, locale, patch) => {
+        const existing = await db.findOne(STATUS, { type, docId: id, locale });
+        if (isErr(existing))
+            return err(transientOnly(existing.error, "persistence@1"));
+        const at = now();
+        const row = existing.value
+            ? await db.updateOne(STATUS, existing.value.id, { ...patch, updatedAt: at })
+            : await db.createOne(STATUS, { type, docId: id, locale, state: "draft", path: null, error: null, publishedAt: null, ...patch, updatedAt: at });
+        if (isErr(row))
+            return err(transientOnly(row.error, "persistence@1"));
+        return ok(row.value);
+    };
+    const removeBlobs = async (path) => {
+        if (path === null)
+            return ok();
+        for (const format of config.formats) {
+            const removed = await blobs.remove(keyFor(config.prefix, path, format));
+            if (isErr(removed))
+                return err(transientOnly(removed.error, "blobstore@1"));
+        }
+        return ok();
+    };
+    // Resolution (findMany) and copying (blobs.get/put) both need to happen before the pure rewriteMedia()
+    // substitution, so this batches them up front and then feeds a synchronous resolver into it.
+    const rewriteAndCopyMedia = async (html, logged) => {
+        const media = config.media;
+        if (!media)
+            return ok(html);
+        const matches = mediaMatches(html, media.publicPath);
+        if (matches.length === 0)
+            return ok(html);
+        const ids = [...new Set(matches.map((m) => m.id))];
+        const mediaRows = await findManyIn(db, media.collection, "id", ids);
+        if (isErr(mediaRows))
+            return mediaRows;
+        const mediaById = new Map(mediaRows.value.map((r) => [r.id, r]));
+        const variantIds = [...new Set(matches.filter((m) => m.size !== undefined).map((m) => m.id))];
+        const variantByKey = new Map();
+        if (variantIds.length > 0) {
+            const variantRows = await findManyIn(db, media.variants, "mediaId", variantIds);
+            if (isErr(variantRows))
+                return variantRows;
+            for (const r of variantRows.value)
+                variantByKey.set(`${r.mediaId}|${r.size}`, r);
+        }
+        const resolutions = new Map();
+        const copies = [];
+        for (const match of matches) {
+            const key = mediaKey(match.id, match.size);
+            if (resolutions.has(key))
+                continue;
+            const row = mediaById.get(match.id);
+            if (!row) {
+                if (!logged.has(key)) {
+                    logger.error("delivery/static: media reference not exported", { id: match.id, path: match.raw });
+                    logged.add(key);
+                }
+                resolutions.set(key, undefined);
+                continue;
+            }
+            assertSafeMediaSegment(row.folder, "folder", match.id);
+            assertSafeMediaSegment(row.filename, "filename", match.id);
+            const folderPrefix = row.folder ? `${row.folder}/` : "";
+            if (match.size === undefined) {
+                const dest = `${media.target}${folderPrefix}${row.filename}`;
+                copies.push({ source: row.key, dest, id: match.id });
+                resolutions.set(key, `/${dest}`);
+                continue;
+            }
+            const variant = variantByKey.get(`${match.id}|${match.size}`);
+            if (!variant || variant.state !== "done") {
+                if (!logged.has(key)) {
+                    logger.error("delivery/static: media reference not exported", { id: match.id, size: match.size, path: match.raw });
+                    logged.add(key);
+                }
+                resolutions.set(key, undefined);
+                continue;
+            }
+            const ext = extname(variant.key).replace(/^\./, "");
+            const dest = `${media.target}${folderPrefix}${row.filename}.${match.size}.${ext}`;
+            copies.push({ source: variant.key, dest, id: match.id });
+            resolutions.set(key, `/${dest}`);
+        }
+        for (const { source, dest, id } of copies) {
+            const destKey = `${config.prefix}${dest}`;
+            if (uploadedAssets.has(destKey))
+                continue;
+            const blob = await blobs.get(source);
+            if (isErr(blob))
+                return err(transientOnly(blob.error, "blobstore@1"));
+            // a row without its blob is not "unresolved" (which leaves the URL untouched) — the HTML would
+            // otherwise be rewritten to a path nothing ever writes, so this fails the publish like any other
+            // copy failure instead.
+            if (!blob.value)
+                throw new Error(`delivery/static: media blob ${source} missing for ${id}`);
+            const stored = await blobs.put(destKey, { data: blob.value.data, contentType: blob.value.contentType });
+            if (isErr(stored))
+                return err(transientOnly(stored.error, "blobstore@1"));
+            uploadedAssets.add(destKey);
+        }
+        return ok(rewriteMedia(html, media.publicPath, (match) => resolutions.get(mediaKey(match.id, match.size))));
+    };
+    const publishLocale = async (type, id, locale) => {
+        const tc = typeConfig(type);
+        const key = locale ?? "";
+        const found = await db.findOne(STATUS, { type, docId: id, locale: key });
+        if (isErr(found))
+            return err(transientOnly(found.error, "persistence@1"));
+        const previous = found.value;
+        const unpublished = async () => {
+            const removed = await removeBlobs(previous?.path ?? null);
+            if (isErr(removed))
+                return removed;
+            return setStatus(type, id, key, { state: "draft", path: null, error: null });
+        };
+        const read = await content.get(type, id, locale === undefined ? {} : { locale });
+        if (isErr(read))
+            return err(transientOnly(read.error, "content@1"));
+        const strict = read.value;
+        if (!strict)
+            return unpublished();
+        if (strict[tc.statusField] !== tc.publishedValue)
+            return unpublished();
+        let fetched = strict;
+        if (config.fallback && locale !== undefined) {
+            const merged = await content.get(type, id, { locale, fallback: true });
+            if (isErr(merged))
+                return err(transientOnly(merged.error, "content@1"));
+            if (merged.value !== null)
+                fetched = merged.value;
+        }
+        const rules = { home: tc.home, slugField: tc.slugField, prefixPrimary: config.prefixPrimary, fallback: config.fallback, filter: { [tc.statusField]: tc.publishedValue } };
+        const options = { ...(locale === undefined ? {} : { locale }), rules };
+        const linked = await site.resolveLinks(type, fetched, options);
+        if (isErr(linked))
+            return err(transientOnly(linked.error, "site@1"));
+        const doc = linked.value;
+        const path = site.pathOf(type, doc, options);
+        if (path === null)
+            return setStatus(type, id, key, { state: "error", error: `no ${tc.slugField}` });
+        const failed = (message) => setStatus(type, id, key, { state: "error", path: previous?.state === "live" ? previous.path : null, error: message });
+        const loggedMedia = new Set();
+        try {
+            for (const format of config.formats) {
+                const rendered = await renderer.render({ type, id, ...(locale === undefined ? {} : { locale }), path, format, document: doc });
+                if (isErr(rendered))
+                    return failed(rendered.error.message);
+                const out = rendered.value;
+                let data = out.data;
+                if (config.media && (typeof out.data === "string" || out.contentType.startsWith("text/"))) {
+                    const html = typeof out.data === "string" ? out.data : new TextDecoder().decode(out.data);
+                    const rewritten = await rewriteAndCopyMedia(html, loggedMedia);
+                    if (isErr(rewritten))
+                        return failed(rewritten.error.message);
+                    data = rewritten.value;
+                }
+                const stored = await blobs.put(keyFor(config.prefix, path, out.extension), { data: bytes(data), contentType: out.contentType });
+                if (isErr(stored))
+                    return failed(stored.error.message);
+                for (const asset of out.assets ?? []) {
+                    const assetPath = asset.path.replace(/^\/+/, "");
+                    if (assetPath === "" || assetPath.split("/").some((p) => p === ".."))
+                        throw new Error(`delivery/static: invalid asset path ${JSON.stringify(asset.path)}`);
+                    const key = `${config.prefix}${assetPath}`;
+                    if (!uploadedAssets.has(key)) {
+                        const put = await blobs.put(key, { data: bytes(asset.data), contentType: asset.contentType });
+                        if (isErr(put))
+                            return failed(put.error.message);
+                        uploadedAssets.add(key);
+                    }
+                }
+            }
+            if (previous?.path && previous.path !== path) {
+                const removed = await removeBlobs(previous.path);
+                if (isErr(removed))
+                    return failed(removed.error.message);
+            }
+            return setStatus(type, id, key, { state: "live", path, error: null, publishedAt: now() });
+        }
+        catch (error) {
+            return failed(error instanceof Error ? error.message : String(error));
+        }
+    };
+    const publish = async (type, id) => {
+        typeConfig(type);
+        const targets = locales.length > 0 ? locales : [undefined];
+        const out = [];
+        for (const locale of targets) {
+            const status = await publishLocale(type, id, locale);
+            if (isErr(status))
+                return status;
+            out.push(status.value);
+        }
+        return ok(out);
+    };
+    return {
+        publish,
+        async unpublish(type, id) {
+            typeConfig(type);
+            const rows = await statusRows(type, id);
+            if (isErr(rows))
+                return rows;
+            for (const row of rows.value) {
+                const removed = await removeBlobs(row.path);
+                if (isErr(removed))
+                    return removed;
+            }
+            const deleted = await db.deleteMany(STATUS, { type, docId: id });
+            if (isErr(deleted))
+                return err(transientOnly(deleted.error, "persistence@1"));
+            return ok(deleted.value);
+        },
+        async status(type, id) {
+            typeConfig(type);
+            return statusRows(type, id);
+        },
+        async publishAll(type) {
+            typeConfig(type);
+            uploadedAssets.clear();
+            let documents = 0;
+            let live = 0;
+            let errors = 0;
+            for (let offset = 0;; offset += PAGE) {
+                const page = await content.list(type, {}, { limit: PAGE, offset });
+                if (isErr(page))
+                    return err(transientOnly(page.error, "content@1"));
+                for (const doc of page.value.items) {
+                    documents += 1;
+                    const statuses = await publish(type, doc.id);
+                    if (isErr(statuses))
+                        return statuses;
+                    for (const s of statuses.value) {
+                        if (s.state === "live")
+                            live += 1;
+                        if (s.state === "error")
+                            errors += 1;
+                    }
+                }
+                if (page.value.items.length < PAGE)
+                    break;
+            }
+            return ok({ documents, live, errors });
+        },
+        async exportLlms() {
+            const exported = await exportLlms(config.llms, { content, blobs, logger, prefix: config.prefix, fallback: config.fallback, defaultLocale: model.defaultLocale, hasLocales: locales.length > 0, types: Object.keys(config.types), sources: liveSources });
+            if (isErr(exported))
+                return err(transientOnly(exported.error, "llms export"));
+            return ok(exported.value);
+        },
+    };
+}

package/dist/llms.d.ts

@@ -0,0 +1,75 @@
+import type { Blobstore } from "@michaelthielemann/kestrel-contracts/blobstore";
+import type { Content, ContentModel } from "@michaelthielemann/kestrel-contracts/content";
+import { type KestrelError, type Result } from "@michaelthielemann/kestrel-contracts/errors";
+import type { Logger } from "@michaelthielemann/kestrel/logger";
+export interface LlmsSettingsConfig {
+    type: string;
+    titleField: string;
+    descriptionField: string;
+}
+export interface LlmsConfig {
+    siteUrl?: string | undefined;
+    full: boolean;
+    settings: LlmsSettingsConfig;
+    titleField: string;
+    seoField: string;
+    headings: Record<string, string>;
+}
+export interface LlmsEntry {
+    title: string;
+    url: string;
+    description?: string;
+}
+export interface LlmsSection {
+    heading: string;
+    entries: LlmsEntry[];
+}
+export interface LlmsFullPage extends LlmsEntry {
+    body: string;
+}
+export interface LlmsFullSection {
+    heading: string;
+    pages: LlmsFullPage[];
+}
+export declare const LLMS_KEY = "llms.txt";
+export declare const LLMS_FULL_KEY = "llms-full.txt";
+export declare const LLMS_CONTENT_TYPE = "text/plain; charset=utf-8";
+export declare function buildLlmsTxt(opts: {
+    siteName: string;
+    siteDescription?: string;
+    sections: LlmsSection[];
+}): string;
+export declare function buildLlmsFullTxt(opts: {
+    siteName: string;
+    siteDescription?: string;
+    sections: LlmsFullSection[];
+}): string;
+export declare function extractMain(html: string): string | null;
+export declare function absolutize(url: string | null, siteUrl: string | undefined): string | null;
+export declare function htmlToMarkdown(html: string, options?: {
+    siteUrl?: string;
+    headingOffset?: number;
+}): string;
+export interface LlmsSource {
+    type: string;
+    path: string;
+    locale: string;
+    docId: string;
+    html(): Promise<Result<string | null, KestrelError>>;
+}
+export interface LlmsDeps {
+    content: Content;
+    blobs: Blobstore;
+    logger: Logger;
+    prefix: string;
+    fallback: boolean;
+    defaultLocale: string | undefined;
+    hasLocales: boolean;
+    types: string[];
+    sources(type: string): Promise<Result<LlmsSource[], KestrelError>>;
+}
+export declare function validateLlmsConfig(config: LlmsConfig, model: ContentModel, formats: string[]): void;
+export declare function exportLlms(config: LlmsConfig, deps: LlmsDeps): Promise<Result<{
+    entries: number;
+    full: boolean;
+}, KestrelError>>;