blume 2.0.2 → 2.0.3

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

@@ -48,6 +48,8 @@ export { logrocket } from "./logrocket.ts";
 export type { LogrocketAdapter, LogrocketOptions } from "./logrocket.ts";
 export { mixpanel } from "./mixpanel.ts";
 export type { MixpanelAdapter, MixpanelOptions, MixpanelRegion, } from "./mixpanel.ts";
+export { oneDollarStats } from "./one-dollar-stats.ts";
+export type { OneDollarStatsAdapter, OneDollarStatsOptions, } from "./one-dollar-stats.ts";
 export { pirsch } from "./pirsch.ts";
 export type { PirschAdapter, PirschOptions } from "./pirsch.ts";
 export { plausible } from "./plausible.ts";

package/dist/types/analytics/one-dollar-stats.d.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import type { HeadScript } from "./head.ts";
+/** The script OneDollarStats' install snippet loads. */
+export declare const ONE_DOLLAR_STATS_SCRIPT_SRC = "https://assets.onedollarstats.com/stonks.js";
+/** The options {@link oneDollarStats} checks itself. */
+export interface OneDollarStatsNamedOptions {
+    /**
+     * A bare host name, e.g. `docs.example.com`. The tracker reports every
+     * event under it on every host, not just `localhost`.
+     */
+    hostname?: string;
+}
+/**
+ * Options for {@link oneDollarStats}: any tracker setting, forwarded as a
+ * `data-` attribute on the tag (`hostname` → `data-hostname`, `devmode`,
+ * `url`, `autocollect`, `"hash-routing"`, …).
+ */
+export type OneDollarStatsOptions = OneDollarStatsNamedOptions & {
+    [setting: string]: string;
+};
+export declare const oneDollarStatsOptionsSchema: z.ZodObject<{
+    hostname: z.ZodOptional<z.ZodString>;
+}, z.core.$catchall<z.ZodString>>;
+export type OneDollarStatsAdapter = AdapterDescriptor<"one-dollar-stats", OneDollarStatsOptions>;
+export declare const oneDollarStatsAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"one-dollar-stats">;
+    options: z.ZodObject<{
+        hostname: z.ZodOptional<z.ZodString>;
+    }, z.core.$catchall<z.ZodString>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * OneDollarStats. Needs no keys — the dashboard matches events to a site by
+ * the domain they come from.
+ */
+export declare const oneDollarStats: (options?: OneDollarStatsOptions) => OneDollarStatsAdapter;
+/**
+ * The deferred tag from the install instructions, with every option as its
+ * own `data-` attribute. The tracker reads them from `document.currentScript`,
+ * so the tag stays a classic external script. It hooks `pushState` and
+ * `popstate` itself, so client-router navigations need no extra hook.
+ *
+ * The tracker turns hash routing on whenever `data-hash-routing` is present,
+ * whatever its value, so `"hash-routing": "false"` leaves the attribute off.
+ */
+export declare const oneDollarStatsHead: (options: OneDollarStatsOptions) => HeadScript[];

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

@@ -106,6 +106,13 @@ export declare const analyticsAdapterSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     }, z.core.$catchall<z.ZodJSONSchema>>;
     requiredSecrets: z.ZodArray<z.ZodString>;
     runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"one-dollar-stats">;
+    options: z.ZodObject<{
+        hostname: 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<"pirsch">;
     options: z.ZodObject<{
@@ -275,6 +282,13 @@ export declare const analyticsConfigSchema: z.ZodDefault<z.ZodArray<z.ZodDiscrim
     }, z.core.$catchall<z.ZodJSONSchema>>;
     requiredSecrets: z.ZodArray<z.ZodString>;
     runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"one-dollar-stats">;
+    options: z.ZodObject<{
+        hostname: 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<"pirsch">;
     options: z.ZodObject<{

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

@@ -53,8 +53,9 @@ export interface BlumeIntegrationOptions {
     /**
      * 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`.
+     * Vercel-config emission, so `curl -I` against `blume dev` shows it too —
+     * built for the `"dev"` surface, which leaves out the targets only a build
+     * writes. Published the same way as `contentRoutes`.
      */
     homeLinkHeader?: string;
     /**

package/dist/types/core/base-path.d.ts

@@ -48,16 +48,18 @@ export declare const isExternalUrl: (target: string) => boolean;
 /**
  * Idempotently prepend `basePath` to a root-relative route. A route already
  * equal to or nested under the base is returned unchanged, so authors who write
- * the base by hand (`/docs/x`) aren't double-prefixed to `/docs/docs/x`.
+ * the base by hand (`/docs/x`, `/docs#install`) aren't double-prefixed to
+ * `/docs/docs/x`.
  */
 export declare const withBasePath: (basePath: string, route: string) => string;
 /**
- * Mount a route Blume generates from content under `basePath`,
- * unconditionally. {@link withBasePath} leaves a route that already starts
- * with the base alone, which is right for a link an author based by hand but
- * wrong for a content route: with `basePath: "/docs"`, `docs/guide.md` routes
- * to `/docs/guide` before the base and publishes at `/docs/docs/guide`, not on
- * top of the root `guide.md`.
+ * Mount a route Blume generates under a base, unconditionally: `basePath` for
+ * a content route, `deployment.base` for any generated URL (a sitemap entry,
+ * a feed item). {@link withBasePath} leaves a route that already starts with
+ * the base alone, which is right for a link an author based by hand but wrong
+ * for a generated route: with `basePath: "/docs"`, `docs/guide.md` routes to
+ * `/docs/guide` before the base and publishes at `/docs/docs/guide`, not on
+ * top of the root `guide.md` — and likewise under `deployment.base: "/docs"`.
  */
 export declare const mountBasePath: (basePath: string, route: string) => string;
 /**
@@ -69,6 +71,18 @@ export declare const mountBasePath: (basePath: string, route: string) => string;
  * and a route already under the full composite is returned unchanged.
  */
 export declare const withComposedBasePath: (deployBase: string, basePath: string, route: string) => string;
+/**
+ * Base a root-relative link an author wrote as if mounted at root — a content
+ * link (`markdown/base-links.ts`, `components/content/base-href.ts`) or a
+ * redirect target (`deploy/redirects.ts`) — by what it names. A page gains the
+ * composed stack ({@link withComposedBasePath}). A public asset — a path whose
+ * final segment carries a file extension, with no page served there (a dotted
+ * route like `/releases/v1.2` is still a page) — gains the deployment base
+ * alone: Astro serves `public/` under `deployment.base`, but never under
+ * `basePath`. `servesPage` answers whether a page is served at a
+ * `basePath`-prefixed, fragment-less path. Other targets pass through.
+ */
+export declare const withAuthoredBasePath: (deployBase: string, basePath: string, target: string, servesPage: (route: string) => boolean) => string;
 /**
  * Remove `basePath` from the front of a route (`/docs/guide` -> `/guide`,
  * `/docs` -> `/`). A route not under the base is returned unchanged. Inverse of

package/dist/types/core/config-input.d.ts

@@ -850,13 +850,15 @@ export interface OgConfig {
      */
     enabled?: boolean;
     /**
-     * Fonts for the generated card, extending Takumi's Latin-only default so
-     * non-Latin titles (CJK, and so on) render instead of tofu. A bare string is
-     * a Google Fonts family fetched at build; the name-only object form pins
-     * weights (`700`, `[400, 700]`, or a `"100..900"` variable range) and
-     * styles; the `src` form reads a local font file from the project instead.
-     * When omitted and `theme.fonts` is explicitly configured, the theme's
-     * display and body fonts are used automatically — pass `[]` to opt out.
+     * Fonts for the generated card, replacing the default stack: Takumi's
+     * Latin-only built-in font plus a Noto fallback per script, which a card
+     * fetches only when its text needs one. A bare string is a Google Fonts
+     * family fetched at build; the name-only object form pins weights (`700`,
+     * `[400, 700]`, or a `"100..900"` variable range) and styles; the `src`
+     * form reads a local font file from the project instead. When omitted and
+     * `theme.fonts` is explicitly configured, the theme's display and body
+     * fonts are used automatically, ahead of the fallbacks — pass `[]` to opt
+     * out of both.
      */
     fonts?: (string | {
         name: string;

package/dist/types/core/directive-diagnostics.d.ts

@@ -0,0 +1,12 @@
+import type { SourceEntry } from "./sources/types.ts";
+import type { Diagnostic } from "./types.ts";
+/**
+ * Warn about each `:::name` container in an `.mdx` entry that isn't a callout.
+ * The page keeps its content — the body renders between the literal `:::`
+ * lines (see `markdown/directives.ts`) — but a typo like `:::warnig`, or a
+ * `:::details` carried over from another docs tool, should read as the
+ * mistake it is rather than as a finished page. Lines point into the file
+ * the author wrote, a partial's own file for a container an `<include>`
+ * brought in.
+ */
+export declare const unknownDirectiveDiagnostics: (entry: SourceEntry, sourceName: string) => Diagnostic[];

package/dist/types/core/heading-markers.d.ts

@@ -44,11 +44,9 @@ export interface HeadingMarkers {
  * the heading count (mid-text brackets are ordinary prose); when a marker kind
  * repeats, the last one written wins.
  *
- * `isRefDefined` reports whether a link-reference definition exists for a
- * bracket's label (`toc`, `!toc`, `#id`): a defined bracket is a CommonMark
- * shortcut link, not a marker — the renderer sees a resolved `<a>` element
- * there and strips nothing at or before it, so the parse stops the same way.
- * The render-time hast plugin never passes it (resolved links are already
- * elements by the time it runs); the raw-source scanner does.
+ * Callers pass the heading's trailing text node after a Markdown parse, so a
+ * bracket that a link-reference definition turns into a CommonMark shortcut
+ * link (`[toc]` with a `[toc]: …` definition) is already an element there and
+ * never reaches this parse.
  */
-export declare const parseHeadingMarkers: (text: string, isRefDefined?: (label: string) => boolean) => HeadingMarkers;
+export declare const parseHeadingMarkers: (text: string) => HeadingMarkers;

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

@@ -89,5 +89,7 @@ export declare const localeTargetPath: (rel: string, ext: string, locale: string
  * recognizes) but aren't declared in `i18n.locales`. Without this they're
  * silently treated as default-locale content under a `/<code>/…` route, which
  * is almost never intended — usually a translation that wasn't registered.
+ * A folder named after the default locale gets the same treatment (see
+ * {@link defaultLocaleFolderDiagnostic}).
  */
 export declare const i18nDiagnostics: (pages: PageRecord[], i18n: ResolvedI18nConfig, versions?: ResolvedVersionsConfig) => Diagnostic[];

package/dist/types/core/last-modified.d.ts

@@ -13,6 +13,16 @@ export declare const resolveLastModifiedConfig: (value: false | "git" | "frontma
  * newest-first, the first date seen for a path wins. Blank lines are ignored.
  */
 export declare const parseGitLog: (output: string) => Map<string, string>;
+/**
+ * `path` with every symlink resolved, the spelling git prints paths in: a
+ * project opened through a link (`/tmp/site` on macOS, where `/tmp` links to
+ * `/private/tmp`) gets `/private/tmp/site` from `rev-parse --show-toplevel`,
+ * so the project's own spelling would compare as outside the repository and
+ * every page would go undated. The native realpath also expands a Windows
+ * 8.3 short name (`RUNNER~1`), which git does too. A path that doesn't exist
+ * stays as written.
+ */
+export declare const realPath: (path: string) => string;
 /**
  * The toplevel of the repository containing `root`, or null when git is
  * unavailable or the project isn't a repo. Callers use it to decide which

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

@@ -11,6 +11,14 @@ export interface FolderMetaSource {
     include?: readonly string[];
     exclude?: readonly string[];
 }
+/**
+ * The folder-meta files a filesystem source contributes: `patterns` (every
+ * meta module name, shared `meta.$.*` included, by default) under the source's
+ * root, minus its `exclude` globs, dependencies, and build output, and only in
+ * folders its `include` globs reach. `blume translate` finds the meta files it
+ * translates through this too, so it covers exactly the ones the scan reads.
+ */
+export declare const findFolderMetaFiles: (source: FolderMetaSource, patterns?: readonly string[]) => Promise<string[]>;
 /**
  * Discover `meta.{ts,js,mjs}` files across the given filesystem sources. Keys are
  * the source's route prefix joined with the directory relative to that source's

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

@@ -1014,6 +1014,13 @@ export declare const blumeConfigSchema: z.ZodObject<{
         }, z.core.$catchall<z.ZodJSONSchema>>;
         requiredSecrets: z.ZodArray<z.ZodString>;
         runtimeDeps: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"one-dollar-stats">;
+        options: z.ZodObject<{
+            hostname: 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<"pirsch">;
         options: z.ZodObject<{

package/dist/types/core/sources/lower.d.ts

@@ -4,6 +4,10 @@
  * blocks) renders inline runs, wraps them in block syntax, and joins blocks
  * with blank lines; these helpers keep that Markdown identical across them.
  */
+/**
+ * CMS text as Markdown that renders as written, wherever it lands — a link
+ * label included, where GFM autolinks nothing, so every special is escaped.
+ */
 export declare const escapeMarkdownText: (text: string) => string;
 /** The marks a lowerer can put on an inline run. */
 export interface InlineMarks {
@@ -12,6 +16,17 @@ export interface InlineMarks {
     italic?: boolean;
     strike?: boolean;
 }
+/** A run of CMS text and the marks on it. */
+export interface InlineRun {
+    marks: InlineMarks;
+    text: string;
+}
+/** Inline Markdown a lowerer rendered itself: a link, an embed, a break. */
+export interface InlineMarkdown {
+    markdown: string;
+}
+/** One piece of a block's inline content, in order. */
+export type InlinePart = InlineMarkdown | InlineRun;
 /**
  * A code span whose delimiter outruns any backtick run inside it, padded with
  * a space on each side when the code starts or ends with a backtick (the
@@ -22,28 +37,26 @@ export declare const codeSpan: (code: string) => string;
  * A block's inline text, guarded where only the whole block can tell. Runs
  * are escaped one at a time, but "import" ending one run and a space or code
  * span opening the next form an MDX `import` statement only once they are
- * joined, and whitespace the first runs put in front of a block turns it into
- * an indented code block. Apply it to the joined text of a paragraph,
- * heading, quote, or list item — never to code.
+ * joined, whitespace the first runs put in front of a block turns it into
+ * an indented code block, two struck runs fuse into literal tildes, and a
+ * trailing ` #` is a heading's closing sequence. Apply it to the joined text
+ * of a paragraph, heading, quote, or list item — never to code.
  */
 export declare const guardBlockStart: (text: string) => string;
-/**
- * Wrap a text run in the Markdown for its marks. Code stays verbatim inside
- * the backticks (an escape would render as a backslash); everything else is
- * escaped first. Whitespace at either edge moves outside the delimiters,
- * since `** bold **` is not strong emphasis but `**bold**` is — editors
- * routinely bold a word together with the space after it.
- */
-export declare const renderInline: (text: string, marks: InlineMarks) => string;
+/** A block's inline content as Markdown. */
+export declare const renderInline: (parts: InlinePart[]) => string;
 /** A link or image destination as Markdown carries it verbatim. */
 export declare const destination: (url: string) => string;
 /**
- * A Markdown link, or the label alone when the target is missing — or unsafe:
- * CMS content is the editor's, not the site author's, so a destination that
- * isn't a web, mail, or relative address (`javascript:`, `data:`) never
- * becomes a clickable link on the docs site (see `safe-links.ts`).
+ * A Markdown link over inline parts, or the parts alone when the target is
+ * missing — or unsafe: CMS content is the editor's, not the site author's, so
+ * a destination that isn't a web, mail, or relative address (`javascript:`,
+ * `data:`) never becomes a clickable link on the docs site (see
+ * `safe-links.ts`). The parts stay parts then, so their runs merge with their
+ * neighbors'. A label escapes a bare URL too: GFM autolinks nothing inside a
+ * link, so its specials would read as syntax.
  */
-export declare const renderLink: (label: string, href?: string) => string;
+export declare const linkParts: (parts: InlinePart[], href?: string) => InlinePart[];
 /** The ATX prefix for a heading level, clamped to Markdown's six. */
 export declare const headingPrefix: (level: number) => string;
 /** Quote every line of a block. */

package/dist/types/core/sources/normalize.d.ts

@@ -21,6 +21,15 @@ export declare const slugify: (text: string) => string;
  * document. Each segment is slugged on its own and the separators kept.
  */
 export declare const slugifyPath: (text: string) => string;
+/**
+ * The error for a content file Astro's content loader can't read, or
+ * undefined when it can. A `#` or `?` anywhere in the path the loader is
+ * handed (`sdks/c#.md`, `faq/why?.md`) truncates the file URL it reads
+ * through, so the read fails with ENOENT and the page renders "Page not
+ * found" at its route. A source leaves such a file out of its scan and
+ * reports this instead of publishing a route that can never render.
+ */
+export declare const unloadablePathDiagnostic: (path: string, file: string) => Diagnostic | undefined;
 export declare const HTML_COMMENT: RegExp;
 export declare const INLINE_CODE: RegExp;
 /** A heading whose trailing `{#id}` marker is unescaped — see `BARE_CURLY_MARKER`. */
@@ -54,7 +63,10 @@ export interface BodyScan {
 /**
  * Scan a body for its headings, explicit HTML anchors, and unescaped `{#id}`
  * markers in one fence-aware walk (the same walk `extractHeadings` exposes for
- * headings alone).
+ * headings alone). The body is the page's content with its front matter
+ * already stripped — the renderers read front matter off the page and never
+ * again from its body — so a leading `---` block is a thematic break and
+ * content, in `.md` and `.mdx` alike.
  */
 export declare const scanBody: (body: string) => BodyScan;
 export declare const extractHeadings: (body: string) => Heading[];

package/dist/types/core/sources/watch.d.ts

@@ -32,14 +32,21 @@ export declare const baselineScanIgnore: () => string[];
  * the scan share the same never-content directory set.
  */
 export declare const BLUME_WATCH_IGNORE_DIRS: string[];
-/** Extract single-segment ignore dirs (`foo`) from `foo/**`-style excludes. */
+/**
+ * Extract root-anchored ignore dirs (`/foo`) from `foo/**`-style excludes. The
+ * scan's glob `foo/**` matches `foo` at the source root only, so the watcher
+ * skips that one directory: a nested `guides/foo/` is still content, and an
+ * edit there must still reload.
+ */
 export declare const excludeDirSegments: (patterns: readonly string[]) => string[];
 /**
  * Build a recursive-watch listener that fires `onChange` for content changes but
- * ignores events whose path crosses an ignored directory segment — one in
- * `ignoreDirs`, or one `ignoreSegment` rejects, for a scan whose skip rule is
- * a shape (every dot-name) rather than a list. A missing `filename` — rare;
- * the platform couldn't name the changed path — falls through to `onChange`
+ * ignores events whose path crosses an ignored directory — a segment named in
+ * `ignoreDirs` at any depth, or one `ignoreSegment` rejects, for a scan whose
+ * skip rule is a shape (every dot-name) rather than a list. An entry written
+ * with a leading slash (`/drafts`, see {@link excludeDirSegments}) names a
+ * directory at the watched root only. A missing `filename` — rare; the
+ * platform couldn't name the changed path — falls through to `onChange`
  * rather than silently dropping a real edit. Exported for testing.
  */
 export declare const ignoringWatchListener: (onChange: () => void, ignoreDirs?: Iterable<string>, ignoreSegment?: (segment: string) => boolean) => WatchListener<string>;

package/dist/types/core/standard-schema.d.ts

@@ -41,5 +41,10 @@ export interface StandardSchema<Input = unknown, Output = Input> {
  * Whether a config-supplied value implements the `~standard` contract. Generic
  * so it can decode any input at the config boundary (`z.custom` hands it the
  * raw config value) while narrowing whatever type the caller holds.
+ *
+ * The contract is the `~standard` property, whatever carries it: Zod and
+ * Valibot schemas are objects, but an ArkType type is a callable function. The
+ * optional-chained probe reads the property off either, and off `null`,
+ * `undefined`, or a primitive it finds nothing.
  */
 export declare const isStandardSchema: <T>(value: T) => value is T & StandardSchema;

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

@@ -8,10 +8,12 @@ import type { BlumeProject } from "../core/project-graph.ts";
  * 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.
+ * build, or `dist/client/<base>/` on Cloudflare, whose `_headers` goes to
+ * the root the platform serves above it). 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).

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

@@ -65,6 +65,11 @@ export interface VercelHeader {
     }[];
     source: string;
 }
+/**
+ * A literal path as `path-to-regexp` source text — what a `vercel.json`
+ * `source` is — with each syntax character escaped, so it matches only itself.
+ */
+export declare const escapeVercelSource: (path: string) => string;
 /**
  * The {@link headerRules} as `vercel.json` `headers` entries. Vercel reads no
  * `_headers` file, so a static deploy of `dist/` carries the same rules here —

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

@@ -103,6 +103,14 @@ export interface DeployPlatform {
     readsHeaderFiles: Record<DeployOutput, boolean>;
     /** The redirect files a static build writes, beside the manifest. */
     redirectFiles: RedirectFile[];
+    /**
+     * Whether the adapter moves a server build's client output under
+     * `deployment.base` (`dist/client/<base>/`, the directory Astro then hands
+     * `astro:build:done`) while the platform keeps serving `serverStaticDir`
+     * as the assets root. The files the platform reads there, like `_headers`,
+     * belong above the directory Astro reports.
+     */
+    serverClientUnderBase: boolean;
     /** Where a server build's deploy bundle lands. */
     serverOutputDir: (context: ProjectContext) => string;
     /** The directory a server build serves as static files. */

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

@@ -1,3 +1,5 @@
+import type { RouteSet } from "../core/locale-links.ts";
+import type { BlumeProject } from "../core/project-graph.ts";
 import type { ResolvedConfig } from "../core/schema.ts";
 import type { VercelHeader } from "./headers.ts";
 /**
@@ -15,29 +17,36 @@ type Redirect = ResolvedConfig["redirects"][number];
  * - `from` gains only `basePath`. Astro builds the match pattern with
  *   `deployment.base` already applied (`getPattern(segments, config.base)`), so
  *   adding it here would serve the redirect at `{base}{base}/from`.
- * - `to` gains the full `{deployment.base}{basePath}` stack. Astro resolves a
- *   destination that matches a known route by regenerating it from that route's
- *   segments, which carry no base — and passes an unmatched destination through
- *   verbatim. Neither path prepends `base`, so a root-relative `to` escapes the
- *   base entirely (withastro/astro#7774, still the behavior in Astro 7).
+ * - `to` gains the full `{deployment.base}{basePath}` stack, or the deployment
+ *   base alone for a public file (see {@link baseRedirectTarget}). Astro
+ *   resolves a destination that matches a known route by regenerating it from
+ *   that route's segments, which carry no base — and passes an unmatched
+ *   destination through verbatim. Neither path prepends `base`, so a
+ *   root-relative `to` escapes the base entirely (withastro/astro#7774, still
+ *   the behavior in Astro 7).
  *
- * Both sides are authored as if mounted at root; external `to` URLs pass
- * through. Idempotent, so a hand-written base isn't doubled.
+ * Both sides are authored as if mounted at root; `routes` (the served page
+ * routes, carrying `basePath`) tell a dotted page route like `/releases/v1.2`
+ * from a file. Idempotent, so a hand-written base isn't doubled.
  */
-export declare const applyBaseToAstroRedirects: (redirects: Redirect[], basePath: string, deployBase: string) => Redirect[];
+export declare const applyBaseToAstroRedirects: (redirects: Redirect[], basePath: string, deployBase: string, routes: RouteSet) => Redirect[];
 /**
  * Base a redirect for the host platform files below. Unlike Astro's config,
- * these are matched against the real served URL, so both sides carry the full
- * `{deployment.base}{basePath}` stack.
+ * these are matched against the real served URL, so `from` carries the full
+ * `{deployment.base}{basePath}` stack, and so does `to` unless it names a
+ * public file (see {@link baseRedirectTarget}).
  */
-export declare const applyBaseToPlatformRedirects: (redirects: Redirect[], basePath: string, deployBase: string) => Redirect[];
+export declare const applyBaseToPlatformRedirects: (redirects: Redirect[], basePath: string, deployBase: string, routes: RouteSet) => Redirect[];
 /**
  * The configured redirects as the host platform matches them, via
  * {@link applyBaseToPlatformRedirects}. The one basing every consumer must
  * share: the emitted redirect files and the Cloudflare worker-first redirect
  * exemptions both compare these paths against real served URLs.
  */
-export declare const platformRedirects: (config: ResolvedConfig) => Redirect[];
+export declare const platformRedirects: (project: {
+    config: ResolvedConfig;
+    manifest: Pick<BlumeProject["manifest"], "routes">;
+}) => Redirect[];
 /**
  * `_redirects` text (Netlify + Cloudflare Pages): `from to status` per line.
  * `force` appends Netlify's `!` to each status (`301!`), so the rule wins over
@@ -50,7 +59,9 @@ export declare const buildNetlifyRedirects: (redirects: Redirect[], force?: bool
  * header rules are given (see `buildVercelHeaders`). Uses `statusCode` (Vercel's
  * alternative to the boolean `permanent`) so the configured code ships exactly:
  * `permanent` would silently coerce a 301 to 308 and a 302 to 307, diverging
- * from the `_redirects` file, which preserves exact codes.
+ * from the `_redirects` file, which preserves exact codes. A `source` is a
+ * `path-to-regexp` pattern, so each exact `from` path is escaped: unescaped,
+ * `/c++-guide` fails the whole config and `/faq(old)` never matches.
  */
 export declare const buildVercelConfig: (redirects: Redirect[], headers?: readonly VercelHeader[]) => string;
 /** Structured manifest for hosts that need manual wiring. */

package/dist/types/markdown/directives.d.ts

@@ -0,0 +1,62 @@
+import type { MdastNode, MdastVisitorContext } from "./mdast.ts";
+export interface DirectiveNode extends MdastNode {
+    attributes?: Record<string, string | null | undefined> | null;
+    children?: MdastNode[] | null;
+    name: string;
+    position?: {
+        start?: {
+            offset?: number;
+        };
+        end?: {
+            offset?: number;
+        };
+    };
+}
+/**
+ * The visitor-context slice the directive visitors use. `source` is the page
+ * the directive offsets index into; without it the literal fallback rebuilds
+ * a directive from its node instead. `parent` walks up to an enclosing
+ * container directive, which renders the directives inside it itself.
+ */
+interface DirectiveVisitorContext extends MdastVisitorContext {
+    parent?: (node: MdastNode) => MdastNode | undefined;
+    source?: string;
+}
+/** Directive names that map directly onto a Callout type. */
+export declare const CALLOUT_TYPES: ReadonlySet<string>;
+/** Friendly aliases for the canonical Callout types. */
+interface CalloutAliases {
+    [alias: string]: string;
+}
+export declare const CALLOUT_ALIASES: Readonly<CalloutAliases>;
+/** Resolve a directive name to a Callout type, or `null` if it is not one. */
+export declare const calloutTypeFor: (name: string) => string | null;
+/**
+ * A text or leaf directive exactly as the author wrote it. The slice by
+ * offsets is the exact text — `[label]` and `{attrs}` included — and is
+ * trusted only when it opens with the directive's own marker and name;
+ * content an `<include>` spliced in carries no offsets into this page, so it
+ * is rebuilt from the node instead.
+ */
+export declare const directiveSource: (node: DirectiveNode, marker: string, source: string) => string;
+/**
+ * Satteri MDAST plugin for directives. Container directives (`:::note`,
+ * `:::warning`, `:::tip`, …) map onto Blume's `<Callout>` component, and any
+ * other container renders its body between its literal fence lines (see
+ * {@link renderContainer}).
+ *
+ * Blume handles no text (`:name`) or leaf (`::name`) directives, and prose is
+ * full of text that parses as one — `16:9`, `10:30am`, `og:image`,
+ * `pets:read` — so both render as the literal source the author wrote instead
+ * of vanishing.
+ */
+export declare const directiveToCalloutPlugin: () => {
+    containerDirective(node: DirectiveNode, ctx: DirectiveVisitorContext): void;
+    leafDirective: (node: DirectiveNode, ctx: DirectiveVisitorContext) => void;
+    name: string;
+    options: {
+        position: boolean;
+    };
+    textDirective: (node: DirectiveNode, ctx: DirectiveVisitorContext) => void;
+};
+export {};

package/dist/types/markdown/features.d.ts

@@ -19,3 +19,24 @@ export declare const MDX_FEATURES: {
     subscript: true;
     superscript: true;
 };
+/**
+ * The feature sets for a page body, once its front matter is off. Astro reads
+ * a page's front matter itself and hands the renderer the body alone, and the
+ * search extractor strips it first too — so front matter parsing is off here:
+ * left on, a body that opens with a `---` rule read everything up to the next
+ * `---` line as front matter and dropped it from the page.
+ */
+export declare const MARKDOWN_BODY_FEATURES: {
+    frontmatter: false;
+    subscript: true;
+    superscript: true;
+};
+export declare const MDX_BODY_FEATURES: {
+    frontmatter: false;
+    directive: true;
+    math: {
+        singleDollarTextMath: false;
+    };
+    subscript: true;
+    superscript: true;
+};