@almadar/shell-web 0.0.0-stage → 1.0.0

package/dist/OrbInspector-QCPEPUPH.js

@@ -0,0 +1,26 @@
+export { OrbInspector } from './chunk-LHP2TK7O.js';
+import './chunk-57DC34LY.js';
+import './chunk-SP5CDJ6K.js';
+import './chunk-CPLN6NBQ.js';
+import './chunk-HH5KSMH5.js';
+import './chunk-REXYVBUO.js';
+import './chunk-AGXD77SL.js';
+import './chunk-TXAUOLWZ.js';
+import './chunk-AB3X7QTE.js';
+import './chunk-DZBQA2OW.js';
+import './chunk-TUPZWTRE.js';
+import './chunk-TZZBINQY.js';
+import './chunk-4T3P43NS.js';
+import './chunk-PCR37T3U.js';
+import './chunk-UXLE3IPR.js';
+import './chunk-ILZ7ORX7.js';
+import './chunk-3VZ36ZKO.js';
+import './chunk-PRXQGGCO.js';
+import './chunk-VO2TTLS5.js';
+import './chunk-AE7VCQB6.js';
+import './chunk-3BBUBJFF.js';
+import './chunk-YHMRX6YA.js';
+import './chunk-4YXBKHHM.js';
+import './chunk-A2LR6VQQ.js';
+import './chunk-P4ZFUQFF.js';
+import './chunk-G7DCAZ22.js';

package/dist/Select-B-iDdnvE.d.ts

@@ -0,0 +1,185 @@
+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
+ * @role button
+ * @tokens --color-primary --color-primary-foreground --color-foreground
+ * @contrast primary-foreground primary
+ * @motion css
+ */
+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;
+    /** Native button type. `type` is reserved for the pattern discriminator in schema render specs. */
+    htmlType?: "button" | "submit" | "reset";
+    /** 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
+ * @role textbox
+ * @tokens --color-card --color-border --color-foreground --color-muted-foreground
+ * @contrast foreground card
+ * @motion css
+ */
+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>>;
+
+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 {
+    variant?: PatternVariant;
+    size?: number;
+    color?: string;
+    strokeWidth?: number;
+    className?: string;
+}
+declare const PatternTile: React__default.FC<PatternTileProps>;
+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-Bqsj-lOU.d.ts

@@ -0,0 +1,124 @@
+import * as React from 'react';
+import React__default, { ReactNode } from 'react';
+import { EntityRow, TraitConfig, SkeletonNode, 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
+ *
+ * Provides the kernel's answer for which orbital owns each trait on the page.
+ * Not a data store: entity rows flow through the state machine's `@payload.data`
+ * binding and land on the rendering component's `entity` prop.
+ *
+ * @packageDocumentation
+ */
+
+interface EntitySchemaContextValue {
+    /** Per-trait owning-orbital name, as the kernel's page circuit answers it; scopes each slot's events. */
+    orbitalsByTrait: ReadonlyMap<string, string>;
+}
+interface EntitySchemaProviderProps {
+    orbitalsByTrait: ReadonlyMap<string, string>;
+    children: React__default.ReactNode;
+}
+declare function EntitySchemaProvider({ orbitalsByTrait, children, }: EntitySchemaProviderProps): React__default.ReactElement;
+declare function useEntitySchema(): EntitySchemaContextValue;
+/** Null when no provider is present (UISlotRenderer may render outside one in compiled mode). */
+declare function useEntitySchemaOptional(): EntitySchemaContextValue | null;
+
+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`) 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 { EntitySchemaProvider as b, ServerBridgeProvider as e, useEntitySchemaOptional as f, useServerBridge as g, AwaitingSkeletonContext as h, EntityBindingContext as i, useAwaitingSkeleton as k, useEntityBindingSnapshot as l, useEntitySchema as u };
+export type { AwaitingSkeletonSource as A, EntityBindingSource as E, ServerBridgeTransport as S, EntitySchemaContextValue as a, EntitySchemaProviderProps as c, ServerBridgeContextValue as d, ServerBridgeProviderProps as j };

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/UISlotContext-Dl_ewwCI.d.ts

@@ -0,0 +1,79 @@
+import React__default from 'react';
+import { U as UISlotManager, a as SlotContent } from './useUISlots-CiobNFGb.js';
+import { UISlot } from '@almadar/core';
+
+/**
+ * UISlotContext
+ *
+ * React context for providing the UI Slot Manager throughout the application.
+ * Traits use this context to render content into slots via render_ui effects.
+ *
+ * Usage:
+ * ```tsx
+ * // In App.tsx or layout
+ * <UISlotProvider>
+ *   <App />
+ * </UISlotProvider>
+ *
+ * // In trait hooks or components
+ * const { render, clear } = useUISlots();
+ * render({ target: 'modal', pattern: 'form-section', props: {...} });
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Context for the UI Slot Manager
+ */
+declare const UISlotContext: React__default.Context<UISlotManager | null>;
+interface UISlotProviderProps {
+    children: React__default.ReactNode;
+}
+/**
+ * Provider component that creates and provides the UI Slot Manager.
+ *
+ * Must wrap any components that use traits with render_ui effects.
+ */
+declare function UISlotProvider({ children }: UISlotProviderProps): React__default.ReactElement;
+/**
+ * Hook to access the UI Slot Manager.
+ *
+ * Must be used within a UISlotProvider.
+ *
+ * @throws Error if used outside of UISlotProvider
+ *
+ * @example
+ * ```tsx
+ * function MyTraitHook() {
+ *   const { render, clear } = useUISlots();
+ *
+ *   const showModal = () => {
+ *     render({
+ *       target: 'modal',
+ *       pattern: 'form-section',
+ *       props: { title: 'Create Item' },
+ *     });
+ *   };
+ *
+ *   const closeModal = () => {
+ *     clear('modal');
+ *   };
+ *
+ *   return { showModal, closeModal };
+ * }
+ * ```
+ */
+declare function useUISlots(): UISlotManager;
+/**
+ * Hook to get content for a specific slot.
+ *
+ * Useful for components that only need to read slot state.
+ */
+declare function useSlotContent(slot: UISlot): SlotContent | null;
+/**
+ * Hook to check if a slot has content.
+ */
+declare function useSlotHasContent(slot: UISlot): boolean;
+
+export { UISlotContext as U, UISlotProvider as a, useSlotHasContent as b, useUISlots as c, useSlotContent as u };

package/dist/UISlotRenderer-C7WWOK43.js

@@ -0,0 +1,26 @@
+export { SlotContainedContext, SlotContentRenderer, SuspenseConfigProvider, UISlotComponent, UISlotRenderer, renderPatternProps, renderPatternValue } from './chunk-LHP2TK7O.js';
+import './chunk-57DC34LY.js';
+import './chunk-SP5CDJ6K.js';
+import './chunk-CPLN6NBQ.js';
+import './chunk-HH5KSMH5.js';
+import './chunk-REXYVBUO.js';
+import './chunk-AGXD77SL.js';
+import './chunk-TXAUOLWZ.js';
+import './chunk-AB3X7QTE.js';
+import './chunk-DZBQA2OW.js';
+import './chunk-TUPZWTRE.js';
+import './chunk-TZZBINQY.js';
+import './chunk-4T3P43NS.js';
+import './chunk-PCR37T3U.js';
+import './chunk-UXLE3IPR.js';
+import './chunk-ILZ7ORX7.js';
+import './chunk-3VZ36ZKO.js';
+import './chunk-PRXQGGCO.js';
+import './chunk-VO2TTLS5.js';
+import './chunk-AE7VCQB6.js';
+import './chunk-3BBUBJFF.js';
+import './chunk-YHMRX6YA.js';
+import './chunk-4YXBKHHM.js';
+import './chunk-A2LR6VQQ.js';
+import './chunk-P4ZFUQFF.js';
+import './chunk-G7DCAZ22.js';