@avocadostudio-ai/orchestrator-core 0.3.2 → 0.4.0

package/dist/checks/run-checks.js

@@ -0,0 +1,159 @@
+import { createHash, randomUUID } from "node:crypto";
+import { getDurableStore } from "../durable/durable-store-singleton.js";
+import { NEUTRAL_PAGE_WEIGHT, impactFor } from "../durable/finding-impact.js";
+import { walkPageFields, walkPageLinks } from "./field-walk.js";
+import { computePageWeights } from "./page-weight.js";
+import { DRAFT_RULES } from "./rules-draft.js";
+/**
+ * The fingerprint: identity of a problem, not of an occurrence of it.
+ *
+ * It is computed here, from `(scopeKey, slug, ruleId, key)`, and never by a
+ * rule — because the one thing that must not leak into it is the offending
+ * *value*. Include the value and half-fixing a title produces a second finding
+ * instead of an updated one, orphaning the first and silently voiding the
+ * dismissal somebody made last week.
+ */
+export function fingerprintFor(scopeKey, slug, ruleId, key = "") {
+    return createHash("sha256").update([scopeKey, slug, ruleId, key].join("\u0000")).digest("hex").slice(0, 32);
+}
+export async function runDraftChecks(args) {
+    const store = args.store ?? getDurableStore();
+    const now = args.now ?? Date.now;
+    const rules = args.rules ?? DRAFT_RULES;
+    const runId = args.runId ?? randomUUID();
+    const startedAt = now();
+    const site = {
+        slugs: args.pages.map((p) => p.slug),
+        pages: args.pages.map((p) => ({ slug: p.slug, title: p.title, ...(p.meta ? { meta: p.meta } : {}) })),
+        config: args.siteConfig ?? {},
+        // Present only when the caller could enumerate the site's documents.
+        // Passing `[]` where it could not would make every file link report broken.
+        ...(args.assets ? { assets: args.assets } : {})
+    };
+    const wanted = args.slugs ? new Set(args.slugs) : null;
+    const scanned = args.pages.filter((p) => (wanted ? wanted.has(p.slug) : true));
+    /*
+     * Every page is walked, not only the scanned ones.
+     *
+     * Page weight is a property of the site's link graph, so scoring it from the
+     * scanned subset would make a finding's impact depend on which run last
+     * touched it — the same finding worth 0.6 after a full sweep and 0.1 after an
+     * incremental one, with the panel resorting itself for no visible reason.
+     *
+     * The walk is pure in-memory work over data already held, and the scanned
+     * pages reuse their entry rather than being walked a second time.
+     */
+    const fieldsBySlug = new Map();
+    const linksBySlug = new Map();
+    for (const page of args.pages) {
+        fieldsBySlug.set(page.slug, walkPageFields(page, args.manifest));
+        linksBySlug.set(page.slug, walkPageLinks(page, args.manifest));
+    }
+    const weights = computePageWeights({ pages: site.pages, fieldsBySlug, config: site.config });
+    await store.startCheckRun({
+        id: runId,
+        scopeKey: args.scopeKey,
+        agent: rules.length === 1 ? rules[0].agent : "checks",
+        trigger: args.trigger ?? "manual",
+        startedAt
+    });
+    const findings = [];
+    const seen = new Set();
+    let error;
+    try {
+        for (const page of scanned) {
+            const pageWeight = weights.get(page.slug)?.weight ?? NEUTRAL_PAGE_WEIGHT;
+            const ctx = {
+                scopeKey: args.scopeKey,
+                page,
+                site,
+                manifest: args.manifest,
+                fields: fieldsBySlug.get(page.slug) ?? [],
+                links: linksBySlug.get(page.slug) ?? []
+            };
+            for (const rule of rules) {
+                // One rule throwing must not cost the run every other rule's findings —
+                // a checker that goes dark because a custom block had an unexpected
+                // prop shape is worse than one that reports twelve of thirteen rules.
+                let produced;
+                try {
+                    produced = rule.run(ctx);
+                }
+                catch (err) {
+                    error ??= `${rule.id}: ${err instanceof Error ? err.message : String(err)}`;
+                    continue;
+                }
+                for (const finding of produced) {
+                    const fingerprint = fingerprintFor(args.scopeKey, page.slug, rule.id, finding.key);
+                    /*
+                     * Two findings from one rule sharing a key are one finding as far as
+                     * the store is concerned — the second upsert overwrites the first.
+                     * Collapsing them here instead keeps the ledger honest (the second
+                     * was being counted as an `updated` row) and makes which one survives
+                     * a decision rather than an accident of iteration order.
+                     */
+                    if (seen.has(fingerprint))
+                        continue;
+                    seen.add(fingerprint);
+                    const severity = finding.severity ?? rule.severity;
+                    findings.push({
+                        fingerprint,
+                        scopeKey: args.scopeKey,
+                        slug: page.slug,
+                        ruleId: rule.id,
+                        agent: rule.agent,
+                        severity,
+                        impact: impactFor(severity, pageWeight),
+                        title: finding.title,
+                        ...(finding.detail ? { detail: finding.detail } : {}),
+                        ...(finding.evidence ? { evidence: finding.evidence } : {}),
+                        ...(finding.proposedOps ? { proposedOps: finding.proposedOps } : {})
+                    });
+                }
+            }
+        }
+        const { opened } = await store.recordFindings(runId, findings);
+        // Reconcile per agent, not once for the whole run. A run of only the SEO
+        // rules that closed everything in scope would mark this morning's
+        // accessibility findings fixed without having looked at them.
+        const scannedSlugs = scanned.map((p) => p.slug);
+        let closed = 0;
+        for (const agent of new Set(rules.map((r) => r.agent))) {
+            const result = await store.reconcileFindings({
+                runId,
+                scopeKey: args.scopeKey,
+                slugs: scannedSlugs,
+                agent,
+                at: now()
+            });
+            closed += result.closed;
+        }
+        const record = {
+            id: runId,
+            scopeKey: args.scopeKey,
+            agent: rules.length === 1 ? rules[0].agent : "checks",
+            trigger: args.trigger ?? "manual",
+            startedAt,
+            finishedAt: now(),
+            pagesScanned: scanned.length,
+            findingsOpened: opened,
+            findingsClosed: closed,
+            costUsd: 0,
+            ...(error ? { error } : {})
+        };
+        await store.finishCheckRun(runId, {
+            finishedAt: record.finishedAt,
+            pagesScanned: record.pagesScanned,
+            findingsOpened: record.findingsOpened,
+            findingsClosed: record.findingsClosed,
+            costUsd: 0,
+            ...(error ? { error } : {})
+        });
+        return record;
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        await store.finishCheckRun(runId, { finishedAt: now(), pagesScanned: scanned.length, error: reason });
+        throw err;
+    }
+}

package/dist/checks/session-runner.d.ts

@@ -0,0 +1,19 @@
+import type { CheckRunRecord, CheckRunTrigger } from "../durable/types.ts";
+import type { Logger } from "../logger.ts";
+export declare function runChecksForSession(args: {
+    scopeKey: string;
+    trigger: CheckRunTrigger;
+    slugs?: string[];
+}): Promise<CheckRunRecord>;
+/**
+ * Queue a draft-tier run after an apply, coalescing a burst of edits into one.
+ *
+ * Debounced rather than throttled: the useful moment is after someone stops
+ * typing, not in the middle of a streamed multi-op plan where half the ops have
+ * landed and the page is transiently wrong.
+ */
+export declare function scheduleChecksAfterApply(scopeKey: string, log?: Logger): void;
+/** Run the draft tier after a successful publish. */
+export declare function scheduleChecksAfterPublish(scopeKey: string, log?: Logger): void;
+/** Cancel any queued run. Tests, and graceful shutdown. */
+export declare function cancelScheduledChecks(): void;

package/dist/checks/session-runner.js

@@ -0,0 +1,99 @@
+import { buildBlockManifest } from "@avocadostudio-ai/shared";
+import { getSessionDraft, getSiteConfig } from "../state/session-state.js";
+import { runDraftChecks } from "./run-checks.js";
+import { getSiteAssets } from "../state/site-assets.js";
+/*
+ * Binds the pure rules engine to session state.
+ *
+ * `run-checks.ts` deliberately takes pages and a manifest as arguments and
+ * touches no globals — it is testable against invented block types and an
+ * invented site. This is the one place that reaches for the real ones, so both
+ * the HTTP action and the triggers below run identical code.
+ */
+export async function runChecksForSession(args) {
+    // `undefined` when the site cannot list its documents — see `site-assets.ts`.
+    const assets = await getSiteAssets();
+    return runDraftChecks({
+        scopeKey: args.scopeKey,
+        pages: [...getSessionDraft(args.scopeKey).values()],
+        // The registry of *this* process — in library mode, the host's own
+        // `registerBlocks()`. Same reason `blocksManifestAction` uses it: a rule
+        // reading our built-ins would be blind to the site's real vocabulary.
+        manifest: buildBlockManifest(),
+        siteConfig: getSiteConfig(args.scopeKey),
+        trigger: args.trigger,
+        ...(assets ? { assets } : {}),
+        ...(args.slugs?.length ? { slugs: args.slugs } : {})
+    });
+}
+// ---------------------------------------------------------------------------
+// Triggers
+// ---------------------------------------------------------------------------
+/*
+ * What wakes a check run, and why the defaults are what they are.
+ *
+ * `on_publish` is on by default: the draft tier is a few milliseconds of
+ * in-memory work, it costs nothing, and the moment content ships is when
+ * anybody cares whether it is broken.
+ *
+ * `on_apply` is off by default, behind `CHECKS_ON_APPLY=1`. It is the one that
+ * fires on every edit, and this repo has already paid once for a fan-out
+ * nobody intended — an ambient linter should be something an operator turns on
+ * having decided to, not something they discover in a CPU graph.
+ *
+ * Both are inert under NODE_ENV=test: the hermetic suite must not have a
+ * background task writing findings into a store its assertions are reading.
+ */
+const ON_APPLY_DEBOUNCE_MS = 2_000;
+const pending = new Map();
+function enabled(flag) {
+    if (process.env.NODE_ENV === "test")
+        return false;
+    if (flag === "apply")
+        return process.env.CHECKS_ON_APPLY === "1";
+    return process.env.CHECKS_ON_PUBLISH !== "0";
+}
+function runInBackground(scopeKey, trigger, log) {
+    void runChecksForSession({ scopeKey, trigger })
+        .then((run) => {
+        log?.info({ scopeKey, trigger, opened: run.findingsOpened, closed: run.findingsClosed }, "checks run complete");
+    })
+        .catch((err) => {
+        // A checker must never be able to fail the edit or the publish that
+        // triggered it. It reports and stops.
+        log?.error({ err: String(err), scopeKey, trigger }, "checks run failed");
+    });
+}
+/**
+ * Queue a draft-tier run after an apply, coalescing a burst of edits into one.
+ *
+ * Debounced rather than throttled: the useful moment is after someone stops
+ * typing, not in the middle of a streamed multi-op plan where half the ops have
+ * landed and the page is transiently wrong.
+ */
+export function scheduleChecksAfterApply(scopeKey, log) {
+    if (!enabled("apply"))
+        return;
+    const existing = pending.get(scopeKey);
+    if (existing)
+        clearTimeout(existing);
+    const timer = setTimeout(() => {
+        pending.delete(scopeKey);
+        runInBackground(scopeKey, "on_apply", log);
+    }, ON_APPLY_DEBOUNCE_MS);
+    // Do not hold the process open for a linter.
+    timer.unref?.();
+    pending.set(scopeKey, timer);
+}
+/** Run the draft tier after a successful publish. */
+export function scheduleChecksAfterPublish(scopeKey, log) {
+    if (!enabled("publish"))
+        return;
+    runInBackground(scopeKey, "on_publish", log);
+}
+/** Cancel any queued run. Tests, and graceful shutdown. */
+export function cancelScheduledChecks() {
+    for (const timer of pending.values())
+        clearTimeout(timer);
+    pending.clear();
+}

package/dist/checks/types.d.ts

@@ -0,0 +1,109 @@
+import type { BlockManifest, FieldKind, Operation, PageDoc, SiteConfig } from "@avocadostudio-ai/shared";
+import type { FindingEvidence, FindingSeverity } from "../durable/types.ts";
+/** One field on one block, located by the manifest rather than by block type. */
+export type FieldEntry = {
+    blockId: string;
+    blockType: string;
+    /** Editable-path form: `title`, `cards[0].imageAlt`. */
+    path: string;
+    kind: FieldKind;
+    label?: string;
+    /**
+     * What a reader would call the block this field belongs to — its own heading,
+     * not the block type. A page with three Card Grids produces three findings
+     * reading `cards[0].imageAlt`, and the type name distinguishes none of them.
+     */
+    blockLabel?: string;
+    value: unknown;
+    /**
+     * The container this field sits in — `""` for a top-level prop, `cards[0]`
+     * for a list item. Pairing an image with its alt text is a question about
+     * siblings, and the container is what makes "sibling" meaningful.
+     */
+    container: string;
+};
+/**
+ * One link on the page, wherever it was written.
+ *
+ * Separate from `FieldEntry` because most links are not fields. A `link`-kind
+ * prop is one source; the other — and on a content-heavy page much the larger —
+ * is prose: `[Menükarte](/downloads/menu-de.pdf)` inside a richtext body. Every
+ * link-aware rule read declared fields only, so those were never checked.
+ *
+ * A prose link has no editable path of its own, which is why `path` points at
+ * the *field that contains it* and `inProse` says so. A finding can still send
+ * you to the right control; it just cannot highlight the link itself.
+ */
+export type LinkEntry = {
+    blockId: string;
+    blockType: string;
+    blockLabel?: string;
+    /** The field the link is in — its own path for a link field, the containing field for a prose link. */
+    path: string;
+    label?: string;
+    /** The href as written. */
+    value: string;
+    /** True when this came out of a richtext body rather than from a link field. */
+    inProse: boolean;
+};
+/** A document the site can link to. Empty is not the same as absent — see `assets`. */
+export type SiteAsset = {
+    path: string;
+    name?: string;
+    contentType?: string;
+    size?: number;
+};
+/** The other pages, for the rules that cannot be answered from one page. */
+export type SiteView = {
+    slugs: string[];
+    pages: Array<Pick<PageDoc, "slug" | "title"> & {
+        meta?: PageDoc["meta"];
+    }>;
+    config: SiteConfig;
+    /**
+     * The documents the site holds, when it can enumerate them.
+     *
+     * `undefined` and `[]` mean different things and rules must keep them apart:
+     * undefined is "this site cannot list its assets", under which no rule may
+     * conclude a file link is broken; `[]` is "it listed them, and there are
+     * none", under which every file link is broken and saying so is correct.
+     * A site answers this by implementing `getMedia`; most do not, and for those
+     * the file rules stay silent rather than reporting every document on the site.
+     */
+    assets?: SiteAsset[];
+};
+export type CheckContext = {
+    scopeKey: string;
+    page: PageDoc;
+    site: SiteView;
+    manifest: BlockManifest;
+    /** Every field on the page, already flattened. Rules should not re-walk. */
+    fields: FieldEntry[];
+    /** Every link on the page — from link fields and from prose alike. */
+    links: LinkEntry[];
+};
+/**
+ * What a rule returns.
+ *
+ * Deliberately *not* a `FindingInput`: the fingerprint is computed by the
+ * runner from `(scopeKey, slug, ruleId, key)`, so a rule cannot accidentally
+ * fold the offending value into it. That mistake is invisible until the day
+ * somebody half-fixes a title and gets a second finding instead of an updated
+ * one, and the dismissal they made last week stops applying.
+ */
+export type RuleFinding = {
+    /** Distinguishes several findings from one rule on one page. Stable, not a value. */
+    key?: string;
+    severity?: FindingSeverity;
+    title: string;
+    detail?: string;
+    evidence?: FindingEvidence;
+    proposedOps?: Operation[];
+};
+export type CheckRule = {
+    id: string;
+    agent: string;
+    /** Used when a finding does not override it. */
+    severity: FindingSeverity;
+    run(ctx: CheckContext): RuleFinding[];
+};

package/dist/checks/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cms/adapter.d.ts

@@ -67,14 +67,33 @@ export type CmsPublishResult = void | {
 export interface CmsMediaItem {
     /** Stable id in the source store. Used as the picker's selection key. */
     id: string;
+    /**
+     * What this asset is.
+     *
+     * Absent means `"image"`, because every adapter written before documents
+     * existed returns images and must keep working unchanged. `"file"` is a
+     * document — a menu PDF, a price list, a consent form — which the editor
+     * offers into a `file` field or a prose link rather than an `<img>`.
+     */
+    kind?: "image" | "file";
     /** Human-facing filename or title, if the store has one. */
     name?: string;
     /** Full-size URL to insert into the page. Omitted only if the store has none. */
     imageUrl?: string;
-    /** Grid thumbnail. May be the same URL as `imageUrl` when no derivative exists. */
+    /**
+     * Grid thumbnail. May be the same URL as `imageUrl` when no derivative
+     * exists. A `file` has nothing to show, so this is `""` for one and the
+     * picker draws an icon from `contentType` instead.
+     */
     thumbUrl: string;
     /** Alt text the store already holds, so the editor does not invent one. */
     alt?: string;
+    /** For `kind: "file"`: the URL to link to. */
+    url?: string;
+    /** MIME type, when the store knows it. Drives the picker's icon and filter. */
+    contentType?: string;
+    /** Bytes, when the store knows it. Shown to a person; nothing decides on it. */
+    size?: number;
 }
 /** One page of a media-library search. */
 export interface CmsMediaQuery {
@@ -84,6 +103,16 @@ export interface CmsMediaQuery {
     page: number;
     /** Items per page. */
     limit: number;
+    /**
+     * Which kind the caller wants.
+     *
+     * Absent means "images", which is what every existing caller meant and every
+     * existing adapter answers. An adapter that does not understand this field
+     * returns images to a request for documents; the route filters the response
+     * by `kind` as well, so an old adapter degrades to an empty document tab
+     * rather than to a grid of images offered as PDFs.
+     */
+    kind?: "image" | "file";
 }
 /** What `getMedia` returns: the page, and how many there are in total. */
 export interface CmsMediaPage {
@@ -200,6 +229,43 @@ export interface CmsAdapter {
      * requirement, and nothing in the route path knows it exists.
      */
     getMedia?(query: CmsMediaQuery): Promise<CmsMediaPage>;
+    /**
+     * Optional media *write*, the other half of `getMedia`.
+     *
+     * Somebody has to be able to add a document, and until this existed the only
+     * way was to put the file on disk yourself and commit it — which is not a
+     * path a non-technical editor has, and is the whole reason the editor could
+     * list a site's PDFs but never gain one.
+     *
+     * The adapter decides where a file goes, for the same reason it decides where
+     * pages come from: we do not know. A static site writes into `public/`; a
+     * Sanity site uploads an asset and gets a CDN URL; a site on a read-only
+     * filesystem implements nothing and the editor offers no upload button.
+     * Owning storage here instead would mean owning it *badly* — the existing
+     * `POST /image/upload` writes to the orchestrator's local disk, which on an
+     * ephemeral container loses every upload on redeploy, and building the
+     * document path on that foundation would spread the defect rather than fix
+     * it.
+     *
+     * Implement it and the editor offers upload. Leave it off and it does not —
+     * silence means no, as everywhere else on this interface.
+     *
+     * Throwing rejects the upload with the thrown message shown to the editor, so
+     * a refusal ("we only accept PDFs", "that name is taken") is expressible
+     * without a second return shape.
+     */
+    uploadMedia?(input: CmsMediaUpload): Promise<CmsMediaItem>;
+}
+/** One file on its way in. */
+export interface CmsMediaUpload {
+    /** Original filename as the browser reported it. Treat as untrusted. */
+    filename: string;
+    /** MIME type the browser reported, or "" — also untrusted. */
+    contentType: string;
+    /** The bytes. */
+    data: Uint8Array;
+    /** What the caller says this is. The adapter may disagree and throw. */
+    kind: "image" | "file";
 }
 /**
  * Per-operation capability declaration. Every field is tri-state, and the
@@ -266,6 +332,13 @@ export interface ResolvedCapabilities {
      * opens onto a method nobody implemented is a worse answer than no tab.
      */
     readsMedia: boolean;
+    /**
+     * Whether this site can take a new file — derived from `uploadMedia`, the
+     * same way `readsMedia` is derived from `getMedia`. The editor offers an
+     * upload control only where there is something behind it; a button that
+     * always fails is worse than no button.
+     */
+    writesMedia: boolean;
     /**
      * The subset the adapter actually declared. A caller that needs to
      * distinguish "this site says no" from "nobody said" reads this; everything

package/dist/cms/adapter.js

@@ -15,6 +15,7 @@ export function resolveCapabilities(adapter, override) {
         // `=== true`, not truthiness: an adapter that says nothing has not said yes.
         readsDraftPerspective: adapter?.perspectives === true,
         readsMedia: typeof adapter?.getMedia === "function",
+        writesMedia: typeof adapter?.uploadMedia === "function",
         declared
     };
 }

package/dist/cms/index.d.ts

@@ -3,4 +3,4 @@ export { resolveCapabilities } from "./adapter.ts";
 export { jsonFileAdapter, type JsonFileAdapterOptions } from "./json-file-adapter.ts";
 export { editorApiAdapter, type EditorApiAdapterOptions } from "./editor-api-adapter.ts";
 export { ensureSessionBootstrapped, createCmsBootstrapCache, _resetCmsBootstrapCache, type CmsBootstrapCache, type CmsBootstrapCacheOptions, warmSessionBootstrap } from "./bootstrap.ts";
-export { cmsMediaSource, cmsMediaLabel, mediaSourceFromUnknown, type CmsMediaSource, type CmsMediaSourceConfig } from "./media-sources.ts";
+export { cmsMediaSource, cmsMediaUploader, cmsMediaLabel, mediaSourceFromUnknown, type CmsMediaSource, type CmsMediaUploader, type CmsMediaSourceConfig } from "./media-sources.ts";

package/dist/cms/index.js

@@ -2,4 +2,4 @@ export { resolveCapabilities } from "./adapter.js";
 export { jsonFileAdapter } from "./json-file-adapter.js";
 export { editorApiAdapter } from "./editor-api-adapter.js";
 export { ensureSessionBootstrapped, createCmsBootstrapCache, _resetCmsBootstrapCache, warmSessionBootstrap } from "./bootstrap.js";
-export { cmsMediaSource, cmsMediaLabel, mediaSourceFromUnknown } from "./media-sources.js";
+export { cmsMediaSource, cmsMediaUploader, cmsMediaLabel, mediaSourceFromUnknown } from "./media-sources.js";

package/dist/cms/media-sources.d.ts

@@ -1,4 +1,4 @@
-import type { CmsMediaPage, CmsMediaQuery } from "./adapter.ts";
+import type { CmsMediaItem, CmsMediaPage, CmsMediaQuery, CmsMediaUpload } from "./adapter.ts";
 /** Connection details for one of the built-in media readers. */
 export type CmsMediaSourceConfig = {
     provider: "contentful";
@@ -17,6 +17,8 @@ export type CmsMediaSourceConfig = {
 };
 /** A media reader: the exact shape of `CmsAdapter.getMedia`. */
 export type CmsMediaSource = (query: CmsMediaQuery) => Promise<CmsMediaPage>;
+/** A media writer: the exact shape of `CmsAdapter.uploadMedia`. */
+export type CmsMediaUploader = (input: CmsMediaUpload) => Promise<CmsMediaItem>;
 /** Display name for a provider id, for the picker's tab. */
 export declare function cmsMediaLabel(provider: CmsMediaSourceConfig["provider"]): string;
 /**
@@ -37,6 +39,32 @@ export declare function cmsMediaLabel(provider: CmsMediaSourceConfig["provider"]
  * promise inside a modal is not.
  */
 export declare function cmsMediaSource(config: CmsMediaSourceConfig): CmsMediaSource;
+/**
+ * Build a media writer from the same connection details as the reader, or
+ * `null` when this provider (or this configuration) cannot take an upload.
+ *
+ * ```ts
+ * const uploadMedia = cmsMediaUploader({ provider: "sanity", projectId, dataset, token })
+ * return { id: "sanity", getPages, getMedia, ...(uploadMedia ? { uploadMedia } : {}) }
+ * ```
+ *
+ * Null rather than a stub that throws, and spread rather than assigned,
+ * because `writesMedia` is derived from whether the method *exists*
+ * (`resolveCapabilities`) and the editor shows its upload control on the
+ * strength of that. A method that is always present and always fails is a
+ * button that is always there and never works.
+ *
+ * So a project with a read-only token gets no upload control at all, which is
+ * the truth about it: Sanity's query API answers a viewer token and its asset
+ * API does not, and that difference is invisible until somebody picks a file.
+ *
+ * **Sanity only, for now.** Uploading to Contentful is a three-step
+ * asynchronous dance — create the asset, ask for processing, poll, publish —
+ * and Strapi's is a multipart POST to its upload plugin; neither is written
+ * yet, and both answer `null` so that an adapter which spreads the result
+ * simply offers no upload rather than offering a broken one.
+ */
+export declare function cmsMediaUploader(config: CmsMediaSourceConfig): CmsMediaUploader | null;
 /**
  * Build a reader from an untrusted object, or `null` if it is not one of the
  * three shapes.