@ggui-ai/project-config 0.1.0-rc.1

package/dist/theme-loader.js

@@ -0,0 +1,263 @@
+/**
+ * Theme loader — resolves `ggui.json#theme` into a validated
+ * `LoadedTheme` at boot.
+ *
+ * The flow:
+ *
+ *   ggui.json.theme (undefined | string | { preset, mode, overrides } | { file, mode })
+ *     → undefined → default light theme
+ *     → string OR { preset } → registry lookup via @ggui-ai/design
+ *     → { file } → readFile → JSON.parse → parseThemeDocument
+ *
+ * Non-throwing per the blueprint + primitive discovery precedent —
+ * one malformed theme should surface as a structured issue, not an
+ * exception. `ggui serve` escalates issues to a fatal exit before
+ * binding a port.
+ *
+ * ## cssVariables pre-rendering
+ *
+ * The loader pre-renders the `:root { --ggui-*: value; }` CSS block
+ * via `@ggui-ai/design/themes`: `parseTheme(id, DtcgTheme)` for the
+ * preset / default paths (full DTCG with canvas + motion tokens) and
+ * `generateCssVariables(ThemeDocument)` for the file path (the
+ * duck-typed walker accepts the plain DTCG document without requiring
+ * the strict {@link DtcgTheme} shape). Downstream consumers (console,
+ * render endpoint, MCP apps iframe) inject the pre-rendered string
+ * without re-walking the token tree.
+ *
+ * ## Mode handling
+ *
+ * `mode: 'light' | 'dark'` is propagated on every `LoadedTheme`
+ * variant so consumers can emit `color-scheme: dark` and pick the
+ * matching variant from the registry. For the file path, `mode`
+ * is metadata only — the file's tokens ARE the resolved theme,
+ * not a switch.
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { dirname, isAbsolute, resolve } from 'node:path';
+import { generateCssVariables, getRawTheme, getTheme, lightTheme, parseTheme, } from '@ggui-ai/design/themes';
+import { parseThemeDocument } from './theme.js';
+/**
+ * Load the theme declared in `ggui.json#theme`, or fall back to the
+ * shipped default when the field is absent.
+ *
+ * Non-throwing — single-issue failure mode returned as a tagged
+ * result. Throws only for programmer errors (non-absolute
+ * `projectRoot`), matching the other discovery helpers.
+ */
+export function loadTheme(options) {
+    const { projectRoot, manifest } = options;
+    if (!isAbsolute(projectRoot)) {
+        throw new Error(`loadTheme: projectRoot must be absolute, got ${projectRoot}`);
+    }
+    const themeConfig = manifest.theme;
+    // ── Default path (no `theme` declared) ──────────────────────────
+    if (themeConfig === undefined) {
+        return {
+            ok: true,
+            theme: {
+                source: 'default',
+                mode: 'light',
+                document: lightTheme,
+                cssVariables: parseTheme('default', lightTheme).cssVariables,
+            },
+        };
+    }
+    // ── String shorthand: preset id ─────────────────────────────────
+    if (typeof themeConfig === 'string') {
+        return loadPreset(themeConfig, 'light', undefined);
+    }
+    // ── File path ───────────────────────────────────────────────────
+    if ('file' in themeConfig) {
+        return loadFile(themeConfig.file, themeConfig.mode ?? 'light', projectRoot);
+    }
+    // ── Preset object ───────────────────────────────────────────────
+    return loadPreset(themeConfig.preset, themeConfig.mode ?? 'light', themeConfig.overrides);
+}
+/**
+ * Resolve a registered preset (with optional mode + overrides) into
+ * a `LoadedTheme`. Returns an issue when the preset id is
+ * unregistered.
+ *
+ * When `overrides` is supplied, each entry is applied as a deep-set
+ * onto the resolved raw `DtcgTheme` BEFORE CSS emission. Unknown
+ * dot-paths are silently dropped — the console token editor mints
+ * valid keys and an accidentally-stale override should not fail
+ * manifest parse.
+ */
+function loadPreset(preset, mode, overrides) {
+    // Resolve the raw token tree first so we can layer overrides
+    // before parseTheme walks the leaves.
+    const raw = getRawTheme(preset, mode);
+    if (!raw) {
+        return {
+            ok: false,
+            issue: {
+                path: preset,
+                message: `Theme preset "${preset}" is not registered. ` +
+                    `Use one of the registered ids (e.g. "ggui", "claudic", ` +
+                    `"premium-zen") or switch to { file: "./..." }.`,
+            },
+        };
+    }
+    // No overrides: hand off to the registry's parser directly so we
+    // share its cache.
+    if (!overrides || Object.keys(overrides).length === 0) {
+        const parsed = getTheme(preset, mode);
+        if (!parsed) {
+            // Should not happen — getRawTheme succeeded above. Defensive.
+            return {
+                ok: false,
+                issue: {
+                    path: preset,
+                    message: `Theme preset "${preset}" parsed unexpectedly empty.`,
+                },
+            };
+        }
+        return {
+            ok: true,
+            theme: {
+                source: 'preset',
+                preset,
+                mode,
+                document: raw,
+                cssVariables: parsed.cssVariables,
+            },
+        };
+    }
+    // With overrides: clone the raw tree, deep-set each leaf's $value,
+    // then re-parse. We bypass the registry's cache because the
+    // override set is per-call and would pollute it.
+    const mutated = applyOverrides(raw, overrides);
+    const parsed = parseTheme(preset, mutated);
+    return {
+        ok: true,
+        theme: {
+            source: 'preset',
+            preset,
+            mode,
+            overrides,
+            document: mutated,
+            cssVariables: parsed.cssVariables,
+        },
+    };
+}
+/**
+ * Load a DTCG JSON file from a project-relative path. Existing
+ * file-loading flow, refactored out of `loadTheme` so the entry
+ * point stays small.
+ */
+function loadFile(filePath, mode, projectRoot) {
+    const absolutePath = isAbsolute(filePath)
+        ? filePath
+        : resolve(projectRoot, filePath);
+    if (!existsSync(absolutePath)) {
+        return {
+            ok: false,
+            issue: {
+                path: filePath,
+                message: `Declared theme file not found. Resolved to ${absolutePath}; ` +
+                    `check the path is correct relative to ggui.json.`,
+            },
+        };
+    }
+    let raw;
+    try {
+        raw = readFileSync(absolutePath, 'utf-8');
+    }
+    catch (cause) {
+        return {
+            ok: false,
+            issue: {
+                path: absolutePath,
+                message: `Could not read theme file: ${errorMessage(cause)}`,
+                cause,
+            },
+        };
+    }
+    let decoded;
+    try {
+        decoded = JSON.parse(raw);
+    }
+    catch (cause) {
+        return {
+            ok: false,
+            issue: {
+                path: absolutePath,
+                message: `Theme file is not valid JSON: ${errorMessage(cause)}`,
+                cause,
+            },
+        };
+    }
+    let document;
+    try {
+        document = parseThemeDocument(decoded);
+    }
+    catch (cause) {
+        return {
+            ok: false,
+            issue: {
+                path: absolutePath,
+                message: `Theme file failed schema validation: ${errorMessage(cause)}`,
+                cause,
+            },
+        };
+    }
+    return {
+        ok: true,
+        theme: {
+            source: 'file',
+            path: absolutePath,
+            mode,
+            document,
+            cssVariables: generateCssVariables(document),
+        },
+    };
+}
+/**
+ * Apply flat dot-path overrides onto a copy of the raw `DtcgTheme`
+ * tree. Each override key (`color.primary.500`) walks into the
+ * tree; only leaves that already exist as `{ $value, $type }` token
+ * objects are mutated — anything else is silently ignored.
+ *
+ * Returns a deep-cloned tree so the source registry entry is not
+ * mutated (the registry's `parsedCache` would otherwise serve stale
+ * CSS to subsequent calls).
+ */
+function applyOverrides(source, overrides) {
+    // Structured clone covers the nested DTCG token tree cleanly —
+    // the tree is plain JSON-shaped data (no functions, no Dates).
+    const cloned = structuredClone(source);
+    for (const [path, value] of Object.entries(overrides)) {
+        const segments = path.split('.');
+        let cursor = cloned;
+        for (let i = 0; i < segments.length - 1; i++) {
+            if (cursor === null || typeof cursor !== 'object')
+                break;
+            cursor = cursor[segments[i]];
+        }
+        if (cursor === null || typeof cursor !== 'object')
+            continue;
+        const leafKey = segments[segments.length - 1];
+        const leaf = cursor[leafKey];
+        if (leaf !== null &&
+            typeof leaf === 'object' &&
+            '$value' in leaf &&
+            '$type' in leaf) {
+            // Mutate $value only — keep $type and any $description intact.
+            leaf.$value = value;
+        }
+    }
+    return cloned;
+}
+/**
+ * Convenience wrapper for the "I have a `ggui.json` path" flow.
+ * Resolves the project root from the manifest path.
+ */
+export function loadThemeFromGguiJsonPath(manifestPath, manifest) {
+    const projectRoot = dirname(resolve(manifestPath));
+    return loadTheme({ projectRoot, manifest });
+}
+function errorMessage(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}

package/dist/theme.d.ts

@@ -0,0 +1,311 @@
+/**
+ * `ggui.json#theme` → plain DTCG JSON document.
+ *
+ * The theme file is a plain JSON document matching the Design Tokens
+ * Community Group (DTCG) spec. It is one of the open file-format
+ * surfaces in the ggui manifest model, alongside
+ * `ggui.primitives.json` and `ggui.ui.json`.
+ *
+ * **Shape parity with the internal `DtcgTheme`.** This v1 schema is
+ * deliberately the same shape as `@ggui-ai/design`'s canonical
+ * {@link DtcgTheme} — `color`/`font`/`spacing`/`shape`/`motion`/
+ * `canvas`/`accessibility`/`zIndex` — so an authored `theme.json`
+ * uses the same vocabulary the curated registry themes (light/dark/
+ * premium-*) use. Previously this schema was Tailwind-style flat
+ * (`typography`/`radius`/`shadow` at root); the v1 schema now mirrors
+ * the internal shape to remove the divergence.
+ *
+ * **External-tool compatibility.** External tooling (Figma Tokens,
+ * Style Dictionary, Tokens Studio) commonly emits only a subset of
+ * the canonical shape. Only the original required groups (`color`,
+ * `font`, `spacing`, `shape`) stay required; `motion`, `canvas`,
+ * `accessibility`, `zIndex`, and the new DTCG metadata fields
+ * (`$name`, `$description`, `$metadata`) are all OPTIONAL so tools
+ * that only emit colors + dimensions still parse cleanly.
+ *
+ * **BREAKING for old `theme.json` files.** Authors who hand-wrote a
+ * `theme.json` against the pre-rc schema must rename:
+ *
+ *   - `typography.fontFamily` → `font.family`
+ *   - `typography.fontSize` → `font.size`
+ *   - `typography.fontWeight` → `font.weight`
+ *   - `typography.lineHeight` → `font.lineHeight`
+ *   - top-level `radius` → `shape.radius`
+ *   - top-level `shadow` → `shape.shadow`
+ *   - top-level `duration` → `motion.duration`
+ *   - top-level `transition` → `motion.transition`
+ *
+ * Plus: under `font.family`, `sans` is the only required sub-token
+ * (was previously freeform); other family slots (`mono`, …) are
+ * optional. The font-family record itself stays open so additional
+ * named families parse without a schema change.
+ *
+ * **Ownership boundary:**
+ *
+ *   - *Where* the theme lives → `ggui.json#theme` (pointer string).
+ *   - *What* the theme file looks like → this module's schema.
+ *   - *How* DTCG tokens become CSS variables → `@ggui-ai/design`'s
+ *     `generateCssVariables` (stays over there; this schema does not
+ *     emit). The duck-typed walker accepts any DTCG-shaped tree, so
+ *     the new nested groups (`font.size`, `shape.radius`, …) walk
+ *     into `--ggui-font-size-md`/`--ggui-shape-radius-md` CSS vars
+ *     without code changes.
+ *   - *Built-in default* when `theme` is absent → `@ggui-ai/design`'s
+ *     shipped `lightTheme`.
+ *
+ * **Extending rules:**
+ *
+ *   1. Additive only within `schema: '1'`. New optional fields must
+ *      default to no-op behaviour so older tooling ignores them.
+ *   2. Framework-neutral + host-neutral. No vendor names in enum
+ *      values, no build-pipeline fields. (`canvas` IS hosting-
+ *      vendor vocabulary; it is opt-in via the optional field.)
+ *   3. Root and per-group objects are strict — unknown keys fail
+ *      parse. Same discipline as `ggui.json`, `ggui.ui.json`, and
+ *      `ggui.primitives.json`.
+ *
+ * **Strictness tradeoff:**
+ *
+ * Individual DTCG token leaves are validated with a discriminated
+ * union over `$type` (color / dimension / fontFamily / fontWeight /
+ * shadow / duration / cubicBezier / transition / number). Each
+ * variant validates its `$value` shape. `$description` is accepted
+ * everywhere as a free-form docstring. Token leaves under newer
+ * groups (`canvas`, `accessibility`, `zIndex`) accept a slightly
+ * wider token vocabulary because external tools sometimes encode
+ * scalar/array values with permissive `$type` strings (`string`,
+ * `array`, …); the schema accepts those without enumerating every
+ * possible spelling.
+ */
+import { z } from 'zod';
+/**
+ * Plain DTCG theme document v1. Required groups (`color`, `font`,
+ * `spacing`, `shape`) map 1:1 to `@ggui-ai/design`'s
+ * `generateCssVariables` walker targets — anything less would mean
+ * a partial CSS output worse than falling back to the shipped
+ * default. Optional groups (`motion`, `canvas`, `accessibility`,
+ * `zIndex`) are the well-known DTCG additives; present → emitted,
+ * absent → the design system's built-in fallbacks apply.
+ *
+ * `$name`, `$description`, and `$metadata` are accepted as optional
+ * DTCG-standard metadata. They round-trip cleanly to/from the
+ * internal `DtcgTheme` shape but external tools don't always emit
+ * them.
+ *
+ * Strict root: unknown top-level keys fail parse. `$schema`,
+ * `$version`, `$name`, `$description`, `$metadata` are all
+ * allow-listed (DTCG metadata); anything else is a typo. Additive
+ * slices add new fields here under `schema: '1'`.
+ */
+export declare const ThemeDocumentV1: z.ZodObject<{
+    /** Optional DTCG spec URL. Not validated — the spec hasn't frozen
+     *  a canonical URL and hand-authored themes often omit it. */
+    $schema: z.ZodOptional<z.ZodString>;
+    /** Optional author-declared version. Not validated — string-form. */
+    $version: z.ZodOptional<z.ZodString>;
+    /** Optional human-readable theme name. DTCG metadata; mirrors
+     *  `DtcgTheme.$name`. */
+    $name: z.ZodOptional<z.ZodString>;
+    /** Optional human-readable theme description. DTCG metadata;
+     *  mirrors `DtcgTheme.$description`. */
+    $description: z.ZodOptional<z.ZodString>;
+    /** Optional metadata bag — font fallback, hosting-philosophy notes,
+     *  etc. Mirrors `DtcgTheme.$metadata`. */
+    $metadata: z.ZodOptional<z.ZodObject<{
+        font: z.ZodOptional<z.ZodString>;
+        fontUrl: z.ZodOptional<z.ZodString>;
+        philosophy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    /** Color tokens — palettes + semantic roles. Required. */
+    color: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        $type: z.ZodLiteral<"color">;
+        $value: z.ZodString;
+        $description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodRecord<z.ZodString, z.ZodObject<{
+        $type: z.ZodLiteral<"color">;
+        $value: z.ZodString;
+        $description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>]>>;
+    /** Spacing scale. Required. */
+    spacing: z.ZodRecord<z.ZodString, z.ZodObject<{
+        $type: z.ZodLiteral<"dimension">;
+        $value: z.ZodString;
+        $description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    /** Font tokens — `family` / `size` / `weight` / `lineHeight`. Required. */
+    font: z.ZodObject<{
+        family: z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodObject<{
+            $type: z.ZodLiteral<"fontFamily">;
+            $value: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>, z.ZodObject<{
+            sans: z.ZodObject<{
+                $type: z.ZodLiteral<"fontFamily">;
+                $value: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strip>>;
+        size: z.ZodRecord<z.ZodString, z.ZodObject<{
+            $type: z.ZodLiteral<"dimension">;
+            $value: z.ZodString;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        weight: z.ZodRecord<z.ZodString, z.ZodObject<{
+            $type: z.ZodLiteral<"fontWeight">;
+            $value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        lineHeight: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            $type: z.ZodLiteral<"number">;
+            $value: z.ZodNumber;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            $type: z.ZodLiteral<"dimension">;
+            $value: z.ZodString;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>;
+    /** Shape tokens — `radius` + `shadow`. Required. */
+    shape: z.ZodObject<{
+        radius: z.ZodRecord<z.ZodString, z.ZodObject<{
+            $type: z.ZodLiteral<"dimension">;
+            $value: z.ZodString;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        shadow: z.ZodRecord<z.ZodString, z.ZodObject<{
+            $type: z.ZodLiteral<"shadow">;
+            $value: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                offsetX: z.ZodString;
+                offsetY: z.ZodString;
+                blur: z.ZodString;
+                spread: z.ZodString;
+                color: z.ZodString;
+            }, z.core.$strict>]>;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    /** Motion tokens — `duration` + `transition` (required sub-records),
+     *  `easing` + `keyframes` (optional sub-records). Optional. */
+    motion: z.ZodOptional<z.ZodObject<{
+        duration: z.ZodRecord<z.ZodString, z.ZodObject<{
+            $type: z.ZodLiteral<"duration">;
+            $value: z.ZodString;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        easing: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            $type: z.ZodLiteral<"cubicBezier">;
+            $value: z.ZodString;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        transition: z.ZodRecord<z.ZodString, z.ZodObject<{
+            $type: z.ZodLiteral<"transition">;
+            $value: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                duration: z.ZodString;
+                timingFunction: z.ZodString;
+                property: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>]>;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        keyframes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            $type: z.ZodString;
+            $value: z.ZodUnknown;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    /** Canvas configuration for the GenerativeCanvas background.
+     *  Optional — external tools won't emit this. */
+    canvas: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodObject<{
+            $type: z.ZodString;
+            $value: z.ZodUnknown;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        speed: z.ZodObject<{
+            $type: z.ZodString;
+            $value: z.ZodUnknown;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        colors: z.ZodObject<{
+            $type: z.ZodString;
+            $value: z.ZodUnknown;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        background: z.ZodObject<{
+            $type: z.ZodString;
+            $value: z.ZodUnknown;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    /** Accessibility tokens (focus ring, reduced motion, high contrast).
+     *  Optional. */
+    accessibility: z.ZodOptional<z.ZodObject<{
+        focusRing: z.ZodOptional<z.ZodObject<{
+            color: z.ZodObject<{
+                $type: z.ZodLiteral<"color">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            width: z.ZodObject<{
+                $type: z.ZodLiteral<"dimension">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            offset: z.ZodObject<{
+                $type: z.ZodLiteral<"dimension">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        reducedMotion: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodObject<{
+                $type: z.ZodLiteral<"duration">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        highContrast: z.ZodOptional<z.ZodObject<{
+            borderWidth: z.ZodObject<{
+                $type: z.ZodLiteral<"dimension">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            textColor: z.ZodObject<{
+                $type: z.ZodLiteral<"color">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            backgroundColor: z.ZodObject<{
+                $type: z.ZodLiteral<"color">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            linkColor: z.ZodObject<{
+                $type: z.ZodLiteral<"color">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    /** Z-index scale. Optional. */
+    zIndex: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        $type: z.ZodLiteral<"number">;
+        $value: z.ZodNumber;
+        $description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+/** Static TypeScript type derived from the v1 schema. */
+export type ThemeDocumentV1 = z.infer<typeof ThemeDocumentV1>;
+/** Canonical type alias used everywhere else. */
+export type ThemeDocument = ThemeDocumentV1;
+/**
+ * Parse a raw JSON value into a validated {@link ThemeDocument}.
+ * Throws a `ZodError` with human-readable issues on invalid input.
+ */
+export declare function parseThemeDocument(raw: unknown): ThemeDocument;
+/**
+ * Safe-parse variant — returns a discriminated `z.safeParse` result.
+ * Prefer this inside CLI tooling where you want to render the issue
+ * list without try/catch.
+ */
+export declare function safeParseThemeDocument(raw: unknown): ReturnType<typeof ThemeDocumentV1.safeParse>;
+//# sourceMappingURL=theme.d.ts.map

package/dist/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../src/theme.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2PxB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,eAAe;IAC1B;kEAC8D;;IAG9D,qEAAqE;;IAGrE;6BACyB;;IAGzB;4CACwC;;IAGxC;8CAC0C;;;;;;IAG1C,0DAA0D;;;;;;;;;;IAG1D,+BAA+B;;;;;;IAG/B,2EAA2E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG3E,oDAAoD;;;;;;;;;;;;;;;;;;;IAGpD;mEAC+D;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG/D;qDACiD;;;;;;;;;;;;;;;;;;;;;;;IAGjD;oBACgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGhB,+BAA+B;;;;;;kBAE/B,CAAC;AAEH,yDAAyD;AACzD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,iDAAiD;AACjD,MAAM,MAAM,aAAa,GAAG,eAAe,CAAC;AAE5C;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,aAAa,CAE9D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,OAAO,GACX,UAAU,CAAC,OAAO,eAAe,CAAC,SAAS,CAAC,CAE9C"}