@takazudo/zudo-doc 3.2.0 → 4.0.0

package/dist/code-syntax/mermaid-init-script.d.ts

@@ -20,30 +20,9 @@ export declare const MERMAID_CDN_MODULE_URL = "https://esm.sh/mermaid@11.15.0";
 /**
  * Build the inline init script with a caller-supplied module URL.
  *
- * Why a builder (vs. just exporting `MERMAID_INIT_SCRIPT`): the
- * constant interpolates `MERMAID_CDN_MODULE_URL` at module-load time,
- * so reassigning the exported binding has no runtime effect — ESM
- * exports are read-only and the script string is already frozen by
- * the time consumers see it. Hosts that need a self-hosted /
+ * Hosts that need a self-hosted /
  * version-pinned / CSP-allowlisted mermaid URL call this builder
  * with their URL and pass the result to `<MermaidInit script={…}/>`
  * (or to their own `<script dangerouslySetInnerHTML>` site).
- *
- * The default-URL flow stays available via `MERMAID_INIT_SCRIPT`
- * (built once below by calling this builder with
- * `MERMAID_CDN_MODULE_URL`) so existing callers keep working
- * unchanged.
  */
 export declare function buildMermaidInitScript(cdnUrl: string): string;
-/**
- * Default-URL init script. Built once at module load by passing
- * `MERMAID_CDN_MODULE_URL` to `buildMermaidInitScript`. Kept as the
- * primary export for backward compatibility — `<MermaidInit/>` (no
- * props) and any direct consumer that grabs this string both end up
- * importing mermaid from `https://esm.sh/mermaid@11`.
- *
- * For a custom URL (self-hosted mirror, version-pinned package,
- * CSP-allowlisted host) call `buildMermaidInitScript(yourUrl)` and
- * pass the result to `<MermaidInit script={…}/>`.
- */
-export declare const MERMAID_INIT_SCRIPT: string;

package/dist/code-syntax/mermaid-init-script.js

@@ -396,9 +396,7 @@ function buildMermaidInitScript(cdnUrl) {
   });
 })();`;
 }
-const MERMAID_INIT_SCRIPT = buildMermaidInitScript(MERMAID_CDN_MODULE_URL);
 export {
   MERMAID_CDN_MODULE_URL,
-  MERMAID_INIT_SCRIPT,
   buildMermaidInitScript
 };

package/dist/code-syntax/mermaid-init.d.ts

@@ -42,4 +42,3 @@ export interface MermaidInitProps {
  * changes the color scheme via the color-tweak panel.
  */
 export declare function MermaidInit(props?: MermaidInitProps): JSX.Element;
-export default MermaidInit;

package/dist/code-syntax/mermaid-init.js

@@ -1,14 +1,13 @@
 import { jsx } from "preact/jsx-runtime";
 import {
-  MERMAID_INIT_SCRIPT,
+  MERMAID_CDN_MODULE_URL,
   buildMermaidInitScript
 } from "./mermaid-init-script.js";
+const MERMAID_INIT_SCRIPT = buildMermaidInitScript(MERMAID_CDN_MODULE_URL);
 function MermaidInit(props = {}) {
   const script = props.script ?? (props.cdnUrl ? buildMermaidInitScript(props.cdnUrl) : MERMAID_INIT_SCRIPT);
   return /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: { __html: script } });
 }
-var mermaid_init_default = MermaidInit;
 export {
-  MermaidInit,
-  mermaid_init_default as default
+  MermaidInit
 };

package/dist/code-syntax/tabs-init.d.ts

@@ -18,4 +18,3 @@ import type { JSX } from "preact";
  * Requires `<Tabs>` to have server-rendered the tab buttons in the DOM.
  */
 export declare function TabsInit(): JSX.Element;
-export default TabsInit;

package/dist/code-syntax/tabs-init.js

@@ -3,8 +3,6 @@ import { TABS_INIT_SCRIPT } from "./tabs-init-script.js";
 function TabsInit() {
   return /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: { __html: TABS_INIT_SCRIPT } });
 }
-var tabs_init_default = TabsInit;
 export {
-  TabsInit,
-  tabs_init_default as default
+  TabsInit
 };

package/dist/code-syntax/tabs.d.ts

@@ -30,4 +30,3 @@ export interface TabsProps {
  * ```
  */
 export declare function Tabs({ groupId, children }: TabsProps): JSX.Element;
-export default Tabs;

package/dist/code-syntax/tabs.js

@@ -55,8 +55,6 @@ function Tabs({ groupId, children }) {
     }
   );
 }
-var tabs_default = Tabs;
 export {
-  Tabs,
-  tabs_default as default
+  Tabs
 };

package/dist/color-scheme-utils.d.ts

@@ -55,6 +55,16 @@ export interface Ramps {
 export type SemanticKey = "surface" | "muted" | "accent" | "accentHover" | "codeBg" | "codeFg" | "success" | "danger" | "warning" | "info" | "mermaidNodeBg" | "mermaidText" | "mermaidLine" | "mermaidLabelBg" | "mermaidNoteBg" | "chatUserBg" | "chatUserText" | "chatAssistantBg" | "chatAssistantText" | "imageOverlayBg" | "imageOverlayFg" | "matchedKeywordBg" | "matchedKeywordFg";
 /** Canonical order of the 23 semantic roles — used for `--zd-*` emit. */
 export declare const SEMANTIC_KEYS: readonly SemanticKey[];
+/**
+ * Compact Tier-2 syntax vocabulary. zfb's fixed 18-role renderer taxonomy is
+ * intentionally collapsed onto these nine public design decisions; see
+ * `ZFB_HIGHLIGHT_ROLE_TO_ZUDO_TOKEN` below.
+ */
+export declare const SYNTAX_SEMANTIC_KEYS: readonly ["syntaxComment", "syntaxString", "syntaxNumber", "syntaxKeyword", "syntaxCallable", "syntaxType", "syntaxName", "syntaxInserted", "syntaxDeleted"];
+export type SyntaxSemanticKey = (typeof SYNTAX_SEMANTIC_KEYS)[number];
+/** Existing semantic role inherited when a syntax role has no explicit map. */
+export declare const SYNTAX_SEMANTIC_ALIASES: Readonly<Record<SyntaxSemanticKey, SemanticKey>>;
+export declare const SYNTAX_CSS_NAMES: Readonly<Record<SyntaxSemanticKey, string>>;
 /** The per-mode wiring: each UI role points at a ramp stop (or literal OKLCH)
  *  via a `RampRef`. Two `ColorScheme`s (light + dark) share `ramps` but carry
  *  their own `ModeMap`. */
@@ -64,6 +74,9 @@ export interface ModeMap {
     selectionBg: RampRef;
     selectionFg: RampRef;
     semantic: Record<SemanticKey, RampRef>;
+    /** Syntax-specific overrides. The map is required, while omitted roles
+     *  inherit the aliases in `SYNTAX_SEMANTIC_ALIASES`. */
+    syntax: Partial<Record<SyntaxSemanticKey, RampRef>>;
 }
 /** A complete color scheme — shared Tier-1 ramps + per-mode Tier-2 wiring. */
 export interface ColorScheme {
@@ -75,6 +88,45 @@ export interface ColorScheme {
  *  where a mode needs a different stop (or a per-mode AA-tuned literal). */
 export declare const SEMANTIC_RAMP_DEFAULTS: Record<SemanticKey, RampRef>;
 export declare const SEMANTIC_CSS_NAMES: Record<SemanticKey, string>;
+/**
+ * Canonical renderer-role contraction shared by native zfb fenced code and
+ * `@takazudo/zfb-md-wasm` HTML Preview output. Values name zudo-doc semantic
+ * tokens, never palette stops, so renderer/component CSS stays downstream of
+ * the theme tier.
+ */
+export declare const ZFB_HIGHLIGHT_ROLE_TO_ZUDO_TOKEN: {
+    readonly foreground: "codeFg";
+    readonly background: "codeBg";
+    readonly escape: "syntaxString";
+    readonly operator: "codeFg";
+    readonly comment: "syntaxComment";
+    readonly string: "syntaxString";
+    readonly number: "syntaxNumber";
+    readonly constant: "syntaxNumber";
+    readonly keyword: "syntaxKeyword";
+    readonly function: "syntaxCallable";
+    readonly type: "syntaxType";
+    readonly namespace: "syntaxType";
+    readonly property: "syntaxName";
+    readonly variable: "syntaxName";
+    readonly tag: "syntaxName";
+    readonly attribute: "syntaxName";
+    readonly punctuation: "codeFg";
+    readonly inserted: "syntaxInserted";
+    readonly deleted: "syntaxDeleted";
+    readonly heading: "syntaxKeyword";
+};
+export type ZfbHighlightRole = keyof typeof ZFB_HIGHLIGHT_ROLE_TO_ZUDO_TOKEN;
+/** Percentage of the inserted/deleted foreground mixed into `codeBg`. */
+export declare const SYNTAX_DIFF_BACKGROUND_MIX_PERCENT = 15;
+/**
+ * Component-token values for zfb's inserted/deleted background variables.
+ * They deliberately do not create public `--zd-syntax-*-bg` roles.
+ */
+export declare const SYNTAX_DIFF_BACKGROUND_CSS: {
+    readonly inserted: `color-mix(in srgb, var(${string}) 15%, var(${string}))`;
+    readonly deleted: `color-mix(in srgb, var(${string}) 15%, var(${string}))`;
+};
 /**
  * Resolve a `RampRef` to a concrete color string against the given `ramps`.
  *   - `{ base: n }`   → `ramps.base[n]`
@@ -90,6 +142,21 @@ export declare function resolveRampRef(ref: RampRef, ramps: Ramps): string;
 /** Resolve every semantic role to a concrete color string via the scheme's
  *  per-mode `map.semantic` wiring. Returns all 23 keys. */
 export declare function resolveSemanticColors(scheme: ColorScheme): Record<SemanticKey, string>;
+export interface ResolvedSyntaxPalette {
+    /** Effective refs retain ramp identity for design-token-panel rows. */
+    refs: Record<SyntaxSemanticKey, RampRef>;
+    /** Concrete colors used by generated CSS and contrast validation. */
+    colors: Record<SyntaxSemanticKey, string>;
+}
+/**
+ * Canonical complete syntax resolver. Explicit partial overrides win; missing
+ * or invalid overrides inherit the scheme's semantic alias. A defensive
+ * `codeFg` / `fg` / first-ramp chain keeps runtime-authored data non-throwing
+ * even when it bypasses TypeScript or serde validation.
+ */
+export declare function resolveSyntaxPalette(scheme: ColorScheme): ResolvedSyntaxPalette;
+/** Convenience view of the canonical syntax palette's concrete colors. */
+export declare function resolveSyntaxColors(scheme: ColorScheme): Record<SyntaxSemanticKey, string>;
 export interface TierItem {
     /** Stable id used as the Record key in persisted state (e.g. `surface`). */
     id: string;
@@ -115,15 +182,15 @@ export interface TierItem {
  *
  * Always the explicit form (independent of `referencesRamps` declaration
  * order) — see item-id contract in `buildRampTiers`
- * (`src/config/design-token-panel-config.ts`): tier ids `base`/`accent`/`state`,
+ * (`./design-token-panel-config/index.ts`): tier ids `base`/`accent`/`state`,
  * item ids `base-0..4`/`accent-0..2`/`state-{danger,success,warning,info}`.
  */
 export declare function rampRefToPanelDefault(ref: RampRef): string;
 /**
- * Build the 27-row mode-scoped semantic tier's `items` for the design-token
+ * Build the 36-row mode-scoped semantic tier's `items` for the design-token
  * panel, from a single (already mode-resolved) `ColorScheme`: 4 base roles
  * (`bg`, `fg`, `selection-bg`, `selection-fg`) followed by the 23
- * `SEMANTIC_KEYS` rows, in that order. Every row's `default` is
+ * `SEMANTIC_KEYS` rows and 9 syntax rows, in that order. Every row's `default` is
  * `rampRefToPanelDefault` of the scheme's `map` entry for that role — never a
  * resolved literal color — so the panel's grouped ramp dropdown can decode it
  * back to a ramp reference (the no-snapping guarantee: a scheme with no
@@ -134,7 +201,7 @@ export declare function buildSemanticTierItems(scheme: ColorScheme): TierItem[];
 /** Which tiers a `schemeToCssPairs` call emits:
  *   - `"all"` (default) — base roles + `--palette-*` + `--zd-*` semantic
  *   - `"palette"`       — only the bare Tier-1 `--palette-*` pairs
- *   - `"roles"`         — base roles + the 23 `--zd-*` semantic pairs
+ *   - `"roles"`         — base roles + the 23 UI and 9 syntax semantic pairs
  *
  * The split lets `generateLightDarkCssProperties` emit the shared `--palette-*`
  * once (bare) while wrapping the per-mode `--zd-*` roles in `light-dark(…)`.
@@ -150,6 +217,7 @@ export type CssEmitScope = "all" | "palette" | "roles";
  *   - Tier-1 ramps: `--palette-base-0..4`, `--palette-accent-0..2`,
  *     `--palette-state-{danger,success,warning,info}`
  *   - the 23 Tier-2 `--zd-{role}` semantic tokens
+ *   - the 9 Tier-2 `--zd-syntax-*` semantic tokens
  *
  * It intentionally does NOT emit the retired `--zd-0..15` slots or `--zd-cursor`.
  */

package/dist/color-scheme-utils.js

@@ -24,6 +24,39 @@ const SEMANTIC_KEYS = [
   "matchedKeywordBg",
   "matchedKeywordFg"
 ];
+const SYNTAX_SEMANTIC_KEYS = [
+  "syntaxComment",
+  "syntaxString",
+  "syntaxNumber",
+  "syntaxKeyword",
+  "syntaxCallable",
+  "syntaxType",
+  "syntaxName",
+  "syntaxInserted",
+  "syntaxDeleted"
+];
+const SYNTAX_SEMANTIC_ALIASES = {
+  syntaxComment: "muted",
+  syntaxString: "success",
+  syntaxNumber: "warning",
+  syntaxKeyword: "accent",
+  syntaxCallable: "info",
+  syntaxType: "warning",
+  syntaxName: "codeFg",
+  syntaxInserted: "success",
+  syntaxDeleted: "danger"
+};
+const SYNTAX_CSS_NAMES = {
+  syntaxComment: "--zd-syntax-comment",
+  syntaxString: "--zd-syntax-string",
+  syntaxNumber: "--zd-syntax-number",
+  syntaxKeyword: "--zd-syntax-keyword",
+  syntaxCallable: "--zd-syntax-callable",
+  syntaxType: "--zd-syntax-type",
+  syntaxName: "--zd-syntax-name",
+  syntaxInserted: "--zd-syntax-inserted",
+  syntaxDeleted: "--zd-syntax-deleted"
+};
 const SEMANTIC_RAMP_DEFAULTS = {
   // Re-pointed for the 5-base / 3-accent minimized ramp (#2602); mirrors the
   // Default Dark reference wiring (surface/chatAssistantBg/imageOverlayBg merged
@@ -79,6 +112,33 @@ const SEMANTIC_CSS_NAMES = {
   matchedKeywordBg: "--zd-matched-keyword-bg",
   matchedKeywordFg: "--zd-matched-keyword-fg"
 };
+const ZFB_HIGHLIGHT_ROLE_TO_ZUDO_TOKEN = {
+  foreground: "codeFg",
+  background: "codeBg",
+  escape: "syntaxString",
+  operator: "codeFg",
+  comment: "syntaxComment",
+  string: "syntaxString",
+  number: "syntaxNumber",
+  constant: "syntaxNumber",
+  keyword: "syntaxKeyword",
+  function: "syntaxCallable",
+  type: "syntaxType",
+  namespace: "syntaxType",
+  property: "syntaxName",
+  variable: "syntaxName",
+  tag: "syntaxName",
+  attribute: "syntaxName",
+  punctuation: "codeFg",
+  inserted: "syntaxInserted",
+  deleted: "syntaxDeleted",
+  heading: "syntaxKeyword"
+};
+const SYNTAX_DIFF_BACKGROUND_MIX_PERCENT = 15;
+const SYNTAX_DIFF_BACKGROUND_CSS = {
+  inserted: `color-mix(in srgb, var(${SYNTAX_CSS_NAMES.syntaxInserted}) ${SYNTAX_DIFF_BACKGROUND_MIX_PERCENT}%, var(${SEMANTIC_CSS_NAMES.codeBg}))`,
+  deleted: `color-mix(in srgb, var(${SYNTAX_CSS_NAMES.syntaxDeleted}) ${SYNTAX_DIFF_BACKGROUND_MIX_PERCENT}%, var(${SEMANTIC_CSS_NAMES.codeBg}))`
+};
 function resolveRampRef(ref, ramps) {
   if (typeof ref === "string") return ref;
   if ("base" in ref) {
@@ -105,6 +165,61 @@ function resolveSemanticColors(scheme) {
   }
   return out;
 }
+function tryResolveRampRef(ref, ramps) {
+  if (typeof ref === "string") return ref.trim().length > 0 ? ref : void 0;
+  if (!ref || typeof ref !== "object") return void 0;
+  const candidate = ref;
+  if ("base" in candidate) {
+    const index = candidate.base;
+    if (typeof index !== "number" || !Number.isInteger(index) || index < 0) return void 0;
+    const value = ramps.base[index];
+    return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+  }
+  if ("accent" in candidate) {
+    const index = candidate.accent;
+    if (typeof index !== "number" || !Number.isInteger(index) || index < 0) return void 0;
+    const value = ramps.accent[index];
+    return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+  }
+  if ("state" in candidate) {
+    const state = candidate.state;
+    if (typeof state !== "string" || !STATE_ROLES.includes(state)) return void 0;
+    const value = ramps.state[state];
+    return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+  }
+  return void 0;
+}
+function copyRampRef(ref) {
+  return typeof ref === "string" ? ref : { ...ref };
+}
+function resolveSyntaxPalette(scheme) {
+  const { ramps, map } = scheme;
+  const refs = {};
+  const colors = {};
+  const emergencyCandidates = [
+    map.semantic.codeFg,
+    map.fg,
+    ramps.base.find((value) => typeof value === "string" && value.trim().length > 0),
+    "currentColor"
+  ];
+  const emergencyRef = emergencyCandidates.find(
+    (candidate) => tryResolveRampRef(candidate, ramps) !== void 0
+  );
+  const emergencyColor = tryResolveRampRef(emergencyRef, ramps) ?? "currentColor";
+  for (const key of SYNTAX_SEMANTIC_KEYS) {
+    const explicitRef = map.syntax[key];
+    const explicitColor = tryResolveRampRef(explicitRef, ramps);
+    const inheritedRef = map.semantic[SYNTAX_SEMANTIC_ALIASES[key]];
+    const inheritedColor = tryResolveRampRef(inheritedRef, ramps);
+    const effectiveRef = explicitColor !== void 0 ? explicitRef : inheritedColor !== void 0 ? inheritedRef : emergencyRef;
+    refs[key] = copyRampRef(effectiveRef);
+    colors[key] = explicitColor ?? inheritedColor ?? emergencyColor;
+  }
+  return { refs, colors };
+}
+function resolveSyntaxColors(scheme) {
+  return resolveSyntaxPalette(scheme).colors;
+}
 function rampRefToPanelDefault(ref) {
   if (typeof ref === "string") return ref;
   if ("base" in ref) return `base:base-${ref.base}`;
@@ -113,6 +228,7 @@ function rampRefToPanelDefault(ref) {
 }
 function buildSemanticTierItems(scheme) {
   const { map } = scheme;
+  const syntax = resolveSyntaxPalette(scheme);
   const items = [
     {
       id: "bg",
@@ -152,6 +268,15 @@ function buildSemanticTierItems(scheme) {
       type: { kind: "color", format: "oklch" }
     });
   }
+  for (const key of SYNTAX_SEMANTIC_KEYS) {
+    items.push({
+      id: key,
+      cssVar: SYNTAX_CSS_NAMES[key],
+      label: key,
+      default: rampRefToPanelDefault(syntax.refs[key]),
+      type: { kind: "color", format: "oklch" }
+    });
+  }
   return items;
 }
 function schemeToCssPairs(scheme, scope = "all") {
@@ -177,6 +302,10 @@ function schemeToCssPairs(scheme, scope = "all") {
     for (const key of SEMANTIC_KEYS) {
       pairs.push([SEMANTIC_CSS_NAMES[key], sem[key]]);
     }
+    const syntax = resolveSyntaxColors(scheme);
+    for (const key of SYNTAX_SEMANTIC_KEYS) {
+      pairs.push([SYNTAX_CSS_NAMES[key], syntax[key]]);
+    }
   }
   return pairs;
 }
@@ -212,11 +341,19 @@ export {
   SEMANTIC_KEYS,
   SEMANTIC_RAMP_DEFAULTS,
   STATE_ROLES,
+  SYNTAX_CSS_NAMES,
+  SYNTAX_DIFF_BACKGROUND_CSS,
+  SYNTAX_DIFF_BACKGROUND_MIX_PERCENT,
+  SYNTAX_SEMANTIC_ALIASES,
+  SYNTAX_SEMANTIC_KEYS,
+  ZFB_HIGHLIGHT_ROLE_TO_ZUDO_TOKEN,
   buildSemanticTierItems,
   generateCssCustomProperties,
   generateLightDarkCssProperties,
   rampRefToPanelDefault,
   resolveRampRef,
   resolveSemanticColors,
+  resolveSyntaxColors,
+  resolveSyntaxPalette,
   schemeToCssPairs
 };

package/dist/color-schemes-defaults/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Default color schemes — Default Light + Default Dark.
+ *
+ * Ported verbatim from the `create-zudo-doc` base template's
+ * `src/config/color-schemes.ts` `colorSchemes` export (epic
+ * zudolab/zudo-doc#2651, S4 #2654), so a generated project needs no
+ * color-schemes config file of its own.
+ *
+ * Ramp-native model (Color Ramp Restructure — zudolab/zudo-doc#2584;
+ * minimized to 5/3 in #2602). A `ColorScheme` is `{ ramps, map }` — the
+ * MECHANISM type is owned by `@takazudo/zudo-doc/color-scheme-utils` and is
+ * reused here, not re-declared:
+ *   - `ramps` — the shared Tier-1 source of truth: a warm-neutral `base` ramp
+ *     (5 stops, index 0 = lightest), an `accent` ramp (3 stops), and 4 `state`
+ *     colors. Light and dark modes SHARE these values.
+ *   - `map` — the per-mode Tier-2 wiring: which ramp stop (or literal OKLCH)
+ *     each UI role points at.
+ *
+ * A project's `ZudoDocConfig.colorSchemes` override is merged over this
+ * default by `zudoDoc()` (#2657).
+ */
+import type { ColorScheme } from "../color-scheme-utils.js";
+export declare const defaultColorSchemes: Record<string, ColorScheme>;

package/dist/color-schemes-defaults/index.js

@@ -0,0 +1,134 @@
+const ramps = {
+  base: [
+    "oklch(.965 .004 65)",
+    // 0 — lightest (light bg / dark fg)
+    "oklch(.705 .008 65)",
+    // 1 — dark muted / light selection & mermaid fill
+    "oklch(.480 .008 65)",
+    // 2 — light muted / dark selection & mermaid note
+    "oklch(.300 .006 65)",
+    // 3 — dark codeBg / mermaid fill
+    "oklch(.185 .005 65)"
+    // 4 — darkest (dark bg / light fg)
+  ],
+  accent: [
+    "oklch(.755 .130 64)",
+    // 0 — dark hover (was accent2)
+    "oklch(.700 .158 62)",
+    // 1 — dark accent (was accent3)
+    "oklch(.470 .120 56)"
+    // 2 — light accent (was accent6)
+  ],
+  state: {
+    danger: "oklch(.640 .170 25)",
+    success: "oklch(.680 .145 145)",
+    warning: "oklch(.760 .135 82)",
+    info: "oklch(.680 .130 245)"
+  }
+};
+const darkMap = {
+  bg: { base: 4 },
+  fg: { base: 0 },
+  selectionBg: { base: 2 },
+  selectionFg: { base: 0 },
+  semantic: {
+    // Merged onto bg (b4) — elevated panels read as page-bg + border, no gray fill.
+    surface: { base: 4 },
+    muted: { base: 1 },
+    accent: { accent: 1 },
+    accentHover: { accent: 0 },
+    codeBg: { base: 3 },
+    codeFg: { base: 0 },
+    success: { state: "success" },
+    // Per-mode AA-tuned literal — shared state.danger oklch(.640 .170 25) is too
+    // dark for the danger-admonition title on its 12%-tint dark bg. L .640→.655
+    // (H/C fixed) — admonition-danger at threshold+0.1; carried from #2593.
+    danger: "oklch(.655 .170 25)",
+    warning: { state: "warning" },
+    info: { state: "info" },
+    mermaidNodeBg: { base: 3 },
+    mermaidText: { base: 0 },
+    mermaidLine: { base: 1 },
+    mermaidLabelBg: { base: 3 },
+    mermaidNoteBg: { base: 2 },
+    chatUserBg: { accent: 1 },
+    chatUserText: { base: 4 },
+    // Merged onto bg (b4) — the chat assistant bubble reads as page-bg + border.
+    chatAssistantBg: { base: 4 },
+    chatAssistantText: { base: 0 },
+    imageOverlayBg: { base: 4 },
+    imageOverlayFg: { base: 0 },
+    // Search-result <mark> highlight: an amber (accent-hue) fill with dark text —
+    // the classic highlighter look, identical in both modes. Kept as literals so
+    // the amber fill is scheme-stable; matchedKeywordFg dark so text clears AA on
+    // the amber bg — matched-keyword at threshold+0.1; carried from #2593.
+    matchedKeywordBg: "oklch(.700 .158 62)",
+    matchedKeywordFg: "oklch(.300 .003 65)"
+  },
+  // Diff foregrounds are checked against their actual 15% foreground tint on
+  // codeBg. The ordinary success/danger aliases are not light enough on that
+  // derived dark background, so only these two syntax roles need overrides.
+  syntax: {
+    syntaxInserted: "oklch(.750 .145 145)",
+    syntaxDeleted: "oklch(.820 .100 25)"
+  }
+};
+const lightMap = {
+  bg: { base: 0 },
+  fg: { base: 4 },
+  selectionBg: { base: 1 },
+  selectionFg: { base: 4 },
+  semantic: {
+    // Merged onto bg (b0) — elevated panels read as page-bg + border, no gray fill.
+    surface: { base: 0 },
+    muted: { base: 2 },
+    accent: { accent: 2 },
+    // Light: per-mode literal — the accent ramp has no stop darker than accent2,
+    // so the link-hover state darkens further (hover-darkens-on-light
+    // convention). L .400, C fitted to the sRGB gamut edge at that L; carried
+    // from #2595. accent-hover-vs-bg clears threshold+0.1.
+    accentHover: "oklch(.400 .096 56)",
+    // Merged onto bg (b0) — inline/code-block fill reads as page-bg + border.
+    codeBg: { base: 0 },
+    codeFg: { base: 4 },
+    // Light: per-mode literals — the shared state colors are authored for a dark
+    // bg and are too light on the 12%-tint admonition backgrounds over a light
+    // page bg. Each darkened (H fixed; C at gamut max, clipped where noted) to
+    // clear its admonition pair at threshold+0.1; carried from #2595.
+    success: "oklch(.470 .140 145)",
+    danger: "oklch(.505 .170 25)",
+    warning: "oklch(.490 .100 82)",
+    // C .135→.100 (gamut-clips at this L)
+    info: "oklch(.485 .122 245)",
+    mermaidNodeBg: { base: 1 },
+    mermaidText: { base: 4 },
+    mermaidLine: { base: 2 },
+    mermaidLabelBg: { base: 1 },
+    mermaidNoteBg: { base: 1 },
+    chatUserBg: { accent: 1 },
+    // Dark text on the amber user bubble (matches Default Dark).
+    chatUserText: { base: 4 },
+    // Merged onto bg (b0) — the chat assistant bubble reads as page-bg + border.
+    chatAssistantBg: { base: 0 },
+    chatAssistantText: { base: 4 },
+    imageOverlayBg: { base: 4 },
+    imageOverlayFg: { base: 0 },
+    // Search-result <mark>: amber highlighter fill with dark text — same look as
+    // Default Dark (an amber-on-white highlight reads identically in both modes).
+    matchedKeywordBg: "oklch(.700 .158 62)",
+    matchedKeywordFg: "oklch(.300 .003 65)"
+  },
+  // Slightly darker than the shared success/danger aliases so the foregrounds
+  // retain >= 4.6:1 on their own 15% tints over the light code background.
+  syntax: {
+    syntaxInserted: "oklch(.460 .140 145)",
+    syntaxDeleted: "oklch(.490 .170 25)"
+  }
+};
+const defaultColorSchemes = {
+  "Default Light": { ramps, map: lightMap },
+  "Default Dark": { ramps, map: darkMap }
+};
+export {
+  defaultColorSchemes
+};