@almadar/shell-web 0.0.0-stage → 0.1.0

package/dist/Select-mDZIwNqN.d.ts

@@ -0,0 +1,199 @@
+import React__default from 'react';
+import { A11yProps, Asset, EventKey, EventPayload, EventEmit } from '@almadar/core';
+import { I as IconInput } from './fx-CmQjnHmT.js';
+
+type ButtonVariant = "primary" | "secondary" | "ghost" | "danger" | "success" | "warning" | "default" | "link";
+type ButtonSize = "sm" | "md" | "lg";
+/** @accessibleName label */
+interface ButtonProps extends Omit<React__default.ButtonHTMLAttributes<HTMLButtonElement>, keyof A11yProps | 'onClick'>, A11yProps {
+    /** Additional CSS classes applied to the root element. */
+    className?: string;
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    isLoading?: boolean;
+    /** Left icon: a Lucide component or a canonical icon name string (e.g. "plus", "trash"). */
+    leftIcon?: IconInput;
+    /** Right icon: a Lucide component or a canonical icon name string. */
+    rightIcon?: IconInput;
+    /** Alias for leftIcon */
+    icon?: IconInput;
+    /** Alias for rightIcon */
+    iconRight?: IconInput;
+    /** Asset image rendered as the leading icon; takes precedence over icon/leftIcon when provided. */
+    iconAsset?: Asset;
+    /** Declarative event name — emits UI:{action} via eventBus on click */
+    action?: EventKey;
+    /** Payload to include with the action event
+     *  @payloadFor action
+     */
+    actionPayload?: EventPayload;
+    /**
+     * Button label text (alternative to children for schema-driven rendering)
+     * @example Button
+     */
+    label?: string;
+    /** Disable the button (greys out, blocks click events) */
+    disabled?: boolean;
+    /** Makes the button a link: `#anchor` scrolls, an absolute URL loads, a path navigates in-app */
+    href?: string;
+    /**
+     * Runs on activation, on the button or, with `href`, on the link; calling
+     * `preventDefault()` there keeps a link from following its `href`.
+     */
+    onClick?: (event: React__default.MouseEvent<HTMLButtonElement | HTMLAnchorElement>) => void;
+    /** Test identifier for automated tests */
+    'data-testid'?: string;
+}
+declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface SelectOption$1 {
+    value: string;
+    label: string;
+}
+/** @accessibleName label */
+interface InputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, "onChange" | Exclude<keyof A11yProps, "role" | "dir">>, Omit<A11yProps, "role" | "dir"> {
+    /** Additional CSS classes applied to the root element. */
+    className?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Current value */
+    value?: string | number;
+    /** Whether input is disabled */
+    disabled?: boolean;
+    /** Declarative event name for trait dispatch.
+     *  @payloadTypeWhen value inputType=number->number
+     */
+    action?: EventEmit<{
+        value: string | number;
+    }>;
+    /**
+     * Input type — selects the field's data mode. Use 'password' for masked
+     * credentials / secret / passphrase entry (there is no separate password
+     * pattern); 'email', 'tel', 'url', 'number', 'search', 'date', and 'time'
+     * for their respective values; and 'select' / 'textarea' for choice and
+     * multi-line entry in addition to the standard single-line types.
+     */
+    inputType?: "text" | "email" | "password" | "number" | "tel" | "url" | "search" | "date" | "datetime-local" | "time" | "checkbox" | "select" | "textarea";
+    label?: string;
+    helperText?: string;
+    error?: string;
+    leftIcon?: IconInput;
+    rightIcon?: IconInput;
+    /** Lucide icon component or canonical kebab-case icon name string for left side */
+    icon?: IconInput;
+    /** Show clear button when input has value */
+    clearable?: boolean;
+    /** Callback or declarative event key when clear button is clicked */
+    onClear?: (() => void) | EventKey;
+    /** Options for select type */
+    options?: SelectOption$1[];
+    /** Rows for textarea type */
+    rows?: number;
+    /** onChange handler or declarative event key for trait dispatch */
+    onChange?: React__default.ChangeEventHandler<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement> | EventEmit<{
+        value: string;
+    } | {
+        checked: boolean;
+    }>;
+}
+declare const Input: React__default.ForwardRefExoticComponent<InputProps & React__default.RefAttributes<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>>;
+
+/**
+ * PatternTile Atom
+ *
+ * Mathematically correct Islamic geometric pattern tiles using the
+ * Polygons-in-Contact (PIC) method (Hankin 1925, formalized by Kaplan 2005).
+ *
+ * Construction: A regular polygon tiling is overlaid with star motifs.
+ * Each motif touches the enclosing polygon at EDGE MIDPOINTS only.
+ * Two rays emanate from each midpoint into the polygon at a specific
+ * CONTACT ANGLE (theta). Where rays from adjacent midpoints intersect,
+ * they form the star points. Gap tiles (squares, triangles) between
+ * polygons receive inferred geometry by extending boundary rays inward.
+ *
+ * Variants:
+ *   star8  — 8-fold star-and-cross on 4.8.8 tiling (theta = 67.5 deg)
+ *   star6  — 6-fold star on hexagonal tiling (theta = 60 deg)
+ *   khatam — 8-fold rosette with interlocking kites (theta = 72 deg)
+ *   star10 — 10-fold girih on decagonal tiling (theta = 72 deg)
+ *   star12 — 12-fold on dodecagonal tiling (theta = 75 deg)
+ *
+ * All tiles use stroke only (no fill), rendering as transparent overlays.
+ */
+
+type PatternVariant = 'star8' | 'star6' | 'khatam' | 'star10' | 'star12' | 'rosette-double' | 'rosette-filled' | 'seigaiha' | 'greek-key' | 'celtic-knot' | 'kolam' | 'arch' | 'arabesque-vine' | 'arabesque-net';
+interface PatternTileProps extends A11yProps {
+    /** Which geometric pattern to render */
+    variant?: PatternVariant;
+    /** Tile unit size in SVG units */
+    size?: number;
+    /** Stroke color (CSS variable or hex) */
+    color?: string;
+    /** Line thickness */
+    strokeWidth?: number;
+    className?: string;
+}
+declare const PatternTile: React__default.FC<PatternTileProps>;
+/** Returns the tile dimensions for a given variant and size */
+declare function getTileDimensions(variant: PatternVariant, size: number): {
+    width: number;
+    height: number;
+};
+
+interface SelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    /** Leading content rendered in rich mode only (native mode ignores this). */
+    icon?: React__default.ReactNode;
+    /** Secondary line of text rendered below label in rich mode only. */
+    secondaryLabel?: string;
+    /** dir attribute applied to the option row in rich mode only. */
+    dir?: string;
+}
+interface SelectOptionGroup {
+    label: string;
+    options: SelectOption[];
+}
+/** @accessibleName label */
+interface SelectProps extends Omit<React__default.SelectHTMLAttributes<HTMLSelectElement>, "children" | "onChange" | "multiple" | keyof A11yProps>, A11yProps {
+    /** Additional CSS classes applied to the root element. */
+    className?: string;
+    /** Visible label naming the control. */
+    label?: string;
+    /** Select options (flat list) */
+    options?: SelectOption[];
+    /** Grouped options — rendered as <optgroup> in native mode, sections in rich mode. */
+    groups?: SelectOptionGroup[];
+    /** Placeholder text */
+    placeholder?: string;
+    /** Current value (string for single, string[] for multiple) */
+    value?: string | string[];
+    /** Declarative event name for trait dispatch — emits `{ value }` on selection commit (same gestures as `onChange`). */
+    action?: EventEmit<{
+        value: string | string[];
+    }>;
+    /** Error message */
+    error?: string;
+    /** Allow selecting multiple values — activates the rich dropdown. */
+    multiple?: boolean;
+    /** Show a search input inside the dropdown — activates the rich dropdown. */
+    searchable?: boolean;
+    /** Show a clear button when a value is selected. */
+    clearable?: boolean;
+    /** onChange handler (native ChangeEvent) or declarative event key for trait dispatch */
+    onChange?: React__default.ChangeEventHandler<HTMLSelectElement> | EventEmit<{
+        value: string | string[];
+    }>;
+    /** Value-based change: a React callback (internal use) OR a declarative event
+     *  key that emits `{ value }` on the bus (render-ui / lolo authoring). Mirrors
+     *  the `onChange` handler|event convention so it's an event-emitting prop, not a
+     *  bare callback. */
+    onValueChange?: ((value: string | string[]) => void) | EventEmit<{
+        value: string | string[];
+    }>;
+}
+declare const Select: React__default.ForwardRefExoticComponent<SelectProps & React__default.RefAttributes<HTMLSelectElement>>;
+
+export { Button as B, Input as I, PatternTile as P, Select as S, getTileDimensions as j };
+export type { ButtonProps as a, ButtonSize as b, ButtonVariant as c, InputProps as d, PatternTileProps as e, PatternVariant as f, SelectOption as g, SelectOptionGroup as h, SelectProps as i };

package/dist/ServerBridge-Cm1On51b.d.ts

@@ -0,0 +1,233 @@
+import * as React from 'react';
+import React__default, { ReactNode } from 'react';
+import { EntityRow, TraitConfig, SkeletonNode, ResolvedEntity, EventPayload, ResolvedTrait, ResolvedTraitBinding, OrbitalSchema } from '@almadar/core';
+import { EventTransport, AccessTokenProvider } from '@almadar/shell-runtime/client/EventTransport';
+import './verification-C5pTeMJv.js';
+
+/**
+ * Read + subscribe surface over the live trait binding stores. Snapshots
+ * are cached objects — a new reference only when the trait's entity
+ * actually changed (the `useSyncExternalStore` contract).
+ */
+interface EntityBindingSource {
+    /** Current entity snapshot for a trait (shared-entity traits read the shared store). */
+    getEntitySnapshot: (traitName: string) => EntityRow;
+    /** Merged render-time config (declared defaults < resolved < call-site). */
+    getConfig: (traitName: string) => TraitConfig | undefined;
+    /** Current state-machine state — evaluation context for `@state` in marked expressions. */
+    getState: (traitName: string) => string;
+    /** Subscribe to entity commits for a trait. Returns unsubscribe. */
+    subscribe: (traitName: string, callback: () => void) => () => void;
+}
+declare const EntityBindingContext: React.Context<EntityBindingSource | null>;
+/**
+ * Bridge one trait's live bindings into React. With no provider (compiled
+ * shell, static renders) or no owning trait, returns empty bindings and
+ * never re-renders — markers resolve to the same `undefined` they would
+ * have resolved to at flush time against an empty entity.
+ */
+declare function useEntityBindingSnapshot(traitName: string | undefined): {
+    entity: EntityRow;
+    config: TraitConfig | undefined;
+    state: string;
+};
+
+interface AwaitingSkeletonSource {
+    /** The predicted skeleton for a top-level slot, from a non-embedded awaiting render. */
+    forSlot: (slot: string) => SkeletonNode | undefined;
+    /** The predicted skeleton for an embedded trait's frame. */
+    forTrait: (traitName: string) => SkeletonNode | undefined;
+    subscribe: (callback: () => void) => () => void;
+    getVersion: () => number;
+}
+declare const AwaitingSkeletonContext: React.Context<AwaitingSkeletonSource | null>;
+declare function useAwaitingSkeleton(target: {
+    slot: string;
+} | {
+    trait: string;
+}): SkeletonNode | undefined;
+
+/**
+ * EntitySchemaContext
+ *
+ * Minimal context providing entity schema definitions (field metadata).
+ * This is NOT a data store — actual entity rows flow through the state
+ * machine's `@payload.data` binding on the emitting trait's fetch-success
+ * transition and land on the rendering component's `entity` prop.
+ *
+ * Replaces EntityStore's schema functionality without the mock data generation.
+ *
+ * @packageDocumentation
+ */
+
+interface EntitySchemaContextValue {
+    /** Entity definitions (schema metadata only) */
+    entities: Map<string, ResolvedEntity>;
+    /**
+     * Per-trait linkedEntity name. `ResolvedTrait` itself doesn't carry
+     * linkedEntity (it lives on `ResolvedTraitBinding` at the page-binding
+     * level), so OrbPreview pre-projects every page's trait bindings into
+     * a flat `traitName → entityName` map for the slot renderer.
+     *
+     * Used by SlotContentRenderer to resolve `entityDef` via
+     * `traitLinkedEntities.get(sourceTrait) → entities.get(...)` when the
+     * rendered pattern's `entity:` prop is a resolved value (V2 path)
+     * rather than a string entity-name. Without this lookup, form-section
+     * can't enrich its fields with entity field metadata (values enum,
+     * etc.) and an enum field renders as a plain text input. Closes VR3.
+     */
+    traitLinkedEntities: ReadonlyMap<string, string>;
+    /**
+     * Per-trait owning-orbital name. Same shape as `traitLinkedEntities`,
+     * built from `schema.orbitals[].traits[]`. UISlotRenderer uses this
+     * to wrap each slot's rendered subtree in `TraitScopeProvider` so
+     * descendant pure components (Button, etc.) emit qualified
+     * `UI:Orbital.Trait.EVENT` keys via the scoped useEventBus.
+     */
+    orbitalsByTrait: ReadonlyMap<string, string>;
+}
+interface EntitySchemaProviderProps {
+    /** Entity definitions from resolved schema */
+    entities: ResolvedEntity[];
+    /**
+     * Per-trait linkedEntity name, projected from every page's
+     * ResolvedTraitBinding. Optional for back-compat; when omitted,
+     * SlotContentRenderer's enrichment path can only follow the
+     * legacy V1 string-entity-name lookup.
+     */
+    traitLinkedEntities?: ReadonlyMap<string, string>;
+    /**
+     * Per-trait owning-orbital name. Required for the runtime path's
+     * trait-scoped event qualification (Button etc. emit qualified keys
+     * via TraitScopeProvider). Optional for back-compat with consumers
+     * that don't yet thread the orbital map through.
+     */
+    orbitalsByTrait?: ReadonlyMap<string, string>;
+    /** Children */
+    children: React__default.ReactNode;
+}
+/**
+ * Provides entity schema definitions to the component tree.
+ *
+ * This is a lightweight provider that only holds schema metadata (field definitions).
+ * Actual entity rows arrive via `@payload.data` on the rendering trait's
+ * success transition — they do NOT live in this context.
+ */
+declare function EntitySchemaProvider({ entities, traitLinkedEntities, orbitalsByTrait, children, }: EntitySchemaProviderProps): React__default.ReactElement;
+/**
+ * Access entity schema definitions.
+ * Use this for field metadata (form building, filter enrichment).
+ * Actual entity rows flow via `@payload.data` on the state machine's
+ * success transition — never read them from a context.
+ */
+declare function useEntitySchema(): EntitySchemaContextValue;
+/**
+ * Safe version of useEntitySchema that returns null when no provider is present.
+ * Used by UISlotRenderer which may render outside an EntitySchemaProvider (compiled mode).
+ */
+declare function useEntitySchemaOptional(): EntitySchemaContextValue | null;
+
+/**
+ * TraitProvider Component
+ *
+ * Provides trait state machines to child components via React context.
+ *
+ * @packageDocumentation
+ */
+
+interface TraitInstance {
+    /** Trait name */
+    name: string;
+    /** Current state */
+    currentState: string;
+    /** Available events (can be triggered) */
+    availableEvents: string[];
+    /** Dispatch an event to the state machine */
+    dispatch: (eventKey: string, payload?: EventPayload) => void;
+    /** Check if an event can be dispatched */
+    canDispatch: (eventKey: string) => boolean;
+    /** Get the full trait definition */
+    trait: ResolvedTrait;
+}
+interface TraitContextValue {
+    /** All trait instances on this page */
+    traits: Map<string, TraitInstance>;
+    /** Get a trait instance by name */
+    getTrait: (name: string) => TraitInstance | undefined;
+    /** Dispatch an event to a specific trait */
+    dispatchToTrait: (traitName: string, eventKey: string, payload?: EventPayload) => void;
+    /** Check if an event can be dispatched to a trait */
+    canDispatch: (traitName: string, eventKey: string) => boolean;
+}
+declare const TraitContext: React__default.Context<TraitContextValue | null>;
+interface TraitProviderProps {
+    /** Trait bindings for this page */
+    traits: ResolvedTraitBinding[];
+    /** Entity map for context */
+    entities: Map<string, ResolvedEntity>;
+    /** Children to render */
+    children: React__default.ReactNode;
+}
+declare function TraitProvider({ traits: traitBindings, children, }: TraitProviderProps): React__default.ReactElement;
+/**
+ * Access the trait context from within the TraitProvider.
+ */
+declare function useTraitContext(): TraitContextValue;
+/**
+ * Access a specific trait instance.
+ */
+declare function useTrait(traitName: string): TraitInstance | undefined;
+
+interface ServerBridgeContextValue {
+    connected: boolean;
+    /**
+     * From the transport's `register()` result
+     * (`EventTransportRegisterResult.carriesCircuitState`, `@almadar/runtime`):
+     * `true` = the stateless topology (a posted leg must carry
+     * `traits`/`entityByTrait`), `false` = the server (or an in-process
+     * evaluator) holds circuit state itself.
+     */
+    carriesCircuitState: boolean;
+    /** `register()` has resolved, so `carriesCircuitState` is the transport's
+     *  real topology rather than the pre-register guess. */
+    topologyKnown: boolean;
+    /** The ONE transport this bridge manages the register/unregister
+     *  lifecycle for — `useCircuitKernel` dispatches through it directly. */
+    transport: EventTransport;
+}
+/**
+ * @deprecated Alias for `@almadar/runtime`'s `EventTransport` (plan P5) —
+ * kept only because in-package consumers (`OrbPreview.tsx`,
+ * `OrbitalPluginHost.tsx`) still import the name.
+ * Import `EventTransport` directly in new code.
+ */
+type ServerBridgeTransport = EventTransport;
+
+/**
+ * Access the server bridge. Returns a no-op stub when outside the provider —
+ * `useCircuitKernel` treats an absent/no-op transport as offline (plan G7).
+ */
+declare function useServerBridge(): ServerBridgeContextValue;
+interface ServerBridgeProviderProps {
+    schema: OrbitalSchema;
+    /** HTTP server URL (canonical playground-runtime / apps/builder-server). */
+    serverUrl?: string;
+    /**
+     * Custom `EventTransport` (plan P5, `@almadar/runtime`). Use this for
+     * in-process execution (e.g. an in-process test harness invokes
+     * `OrbitalServerRuntime.processOrbitalEvent` directly via
+     * `createInProcessTransport`). Mutually exclusive with `serverUrl`.
+     */
+    transport?: EventTransport;
+    /**
+     * Bearer token for the HTTP transport (`Authorization` on every fetch, and on the
+     * request that mints the SSE stream's single-use ticket, since EventSource cannot set headers).
+     * Ignored with a custom `transport`.
+     */
+    getAccessToken?: AccessTokenProvider;
+    children: ReactNode;
+}
+declare function ServerBridgeProvider({ schema, serverUrl, transport: customTransport, getAccessToken, children, }: ServerBridgeProviderProps): React.JSX.Element;
+
+export { TraitContext as T, EntitySchemaProvider as b, ServerBridgeProvider as e, TraitProvider as h, useEntitySchemaOptional as j, useServerBridge as k, useTrait as l, useTraitContext as m, AwaitingSkeletonContext as n, EntityBindingContext as o, useAwaitingSkeleton as q, useEntityBindingSnapshot as r, useEntitySchema as u };
+export type { AwaitingSkeletonSource as A, EntityBindingSource as E, ServerBridgeTransport as S, EntitySchemaContextValue as a, EntitySchemaProviderProps as c, ServerBridgeContextValue as d, TraitContextValue as f, TraitInstance as g, TraitProviderProps as i, ServerBridgeProviderProps as p };

package/dist/ThemeContext-DJmO59xd.d.ts

@@ -0,0 +1,147 @@
+import React__default from 'react';
+
+/**
+ * Unified ThemeContext - Single provider for theme and color mode
+ *
+ * Combines design theme selection (glass, wireframe, etc.) with
+ * color mode (light/dark) into a single, simple system.
+ *
+ * Uses a single data attribute: data-theme="glass-light" or data-theme="glass-dark"
+ *
+ * @packageDocumentation
+ */
+
+/** Color mode preference */
+type ColorMode = "light" | "dark" | "system";
+/** Resolved color mode (what's actually applied) */
+type ResolvedMode = "light" | "dark";
+/** Theme definition */
+interface UIThemeDefinition {
+    /** Theme identifier (e.g., "glass", "wireframe") */
+    name: string;
+    /** Display name for UI (e.g., "Ocean Blue") */
+    displayName?: string;
+    /** Whether this theme has light mode styles */
+    hasLightMode?: boolean;
+    /** Whether this theme has dark mode styles */
+    hasDarkMode?: boolean;
+}
+
+/** Theme context value */
+interface ThemeContextValue {
+    /** Current theme name */
+    theme: string;
+    /** Current color mode setting (may be 'system') */
+    mode: ColorMode;
+    /** Resolved color mode (always 'light' or 'dark') */
+    resolvedMode: ResolvedMode;
+    /** Set the theme */
+    setTheme: (theme: string) => void;
+    /** Set the color mode */
+    setMode: (mode: ColorMode) => void;
+    /** Toggle between light and dark modes */
+    toggleMode: () => void;
+    /** Available themes */
+    availableThemes: UIThemeDefinition[];
+    /** The full theme string applied to data-theme (e.g., "glass-light") */
+    appliedTheme: string;
+}
+/**
+ * The theme in effect at a point of the React tree: what `data-theme`, mode
+ * class and inline token variables a subtree renders under. Portaled UI reads
+ * it so a modal takes the theme of the place it opened from.
+ */
+interface ThemeScope {
+    theme?: string;
+    mode?: ResolvedMode;
+    vars?: Readonly<Record<string, string>>;
+    /**
+     * A host's explicit theme pick (e.g. the playground picker): every
+     * `data-theme` a component declares inside this scope renders this key
+     * instead. Set only by `OrbitalThemeProvider`'s `override`.
+     */
+    override?: string;
+}
+declare const ThemeScopeContext: React__default.Context<ThemeScope>;
+declare function useThemeScope(): ThemeScope;
+/**
+ * The mode a registry `data-theme` key was built with: `<name>-light` /
+ * `<name>-dark` of a declared theme that has that mode (the same construction
+ * as `appliedTheme`). Undefined for any key no declared theme builds.
+ */
+declare function registryKeyMode(key: string, themes: readonly UIThemeDefinition[]): ResolvedMode | undefined;
+/** The declared theme and mode a registry key was built from, or undefined. */
+declare function registryKeyTheme(key: string, themes: readonly UIThemeDefinition[]): {
+    theme: UIThemeDefinition;
+    mode: ResolvedMode;
+} | undefined;
+/**
+ * A declared registry key as it renders: the key names a theme and its starting
+ * mode, and the viewer's mode wins when the theme has it. A key no declared
+ * theme builds passes through with no mode.
+ */
+declare function keyInViewerMode(key: string, themes: readonly UIThemeDefinition[], viewerMode: ResolvedMode): {
+    key: string;
+    mode?: ResolvedMode;
+};
+declare function themeHasMode(theme: UIThemeDefinition, mode: ResolvedMode): boolean;
+/** The color mode in effect at this point of the tree: a pinned orbital theme's, else the document's. */
+declare function useScopedMode(): ResolvedMode;
+interface ThemeProviderProps {
+    children: React__default.ReactNode;
+    /** Available themes (will be merged with built-in themes) */
+    themes?: readonly UIThemeDefinition[] | UIThemeDefinition[];
+    /** Default theme name */
+    defaultTheme?: string;
+    /** Default color mode */
+    defaultMode?: ColorMode;
+    /** Optional target element ref — when provided, theme attributes are applied to this element instead of document.documentElement */
+    targetRef?: React__default.RefObject<HTMLElement>;
+}
+/**
+ * Unified ThemeProvider component
+ *
+ * @example
+ * ```tsx
+ * // Basic usage with built-in themes
+ * <ThemeProvider defaultTheme="wireframe" defaultMode="light">
+ *   <App />
+ * </ThemeProvider>
+ *
+ * // With custom themes from orbital schema
+ * import { THEMES } from './generated/theme-manifest';
+ * <ThemeProvider themes={THEMES} defaultTheme="glass" defaultMode="system">
+ *   <App />
+ * </ThemeProvider>
+ * ```
+ */
+declare const ThemeProvider: React__default.FC<ThemeProviderProps>;
+/**
+ * Hook for accessing theme context
+ *
+ * @returns Theme context value
+ *
+ * @example
+ * ```tsx
+ * const { theme, resolvedMode, toggleMode, setTheme } = useTheme();
+ *
+ * // Toggle dark mode
+ * <button onClick={toggleMode}>
+ *   {resolvedMode === 'dark' ? 'Light' : 'Dark'}
+ * </button>
+ *
+ * // Change theme
+ * <select value={theme} onChange={(e) => setTheme(e.target.value)}>
+ *   {availableThemes.map(t => (
+ *     <option key={t.name} value={t.name}>{t.displayName || t.name}</option>
+ *   ))}
+ * </select>
+ * ```
+ */
+declare function useTheme(): ThemeContextValue;
+type Theme = ColorMode;
+type ResolvedTheme = ResolvedMode;
+type DesignTheme = UIThemeDefinition;
+
+export { ThemeProvider as c, ThemeScopeContext as e, registryKeyTheme as f, useTheme as g, useThemeScope as h, keyInViewerMode as k, registryKeyMode as r, themeHasMode as t, useScopedMode as u };
+export type { ColorMode as C, DesignTheme as D, ResolvedMode as R, ThemeProviderProps as T, UIThemeDefinition as U, ResolvedTheme as a, Theme as b, ThemeScope as d };

package/dist/TraitValueFrame-2PJGLLVI.js

@@ -0,0 +1,28 @@
+export { MountedInit, TraitValueFrame, TraitValueMountContext, TraitValueMountProvider, TraitValueFrame_default as default } from './chunk-FIW6WN23.js';
+import './chunk-GYTPOFVC.js';
+import './chunk-YDNJLLG6.js';
+import './chunk-KVQS4GXU.js';
+import './chunk-L677XGY3.js';
+import './chunk-FP3WIKTC.js';
+import './chunk-42FY4RYA.js';
+import './chunk-FAJDTHWC.js';
+import './chunk-GAR5TQ5B.js';
+import './chunk-SJGJJKBY.js';
+import './chunk-DZ42OJQC.js';
+import './chunk-P4LNHAFI.js';
+import './chunk-TZZBINQY.js';
+import './chunk-PC7K4SK7.js';
+import './chunk-VFF5OO47.js';
+import './chunk-DFNZUYX4.js';
+import './chunk-B4BU77LT.js';
+import './chunk-6P3MWXYE.js';
+import './chunk-DYEKAA4L.js';
+import './chunk-R5O5AUPI.js';
+import './chunk-L2DEKY4J.js';
+import './chunk-AILY3XPS.js';
+import './chunk-3BBUBJFF.js';
+import './chunk-YHMRX6YA.js';
+import './chunk-MBQAMMSE.js';
+import './chunk-A2LR6VQQ.js';
+import './chunk-P4ZFUQFF.js';
+import './chunk-G7DCAZ22.js';