blume 0.5.3 → 0.6.0

package/src/theme/icons.ts

@@ -1,16 +1,11 @@
 /**
- * Icon resolution backed by the open Iconify icon sets — Font Awesome (free),
- * Lucide, and Tabler — the three libraries Mintlify exposes. Resolution runs at
+ * Icon resolution backed by the open Iconify Lucide set. Resolution runs at
  * **build time, server-side**, and returns ready-to-inline SVG, so icons stay
- * zero-JS and fully self-contained (no runtime CDN fetch, unlike Mintlify).
+ * zero-JS and fully self-contained (no runtime CDN fetch).
  *
  * Because the Iconify set data is large, this module must only be imported from
  * server contexts (`.astro` frontmatter, the CLI). Client scripts use the tiny
  * hand-inlined set in `./chrome-icons.ts` instead.
- *
- * Coverage vs Mintlify: full parity for every Font Awesome *free* name, Lucide,
- * and Tabler. Font Awesome Pro styles (`light`/`thin`/`duotone`/`sharp-solid`)
- * aren't in the open data, so they fall back to `solid`.
  */
 import { createRequire } from "node:module";
 
@@ -25,61 +20,22 @@ const requireJson = createRequire(import.meta.url);
 const loadSet = (pkg: string): IconifyJSON => requireJson(pkg) as IconifyJSON;
 
 const SETS: Record<string, IconifyJSON> = {
-  "fa6-brands": loadSet("@iconify-json/fa6-brands/icons.json"),
-  "fa6-regular": loadSet("@iconify-json/fa6-regular/icons.json"),
-  "fa6-solid": loadSet("@iconify-json/fa6-solid/icons.json"),
   lucide: loadSet("@iconify-json/lucide/icons.json"),
-  tabler: loadSet("@iconify-json/tabler/icons.json"),
 };
 
-/** Blume's default library when a project sets no `icons.library`. */
+/** Blume's only icon library. */
 const DEFAULT_SET = "lucide";
 
-/** `icons.library` config value → Iconify set. */
-const LIBRARY_SETS: Record<string, string> = {
-  fa: "fa6-solid",
-  "font-awesome": "fa6-solid",
-  fontawesome: "fa6-solid",
-  lucide: "lucide",
-  tabler: "tabler",
-};
-
-/**
- * Mintlify Font Awesome `iconType` → Iconify set. The Pro-only styles
- * (`light`/`thin`/`duotone`/`sharp-solid`) aren't in the free data, so they map
- * to `solid` rather than render nothing.
- */
-const ICON_TYPE_SETS: Record<string, string> = {
-  brands: "fa6-brands",
-  duotone: "fa6-solid",
-  light: "fa6-solid",
-  regular: "fa6-regular",
-  "sharp-solid": "fa6-solid",
-  solid: "fa6-solid",
-  thin: "fa6-solid",
-};
-
-/** Explicit `prefix:name` prefixes (Iconify prefixes + common FA aliases). */
+/** Explicit `prefix:name` prefixes. Lucide is the only bundled set. */
 const PREFIX_SETS: Record<string, string> = {
-  ...LIBRARY_SETS,
-  fa: "fa6-solid",
-  "fa-brands": "fa6-brands",
-  "fa-regular": "fa6-regular",
-  "fa-solid": "fa6-solid",
-  "fa6-brands": "fa6-brands",
-  "fa6-regular": "fa6-regular",
-  "fa6-solid": "fa6-solid",
-  fab: "fa6-brands",
-  far: "fa6-regular",
-  fas: "fa6-solid",
-  ti: "tabler",
+  lucide: "lucide",
 };
 
 /**
- * Own-property map lookup. Icon names and library/iconType hints come from
- * content and config, so a value like `constructor:x` would otherwise resolve
- * an Object.prototype member (a function) and crash resolution deep in the
- * build with no pointer to the offending page.
+ * Own-property map lookup. Icon names come from content and config, so a value
+ * like `constructor:x` would otherwise resolve an Object.prototype member (a
+ * function) and crash resolution deep in the build with no pointer to the
+ * offending page.
  */
 const ownEntry = <T>(map: Record<string, T>, key: string): T | undefined =>
   Object.hasOwn(map, key) ? map[key] : undefined;
@@ -89,40 +45,16 @@ export interface ResolvedIcon {
   body: string;
   /** The resolved icon name. */
   name: string;
-  /** The icon's viewBox, which varies per library (24×24, 512-height, …). */
+  /** The icon's viewBox (Lucide is 24×24). */
   viewBox: string;
 }
 
-export interface ResolveIconOptions {
-  /** Font Awesome style selector (`solid`, `regular`, `brands`, …). */
-  iconType?: string;
-  /** Default library for a bare name (`fontawesome` | `lucide` | `tabler`). */
-  library?: string;
-}
-
 const normalize = (name: string): string =>
   name
     .trim()
     .toLowerCase()
     .replaceAll(/[\s_]+/gu, "-");
 
-/** Which set a bare name resolves against, given library/iconType hints. */
-const setFor = (options: ResolveIconOptions): string => {
-  if (options.iconType) {
-    const set = ownEntry(ICON_TYPE_SETS, normalize(options.iconType));
-    if (set) {
-      return set;
-    }
-  }
-  if (options.library) {
-    const set = ownEntry(LIBRARY_SETS, normalize(options.library));
-    if (set) {
-      return set;
-    }
-  }
-  return DEFAULT_SET;
-};
-
 const fromSet = (setName: string, iconName: string): ResolvedIcon | null => {
   const set = ownEntry(SETS, setName);
   const data = set && getIconData(set, iconName);
@@ -133,46 +65,23 @@ const fromSet = (setName: string, iconName: string): ResolvedIcon | null => {
   return { body, name: iconName, viewBox: attributes.viewBox };
 };
 
-// Font Awesome splits brands into their own set, so a bare `github` under a
-// solid/regular default still resolves.
-const fromFaSet = (setName: string, name: string): ResolvedIcon | null =>
-  fromSet(setName, name) ?? fromSet("fa6-brands", name);
-
-const resolveInSet = (setName: string, name: string): ResolvedIcon | null =>
-  setName.startsWith("fa6-")
-    ? fromFaSet(setName, name)
-    : fromSet(setName, name);
-
 /**
- * Resolve an icon name to inline SVG. Honors an explicit `prefix:name`
- * (`lucide:rocket`, `fa6-brands:github`), then `iconType`, then the configured
- * `library`, falling back to Lucide.
+ * Resolve an icon name to inline SVG. Honors an explicit `lucide:name` prefix;
+ * a bare name resolves against Lucide.
  */
-export const resolveIcon = (
-  name: string,
-  options: ResolveIconOptions = {}
-): ResolvedIcon | null => {
+export const resolveIcon = (name: string): ResolvedIcon | null => {
   const normalized = normalize(name);
   const colon = normalized.indexOf(":");
   if (colon > 0) {
     const setName = ownEntry(PREFIX_SETS, normalized.slice(0, colon));
-    if (setName) {
-      return resolveInSet(setName, normalized.slice(colon + 1));
-    }
+    return setName ? fromSet(setName, normalized.slice(colon + 1)) : null;
   }
-  return resolveInSet(setFor(options), normalized);
+  return fromSet(DEFAULT_SET, normalized);
 };
 
-/**
- * Whether a name resolves to a known icon. Without a library hint this checks
- * every bundled set, so a valid Font Awesome/Tabler name isn't flagged as a typo
- * just because the project's default library is Lucide.
- */
-export const hasIcon = (
-  name: string,
-  options: ResolveIconOptions = {}
-): boolean => {
-  if (resolveIcon(name, options)) {
+/** Whether a name resolves to a known Lucide icon. */
+export const hasIcon = (name: string): boolean => {
+  if (resolveIcon(name)) {
     return true;
   }
   const normalized = normalize(name);

package/src/theme/palette.ts

@@ -52,36 +52,11 @@ const backgroundImageCss = (image: string): string =>
 const cssToken = (name: string, value?: string | null): string[] =>
   value ? [`  ${name}: ${value};`] : [];
 
-const backgroundDecorationCss = (
-  decoration: ResolvedConfig["theme"]["backgroundDecoration"]
-): string => {
-  if (decoration === "gradient") {
-    return `  --blume-background-decoration: radial-gradient(circle at top left, color-mix(in oklab, var(--blume-accent) 18%, transparent), transparent 28rem), radial-gradient(circle at top right, color-mix(in oklab, var(--blume-action) 12%, transparent), transparent 24rem);
-  --blume-background-decoration-repeat: no-repeat, no-repeat;
-  --blume-background-decoration-size: auto, auto;
-`;
-  }
-  if (decoration === "grid") {
-    return `  --blume-background-decoration: linear-gradient(var(--blume-border) 1px, transparent 1px), linear-gradient(90deg, var(--blume-border) 1px, transparent 1px);
-  --blume-background-decoration-repeat: repeat, repeat;
-  --blume-background-decoration-size: 2rem 2rem, 2rem 2rem;
-`;
-  }
-  if (decoration === "windows") {
-    return `  --blume-background-decoration: linear-gradient(90deg, color-mix(in oklab, var(--blume-border) 70%, transparent) 1px, transparent 1px), linear-gradient(var(--blume-border) 1px, transparent 1px);
-  --blume-background-decoration-repeat: repeat, repeat;
-  --blume-background-decoration-size: 7rem 4.5rem, 7rem 4.5rem;
-`;
-  }
-  return "";
-};
-
 const themeRootCss = (
   theme: ResolvedConfig["theme"],
   options: {
     accent: string;
     action: string | null;
-    backgroundDecoration: string;
     radius: string;
   }
 ): string =>
@@ -92,12 +67,13 @@ const themeRootCss = (
       "--blume-action-foreground",
       options.action ? "oklch(1 0 0)" : null
     ),
-    ...cssToken("--blume-background", safeColorOrNull(theme.background)),
+    ...cssToken("--blume-background", safeColorOrNull(theme.background?.light)),
     ...cssToken(
       "--blume-background-image",
-      theme.backgroundImage ? backgroundImageCss(theme.backgroundImage) : null
+      theme.backgroundImage?.light
+        ? backgroundImageCss(theme.backgroundImage.light)
+        : null
     ),
-    options.backgroundDecoration.trimEnd(),
     `  --blume-radius: ${options.radius};`,
   ]
     .filter(Boolean)
@@ -108,13 +84,12 @@ const themeDarkCss = (
   options: {
     accent: string;
     action: string | null;
-    backgroundDecoration: string;
   }
 ): string => {
-  // Mode-shared tokens (accent, action, decoration) must be re-declared here:
-  // the base stylesheet's own `:root[data-theme="dark"]` block outranks the
-  // `:root` config tokens on specificity, so without this block dark mode
-  // would silently keep its neutral defaults and ignore the config.
+  // Mode-shared tokens (accent, action) must be re-declared here: the base
+  // stylesheet's own `:root[data-theme="dark"]` block outranks the `:root`
+  // config tokens on specificity, so without this block dark mode would
+  // silently keep its neutral defaults and ignore the config.
   const tokens = [
     `  --blume-accent: ${options.accent};`,
     "  --blume-accent-foreground: oklch(1 0 0);",
@@ -123,14 +98,13 @@ const themeDarkCss = (
       "--blume-action-foreground",
       options.action ? "oklch(1 0 0)" : null
     ),
-    ...cssToken("--blume-background", safeColorOrNull(theme.backgroundDark)),
+    ...cssToken("--blume-background", safeColorOrNull(theme.background?.dark)),
     ...cssToken(
       "--blume-background-image",
-      theme.backgroundImageDark
-        ? backgroundImageCss(theme.backgroundImageDark)
+      theme.backgroundImage?.dark
+        ? backgroundImageCss(theme.backgroundImage.dark)
         : null
     ),
-    options.backgroundDecoration.trimEnd(),
   ].filter(Boolean);
   return `:root[data-theme="dark"] {
 ${tokens.join("\n")}
@@ -139,12 +113,18 @@ ${tokens.join("\n")}
 };
 
 /**
- * Resolve the configured accent to a CSS color. A named accent resolves to its
- * preset; any other value is treated as a raw CSS color so users can pass
- * arbitrary colors without a config change.
+ * Resolve the configured accent to per-mode CSS colors. A named accent
+ * resolves to its preset; any other value is treated as a raw CSS color so
+ * users can pass arbitrary colors without a config change. A string accent
+ * has already been normalized by the config schema to the same color for
+ * both modes.
  */
-export const resolveAccent = (theme: ResolvedConfig["theme"]): string =>
-  presetOrColor(theme.accent);
+export const resolveAccent = (
+  theme: ResolvedConfig["theme"]
+): { dark: string; light: string } => ({
+  dark: presetOrColor(theme.accent.dark),
+  light: presetOrColor(theme.accent.light),
+});
 
 /** Resolve the configured radius preset to a CSS length. */
 export const resolveRadius = (theme: ResolvedConfig["theme"]): string =>
@@ -156,23 +136,17 @@ export const resolveRadius = (theme: ResolvedConfig["theme"]): string =>
  * arbitrary colors without a config change.
  */
 export const buildThemeCss = (theme: ResolvedConfig["theme"]): string => {
-  const accent = presetOrColor(theme.accent);
-  const accentDark = theme.accentDark ? presetOrColor(theme.accentDark) : null;
+  const accent = resolveAccent(theme);
   const action = theme.action ? presetOrColor(theme.action) : null;
-  const backgroundDecoration = backgroundDecorationCss(
-    theme.backgroundDecoration
-  );
   const radius = RADII[theme.radius];
   const root = themeRootCss(theme, {
-    accent,
+    accent: accent.light,
     action,
-    backgroundDecoration,
     radius,
   });
   const dark = themeDarkCss(theme, {
-    accent: accentDark ?? accent,
+    accent: accent.dark,
     action,
-    backgroundDecoration,
   });
 
   return `/* Generated by Blume from theme config. */

package/src/theme/twoslash.ts

@@ -33,9 +33,14 @@ const OVERRIDES = `
 
 /* Popups are absolutely positioned and must escape the pre's scroll container.
    The base prose pre rule (from the typography layer) wins the cascade here
-   despite lower specificity, so !important is needed to force visibility. */
+   despite lower specificity, so !important is needed to force visibility.
+   Regular code blocks scroll their inner code element and carry the horizontal
+   padding there; twoslash code opts out of that scroller (popups again), so the
+   padding is restored on the pre. */
 .prose pre.twoslash {
   overflow: visible !important;
+  padding-left: 1.25rem;
+  padding-right: 1.25rem;
 }
 
 /* The rich renderer renders each popup's type signature as a nested Shiki

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

@@ -1,24 +0,0 @@
-import type { BlumeConfig } from "./schema.ts";
-/** A detected docs-tool config that Blume can serve without a migration. */
-export interface BridgeDetection {
-    /** Which foreign docs tool was detected. */
-    tool: "mintlify";
-    /** Absolute path of the detected config file (`docs.json`/`mint.json`). */
-    configFile: string;
-    /** A Blume config synthesized from the foreign config, ready to validate. */
-    raw: BlumeConfig;
-}
-/**
- * Detect a Mintlify project at `root` and synthesize an equivalent Blume config.
- *
- * "Bridge mode" lets a team swap `mintlify dev` for `blume dev` with no file
- * changes: `docs.json` is translated to Blume config (`loadMintlifyConfig`) and
- * its content block is rewired to a single `mintlify` content source, which
- * transforms each MDX page to Blume idiom at scan time. The original
- * `content.root`/`exclude` and `variables` move onto the source (Blume has no
- * runtime variable substitution, so globals are inlined into content there).
- *
- * Returns `null` when no Mintlify config is present. Only called when no
- * `blume.config.*` exists, so an explicit Blume config always takes precedence.
- */
-export declare const detectMintlifyBridge: (root: string) => Promise<BridgeDetection | null>;

package/dist/types/core/package-json.d.ts

@@ -1,12 +0,0 @@
-/**
- * Derive a valid npm package name from a directory name, falling back to
- * `docs` when nothing usable remains.
- */
-export declare const toPackageName: (raw: string) => string;
-/**
- * A minimal, runnable `package.json` body for a Blume project: the `blume`
- * dependency pinned to the installed version plus `dev`/`build`/`doctor`
- * scripts, so `npm install && npm run dev` works immediately. Shared by
- * `blume init` and the migrators, which scaffold one when a project has none.
- */
-export declare const blumePackageJson: (name: string) => string;

package/dist/types/migrate/mintlify/assets.d.ts

@@ -1,8 +0,0 @@
-import type { BlumeConfig } from "../../core/schema.ts";
-/**
- * Top-level path segments referenced as static assets by a Mintlify config
- * (the conventional `/images`, plus logo/favicon/background paths). These are
- * the root-served folders Mintlify exposes at the site root; Blume serves them
- * via `content.assets` (bridge) or relocates them under `public/` (migrator).
- */
-export declare const assetSegments: (config: BlumeConfig) => string[];

package/dist/types/migrate/mintlify/config.d.ts

@@ -1,16 +0,0 @@
-import type { BlumeConfig } from "../../core/schema.ts";
-type JsonObject = Record<string, unknown>;
-export interface MintlifyRedirectPartition {
-    /** Static redirects Blume can honor, translated to Blume's `from`/`to` shape. */
-    kept: NonNullable<BlumeConfig["redirects"]>;
-    /** Source paths of dynamic redirects dropped because Blume can't model them. */
-    dropped: string[];
-}
-/**
- * Split a spec's redirects into the static ones Blume emits and the dynamic
- * (wildcard/param) ones it drops. Keeping a dynamic redirect crashes the Astro
- * build, so the migrator surfaces the dropped sources as a warning instead.
- */
-export declare const partitionMintlifyRedirects: (spec: JsonObject) => MintlifyRedirectPartition;
-export declare const loadMintlifyConfig: (root: string, file: string) => Promise<BlumeConfig>;
-export {};

package/dist/types/migrate/mintlify/i18n.d.ts

@@ -1,7 +0,0 @@
-import type { BlumeConfig } from "../../core/schema.ts";
-/**
- * Map a Mintlify `navigation.languages[]` array to a Blume `i18n` config. The
- * entry marked `default: true` becomes `defaultLocale`; translated content
- * already lives in ISO-code directories, which match Blume's `dir` parser.
- */
-export declare const mintlifyI18n: (spec: Record<string, unknown>) => BlumeConfig["i18n"] | null;

package/dist/types/migrate/shared.d.ts

@@ -1,153 +0,0 @@
-import type { BlumeConfig } from "../core/schema.ts";
-/**
- * Whether `candidate` resolves to a path inside `root` (or is `root` itself).
- * Guards migrators against `../` traversal in author-controlled source paths
- * (`pages` entries, `<include>` targets) that would otherwise read or move
- * files outside the docs tree.
- */
-export declare const isInsideRoot: (root: string, candidate: string) => boolean;
-/**
- * Framework-agnostic helpers shared by more than one migrator. Each piece here
- * was generalized from a migrator-specific implementation so Mintlify, Nextra,
- * and future migrators converge on a single copy.
- */
-/** Serialize a `BlumeConfig` to a `blume.config.ts` at the project root. */
-export declare const writeBlumeConfig: (root: string, config: BlumeConfig) => Promise<void>;
-/**
- * Rewrite a migrated project's npm scripts off the old framework's CLI. A
- * `dev`/`build`/`start` script whose command invokes `cli` (e.g. `/\bnext\b/`)
- * is repointed at the matching Blume command (`start` -> `blume preview`); a
- * script whose command matches `remove` (e.g. a `fumadocs-mdx` postinstall) is
- * dropped. Scripts that don't match either are left untouched, so custom tasks
- * survive. Returns true when `package.json` changed.
- */
-export declare const rewriteFrameworkScripts: (root: string, cli: RegExp, remove?: RegExp) => Promise<boolean>;
-/** Of the candidate project-relative paths, the ones that still exist — the old
- * framework files a migration leaves behind for the user to remove by hand. */
-export declare const leftoverFiles: (root: string, candidates: string[]) => string[];
-/**
- * Scaffold a minimal, runnable `package.json` when the migrated project has
- * none. Config-only sources (e.g. a Mintlify `docs.json`) ship no npm manifest,
- * so a fresh migration has nothing to run `blume dev` with; this writes a stub
- * with `blume` as a dependency and `dev`/`build`/`doctor` scripts, making
- * `npm install && npm run dev` work immediately. A pre-existing `package.json`
- * is left untouched — {@link rewriteFrameworkScripts} repoints those instead.
- * Returns true when a file was created.
- */
-export declare const ensurePackageJson: (root: string) => Promise<boolean>;
-/**
- * Remove every match of an import pattern, collapsing the blank gap each
- * removal leaves behind — without touching blank runs elsewhere in the
- * document (double blank lines inside code fences are real content that a
- * whole-document `\n{3,}` collapse used to corrupt).
- */
-export declare const stripImports: (source: string, pattern: RegExp) => string;
-export interface CalloutRewriteOptions {
-    /** Directive for a type-bearing tag with no `type` attribute (e.g. bare `<Callout>`). */
-    defaultDirective: string;
-    /** Tag names whose directive is fixed by the tag itself (e.g. `<Warning>`). */
-    tagDirectives: Record<string, string>;
-    /** Component tag names to convert. */
-    tags: string[];
-    /** `type="…"` values mapped to Blume directive names. */
-    typeDirectives: Record<string, string>;
-}
-/** Read a quoted string attribute (`name="…"` or `name='…'`) from a tag. */
-export declare const attribute: (attrs: string, name: string) => string | undefined;
-/**
- * Find the `>` that closes an opening JSX tag, honoring quotes and `{…}`
- * expression attributes (so a `>` inside `icon={"<svg…>"}` is not mistaken for
- * the tag end). Returns -1 if unterminated.
- */
-export declare const findOpenTagEnd: (source: string, from: number) => number;
-/**
- * Convert callout-style JSX components into Blume `:::` directives. Uses a
- * quote/brace-aware tag scanner so callouts carrying JSX-expression attributes
- * (e.g. inline-SVG icons) convert cleanly; non-convertible attributes (icons,
- * colors, emoji) are dropped. A tag whose resolved directive is unknown is left
- * untouched.
- */
-export declare const rewriteCallouts: (source: string, options: CalloutRewriteOptions) => string;
-/**
- * Remove frontmatter keys Blume's strict page schema would reject (e.g. stray
- * `og:*`/`twitter:*` metatags) so the migrated page validates, reporting what
- * was dropped. Validation errors other than stray keys are left for `blume dev`
- * to surface.
- */
-export declare const stripUnknownPageMeta: (data: Record<string, unknown>) => {
-    data: Record<string, unknown>;
-    removed: string[];
-};
-/**
- * Rename a JSX tag (open and close) while preserving its attributes. The
- * trailing lookahead means a longer tag (e.g. `CardGrid`) is never matched by a
- * rule for its shorter prefix (`Card`), so prefix-sharing renames can be chained
- * — run the item-level rename before the container rename.
- */
-export declare const renameTag: (source: string, from: string, to: string) => string;
-/**
- * Static readers for JS/TS config files (Nextra `_meta`, Starlight
- * `astro.config`). Config is parsed by walking the source as text — quote-,
- * comment-, and bracket-aware — rather than executing user code, matching the
- * other migrators (which never eval). Values that aren't pure literals (an
- * identifier, call, JSX, or interpolated template) are reported as `UNPARSEABLE`
- * so the caller can drop the field and warn.
- */
-/** Index of a string within a JS source: the close quote matching `s[open]`. */
-export declare const findStringEnd: (s: string, open: number) => number;
-export declare const unescapeString: (inner: string) => string;
-export interface ObjectScanResult {
-    end: number;
-    entries: string[];
-}
-/**
- * Walk a `{…}` object literal starting at `openIndex`, returning the matching
- * close-brace index and the raw `key: value` text of each top-level entry.
- * Quote-, comment-, and bracket-aware so commas/braces nested in strings,
- * arrays, or child objects don't split entries. Returns null if unterminated.
- */
-export declare const scanObject: (source: string, openIndex: number) => ObjectScanResult | null;
-export interface ArrayScanResult {
-    elements: string[];
-    end: number;
-}
-/**
- * Walk a `[…]` array literal starting at `openIndex`, returning the matching
- * close-bracket index and the raw text of each top-level element. The sibling of
- * {@link scanObject}; a trailing comma yields no empty element.
- */
-export declare const scanArray: (source: string, openIndex: number) => ArrayScanResult | null;
-/**
- * Strip `//` and block comments so they don't leak into entry text (the scanner
- * splits on slices, so an inter-entry comment would otherwise attach to the next
- * entry). String literals are preserved verbatim.
- */
-export declare const stripJsComments: (source: string) => string;
-export interface KeyValue {
-    key: string;
-    value: string;
-}
-/** Split a raw `key: value` entry at its top-level colon. */
-export declare const splitKeyValue: (entry: string) => KeyValue | null;
-/** Read an object key, unquoting it when it is a string literal. */
-export declare const parseKey: (key: string) => string;
-/** Read a clean string literal value, or null if it's an expression. */
-export declare const readString: (value: string) => string | null;
-/** A value that isn't a pure literal (identifier, call, JSX, computed, …). */
-export declare const UNPARSEABLE: unique symbol;
-export type LiteralValue = LiteralValue[] | boolean | null | number | string | typeof UNPARSEABLE | {
-    [key: string]: LiteralValue;
-};
-/**
- * Evaluate a JS literal expression (string / number / boolean / null / array /
- * object) into its value without executing it. Anything else resolves to
- * {@link UNPARSEABLE}; inside arrays the sentinel keeps the element's position,
- * inside objects it stays as the field's value so the caller can warn and drop.
- */
-export declare const parseLiteral: (source: string) => LiteralValue;
-/** Narrow a parsed literal to a string. */
-export declare const asLiteralString: (value: LiteralValue | undefined) => string | undefined;
-/** Narrow a parsed literal to a plain object (not an array or `UNPARSEABLE`). */
-export declare const isLiteralObject: (value: LiteralValue | undefined) => value is Record<string, LiteralValue>;
-/** Narrow a parsed literal to an array. */
-export declare const asLiteralArray: (value: LiteralValue | undefined) => LiteralValue[] | undefined;

package/docs/advanced/bridge.mdx

@@ -1,76 +0,0 @@
----
-title: Bridge
-description: Run blume dev directly on a Mintlify codebase — no config, no migration, no file changes. Blume detects docs.json and serves it in place.
----
-
-Bridge mode lets you point Blume at a **Mintlify** project and run it as-is. There's no config to write and no migration to commit: drop `blume dev` into a directory that has a `docs.json` (or legacy `mint.json`) and Blume detects it, synthesizes an equivalent config in memory, and serves your existing MDX — transformed to Blume idiom on the fly, on disk untouched.
-
-```bash
-cd my-mintlify-docs
-npx blume dev
-```
-
-```txt
-ℹ Detected docs.json — running in Mintlify bridge mode (no migration).
-  Run "blume migrate mintlify" to convert permanently.
-```
-
-It's the zero-commitment way to see what your docs look like on Blume — you can keep running `mintlify dev` in one terminal and `blume dev` in another, side by side, and decide later.
-
-## When it activates
-
-Bridge mode is entirely automatic, gated on two conditions:
-
-- **No Blume config.** There's no `blume.config.{ts,js,mjs}` at the project root. An explicit Blume config always wins — the moment one exists, Blume runs a normal project and bridge mode never triggers.
-- **A Mintlify config is present.** A `docs.json` or `mint.json` sits at the root.
-
-With both true, Blume treats the Mintlify config as its source of truth for that run.
-
-:::note
-Bridge mode applies to `blume build` too, not just `blume dev` — you can produce a static site from an unconverted Mintlify project. Only `blume dev` prints the detection notice.
-:::
-
-## What happens under the hood
-
-Bridge mode is the **read-only twin** of [`blume migrate mintlify`](/docs/advanced/migrate#mintlify): the same translation, without writing anything back.
-
-- **Config is synthesized in memory.** `docs.json` is translated to a Blume config — navigation, theme, and chrome mapped across — exactly as the migrator would, but nothing is written to disk.
-- **Content is served through a Mintlify source.** The config's content block is rewired to a single [`mintlify` content source](/docs/content/sources) rooted at the project. Each MDX page is transformed to Blume markup **at scan time** as it's read, so your files never change.
-- **Variables are inlined at scan time.** `docs.json` `variables` (`{{name}}`) are substituted into content as it's scanned — Blume has no runtime substitution.
-- **Assets are served in place.** Referenced folders like `images/` are served through [`content.assets`](/docs/content/sources) rather than moved to `public/`, so nothing is relocated.
-- **Languages map to i18n.** A multi-language `docs.json` maps to Blume's [`i18n`](/docs/content/i18n), with the language switch handled by Blume's locale routing instead of a nav selector.
-
-Because it reads the same `docs.json` and runs the same transforms, what you see in bridge mode is what you'd get from a full migration.
-
-## Bridge vs. migrate
-
-<CardGroup cols={2}>
-  <Card title="Bridge mode" icon="cable">
-    **Try Blume with zero changes.** Nothing is written; your Mintlify project
-    stays exactly as it is. Ideal for evaluating Blume, running both dev servers
-    side by side, or a reversible spike.
-  </Card>
-  <Card title="Migrate" href="/docs/advanced/migrate" icon="arrow-right">
-    **Convert for good.** [`blume migrate mintlify`](/docs/advanced/migrate)
-    rewrites your pages, config, and assets in place so Blume becomes the source
-    of truth. Do this once you've decided to switch.
-  </Card>
-</CardGroup>
-
-Everything you can do in bridge mode, you can do permanently by migrating — bridge is the preview, migrate is the commit.
-
-## Limitations
-
-- **Mintlify only.** Bridge detection is Mintlify-specific. The other frameworks — Fumadocs, Nextra, Starlight — need a [one-shot migration](/docs/advanced/migrate).
-- **Same idiom gaps as the migrator.** Components without a Blume equivalent are transformed on a best-effort basis; when you hit one, [migrate](/docs/advanced/migrate) and address the warnings, or switch that page to a Blume-native equivalent such as the [OpenAPI reference](/docs/advanced/api-reference).
-- **No runtime variables.** As with a migration, `{{variable}}` values are inlined at scan time rather than substituted at runtime.
-
-<CardGroup cols={2}>
-  <Card title="Migrate" href="/docs/advanced/migrate" icon="arrow-right">
-    Convert a Mintlify, Fumadocs, Nextra, or Starlight project permanently.
-  </Card>
-  <Card title="Content sources" href="/docs/content/sources" icon="folder-tree">
-    How the `mintlify` source and `content.assets` fit into Blume's content
-    graph.
-  </Card>
-</CardGroup>