@vuecs/design 1.0.0

package/dist/core/color-palette/bind.d.ts

@@ -0,0 +1,14 @@
+import type { Ref } from 'vue';
+import type { BindColorPaletteOptions, UseColorPaletteReturn } from './types';
+/**
+ * Wire any reactive `Ref<T>` into the palette runtime: render the
+ * current value via the theme-supplied `render` function, apply it via
+ * `applyColorPaletteCss`, and re-apply on every change.
+ *
+ * Generic: each theme defines its own palette shape `T` and renderer.
+ * `@vuecs/theme-tailwind` wraps this with its `ColorPaletteConfig` and
+ * `renderColorPaletteStyles`; community themes can do the same with their
+ * own shapes — including custom merge semantics via `options.extend`.
+ */
+export declare function bindColorPalette<T>(source: Ref<T>, options: BindColorPaletteOptions<T>): UseColorPaletteReturn<T>;
+//# sourceMappingURL=bind.d.ts.map

package/dist/core/color-palette/bind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.d.ts","sourceRoot":"","sources":["../../../src/core/color-palette/bind.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE/B,OAAO,KAAK,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAE9E;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAC9B,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,EACd,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GACpC,qBAAqB,CAAC,CAAC,CAAC,CAyC1B"}

package/dist/core/color-palette/catalog.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Canonical palette catalog for the vuecs design system.
+ *
+ * The names originated in Tailwind v4 (see `@vuecs/design/standalone`'s
+ * `palettes.css`, generated from `tailwindcss/theme.css`), but the
+ * catalog is now considered design-owned: every supported palette
+ * source — Tailwind via `@import "tailwindcss"`, or the
+ * standalone subpath — provides the matching `--color-<palette>-<shade>`
+ * literals so `setColorPalette()` resolves correctly regardless of
+ * whether Tailwind is loaded.
+ *
+ * Themes typically reuse this catalog verbatim (theme-tailwind and
+ * theme-bulma both declare `palette.names: COLOR_PALETTES`). A theme
+ * with extra palette names just defines its own local union:
+ *
+ *     type AcmePaletteName = ColorPaletteName | 'acme-blue';
+ *
+ * — and ships its own `palette.names` array.
+ */
+/**
+ * The six semantic scales every vuecs theme exposes through the
+ * `--vc-color-<scale>-*` variable family. A `setColorPalette({
+ * primary: 'green' })` call binds one scale to one palette catalog
+ * entry at runtime.
+ */
+export declare const SEMANTIC_SCALES: readonly ["primary", "neutral", "success", "warning", "error", "info"];
+export type SemanticScaleName = typeof SEMANTIC_SCALES[number];
+/**
+ * The 22 catalog palettes shipped with `@vuecs/design` (sourced
+ * verbatim from Tailwind v4). Any of these can be assigned to a
+ * `SemanticScaleName` via `setColorPalette()`.
+ */
+export declare const COLOR_PALETTES: readonly ["slate", "gray", "zinc", "neutral", "stone", "red", "orange", "amber", "yellow", "lime", "green", "emerald", "teal", "cyan", "sky", "blue", "indigo", "violet", "purple", "fuchsia", "pink", "rose"];
+/**
+ * Augmentation hook for community themes that extend the catalog with
+ * their own palette names. Defaults to empty — `ColorPaletteName` is just
+ * the 22-name Tailwind-derived catalog. A theme that ships extra palettes
+ * widens the union via declaration merging:
+ *
+ *     declare module '@vuecs/design' {
+ *         interface ExtraColorPaletteNames {
+ *             'acme-blue': true;
+ *             'acme-orange': true;
+ *         }
+ *     }
+ *
+ * Both the SPA composables (`@vuecs/theme-tailwind`'s `useColorPalette`,
+ * etc.) and `@vuecs/nuxt`'s `colorPalette.value` option pick up the
+ * extension automatically because both type against `ColorPaletteName`.
+ */
+export interface ExtraColorPaletteNames {
+}
+export type ColorPaletteName = typeof COLOR_PALETTES[number] | keyof ExtraColorPaletteNames;
+/**
+ * Tailwind-style 11-stop shade ladder. The same ladder appears in
+ * every catalog entry (the standalone subpath's `palettes.css` and
+ * Tailwind's own `theme.css` both emit `--color-<palette>-<shade>`
+ * for each stop).
+ */
+export declare const COLOR_PALETTE_SHADES: readonly ["50", "100", "200", "300", "400", "500", "600", "700", "800", "900", "950"];
+export type ColorPaletteShade = typeof COLOR_PALETTE_SHADES[number];
+/**
+ * Canonical runtime palette config — a partial mapping of every
+ * semantic scale to a catalog palette name. Used by every theme that
+ * opts into runtime palette switching (`theme-tailwind`, `theme-bulma`,
+ * and any future palette-aware theme).
+ *
+ * Both keys (`SemanticScaleName`) and values (`ColorPaletteName`)
+ * widen automatically via declaration merging: `ExtraColorPaletteNames`
+ * adds value-side names; the canonical scale list is fixed at six.
+ *
+ * Themes whose internal scale names diverge from the canonical six
+ * declare a `scaleAliases` map on their `Theme.palette` slot — the
+ * dispatcher translates input keys before calling `palette.handle`,
+ * so the public-facing config still uses canonical names.
+ */
+export type ColorPaletteConfig = Partial<Record<SemanticScaleName, ColorPaletteName>>;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/core/color-palette/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/core/color-palette/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,eAAe,wEAOlB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,cAAc,gNAuBjB,CAAC;AAEX;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,sBAAsB;CAAG;AAE1C,MAAM,MAAM,gBAAgB,GAAG,OAAO,cAAc,CAAC,MAAM,CAAC,GAAG,MAAM,sBAAsB,CAAC;AAE5F;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,uFAYvB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,OAAO,oBAAoB,CAAC,MAAM,CAAC,CAAC;AAEpE;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,iBAAiB,EAAE,gBAAgB,CAAC,CAAC,CAAC"}

package/dist/core/color-palette/composable.d.ts

@@ -0,0 +1,34 @@
+import type { UseColorPaletteOptions, UseColorPaletteReturn } from './types';
+/**
+ * Theme-aware reactive palette state — un-shared variant.
+ *
+ * Concatenates every installed theme's `palette.handle` output into the
+ * `<style id="vc-color-palette">` element. Walking the installed themes
+ * each render means runtime theme swaps via `setThemes()` automatically
+ * pick up the new renderer chain.
+ *
+ * Concat (rather than last-wins) is the doctrinal semantic: when an app
+ * stacks multiple palette-aware themes (the docs-site case where
+ * Tailwind components and Bulma components share the same picker UI),
+ * each theme's renderer emits its own non-overlapping CSS rules —
+ * Tailwind rebinds `--vc-color-*`, Bulma writes per-variant HSL channel
+ * vars. The CSS cascade resolves any incidental overlap with
+ * later-rule-wins semantics, so concat behaves like last-wins for
+ * overlapping properties AND emits both themes' unique properties.
+ *
+ * Production callers should use `useColorPalette` (the shared variant
+ * below). This un-shared form is exposed primarily for testing — every
+ * call creates a fresh `watchEffect` and palette state.
+ */
+export declare function useColorPaletteUnshared<T extends Record<string, unknown> = Record<string, string>>(options?: UseColorPaletteOptions<T>): UseColorPaletteReturn<T>;
+/**
+ * Theme-aware reactive palette state with localStorage persistence
+ * (plan 021 slice 2).
+ *
+ * Wrapped with `createSharedComposable` so every call site shares the
+ * same ref + watcher. For SSR-aware cookie-backed storage (Nuxt), the
+ * matching Nuxt module ships its own composable that calls
+ * `bindColorPalette()` directly with a cookie-backed ref.
+ */
+export declare const useColorPalette: typeof useColorPaletteUnshared;
+//# sourceMappingURL=composable.d.ts.map

package/dist/core/color-palette/composable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composable.d.ts","sourceRoot":"","sources":["../../../src/core/color-palette/composable.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AA4C7E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CACnC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5D,OAAO,GAAE,sBAAsB,CAAC,CAAC,CAAM,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAkFnE;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,gCAAkD,CAAC"}

package/dist/core/color-palette/index.d.ts

@@ -0,0 +1,7 @@
+export * from './apply';
+export * from './bind';
+export * from './catalog';
+export * from './composable';
+export * from './render';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/color-palette/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/color-palette/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}

package/dist/core/color-palette/render.d.ts

@@ -0,0 +1,16 @@
+import type { ThemeRuntimeEntry } from '../theme-runtime/types';
+/**
+ * Concatenate every installed theme's `palette.handle` output into a
+ * single CSS string. SSR plugins emit the result as the
+ * `<style id="vc-color-palette">` block so palette-aware themes flow
+ * on first paint.
+ *
+ * Mirrors the client-side concat semantics in `useColorPalette()`:
+ * non-overlapping rules from different themes coexist; CSS cascade
+ * resolves any incidental overlap with later-rule-wins.
+ *
+ * Errors thrown by a theme's handler are caught + logged so one
+ * broken theme can't crash SSR; other themes still emit.
+ */
+export declare function renderColorPaletteFromThemes(themes: readonly ThemeRuntimeEntry[], palette: Record<string, string>): string;
+//# sourceMappingURL=render.d.ts.map

package/dist/core/color-palette/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../../src/core/color-palette/render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CACxC,MAAM,EAAE,SAAS,iBAAiB,EAAE,EACpC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,MAAM,CAgCR"}

package/dist/core/color-palette/types.d.ts

@@ -0,0 +1,107 @@
+import type { ComputedRef, Ref } from 'vue';
+export interface UseColorPaletteReturn<T> {
+    /** Read-only view of the current palette. */
+    current: ComputedRef<T>;
+    /**
+     * Replace the entire palette. Themes typically pass an empty config
+     * to reset to defaults (the meaning of "empty" is theme-defined).
+     */
+    set(palette: T): void;
+    /**
+     * Merge `partial` over the current value via the theme's `extend`
+     * implementation. Default semantics: shallow object spread. Themes
+     * with non-object palette shapes pass their own via `BindColorPaletteOptions.extend`.
+     */
+    extend(partial: Partial<T>): void;
+}
+export interface BindColorPaletteOptions<T> {
+    /** Render the palette value as a CSS string applied to `<style id="vc-color-palette">`. */
+    render: (value: T) => string;
+    /**
+     * Override the default shallow-merge semantics of `extend()`. The
+     * default works for any `Record`-shaped palette; themes with
+     * structured non-object shapes (deep-merge, replace-on-conflict,
+     * etc.) supply their own here.
+     */
+    extend: (current: T, partial: Partial<T>) => T;
+    /**
+     * Target a non-global Document (iframes, test environments).
+     * Defaults to `globalThis.document`; on the server (`undefined`)
+     * the watcher is still installed but `applyColorPaletteCss` is a
+     * no-op — the first reactive read on the client triggers a re-paint.
+     */
+    document?: Document;
+    /**
+     * CSP nonce written to the `<style id="vc-color-palette">` element.
+     * Accepts a string (resolved once) or a getter `() => string | undefined`
+     * (called on every re-apply, so reactive nonce changes propagate).
+     */
+    nonce?: string | (() => string | undefined);
+}
+/**
+ * Options for the generic theme-aware `useColorPalette()` dispatcher.
+ *
+ * `useColorPalette` is wrapped with `createSharedComposable`, so these
+ * options are honored **only on the first call**. Subsequent invocations
+ * from anywhere in the app receive the cached instance with the original
+ * options — passing a different `storageKey`, `sanitize`, or `extend` is
+ * a silent no-op. For per-call configuration with custom storage,
+ * compose `bindColorPalette()` directly with your own ref.
+ */
+export interface UseColorPaletteOptions<T extends Record<string, unknown>> {
+    /** Initial palette when no persisted value exists. Default: `{}` (cast to `T`). */
+    initial?: T;
+    /**
+     * Reactive backing store for the palette state. When provided,
+     * overrides the default `useStorage` / `ref` backing — useful for
+     * SSR-aware persistence (e.g. `@vuecs/nuxt`'s cookie-backed
+     * composable passes `useCookie<T>(name)` here). When omitted, the
+     * composable falls back to localStorage (`persist: true`) or an
+     * in-memory `ref` (`persist: false`).
+     *
+     * The composable still walks installed themes' `palette.handle`
+     * hooks and re-applies the rendered CSS on every change to `source`
+     * — only the persistence layer is replaced.
+     */
+    source?: Ref<T>;
+    /**
+     * Persist via localStorage (`useStorage` from `@vueuse/core`).
+     * Ignored when `source` is provided. Default: `true`.
+     */
+    persist?: boolean;
+    /**
+     * Storage key for the default backend. Ignored when `source` is
+     * provided. Default: `'vc-color-palette'`.
+     */
+    storageKey?: string;
+    /**
+     * Theme-aware sanitizer for serialized values. The default filters
+     * input keys to `SEMANTIC_SCALES` and input values to `COLOR_PALETTES`
+     * (the canonical catalog) — sufficient for both shipping themes.
+     * Pass your own to widen acceptance for themes that use
+     * `ExtraColorPaletteNames`. (`Theme.palette.scaleAliases` doesn't
+     * affect this layer — aliases translate canonical keys inside the
+     * dispatcher AFTER sanitize runs, so the sanitizer still keys on
+     * canonical names.)
+     */
+    sanitize?: (raw: unknown) => T;
+    /**
+     * Override the default shallow-merge semantics of `extend()`. Default:
+     * `{ ...current, ...partial }`. Themes with structured non-object
+     * shapes supply their own.
+     */
+    extend?: (current: T, partial: Partial<T>) => T;
+    /**
+     * CSP nonce written to the `<style id="vc-color-palette">` element.
+     * Accepts a string (resolved once) or a getter
+     * `() => string | undefined` (called on every re-render, so reactive
+     * nonce changes propagate). CSP-strict consumers wire this from
+     * `@vuecs/core`'s `useConfig('nonce')`:
+     *
+     *     useColorPalette({ nonce: () => useConfig('nonce').value })
+     *
+     * Left unset, no nonce attribute is emitted.
+     */
+    nonce?: string | (() => string | undefined);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/color-palette/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/color-palette/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE5C,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACpC,6CAA6C;IAC7C,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACxB;;;OAGG;IACH,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC;IACtB;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;CACrC;AAED,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACtC,2FAA2F;IAC3F,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAC/C;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC;CAC/C;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,sBAAsB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACrE,mFAAmF;IACnF,OAAO,CAAC,EAAE,CAAC,CAAC;IACZ;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;IAChB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,CAAC,CAAC;IAC/B;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAChD;;;;;;;;;;OAUG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC;CAC/C"}

package/dist/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from './color-mode';
+export * from './color-palette';
+export * from './theme-runtime';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC"}

package/dist/core/theme-runtime/capture.d.ts

@@ -0,0 +1,32 @@
+import type { ThemeRuntimeEntry } from './types';
+/**
+ * Build a synthetic Document-like whose `documentElement` records
+ * `setAttribute` / `removeAttribute` calls into the supplied target
+ * record, plus a no-op `classList`. **No other Document or Element
+ * APIs are stubbed** — themes that call `doc.createElement`,
+ * `doc.head.appendChild`, etc. WILL throw at SSR runtime. Themes
+ * needing richer DOM access from `colorMode.handle` should guard their
+ * CSR-only logic with `if (typeof window === 'undefined') return;`
+ * and split the SSR-flowing bits into declarative `setAttribute` calls.
+ *
+ * Exposed for advanced consumers; the higher-level
+ * `captureColorModeAttrs()` covers the common case and catches errors
+ * per theme so a single broken theme can't crash SSR.
+ */
+export declare function createCaptureDocument(target: Record<string, string>): Document;
+/**
+ * Walk every installed theme's `colorMode.handle` against a synthetic
+ * Document and capture the resulting attribute mutations. SSR plugins
+ * use this to flow `data-bs-theme` / `data-theme` (or any other
+ * attribute a theme declares) into `useHead({ htmlAttrs })` before
+ * first paint.
+ *
+ * Each theme's handler runs in install order. If multiple themes set
+ * the same attribute, the last one wins — same semantic as the live
+ * `document.documentElement.setAttribute` chain on the client.
+ *
+ * Errors thrown by a theme's handler are caught + logged as a warning
+ * so one malformed theme can't crash SSR; other themes still run.
+ */
+export declare function captureColorModeAttrs(themes: readonly ThemeRuntimeEntry[], mode: 'light' | 'dark'): Record<string, string>;
+//# sourceMappingURL=capture.d.ts.map

package/dist/core/theme-runtime/capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../../../src/core/theme-runtime/capture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAuBjD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,QAAQ,CAwB9E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACjC,MAAM,EAAE,SAAS,iBAAiB,EAAE,EACpC,IAAI,EAAE,OAAO,GAAG,MAAM,GACvB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA8BxB"}

package/dist/core/theme-runtime/composable.d.ts

@@ -0,0 +1,34 @@
+import type { InjectionKey } from 'vue';
+import type { ThemeRuntimeManager } from './types';
+/**
+ * Globally-shared `InjectionKey` for the ThemeManager. SSR plugins
+ * (Nuxt, future frameworks) that need to look up the manager from
+ * outside Vue's component context use this with `app.runWithContext`
+ * (or equivalent) + `inject`.
+ *
+ * Bridge between `@vuecs/design` and `@vuecs/core`'s `ThemeManager`
+ * without a hard runtime dep: both packages reference the same
+ * `Symbol.for('VCThemeManager')` registry key, so the ThemeManager
+ * provided by `installThemeManager(app)` (in `@vuecs/core`) is
+ * reachable here. `Symbol.for(...)` is reference-equal across module
+ * boundaries, and the `InjectionKey<ThemeRuntimeManager>` cast
+ * surfaces the manager type to `inject()` callers without leaking
+ * `@vuecs/core` internals.
+ *
+ * `inject()` returns `undefined` if no ThemeManager is installed —
+ * design composables use that as the "no theme dispatch" fallback so
+ * they keep working in standalone apps that import `@vuecs/design`
+ * without `@vuecs/core`.
+ */
+export declare const THEME_RUNTIME_MANAGER_SYMBOL: InjectionKey<ThemeRuntimeManager>;
+/**
+ * Look up the ThemeManager installed by `app.use(vuecs)` (or
+ * `installThemeManager(app)`). Returns `undefined` if no manager is
+ * provided in the current setup context — design composables fall back
+ * to no-dispatch behaviour in that case.
+ *
+ * Must be called during `setup()` or another composable's setup phase
+ * (Vue's `inject()` requirement).
+ */
+export declare function useThemeRuntimeManager(): ThemeRuntimeManager | undefined;
+//# sourceMappingURL=composable.d.ts.map

package/dist/core/theme-runtime/composable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composable.d.ts","sourceRoot":"","sources":["../../../src/core/theme-runtime/composable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAC;AAExC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,4BAA4B,EAAmC,YAAY,CAAC,mBAAmB,CAAC,CAAC;AAE9G;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,IAAI,mBAAmB,GAAG,SAAS,CAExE"}

package/dist/core/theme-runtime/index.d.ts

@@ -0,0 +1,4 @@
+export * from './capture';
+export * from './composable';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/theme-runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/theme-runtime/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}

package/dist/core/theme-runtime/types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Minimal structural projection of `@vuecs/core`'s `ThemeManager`.
+ * Only the surface design composables actually need is declared
+ * locally — keeps the bridge a runtime-only contract.
+ */
+export interface ThemeRuntimeColorModeHook {
+    /**
+     * Called when the resolved color mode changes (or on first mount).
+     * Side-effecting — themes typically set framework-specific
+     * attributes on `doc.documentElement`. Named `handle` (not `apply`)
+     * to avoid collision with `Function.prototype.apply`.
+     */
+    handle(doc: Document, mode: 'light' | 'dark'): void;
+}
+export interface ThemeRuntimePaletteHook {
+    /**
+     * Pure function — receives the resolved palette config and returns
+     * a CSS string. Named `handle` to align with
+     * `ThemeRuntimeColorModeHook.handle`.
+     */
+    handle(palette: Record<string, string>): string;
+    names?: readonly string[];
+    /**
+     * Optional canonical-scale → theme-scale rename map. The dispatcher
+     * translates input keys before calling `handle`. See `PaletteHook`
+     * in `@vuecs/core` for the authoring-side contract.
+     */
+    scaleAliases?: Record<string, string>;
+}
+export interface ThemeRuntimeEntry {
+    colorMode?: ThemeRuntimeColorModeHook;
+    palette?: ThemeRuntimePaletteHook;
+}
+export interface ThemeRuntimeManager {
+    /**
+     * Reactive list of installed themes (reads through `ThemeManager`'s
+     * `shallowRef`, so accessing this inside a `watch` callback tracks
+     * theme swaps via `setThemes()`).
+     */
+    readonly themes: readonly ThemeRuntimeEntry[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/theme-runtime/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/theme-runtime/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACtC;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAAC;CACvD;AAED,MAAM,WAAW,uBAAuB;IACpC;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC;IAChD,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAC9B,SAAS,CAAC,EAAE,yBAAyB,CAAC;IACtC,OAAO,CAAC,EAAE,uBAAuB,CAAC;CACrC;AAED,MAAM,WAAW,mBAAmB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACjD"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './core';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC"}