blume 1.7.2 → 2.0.0

package/dist/types/core/versions.d.ts

@@ -0,0 +1,72 @@
+import type { ArchivedVersionConfig, ResolvedConfig, ResolvedI18nConfig, ResolvedVersionsConfig } from "./schema.ts";
+import type { Diagnostic, PageRecord } from "./types.ts";
+/**
+ * Version logic, centralized. Every seam that needs to reason about docs
+ * versions (content discovery, navigation, manifest, runtime generation, the
+ * catch-all) goes through these helpers so the routing rules live in exactly
+ * one place — the same contract `./i18n.ts` holds for locales.
+ *
+ * The current version is the empty string `""`: the latest docs live at the
+ * content root with unprefixed URLs, and only archived snapshots have a
+ * directory and a URL segment.
+ */
+/**
+ * Top-level folders that look like a version (`v1`, `V2.0`) — used by the
+ * unconfigured-snapshot diagnostic and by `blume version` to keep such folders
+ * out of new snapshots.
+ */
+export declare const VERSION_LIKE: RegExp;
+/** True when the project opts into versioning. */
+export declare const versionsEnabled: (config: ResolvedConfig) => config is ResolvedConfig & {
+    versions: ResolvedVersionsConfig;
+};
+/** All archived version ids, in configured (switcher) order. */
+export declare const archivedIds: (versions: ResolvedVersionsConfig) => string[];
+/** Switcher label for a version: the current label for `""`, else per config. */
+export declare const versionLabel: (id: string, versions: ResolvedVersionsConfig) => string;
+/** The archived version config for an id (`undefined` for current/unknown). */
+export declare const archivedVersion: (id: string, versions: ResolvedVersionsConfig) => ArchivedVersionConfig | undefined;
+/** A resolved version (`""` for current) and the version-stripped remainder. */
+export interface DetectedVersion {
+    version: string;
+    rest: string[];
+}
+/** {@link DetectedVersion} for a slash-joined source ref. */
+export interface DetectedVersionRef {
+    version: string;
+    rest: string;
+}
+/**
+ * Detect a leading archived-version directory in a path's segments. The
+ * current version lives at the content root, so only archived ids are matched
+ * as a leading segment. Returns the resolved version (`""` for current) and
+ * the remaining (version-stripped) segments. Runs BEFORE locale detection —
+ * the snapshot directory is outermost on disk, so the locale parser must see
+ * a version-stripped path.
+ */
+export declare const detectVersion: (parts: string[], versions: ResolvedVersionsConfig) => DetectedVersion;
+/**
+ * {@link detectVersion} over a slash-joined source ref (`v1.0/fr/x.mdx`):
+ * returns the version and the version-stripped ref for the locale parser and
+ * route mapping to consume.
+ */
+export declare const detectVersionRef: (ref: string, versions: ResolvedVersionsConfig) => DetectedVersionRef;
+/**
+ * Prefix a version-agnostic logical route with its version: `/guides/x`
+ * becomes `/v1.0/guides/x`, `/` becomes `/v1.0`. The current version (`""`)
+ * is the identity.
+ */
+export declare const versionizeRoute: (logicalRoute: string, version: string) => string;
+/**
+ * The localized root route of a version: `/`, `/fr`, `/v1.0`, or `/fr/v1.0`.
+ * The locale prefix stays outermost, matching how page routes compose
+ * (`localizeRoute(versionizeRoute(...))`).
+ */
+export declare const versionRoot: (version: string, locale?: string, i18n?: ResolvedI18nConfig) => string;
+/**
+ * Warn about top-level content folders shaped like a version (`v1`, `v2.0`)
+ * that aren't declared in `versions.archived`. Without this they're silently
+ * treated as current-version content under a `/<folder>/…` route — usually a
+ * snapshot that wasn't registered in config.
+ */
+export declare const versionsDiagnostics: (pages: PageRecord[], versions: ResolvedVersionsConfig) => Diagnostic[];

package/dist/types/core/yaml.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The schema js-yaml 4 loaded with by default: YAML 1.2 core scalars plus the
+ * `!!timestamp`, `!!merge`, `!!binary`, `!!omap`, `!!pairs`, and `!!set` tags.
+ * js-yaml 5 loads with the bare core schema instead, which turns
+ * `date: 2024-01-01` into a string and leaves `<<:` merge keys unresolved — a
+ * silent change to every page's front matter. Every Blume `load` call passes
+ * this schema so parsing stays identical across the upgrade.
+ */
+export declare const YAML_SCHEMA: import("js-yaml").Schema;

package/dist/types/deploy/adapter-output.d.ts

@@ -0,0 +1,45 @@
+import type { ResolvedConfig } from "../core/schema.ts";
+import type { ProjectContext } from "../core/types.ts";
+import type { ResolvedDeployment } from "./adapters/registry.ts";
+/**
+ * Where a build's output lands. Every static build and most server builds
+ * write to Astro's `outDir`; the Vercel adapter writes its Build Output tree
+ * beside it instead. Each platform declares its own (see `deploy/platforms`).
+ */
+export declare const deployOutputDir: (config: ResolvedConfig, context: ProjectContext) => string;
+/**
+ * Directory whose contents the deploy platform serves as static files. Build
+ * artifacts (robots.txt, sitemap.xml, llms.txt, …) must be written here to be
+ * served. A static build serves `dist/` wherever it lands; a server build
+ * serves what its platform declares — the Build Output tree's `static/` half
+ * on Vercel, Astro's `build.client` dir (`dist/client/`) on Node and
+ * Cloudflare, `dist/` on Netlify.
+ */
+export declare const deployStaticDir: (config: ResolvedConfig, context: ProjectContext) => string;
+/**
+ * Whether the platform applies a `_headers` file to the static assets it
+ * serves — true where Netlify or Cloudflare read one, including a Cloudflare
+ * **server** build (the Worker serves `dist/client` through its ASSETS
+ * binding, which honors `_headers` exactly as Pages does), and for a static
+ * build with no named host. Deliberately false where the file would be inert:
+ * Node's standalone server has its own static handler with no `_headers`
+ * support, and Vercel's headers arrive through the routing config instead.
+ * Reporting a header that is not applied is worse than omitting it.
+ */
+export declare const readsHeaderFiles: (deployment: ResolvedDeployment) => boolean;
+/** Outcome of {@link surfaceAdapterOutput}, for logging. */
+export type SurfaceResult = {
+    moved: false;
+} | {
+    from: string;
+    moved: true;
+    to: string;
+};
+/**
+ * Move a server adapter's deploy bundle out of the hidden `.blume` runtime and
+ * up to the project root, where the deploy platform expects it. A no-op for
+ * static builds, for platforms whose bundle already lands where they look
+ * (`hiddenRuntime.surfacePath` is null), and when the expected output is
+ * absent.
+ */
+export declare const surfaceAdapterOutput: (config: ResolvedConfig, context: ProjectContext) => Promise<SurfaceResult>;

package/dist/types/deploy/adapters/cloudflare.d.ts

@@ -0,0 +1,40 @@
+import type { DeployAdapter, DeployOptions } from "./types.ts";
+/** The Astro adapter package a Cloudflare server build imports. */
+export declare const CLOUDFLARE_ADAPTER_PACKAGE = "@astrojs/cloudflare";
+/**
+ * Options for {@link cloudflare}: `output`, `site`, and `base`, plus any
+ * option of `@astrojs/cloudflare` forwarded verbatim (`platformProxy`,
+ * `routes`, `cloudflareModules`, …). Blume sets `prerenderEnvironment`,
+ * `imageService`, and `configPath` itself; an option you pass wins.
+ */
+export type CloudflareOptions = DeployOptions;
+export type CloudflareAdapter = DeployAdapter<"cloudflare">;
+export declare const cloudflareOptionsSchema: import("zod").ZodObject<{
+    base: import("zod").ZodOptional<import("zod").ZodString>;
+    output: import("zod").ZodOptional<import("zod").ZodEnum<{
+        static: "static";
+        server: "server";
+    }>>;
+    site: import("zod").ZodOptional<import("zod").ZodURL>;
+}, import("zod/v4/core").$catchall<import("zod").ZodJSONSchema>>;
+export declare const cloudflareAdapterSchema: import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"cloudflare">;
+    options: import("zod").ZodObject<{
+        base: import("zod").ZodOptional<import("zod").ZodString>;
+        output: import("zod").ZodOptional<import("zod").ZodEnum<{
+            static: "static";
+            server: "server";
+        }>>;
+        site: import("zod").ZodOptional<import("zod").ZodURL>;
+    }, import("zod/v4/core").$catchall<import("zod").ZodJSONSchema>>;
+    requiredSecrets: import("zod").ZodArray<import("zod").ZodString>;
+    runtimeDeps: import("zod").ZodArray<import("zod").ZodString>;
+}, import("zod/v4/core").$strict>;
+/**
+ * Cloudflare Workers and Pages. A server build emits a Worker into
+ * `dist/server` (with a generated wrapper that answers `Accept:
+ * text/markdown`) and serves `dist/client` through the ASSETS binding.
+ * `@astrojs/cloudflare` is an optional peer: install it in the project
+ * (`npm install @astrojs/cloudflare`).
+ */
+export declare const cloudflare: (options?: CloudflareOptions) => CloudflareAdapter;

package/dist/types/deploy/adapters/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Deployment adapters for `blume.config.ts`:
+ *
+ * ```ts
+ * import { defineConfig } from "blume";
+ * import { vercel } from "blume/deploy";
+ *
+ * export default defineConfig({
+ *   deployment: vercel({ site: "https://docs.example.com" }),
+ * });
+ * ```
+ *
+ * Naming a host switches the build to server output on that host; leave
+ * `deployment` unset (or `{ site, base }`) for a static build anywhere. Each
+ * factory returns a plain descriptor (see `core/adapter.ts`) that the schema
+ * validates; the generated `astro.config.mjs` imports the real `@astrojs/*`
+ * adapter and passes the options through verbatim.
+ */
+export type { AdapterDescriptor, JsonValue } from "../../core/adapter.ts";
+export { cloudflare } from "./cloudflare.ts";
+export type { CloudflareAdapter, CloudflareOptions } from "./cloudflare.ts";
+export { netlify } from "./netlify.ts";
+export type { NetlifyAdapter, NetlifyOptions } from "./netlify.ts";
+export { node } from "./node.ts";
+export type { NodeAdapter, NodeOptions } from "./node.ts";
+export type { AnyDeployAdapter, DeployAdapterKind, DeploymentInput, ResolvedDeployment, ResolvedDeployOptions, } from "./registry.ts";
+export type { DeployAdapter, DeployNamedOptions, DeployOptions, DeployOutput, StaticDeployment, } from "./types.ts";
+export { vercel } from "./vercel.ts";
+export type { VercelAdapter, VercelOptions } from "./vercel.ts";

package/dist/types/deploy/adapters/netlify.d.ts

@@ -0,0 +1,37 @@
+import type { DeployAdapter, DeployOptions } from "./types.ts";
+/** The Astro adapter package a Netlify server build imports. */
+export declare const NETLIFY_ADAPTER_PACKAGE = "@astrojs/netlify";
+/**
+ * Options for {@link netlify}: `output`, `site`, and `base`, plus any option
+ * of `@astrojs/netlify` forwarded verbatim (`edgeMiddleware`, `imageCDN`,
+ * `cacheOnDemandPages`, …).
+ */
+export type NetlifyOptions = DeployOptions;
+export type NetlifyAdapter = DeployAdapter<"netlify">;
+export declare const netlifyOptionsSchema: import("zod").ZodObject<{
+    base: import("zod").ZodOptional<import("zod").ZodString>;
+    output: import("zod").ZodOptional<import("zod").ZodEnum<{
+        static: "static";
+        server: "server";
+    }>>;
+    site: import("zod").ZodOptional<import("zod").ZodURL>;
+}, import("zod/v4/core").$catchall<import("zod").ZodJSONSchema>>;
+export declare const netlifyAdapterSchema: import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"netlify">;
+    options: import("zod").ZodObject<{
+        base: import("zod").ZodOptional<import("zod").ZodString>;
+        output: import("zod").ZodOptional<import("zod").ZodEnum<{
+            static: "static";
+            server: "server";
+        }>>;
+        site: import("zod").ZodOptional<import("zod").ZodURL>;
+    }, import("zod/v4/core").$catchall<import("zod").ZodJSONSchema>>;
+    requiredSecrets: import("zod").ZodArray<import("zod").ZodString>;
+    runtimeDeps: import("zod").ZodArray<import("zod").ZodString>;
+}, import("zod/v4/core").$strict>;
+/**
+ * Netlify. A server build runs on Netlify Functions from the Frameworks API
+ * tree the adapter writes to `.netlify/v1`. `@astrojs/netlify` is an optional
+ * peer: install it in the project (`npm install @astrojs/netlify`).
+ */
+export declare const netlify: (options?: NetlifyOptions) => NetlifyAdapter;

package/dist/types/deploy/adapters/node.d.ts

@@ -0,0 +1,37 @@
+import type { DeployAdapter, DeployOptions } from "./types.ts";
+/** The Astro adapter package a Node server build imports. */
+export declare const NODE_ADAPTER_PACKAGE = "@astrojs/node";
+/**
+ * Options for {@link node}: `output`, `site`, and `base`, plus any option of
+ * `@astrojs/node` forwarded verbatim (`mode`, `host`, `port`, …). Blume
+ * defaults `mode` to `"standalone"`; an option you pass wins.
+ */
+export type NodeOptions = DeployOptions;
+export type NodeAdapter = DeployAdapter<"node">;
+export declare const nodeOptionsSchema: import("zod").ZodObject<{
+    base: import("zod").ZodOptional<import("zod").ZodString>;
+    output: import("zod").ZodOptional<import("zod").ZodEnum<{
+        static: "static";
+        server: "server";
+    }>>;
+    site: import("zod").ZodOptional<import("zod").ZodURL>;
+}, import("zod/v4/core").$catchall<import("zod").ZodJSONSchema>>;
+export declare const nodeAdapterSchema: import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"node">;
+    options: import("zod").ZodObject<{
+        base: import("zod").ZodOptional<import("zod").ZodString>;
+        output: import("zod").ZodOptional<import("zod").ZodEnum<{
+            static: "static";
+            server: "server";
+        }>>;
+        site: import("zod").ZodOptional<import("zod").ZodURL>;
+    }, import("zod/v4/core").$catchall<import("zod").ZodJSONSchema>>;
+    requiredSecrets: import("zod").ZodArray<import("zod").ZodString>;
+    runtimeDeps: import("zod").ZodArray<import("zod").ZodString>;
+}, import("zod/v4/core").$strict>;
+/**
+ * A self-hosted Node server (containers, VMs). The standalone server in
+ * `dist/server/entry.mjs` serves `dist/client` itself. `@astrojs/node` is one
+ * of Blume's own dependencies.
+ */
+export declare const node: (options?: NodeOptions) => NodeAdapter;

package/dist/types/deploy/adapters/registry.d.ts

@@ -0,0 +1,133 @@
+import { z } from "zod";
+import type { AdapterDescriptor, JsonValue } from "../../core/adapter.ts";
+import type { CloudflareAdapter } from "./cloudflare.ts";
+import type { NetlifyAdapter } from "./netlify.ts";
+import type { NodeAdapter } from "./node.ts";
+import type { DeployOutput, StaticDeployment } from "./types.ts";
+import type { VercelAdapter } from "./vercel.ts";
+/** Every descriptor a host adapter factory can return. */
+export type AnyDeployAdapter = CloudflareAdapter | NetlifyAdapter | NodeAdapter | VercelAdapter;
+/** Every adapter identity, including the resolved `static` default. */
+export type DeployAdapterKind = "static" | AnyDeployAdapter["kind"];
+/**
+ * A resolved deployment's options: `output` is always present (a host adapter
+ * defaults to `server`, the static form is `static`), and anything else the
+ * adapter was given rides along for the `@astrojs/*` constructor.
+ */
+export type ResolvedDeployOptions = {
+    base?: string;
+    output: DeployOutput;
+    site?: string;
+} & {
+    [option: string]: JsonValue;
+};
+/**
+ * What `config.deployment` resolves to: the descriptor the factory returned
+ * with `output` filled in, or the `static` descriptor for the plain form.
+ */
+export type ResolvedDeployment = AdapterDescriptor<DeployAdapterKind, ResolvedDeployOptions>;
+/** What `blume.config.ts` accepts under `deployment`. */
+export type DeploymentInput = AnyDeployAdapter | StaticDeployment;
+/**
+ * Validates what a factory returned (or the plain static form) and resolves
+ * it to the canonical descriptor, re-derived through the factory so a
+ * descriptor that went through JSON carries the same metadata Blume ships.
+ * `static` is internal: `kind: "static"` is admitted but never needed.
+ */
+export declare const resolvedDeploymentSchema: z.ZodPipe<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"cloudflare">;
+    options: z.ZodObject<{
+        base: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodEnum<{
+            static: "static";
+            server: "server";
+        }>>;
+        site: z.ZodOptional<z.ZodURL>;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"netlify">;
+    options: z.ZodObject<{
+        base: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodEnum<{
+            static: "static";
+            server: "server";
+        }>>;
+        site: z.ZodOptional<z.ZodURL>;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"node">;
+    options: z.ZodObject<{
+        base: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodEnum<{
+            static: "static";
+            server: "server";
+        }>>;
+        site: z.ZodOptional<z.ZodURL>;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"vercel">;
+    options: z.ZodObject<{
+        base: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodEnum<{
+            static: "static";
+            server: "server";
+        }>>;
+        site: z.ZodOptional<z.ZodURL>;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    base: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodLiteral<"static">>;
+    site: z.ZodOptional<z.ZodURL>;
+}, z.core.$strict>], "kind">, z.ZodTransform<ResolvedDeployment, {
+    kind: "cloudflare";
+    options: {
+        [x: string]: z.core.util.JSONType;
+        base?: string | undefined;
+        output?: "static" | "server" | undefined;
+        site?: string | undefined;
+    };
+    requiredSecrets: string[];
+    runtimeDeps: string[];
+} | {
+    kind: "netlify";
+    options: {
+        [x: string]: z.core.util.JSONType;
+        base?: string | undefined;
+        output?: "static" | "server" | undefined;
+        site?: string | undefined;
+    };
+    requiredSecrets: string[];
+    runtimeDeps: string[];
+} | {
+    kind: "node";
+    options: {
+        [x: string]: z.core.util.JSONType;
+        base?: string | undefined;
+        output?: "static" | "server" | undefined;
+        site?: string | undefined;
+    };
+    requiredSecrets: string[];
+    runtimeDeps: string[];
+} | {
+    kind: "vercel";
+    options: {
+        [x: string]: z.core.util.JSONType;
+        base?: string | undefined;
+        output?: "static" | "server" | undefined;
+        site?: string | undefined;
+    };
+    requiredSecrets: string[];
+    runtimeDeps: string[];
+} | {
+    base?: string | undefined;
+    kind?: "static" | undefined;
+    site?: string | undefined;
+}>>;

package/dist/types/deploy/adapters/types.d.ts

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import type { AdapterDescriptor, JsonValue } from "../../core/adapter.ts";
+/** Build output mode: prerendered HTML only, or a server that can also answer requests. */
+export type DeployOutput = "static" | "server";
+/** The options every host adapter maps itself. */
+export interface DeployNamedOptions {
+    /** Base path when the site is served from a subdirectory (`/docs`). */
+    base?: string;
+    /**
+     * Build output mode. Defaults to `server`: naming a host adapter is how a
+     * site opts into server rendering. Pass `"static"` to keep a static build
+     * on that host, with its site detection and platform files.
+     */
+    output?: DeployOutput;
+    /**
+     * Canonical site URL. Needed for absolute links, the sitemap, and OG images;
+     * detected from the platform's env at build time when unset.
+     */
+    site?: string;
+}
+/**
+ * Options for a host adapter: the named options plus anything else, forwarded
+ * verbatim to the underlying `@astrojs/*` adapter's constructor. JSON values
+ * only — the descriptor is inlined into the generated `astro.config.mjs`.
+ */
+export type DeployOptions = DeployNamedOptions & {
+    [option: string]: JsonValue;
+};
+/**
+ * The descriptor a host adapter factory returns and `blume.config.ts` carries
+ * under `deployment`: the shared {@link AdapterDescriptor} contract, with the
+ * options a host takes. Plain data, never an Astro integration — the generated
+ * config imports the real adapter package itself.
+ */
+export type DeployAdapter<Kind extends string, Options extends DeployOptions = DeployOptions> = AdapterDescriptor<Kind, Options>;
+/**
+ * A static build for any host — the form `deployment` takes when no adapter is
+ * named: `{ site, base }`, or nothing at all. `kind` is the resolved
+ * discriminator; leave it unset.
+ */
+export interface StaticDeployment {
+    /** Base path when the site is served from a subdirectory (`/docs`). */
+    base?: string;
+    /** The resolved kind; never needed in a config. */
+    kind?: "static";
+    /**
+     * Canonical site URL. Needed for absolute links, the sitemap, and OG images;
+     * detected from the platform's env at build time when unset.
+     */
+    site?: string;
+}
+/** The named options' schema; every host adapter extends it with `z.json()` passthrough. */
+export declare const deployOptionsSchema: z.ZodObject<{
+    base: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodEnum<{
+        static: "static";
+        server: "server";
+    }>>;
+    site: z.ZodOptional<z.ZodURL>;
+}, z.core.$catchall<z.ZodJSONSchema>>;
+/**
+ * The options Blume does not name — what reaches the `@astrojs/*` adapter's
+ * constructor verbatim.
+ */
+export declare const deployPassthrough: (options: DeployOptions) => Record<string, JsonValue>;
+/**
+ * The runtime dependency a host adapter declares: its `@astrojs/*` package,
+ * which the generated `astro.config.mjs` imports for a server build and
+ * nothing imports for a static one. Unset `output` means server.
+ */
+export declare const serverRuntimeDeps: (options: DeployNamedOptions, adapterPackage: string) => string[];

package/dist/types/deploy/adapters/vercel.d.ts

@@ -0,0 +1,38 @@
+import type { DeployAdapter, DeployOptions } from "./types.ts";
+/** The Astro adapter package a Vercel server build imports. */
+export declare const VERCEL_ADAPTER_PACKAGE = "@astrojs/vercel";
+/**
+ * Options for {@link vercel}: `output`, `site`, and `base`, plus any option of
+ * `@astrojs/vercel` forwarded verbatim (`isr`, `maxDuration`, `imageService`,
+ * `webAnalytics`, …).
+ */
+export type VercelOptions = DeployOptions;
+export type VercelAdapter = DeployAdapter<"vercel">;
+export declare const vercelOptionsSchema: import("zod").ZodObject<{
+    base: import("zod").ZodOptional<import("zod").ZodString>;
+    output: import("zod").ZodOptional<import("zod").ZodEnum<{
+        static: "static";
+        server: "server";
+    }>>;
+    site: import("zod").ZodOptional<import("zod").ZodURL>;
+}, import("zod/v4/core").$catchall<import("zod").ZodJSONSchema>>;
+export declare const vercelAdapterSchema: import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"vercel">;
+    options: import("zod").ZodObject<{
+        base: import("zod").ZodOptional<import("zod").ZodString>;
+        output: import("zod").ZodOptional<import("zod").ZodEnum<{
+            static: "static";
+            server: "server";
+        }>>;
+        site: import("zod").ZodOptional<import("zod").ZodURL>;
+    }, import("zod/v4/core").$catchall<import("zod").ZodJSONSchema>>;
+    requiredSecrets: import("zod").ZodArray<import("zod").ZodString>;
+    runtimeDeps: import("zod").ZodArray<import("zod").ZodString>;
+}, import("zod/v4/core").$strict>;
+/**
+ * Vercel. A server build writes the Build Output tree to `.vercel/output`,
+ * audits the function bundle for imports the platform's dependency trace
+ * dropped, and wires `Accept: text/markdown` negotiation into the routing
+ * config. `@astrojs/vercel` is one of Blume's own dependencies.
+ */
+export declare const vercel: (options?: VercelOptions) => VercelAdapter;

package/dist/types/deploy/artifacts.d.ts

@@ -0,0 +1,65 @@
+import type { BlumeProject } from "../core/project-graph.ts";
+/**
+ * The deploy artifacts Blume layers onto Astro's build output: the search
+ * index (and hosted-provider sync), llms.txt, sitemap, robots, the
+ * agent-readability manifest, the `.well-known` discovery files, Agent
+ * Skills, and the platform `_redirects`/`_headers` files.
+ *
+ * Written from the integration's `astro:build:done` hook — Astro's channel
+ * for exactly this kind of post-build work — into the directory Astro
+ * reports as the client output (`dist/`, or `dist/client` for a server
+ * build). The Vercel adapter copies that directory into its Build Output
+ * static tree in a later hook, so the artifacts ride along; every other
+ * adapter serves it directly. Running inside the hook rather than after
+ * `astro build` returns means an ejected project keeps producing them.
+ *
+ * Every file yields to one the user ships in `public/` (Astro copied it into
+ * the output before this runs).
+ */
+/** The log surface the writers report through (Astro's integration logger). */
+export interface ArtifactLogger {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+}
+/**
+ * Emit a `_headers` file so Netlify / Cloudflare serve the raw AI-ready
+ * endpoints (`*.md`, `*.mdx`, `*.txt`) with an explicit `charset=utf-8`. Without
+ * it those hosts send `text/markdown` / `text/plain` with no charset and
+ * browsers fall back to Windows-1252, garbling any non-ASCII docs (#82).
+ *
+ * The same file carries the rest of the agent-discovery surface that only a
+ * response header can express: the homepage `Link` header (RFC 8288, see
+ * `ai/link-headers.ts`), and the registered media types for the extensionless
+ * well-known files — `application/linkset+json` for the API catalog, the
+ * signatures directory, and the Agent Skills archives. A static host serves
+ * those as `octet-stream` or nothing at all without a rule.
+ *
+ * A `_headers` shipped in `public/` wins, exactly like `_redirects` — the opt-out
+ * is checked at its source rather than in `dist`, because on Cloudflare the file
+ * in `dist` is not necessarily the user's: `@astrojs/cloudflare` writes its own
+ * `_headers` (an immutable `Cache-Control` rule for `/_astro/*`) during the
+ * build, before this runs. Testing `dist` therefore read an adapter-generated
+ * file as a user opt-out and skipped silently. When both exist, the adapter's
+ * rules are preserved and ours are appended.
+ *
+ * Gated on {@link readsHeaderFiles}, not on `output === "static"`. A **Cloudflare
+ * server** build serves `dist/client` through the Worker's ASSETS binding, and
+ * Workers static assets honor `_headers` from that directory — so the file
+ * applies there too, and skipping it left every Cloudflare server build with no
+ * `Link` header and no media type on its own discovery files. The charset half
+ * of this file *is* redundant on a server build, because the runtime endpoint
+ * sets Content-Type on the Response itself; the `Link` and well-known halves are
+ * not, and one conclusion about the first was applied to all three.
+ *
+ * Exported for the test suite, which exercises it in a subprocess like the
+ * command helpers.
+ */
+export declare const emitHeaderFiles: (project: BlumeProject, distDir: string, logger: ArtifactLogger) => Promise<void>;
+/**
+ * Write every deploy artifact into `distDir`, the directory the platform
+ * serves as static files (see the module comment). A user's own `public/`
+ * file always wins. `indexSearch` is the Pagefind indexer, replaceable by
+ * tests: Pagefind's in-process service cannot be reopened once a build has
+ * closed it, so only one suite may run the real one.
+ */
+export declare const publishBuildArtifacts: (project: BlumeProject, distDir: string, logger: ArtifactLogger, indexSearch?: (outDir: string) => Promise<number>) => Promise<void>;