blume 1.7.3 → 2.0.0

package/dist/types/analytics/schema.d.ts

@@ -0,0 +1,320 @@
+import { z } from "zod";
+/** One configured analytics adapter, as its factory returned it. */
+export declare const analyticsAdapterSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"adobe">;
+    options: z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"amplitude">;
+    options: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"clarity">;
+    options: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"clearbit">;
+    options: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"cloudflare">;
+    options: z.ZodObject<{
+        token: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"fathom">;
+    options: z.ZodObject<{
+        site: z.ZodString;
+    }, z.core.$catchall<z.ZodString>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"google-analytics">;
+    options: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"google-tag-manager">;
+    options: z.ZodObject<{
+        dataLayer: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"heap">;
+    options: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"hightouch">;
+    options: z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        key: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"hotjar">;
+    options: z.ZodObject<{
+        id: z.ZodNumber;
+        version: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"logrocket">;
+    options: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"mixpanel">;
+    options: z.ZodObject<{
+        region: z.ZodOptional<z.ZodEnum<{
+            in: "in";
+            eu: "eu";
+            us: "us";
+        }>>;
+        token: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"pirsch">;
+    options: z.ZodObject<{
+        code: z.ZodString;
+    }, z.core.$catchall<z.ZodString>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"plausible">;
+    options: z.ZodObject<{
+        domain: z.ZodString;
+        host: z.ZodOptional<z.ZodString>;
+    }, z.core.$catchall<z.ZodString>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"posthog">;
+    options: z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        key: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"script">;
+    options: z.ZodObject<{
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        content: z.ZodOptional<z.ZodString>;
+        src: z.ZodOptional<z.ZodString>;
+        strategy: z.ZodOptional<z.ZodEnum<{
+            defer: "defer";
+            async: "async";
+        }>>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"segment">;
+    options: z.ZodObject<{
+        cdn: z.ZodOptional<z.ZodString>;
+        key: z.ZodString;
+    }, 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<{
+        debug: z.ZodOptional<z.ZodBoolean>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            development: "development";
+            production: "production";
+        }>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export type AnalyticsAdapter = z.output<typeof analyticsAdapterSchema>;
+/**
+ * `blume.config.analytics`: the adapters to emit, in order. Unset means none.
+ * A non-array (the pre-adapter object form, say) fails with the list hint;
+ * element errors keep their own messages.
+ */
+export declare const analyticsConfigSchema: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"adobe">;
+    options: z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"amplitude">;
+    options: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"clarity">;
+    options: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"clearbit">;
+    options: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"cloudflare">;
+    options: z.ZodObject<{
+        token: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"fathom">;
+    options: z.ZodObject<{
+        site: z.ZodString;
+    }, z.core.$catchall<z.ZodString>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"google-analytics">;
+    options: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"google-tag-manager">;
+    options: z.ZodObject<{
+        dataLayer: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"heap">;
+    options: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"hightouch">;
+    options: z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        key: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"hotjar">;
+    options: z.ZodObject<{
+        id: z.ZodNumber;
+        version: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"logrocket">;
+    options: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"mixpanel">;
+    options: z.ZodObject<{
+        region: z.ZodOptional<z.ZodEnum<{
+            in: "in";
+            eu: "eu";
+            us: "us";
+        }>>;
+        token: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"pirsch">;
+    options: z.ZodObject<{
+        code: z.ZodString;
+    }, z.core.$catchall<z.ZodString>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"plausible">;
+    options: z.ZodObject<{
+        domain: z.ZodString;
+        host: z.ZodOptional<z.ZodString>;
+    }, z.core.$catchall<z.ZodString>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"posthog">;
+    options: z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        key: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"script">;
+    options: z.ZodObject<{
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        content: z.ZodOptional<z.ZodString>;
+        src: z.ZodOptional<z.ZodString>;
+        strategy: z.ZodOptional<z.ZodEnum<{
+            defer: "defer";
+            async: "async";
+        }>>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"segment">;
+    options: z.ZodObject<{
+        cdn: z.ZodOptional<z.ZodString>;
+        key: z.ZodString;
+    }, 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<{
+        debug: z.ZodOptional<z.ZodBoolean>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            development: "development";
+            production: "production";
+        }>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "kind">>>;

package/dist/types/analytics/script.d.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import type { HeadScript } from "./head.ts";
+/** Options for {@link script}; set exactly one of `src` or `content`. */
+export interface ScriptOptions {
+    /** Extra attributes spread onto the `<script>` (e.g. `data-domain`, `id`). */
+    attributes?: Record<string, string>;
+    /** Inline script body. Mutually exclusive with `src`. */
+    content?: string;
+    /** External script URL. Mutually exclusive with `content`. */
+    src?: string;
+    /** Load strategy for an external script. */
+    strategy?: "async" | "defer";
+}
+export declare const scriptOptionsSchema: z.ZodObject<{
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    content: z.ZodOptional<z.ZodString>;
+    src: z.ZodOptional<z.ZodString>;
+    strategy: z.ZodOptional<z.ZodEnum<{
+        defer: "defer";
+        async: "async";
+    }>>;
+}, z.core.$strict>;
+export type ScriptAdapter = AdapterDescriptor<"script", ScriptOptions>;
+export declare const scriptAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"script">;
+    options: z.ZodObject<{
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        content: z.ZodOptional<z.ZodString>;
+        src: z.ZodOptional<z.ZodString>;
+        strategy: z.ZodOptional<z.ZodEnum<{
+            defer: "defer";
+            async: "async";
+        }>>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Any other provider (Plausible, Fathom, GA, Umami, …) as one `<script>` tag:
+ * external via `src`, inline via `content`. `attributes` is the verbatim
+ * passthrough here — every entry lands on the tag as-is.
+ */
+export declare const script: (options: ScriptOptions) => ScriptAdapter;
+/** The tag. Explicit `src`/`strategy` win over a same-named spread attribute. */
+export declare const scriptHead: (options: ScriptOptions) => HeadScript[];

package/dist/types/analytics/segment.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import type { AdapterDescriptor, JsonValue } from "../core/adapter.ts";
+import type { HeadScript } from "./head.ts";
+/** Segment's CDN, where `segment()` loads analytics.js from when `cdn` is unset. */
+export declare const SEGMENT_DEFAULT_CDN = "https://cdn.segment.com";
+/** The options {@link segment} maps itself. */
+export interface SegmentNamedOptions {
+    /**
+     * Origin of a custom domain that proxies Segment's CDN, e.g.
+     * `https://cdn.example.com`. Defaults to Segment's own.
+     */
+    cdn?: string;
+    /** Write key of the JavaScript source. */
+    key: string;
+}
+/**
+ * Options for {@link segment}: the named options plus any other
+ * `analytics.load` option, forwarded verbatim (`integrations`, …). JSON
+ * values only.
+ */
+export type SegmentOptions = SegmentNamedOptions & {
+    [option: string]: JsonValue;
+};
+export declare const segmentOptionsSchema: z.ZodObject<{
+    cdn: z.ZodOptional<z.ZodString>;
+    key: z.ZodString;
+}, z.core.$catchall<z.ZodJSONSchema>>;
+export type SegmentAdapter = AdapterDescriptor<"segment", SegmentOptions>;
+export declare const segmentAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"segment">;
+    options: z.ZodObject<{
+        cdn: z.ZodOptional<z.ZodString>;
+        key: z.ZodString;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Segment (Twilio Segment) analytics.js. The write key is meant for the
+ * browser — it identifies the source the SDK reports to.
+ */
+export declare const segment: (options: SegmentOptions) => SegmentAdapter;
+/**
+ * The install snippet, with `key` mapped to the write key, `cdn` mapped to
+ * the script origin (and `analytics._cdn`, so the library fetches its
+ * integrations from the same place), and everything else forwarded as the
+ * load options; the object is left off when there is nothing to pass, as the
+ * snippet prints it.
+ */
+export declare const segmentHead: (options: SegmentOptions) => HeadScript[];

package/dist/types/analytics/vercel.d.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import type { AdapterDescriptor, JsonValue } from "../core/adapter.ts";
+/** The props of `@vercel/analytics/astro` that {@link vercel} documents. */
+export interface VercelNamedOptions {
+    /** Log every event to the console. Defaults to the component's own rule (on outside production). */
+    debug?: boolean;
+    /** Force the script's environment instead of letting it detect one. */
+    mode?: "auto" | "development" | "production";
+}
+/**
+ * Options for {@link vercel}: the documented props plus any other prop of the
+ * official component, forwarded verbatim (`endpoint`, `scriptSrc`, `dsn`, …).
+ * JSON values only; `beforeSend` is a function and can't travel through
+ * config — assign `window.webAnalyticsBeforeSend` from a `script()` adapter
+ * listed before `vercel()` instead.
+ */
+export type VercelOptions = VercelNamedOptions & {
+    [option: string]: JsonValue;
+};
+export declare const vercelOptionsSchema: z.ZodObject<{
+    debug: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        development: "development";
+        production: "production";
+    }>>;
+}, z.core.$catchall<z.ZodJSONSchema>>;
+export type VercelAdapter = AdapterDescriptor<"vercel", VercelOptions>;
+export declare const vercelAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"vercel">;
+    options: z.ZodObject<{
+        debug: z.ZodOptional<z.ZodBoolean>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            development: "development";
+            production: "production";
+        }>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Vercel Web Analytics, rendered through the official Astro component, which
+ * injects the first-party script Vercel serves at `/_vercel/insights` once Web
+ * Analytics is enabled for the project. Needs no keys. `@vercel/analytics` is
+ * one of Blume's own dependencies, so the adapter declares no runtime dep.
+ */
+export declare const vercel: (options?: VercelOptions) => VercelAdapter;

package/dist/types/astro/integration.d.ts

@@ -0,0 +1,76 @@
+import type { AstroIntegration } from "astro";
+import type { CustomPageRoute } from "../core/custom-pages.ts";
+import type { BlumeProject } from "../core/project-graph.ts";
+import type { Diagnostic } from "../core/types.ts";
+/**
+ * Hand the scanned project to the integration ahead of `build()`, so its
+ * `astro:build:done` hook can write the deploy artifacts without scanning
+ * again. `blume build` publishes it for a real build and nothing for an
+ * isolated verify build, which produces no artifacts. `null` withdraws it.
+ */
+export declare const publishBuildProject: (project: BlumeProject | null) => void;
+/**
+ * Publish the dev negotiation inputs for the running server: the content
+ * routes with a Markdown variant and the homepage `Link` header. Called by
+ * `generateRuntime` on every pass, so the middleware follows a route rename
+ * without the generated config changing. `null` withdraws a publication, so
+ * the middleware falls back to the options baked into the integration call
+ * (an ejected project has no CLI to publish).
+ */
+export declare const publishDevNegotiation: (negotiation: {
+    contentRoutes: readonly string[];
+    homeLinkHeader?: string;
+} | null) => void;
+/**
+ * Re-run Astro's content-layer loaders against the live dev server. Returns
+ * `false` when no server has registered one — before the first
+ * `astro:server:setup`, or outside `blume dev` — so the caller can fall back.
+ * A route-set change (a page added, removed, or a folder renamed) is what
+ * needs this: Astro's glob watcher misses directory renames, and its in-place
+ * config restart never re-globs, so without a re-sync `getEntry` reads a
+ * stale store and the moved page 404s.
+ */
+export declare const refreshBlumeContent: () => Promise<boolean>;
+/**
+ * Surface Blume's own diagnostics (config/frontmatter/content errors) in the
+ * Vite/Astro browser error overlay during `blume dev`, so they don't hide in the
+ * terminal. A no-op when there are no errors or the dev server isn't up. The
+ * overlay clears itself on the next successful HMR update.
+ */
+export declare const showBlumeErrorOverlay: (diagnostics: Diagnostic[]) => void;
+/** A user page mounted into the generated runtime. */
+export type BlumePageRoute = CustomPageRoute;
+export interface BlumeIntegrationOptions {
+    pages: BlumePageRoute[];
+    /**
+     * Page routes that have a raw-Markdown variant (the content manifest). The
+     * hidden runtime leaves this out: the CLI publishes the live set through
+     * `publishDevNegotiation` on every regeneration, so a route change never
+     * rewrites the generated config. An ejected project, which has no CLI,
+     * bakes it in here.
+     */
+    contentRoutes?: string[];
+    /**
+     * Homepage `Link` header value for agent discovery (see
+     * `ai/link-headers.ts`); the dev-server counterpart of the `_headers` /
+     * Vercel-config emission, so `curl -I` against `blume dev` shows what the
+     * deployed site will send. Published the same way as `contentRoutes`.
+     */
+    homeLinkHeader?: string;
+    /**
+     * Blume project root to scan on `astro:build:done` for the deploy artifacts
+     * (search index, llms.txt, sitemap, …) when no CLI has published the
+     * project — an ejected app running plain `astro build`. Relative to the
+     * Astro root. The hidden runtime leaves it unset: `blume build` publishes
+     * its already-scanned project instead.
+     */
+    buildArtifactsRoot?: string;
+}
+/**
+ * Blume's Astro integration. Mounts user-authored pages from `pages/` into the
+ * generated runtime via `injectRoute`, keeping each file in its original
+ * location so relative imports and `getStaticPaths` keep working; declares
+ * the `blume:*` virtual modules' types through `injectTypes`; and teaches the
+ * dev server to honor `Accept: text/markdown`.
+ */
+export declare const blumeIntegration: (options: BlumeIntegrationOptions) => AstroIntegration;

package/dist/types/astro/markdown-negotiation.d.ts

@@ -0,0 +1,23 @@
+/**
+ * HTTP content negotiation for the raw-Markdown variants. The `<route>.md`
+ * endpoints already serve a page's source verbatim; these helpers let the dev
+ * server honor `Accept: text/markdown` by transparently rewriting a page
+ * request to its `.md` variant.
+ *
+ * The Cloudflare negotiation Worker embeds a plain-JavaScript copy of these
+ * helpers (`deploy/cloudflare-negotiation.ts` — its deploy bundle is uploaded
+ * unbundled, so it cannot import this module); when editing here, mirror the
+ * change there. Parity is enforced by `test/cloudflare-negotiation.test.ts`.
+ */
+/**
+ * Whether the client explicitly prefers Markdown over HTML. Browsers never send
+ * `text/markdown`, so an ordinary page request (`text/html` or the catch-all wildcard) is false.
+ */
+export declare const prefersMarkdown: (accept: string | null | undefined) => boolean;
+/**
+ * Map a page request URL to its `.md` variant, or `null` when the requested
+ * path is not a known content route (Vite/Astro internals, assets, API routes,
+ * landing pages, and user `.astro` pages all fall through). `routes` is the set
+ * of page paths that have a raw-Markdown variant.
+ */
+export declare const markdownVariantUrl: (rawUrl: string | null | undefined, routes: ReadonlySet<string>, base?: string) => string | null;

package/dist/types/astro/module-types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Ambient declarations for the `blume:*` virtual modules the generated pages
+ * and Blume's own layouts import. The integration hands them to Astro through
+ * `injectTypes` on `astro:config:done`, so they land under
+ * `.astro/integrations/blume/` and are referenced from Astro's generated
+ * `types.d.ts` — the same channel `astro:content` and `astro:env` use — rather
+ * than a hand-written `src/env.d.ts` the generator and eject each had to
+ * write. Every project that mounts the integration gets the types with it.
+ *
+ * `examplesModule` is the path of the generated `examples.ts` relative to the
+ * declaration file: the `blume:examples` map is typed from that module's
+ * literal export so `<Component path>` lookups stay typed per project.
+ */
+export declare const runtimeModuleDeclarations: (examplesModule: string) => string;

package/dist/types/astro/pages.d.ts

@@ -0,0 +1,44 @@
+import type { BlumeProject } from "../core/project-graph.ts";
+import type { BlumePageRoute } from "./integration.ts";
+export { customStaticRoutes, discoverPages, discoverPagesSync, } from "../core/custom-pages.ts";
+/**
+ * Whether the project already owns `route` — through a custom `.astro` page
+ * (injected, so matched on `pattern`) or a content page (matched on `route`).
+ * Used to skip a generated default page (e.g. `/404`, `/changelog`) so a
+ * user-authored page overrides it without a route collision.
+ */
+export declare const routeIsTaken: (pages: {
+    pattern: string;
+}[], contentPages: {
+    route: string;
+}[], route: string) => boolean;
+/** A custom-page route that should get a generated OG card. */
+export interface OgCustomRoute {
+    /** `og/<slug>.png` path segment; `index` for the site root. */
+    slug: string;
+    /** Card headline. */
+    title: string;
+}
+/**
+ * Whether the generated `/changelog` index route exists for this project —
+ * `generate.ts` (which writes the page) and the sitemap/link validator all
+ * share this check: there are visible `type: changelog` entries — or a
+ * release-backed changelog source, whose route must resolve even when a fetch
+ * fails — and no user content or custom page already owns `/changelog`.
+ */
+export declare const hasGeneratedChangelog: (project: BlumeProject, userPages: {
+    pattern: string;
+}[]) => boolean;
+/**
+ * Pick the custom-page routes that should get a generated Open Graph card, with
+ * the card's slug and text. OG is otherwise content-route only, so a custom page
+ * — most importantly the landing `/`, the most-shared URL — would have no card.
+ *
+ * Dynamic (`[param]`) routes and private segments (`_partials`, `.well-known`)
+ * are skipped: they aren't shareable pages. A `titles` entry (`seo.og.titles`,
+ * keyed by route) names a card outright — the only way to say "CLI" when the
+ * segment humanizes to "Cli". Otherwise the home is titled with the site title
+ * and a deeper page from its last path segment. The card's brand lockup,
+ * description, and footer come from the resolved config at render time.
+ */
+export declare const customOgRoutes: (pages: BlumePageRoute[], siteTitle: string, titles?: Record<string, string>) => OgCustomRoute[];

package/dist/types/cli/env.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Load `.env`/`.env.local`, cascading from `startDir` up to the repository root
+ * (the first ancestor containing a `.git`) or the filesystem root. The ordered
+ * path list is handed to dotenv, whose `config` is first-wins, never clobbers
+ * existing `process.env` values, and treats unreadable files as best-effort —
+ * so shell/CI overrides are never lost, `.env.local` layers over `.env`, and a
+ * bad file never aborts a build. dotenv is also the parser Vite runs over
+ * these files at build time, so a value means the same thing to the pre-boot
+ * content scan and the built site — including multi-line double-quoted values
+ * (PEM keys), which a line-based parser silently truncates.
+ */
+export declare const loadEnvFiles: (startDir: string) => void;