@takazudo/zudo-doc 0.2.21 → 0.2.22

package/dist/breadcrumb/breadcrumb.d.ts

@@ -1,9 +1,7 @@
-import { ComponentChildren, VNode } from 'preact';
-import { BreadcrumbItem, SidebarNode } from './types.js';
-
 /** @jsxRuntime automatic */
 /** @jsxImportSource preact */
-
+import type { ComponentChildren, VNode } from "preact";
+import type { BreadcrumbItem, SidebarNode } from "./types.js";
 /**
  * Convert a sidebar tree + the current page's id into the ordered list
  * of crumbs the renderer walks. The first crumb is the home rung
@@ -15,8 +13,8 @@ import { BreadcrumbItem, SidebarNode } from './types.js';
  * src/utils/docs.ts so the rendered output stays parity-equivalent
  * with the original Astro breadcrumb component.
  */
-declare function buildBreadcrumbItems(tree: SidebarNode[], currentId: string, homeHref: string): BreadcrumbItem[];
-interface BreadcrumbProps {
+export declare function buildBreadcrumbItems(tree: SidebarNode[], currentId: string, homeHref: string): BreadcrumbItem[];
+export interface BreadcrumbProps {
     /** Pre-built items, or omit and pass `tree` + `currentId` instead. */
     items?: BreadcrumbItem[];
     /** Sidebar tree to derive the trail from. Required when `items` is omitted. */
@@ -52,6 +50,4 @@ interface BreadcrumbProps {
  * Returns null when no items resolve, matching the documented
  * `items.length > 0 &&` guard.
  */
-declare function Breadcrumb(props: BreadcrumbProps): VNode | null;
-
-export { Breadcrumb, type BreadcrumbProps, buildBreadcrumbItems };
+export declare function Breadcrumb(props: BreadcrumbProps): VNode | null;

package/dist/breadcrumb/find-path.d.ts

@@ -1,5 +1,4 @@
-import { BreadcrumbNode, SidebarNode } from './types.js';
-
+import type { BreadcrumbNode, SidebarNode } from "./types.js";
 /**
  * Walk the sidebar tree and return the chain of nodes from the root
  * level down to (and including) the node whose `id` matches `targetId`.
@@ -11,6 +10,4 @@ import { BreadcrumbNode, SidebarNode } from './types.js';
  * ancestry. The home/root crumb is the renderer's responsibility — this
  * helper deals strictly with the tree itself.
  */
-declare function findPath<T extends BreadcrumbNode = SidebarNode>(nodes: readonly T[], targetId: string): T[];
-
-export { findPath };
+export declare function findPath<T extends BreadcrumbNode = SidebarNode>(nodes: readonly T[], targetId: string): T[];

package/dist/breadcrumb/index.d.ts

@@ -1,4 +1,4 @@
-export { Breadcrumb, BreadcrumbProps, buildBreadcrumbItems } from './breadcrumb.js';
-export { findPath } from './find-path.js';
-export { BreadcrumbItem, SidebarNode } from './types.js';
-import 'preact';
+export { Breadcrumb, buildBreadcrumbItems } from "./breadcrumb.js";
+export type { BreadcrumbProps } from "./breadcrumb.js";
+export { findPath } from "./find-path.js";
+export type { BreadcrumbItem, SidebarNode } from "./types.js";

package/dist/breadcrumb/types.d.ts

@@ -7,7 +7,7 @@
  * is structurally assignable to this, so callers can pass either shape
  * unchanged.
  */
-interface BreadcrumbNode {
+export interface BreadcrumbNode {
     type: "doc" | "category";
     id: string;
     label: string;
@@ -19,14 +19,12 @@ interface BreadcrumbNode {
  * Backward-compatible alias retained for callers that previously imported
  * `SidebarNode` from this subpath.
  */
-type SidebarNode = BreadcrumbNode;
+export type SidebarNode = BreadcrumbNode;
 /**
  * One rung of the breadcrumb trail. `href` is omitted on the final
  * (current-page) item so the renderer can present it as plain text.
  */
-interface BreadcrumbItem {
+export interface BreadcrumbItem {
     label: string;
     href?: string;
 }
-
-export type { BreadcrumbItem, BreadcrumbNode, SidebarNode };

package/dist/category-nav/index.d.ts

@@ -0,0 +1,86 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { JSX } from "preact";
+/** Minimal nav node shape required by the category-nav factory. */
+export interface CategoryNavNode {
+    label: string;
+    description?: string;
+    href?: string;
+    hasPage: boolean;
+    children: CategoryNavNode[];
+}
+/** Minimal nav source needed by the category-nav factory. */
+export interface CategoryNavSource {
+    navDocs: unknown[];
+    categoryMeta: Map<string, unknown>;
+}
+/** Props for the CategoryNavWrapper component. */
+export interface CategoryNavWrapperProps {
+    /**
+     * Slug of the category whose immediate children should be listed, e.g.
+     * "getting-started" or "guides/layout-demos".
+     */
+    category?: string;
+    /**
+     * Explicit list of top-level category slugs to render as cards. Use this
+     * when the target categories are not children of a single parent node in
+     * the nav tree (e.g. "claude-md", "claude-skills" are top-level siblings
+     * of "claude", not children). Each slug is resolved to its nav node; nodes
+     * not found in the tree are silently skipped.
+     *
+     * A `category_no_page` category has no route of its own, so its card links to
+     * the first routed descendant page (via firstRoutedHref); categories with no
+     * reachable page are skipped rather than emitting a dead link.
+     */
+    categories?: string[];
+    /**
+     * Active locale. Injected via createMdxComponents() closure.
+     * Defaults to defaultLocale when not provided.
+     */
+    lang?: string;
+    /** Optional extra CSS classes forwarded to the <nav> element. */
+    class?: string;
+}
+/** Injected dependencies for {@link createCategoryNavWrapper}. */
+export interface CategoryNavDeps {
+    /** Default locale code (e.g. `"en"`). */
+    defaultLocale: string;
+    /**
+     * Resolve the identity-stable nav source for an EN/locale context.
+     * Host passes `resolveNavSource` from `pages/lib/_nav-source-docs.ts`.
+     */
+    resolveNavSource: (lang: string, currentVersion: string | undefined, options?: {
+        applyDefaultLocaleOnlyFilter?: boolean;
+        keepUnlisted?: boolean;
+    }) => CategoryNavSource;
+    /**
+     * Build the nav tree for a locale.
+     * Host passes `buildNavTree` from `@/utils/docs`.
+     */
+    buildNavTree: (docs: unknown[], locale: string, categoryMeta: Map<string, unknown>) => CategoryNavNode[];
+    /**
+     * Find a node by slug in the nav tree.
+     * Host passes `findNode` from `@/utils/docs`.
+     */
+    findNode: (tree: CategoryNavNode[], slug: string) => CategoryNavNode | undefined;
+    /**
+     * Recursively find the first href in a node's subtree.
+     * Host passes `firstRoutedHref` from `@/utils/docs`.
+     */
+    firstRoutedHref: (node: CategoryNavNode) => string | undefined;
+}
+/**
+ * Create the `CategoryNavWrapper` component bound to the host's nav source
+ * and tree-building dependencies.
+ *
+ * Supports two modes:
+ * - `category`: resolves immediate children of a single category node.
+ * - `categories`: resolves an explicit list of top-level slugs as cards.
+ *   Use this when the target categories are siblings in the nav tree rather
+ *   than children of a common parent (e.g. claude-md / claude-skills are
+ *   top-level peers of claude, not children of it). A noPage category card
+ *   links to its first routed descendant page (it has no route of its own).
+ *
+ * Returns null when no visible children are resolved.
+ */
+export declare function createCategoryNavWrapper(deps: CategoryNavDeps): (props: CategoryNavWrapperProps) => JSX.Element | null;

package/dist/category-nav/index.js

@@ -0,0 +1,44 @@
+import { jsx } from "preact/jsx-runtime";
+import { CategoryNav as CategoryNavV2 } from "../nav-indexing/index.js";
+function createCategoryNavWrapper(deps) {
+  const { defaultLocale, resolveNavSource, buildNavTree, findNode, firstRoutedHref } = deps;
+  function CategoryNavWrapper({
+    category,
+    categories,
+    lang = defaultLocale,
+    class: className
+  }) {
+    const locale = lang;
+    const { navDocs, categoryMeta } = resolveNavSource(locale, void 0, {
+      keepUnlisted: true
+    });
+    const tree = buildNavTree(navDocs, locale, categoryMeta);
+    let children;
+    if (categories !== void 0) {
+      children = categories.map((slug) => {
+        const node = findNode(tree, slug);
+        if (!node) return null;
+        const href = node.href ?? firstRoutedHref(node);
+        if (!href) return null;
+        return {
+          label: node.label,
+          description: node.description,
+          href,
+          hasPage: true,
+          children: []
+        };
+      }).filter((n) => n !== null);
+    } else if (category !== void 0) {
+      const categoryNode = findNode(tree, category);
+      children = categoryNode?.children.filter((c) => c.hasPage) ?? [];
+    } else {
+      return null;
+    }
+    if (children.length === 0) return null;
+    return /* @__PURE__ */ jsx(CategoryNavV2, { children, class: className });
+  }
+  return CategoryNavWrapper;
+}
+export {
+  createCategoryNavWrapper
+};

package/dist/category-tree-nav/index.d.ts

@@ -0,0 +1,65 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { JSX } from "preact";
+/** Minimal nav node shape required by the category-tree-nav factory. */
+export interface CategoryTreeNavNode {
+    label: string;
+    description?: string;
+    href?: string;
+    hasPage: boolean;
+    children: CategoryTreeNavNode[];
+}
+/** Minimal nav source needed by the category-tree-nav factory. */
+export interface CategoryTreeNavSource {
+    navDocs: unknown[];
+    categoryMeta: Map<string, unknown>;
+}
+/** Props for the CategoryTreeNavWrapper component. */
+export interface CategoryTreeNavWrapperProps {
+    /**
+     * Slug of the category whose children should be rendered as a tree,
+     * e.g. "guides" or "getting-started".
+     */
+    category: string;
+    /**
+     * Active locale. Injected via createMdxComponents() closure.
+     * Defaults to defaultLocale when not provided.
+     */
+    lang?: string;
+}
+/** Injected dependencies for {@link createCategoryTreeNavWrapper}. */
+export interface CategoryTreeNavDeps {
+    /** Default locale code (e.g. `"en"`). */
+    defaultLocale: string;
+    /**
+     * Resolve the identity-stable nav source for an EN/locale context.
+     * Host passes `resolveNavSource` from `pages/lib/_nav-source-docs.ts`.
+     */
+    resolveNavSource: (lang: string, currentVersion: string | undefined, options?: {
+        applyDefaultLocaleOnlyFilter?: boolean;
+        keepUnlisted?: boolean;
+    }) => CategoryTreeNavSource;
+    /**
+     * Build the nav tree for a locale.
+     * Host passes `buildNavTree` from `@/utils/docs`.
+     */
+    buildNavTree: (docs: unknown[], locale: string, categoryMeta: Map<string, unknown>) => CategoryTreeNavNode[];
+    /**
+     * Group satellite nodes under target category prefixes in the nav tree.
+     * Host passes `groupSatelliteNodes` from `@/utils/docs`.
+     */
+    groupSatelliteNodes: (tree: CategoryTreeNavNode[], prefixes: string[]) => CategoryTreeNavNode[];
+    /**
+     * Find a node by slug in the nav tree.
+     * Host passes `findNode` from `@/utils/docs`.
+     */
+    findNode: (tree: CategoryTreeNavNode[], slug: string) => CategoryTreeNavNode | undefined;
+}
+/**
+ * Create the `CategoryTreeNavWrapper` component bound to the host's nav source
+ * and tree-building dependencies.
+ *
+ * Returns null when the category is not found or has no renderable children —
+ * matching the original Astro component's guard.
+ */
+export declare function createCategoryTreeNavWrapper(deps: CategoryTreeNavDeps): (props: CategoryTreeNavWrapperProps) => JSX.Element | null;

package/dist/category-tree-nav/index.js

@@ -0,0 +1,24 @@
+import { jsx } from "preact/jsx-runtime";
+import { CategoryTreeNav as CategoryTreeNavV2 } from "../nav-indexing/index.js";
+function createCategoryTreeNavWrapper(deps) {
+  const { defaultLocale, resolveNavSource, buildNavTree, groupSatelliteNodes, findNode } = deps;
+  function CategoryTreeNavWrapper({
+    category,
+    lang = defaultLocale
+  }) {
+    const locale = lang;
+    const { navDocs, categoryMeta } = resolveNavSource(locale, void 0, {
+      keepUnlisted: true
+    });
+    const rawTree = buildNavTree(navDocs, locale, categoryMeta);
+    const tree = groupSatelliteNodes(rawTree, [category]);
+    const categoryNode = findNode(tree, category);
+    const children = categoryNode?.children.filter((c) => c.hasPage || c.children.length > 0) ?? [];
+    if (children.length === 0) return null;
+    return /* @__PURE__ */ jsx(CategoryTreeNavV2, { children });
+  }
+  return CategoryTreeNavWrapper;
+}
+export {
+  createCategoryTreeNavWrapper
+};

package/dist/code-group/index.d.ts

@@ -0,0 +1,10 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { ComponentChildren } from "preact";
+type Props = {
+    tabs?: string[];
+    children?: ComponentChildren;
+    [key: string]: unknown;
+};
+export declare function CodeGroup({ tabs, children, name }: Props): import("preact").JSX.Element;
+export {};

package/dist/code-group/index.js

@@ -0,0 +1,37 @@
+import { Fragment, jsx } from "preact/jsx-runtime";
+import { Tabs } from "../code-syntax/index.js";
+import { TabItem } from "../tab-item/index.js";
+function toArray(children) {
+  if (!children) return [];
+  if (Array.isArray(children)) return children;
+  return [children];
+}
+function CodeGroup({ tabs = [], children, name }) {
+  const childArray = toArray(children);
+  const items = tabs.map((label, i) => {
+    const child = childArray[i];
+    return { label, child };
+  });
+  if (items.length === 0) {
+    return /* @__PURE__ */ jsx(Fragment, { children });
+  }
+  const groupId = typeof name === "string" ? name : void 0;
+  return /* @__PURE__ */ jsx(Tabs, { groupId, children: items.map(({ label, child }, i) => (
+    // value is suffixed with the index so two fences sharing a label
+    // (e.g. both titled "ts") get distinct stable tab identities; the
+    // label stays the visible text.
+    /* @__PURE__ */ jsx(
+      TabItem,
+      {
+        label,
+        value: `${label}-${i}`,
+        default: i === 0 ? true : void 0,
+        children: /* @__PURE__ */ jsx("div", { class: "code-group-panel", children: child })
+      },
+      `${label}-${i}`
+    )
+  )) });
+}
+export {
+  CodeGroup
+};

package/dist/code-syntax/code-block-enhancer-script.d.ts

@@ -1,3 +1 @@
-declare const CODE_BLOCK_ENHANCER_SCRIPT: string;
-
-export { CODE_BLOCK_ENHANCER_SCRIPT };
+export declare const CODE_BLOCK_ENHANCER_SCRIPT: string;

package/dist/code-syntax/code-block-enhancer.d.ts

@@ -1,8 +1,6 @@
-import { JSX } from 'preact';
-
 /** @jsxRuntime automatic */
 /** @jsxImportSource preact */
-
+import type { JSX } from "preact";
 /**
  * Drop-in JSX replacement for the legacy `code-block-enhancer` component.
  *
@@ -17,6 +15,5 @@ import { JSX } from 'preact';
  *   Transitions. Event names come from `BEFORE_NAVIGATE_EVENT` /
  *   `AFTER_NAVIGATE_EVENT` in `../transitions/page-events.ts`.
  */
-declare function CodeBlockEnhancer(): JSX.Element;
-
-export { CodeBlockEnhancer, CodeBlockEnhancer as default };
+export declare function CodeBlockEnhancer(): JSX.Element;
+export default CodeBlockEnhancer;

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

@@ -1,8 +1,9 @@
-export { CodeBlockEnhancer, CodeBlockEnhancer as CodeBlockEnhancerDefault } from './code-block-enhancer.js';
-export { CODE_BLOCK_ENHANCER_SCRIPT } from './code-block-enhancer-script.js';
-export { MermaidInit, MermaidInit as MermaidInitDefault, MermaidInitProps } from './mermaid-init.js';
-export { MERMAID_CDN_MODULE_URL, MERMAID_INIT_SCRIPT, buildMermaidInitScript } from './mermaid-init-script.js';
-export { Tabs, Tabs as TabsDefault, TabsProps } from './tabs.js';
-export { TabsInit, TabsInit as TabsInitDefault } from './tabs-init.js';
-export { TABS_INIT_SCRIPT } from './tabs-init-script.js';
-import 'preact';
+export { CodeBlockEnhancer, default as CodeBlockEnhancerDefault } from "./code-block-enhancer.js";
+export { CODE_BLOCK_ENHANCER_SCRIPT } from "./code-block-enhancer-script.js";
+export { MermaidInit, default as MermaidInitDefault, } from "./mermaid-init.js";
+export type { MermaidInitProps } from "./mermaid-init.js";
+export { MERMAID_INIT_SCRIPT, MERMAID_CDN_MODULE_URL, buildMermaidInitScript, } from "./mermaid-init-script.js";
+export { Tabs, default as TabsDefault } from "./tabs.js";
+export type { TabsProps } from "./tabs.js";
+export { TabsInit, default as TabsInitDefault } from "./tabs-init.js";
+export { TABS_INIT_SCRIPT } from "./tabs-init-script.js";

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

@@ -16,7 +16,7 @@
  * tests can override the URL — e.g. self-hosted mirrors, version-
  * locked deployments — without re-templating the whole script.
  */
-declare const MERMAID_CDN_MODULE_URL = "https://esm.sh/mermaid@11.15.0";
+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.
  *
@@ -34,7 +34,7 @@ declare const MERMAID_CDN_MODULE_URL = "https://esm.sh/mermaid@11.15.0";
  * `MERMAID_CDN_MODULE_URL`) so existing callers keep working
  * unchanged.
  */
-declare function buildMermaidInitScript(cdnUrl: string): string;
+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
@@ -46,6 +46,4 @@ declare function buildMermaidInitScript(cdnUrl: string): string;
  * CSP-allowlisted host) call `buildMermaidInitScript(yourUrl)` and
  * pass the result to `<MermaidInit script={…}/>`.
  */
-declare const MERMAID_INIT_SCRIPT: string;
-
-export { MERMAID_CDN_MODULE_URL, MERMAID_INIT_SCRIPT, buildMermaidInitScript };
+export declare const MERMAID_INIT_SCRIPT: string;

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

@@ -1,8 +1,6 @@
-import { JSX } from 'preact';
-
 /** @jsxRuntime automatic */
 /** @jsxImportSource preact */
-
+import type { JSX } from "preact";
 /**
  * Props for `<MermaidInit/>`.
  *
@@ -12,7 +10,7 @@ import { JSX } from 'preact';
  * `script` wins over `cdnUrl` when both are provided so a fully
  * hand-rolled script can short-circuit the builder entirely.
  */
-interface MermaidInitProps {
+export interface MermaidInitProps {
     /**
      * Override the mermaid module URL the inline script imports at
      * runtime. Use this for self-hosted mirrors, version-pinned
@@ -43,6 +41,5 @@ interface MermaidInitProps {
  * a `MutationObserver` on `:root[style]` to re-render when the user
  * changes the color scheme via the color-tweak panel.
  */
-declare function MermaidInit(props?: MermaidInitProps): JSX.Element;
-
-export { MermaidInit, type MermaidInitProps, MermaidInit as default };
+export declare function MermaidInit(props?: MermaidInitProps): JSX.Element;
+export default MermaidInit;

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

@@ -1,3 +1 @@
-declare const TABS_INIT_SCRIPT: string;
-
-export { TABS_INIT_SCRIPT };
+export declare const TABS_INIT_SCRIPT: string;

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

@@ -1,8 +1,6 @@
-import { JSX } from 'preact';
-
 /** @jsxRuntime automatic */
 /** @jsxImportSource preact */
-
+import type { JSX } from "preact";
 /**
  * Drop-in JSX replacement for the legacy `tabs-init` component.
  *
@@ -19,6 +17,5 @@ import { JSX } from 'preact';
  *
  * Requires `<Tabs>` to have server-rendered the tab buttons in the DOM.
  */
-declare function TabsInit(): JSX.Element;
-
-export { TabsInit, TabsInit as default };
+export declare function TabsInit(): JSX.Element;
+export default TabsInit;

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

@@ -1,9 +1,7 @@
-import { ComponentChildren, JSX } from 'preact';
-
 /** @jsxRuntime automatic */
 /** @jsxImportSource preact */
-
-interface TabsProps {
+import type { ComponentChildren, JSX } from "preact";
+export interface TabsProps {
     /**
      * When set, clicking a tab in this group persists the chosen value to
      * `localStorage` under `tabs-group-{groupId}` and syncs all other
@@ -31,6 +29,5 @@ interface TabsProps {
  * </Tabs>
  * ```
  */
-declare function Tabs({ groupId, children }: TabsProps): JSX.Element;
-
-export { Tabs, type TabsProps, Tabs as default };
+export declare function Tabs({ groupId, children }: TabsProps): JSX.Element;
+export default Tabs;

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

@@ -0,0 +1,125 @@
+/**
+ * Color-scheme MECHANISM — palette → `--zd-*` CSS custom-property injection.
+ *
+ * This module ships the pure computation layer used by every project that
+ * builds on @takazudo/zudo-doc. It is DATA-free: callers pass in their own
+ * color-scheme manifest and settings.
+ *
+ * Moved from the host's `src/config/color-scheme-utils.ts` as part of the
+ * package-first migration (S9a zudolab/zudo-doc#2333). The DATA (palette
+ * values, scheme names, `colorMode` settings) stays project-side.
+ */
+/** A color reference: palette index (number) or direct color value (string) */
+export type ColorRef = number | string;
+export interface ColorScheme {
+    background: ColorRef;
+    foreground: ColorRef;
+    cursor: ColorRef;
+    selectionBg: ColorRef;
+    selectionFg: ColorRef;
+    palette: [
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string
+    ];
+    /** Optional, vestigial — no visible effect on rendering; carried only for
+     *  the zdtp design-token panel config envelope. See project CLAUDE.md. */
+    shikiTheme?: string;
+    /** Optional semantic overrides. When omitted, defaults from
+     *  `SEMANTIC_DEFAULTS` are used (surface=p0, muted=p8, accent=p5, …). */
+    semantic?: {
+        surface?: ColorRef;
+        muted?: ColorRef;
+        accent?: ColorRef;
+        accentHover?: ColorRef;
+        codeBg?: ColorRef;
+        codeFg?: ColorRef;
+        success?: ColorRef;
+        danger?: ColorRef;
+        warning?: ColorRef;
+        info?: ColorRef;
+        mermaidNodeBg?: ColorRef;
+        mermaidText?: ColorRef;
+        mermaidLine?: ColorRef;
+        mermaidLabelBg?: ColorRef;
+        mermaidNoteBg?: ColorRef;
+        chatUserBg?: ColorRef;
+        chatUserText?: ColorRef;
+        chatAssistantBg?: ColorRef;
+        chatAssistantText?: ColorRef;
+        /** UI chrome over user images — enlarge/close overlay buttons */
+        imageOverlayBg?: ColorRef;
+        imageOverlayFg?: ColorRef;
+        /** <mark> highlight for matched keywords in search results */
+        matchedKeywordBg?: ColorRef;
+        matchedKeywordFg?: ColorRef;
+    };
+}
+/** Default mapping: semantic token name → palette index */
+export declare const SEMANTIC_DEFAULTS: Record<string, number>;
+export declare const SEMANTIC_CSS_NAMES: Record<string, string>;
+/** Resolve a ColorRef to a concrete color string.
+ *  - number → palette[value]
+ *  - string → used as-is
+ *  - undefined → fallback */
+export declare function resolveColor(value: ColorRef | undefined, palette: string[], fallback: string): string;
+/** Resolve semantic colors with fallbacks to default palette slots */
+export declare function resolveSemanticColors(scheme: ColorScheme): {
+    surface: string;
+    muted: string;
+    accent: string;
+    accentHover: string;
+    codeBg: string;
+    codeFg: string;
+    success: string;
+    danger: string;
+    warning: string;
+    info: string;
+    mermaidNodeBg: string;
+    mermaidText: string;
+    mermaidLine: string;
+    mermaidLabelBg: string;
+    mermaidNoteBg: string;
+    chatUserBg: string;
+    chatUserText: string;
+    chatAssistantBg: string;
+    chatAssistantText: string;
+    imageOverlayBg: string;
+    imageOverlayFg: string;
+    matchedKeywordBg: string;
+    matchedKeywordFg: string;
+};
+/** Convert a ColorScheme to a flat list of [cssProperty, value] pairs.
+ *  The result is the exact set of `--zd-*` custom properties that the
+ *  ColorSchemeProvider emits onto `:root`. */
+export declare function schemeToCssPairs(scheme: ColorScheme): [string, string][];
+/**
+ * Generate the `:root { --zd-* }` CSS block for a single active color scheme.
+ *
+ * The caller passes in the active `ColorScheme` object — resolved from the
+ * project's `colorSchemes` map and `settings.colorScheme`. This function is
+ * DATA-free: it performs no settings lookup itself.
+ */
+export declare function generateCssCustomProperties(scheme: ColorScheme): string;
+/**
+ * Generate the `:root { --zd-*: light-dark(…, …); }` CSS block for a
+ * light/dark pair.
+ *
+ * The caller passes in the `light` and `dark` `ColorScheme` objects — resolved
+ * from the project's `colorSchemes` map and `settings.colorMode`. This
+ * function is DATA-free.
+ */
+export declare function generateLightDarkCssProperties(light: ColorScheme, dark: ColorScheme): string;