@w0nna_dev/lina-widget 1.0.0

package/dist/src/components/floating-call/floating-call.d.ts

@@ -0,0 +1,53 @@
+import { LitElement } from 'lit';
+import { OrbColors } from '../../core/orb';
+export declare class FloatingCall extends LitElement {
+    static styles: import('lit').CSSResult;
+    private callManager;
+    private orbRenderer;
+    private audioAnalyzer;
+    private soundManager;
+    private orbContainerRef;
+    private animationId;
+    agentId: string;
+    voiceServiceUrl?: string;
+    private callStatus;
+    private microphoneEnabled;
+    buttonStartText: string;
+    buttonConnectingText: string;
+    position: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left' | 'static';
+    size: number;
+    theme: string;
+    themeMode: 'dark' | 'light' | 'auto';
+    orbColors: Partial<OrbColors>;
+    glowIntensity: number;
+    idleGlowMultiplier: number;
+    morphStrength: number;
+    noiseScale: number;
+    noiseSpeed: number;
+    fresnelPower: number;
+    rotationSpeed: number;
+    audioReactivity: number;
+    audioSmoothing: number;
+    idleMorphMultiplier: number;
+    colorContrast: number;
+    soundEnabled: boolean;
+    soundVolume: number;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    firstUpdated(): void;
+    updated(changedProperties: Map<string | number | symbol, unknown>): void;
+    private applyTheme;
+    private initializeOrb;
+    private cleanupOrb;
+    private startIdleAnimation;
+    private startRealAudioLoop;
+    private handleAudioTrack;
+    private handleLocalAudioTrack;
+    private handleMicrophoneEnabled;
+    private handleMicrophoneDisabled;
+    private handleStatusChange;
+    private toggleCall;
+    private getButtonIcon;
+    private get buttonText();
+    render(): import('lit-html').TemplateResult<1>;
+}

package/dist/src/components/floating-call/index.d.ts

@@ -0,0 +1 @@
+export * from './floating-call';

package/dist/src/components/index.d.ts

@@ -0,0 +1,10 @@
+export * from './inline-call';
+export * from './floating-call';
+export * from './pill-call';
+export * from '../lina';
+export { darkPresets, lightPresets, getColorPreset, getPresetNames } from '../core/orb/colorPresets';
+export type { OrbColors } from '../core/orb';
+export { themes, darkThemes, lightThemes, getTheme, getThemeNames, applyTheme, detectSystemTheme, watchSystemTheme } from '../core/orb/themes';
+export type { ThemeConfig, Theme } from '../core/orb';
+export { SoundManager } from '../core/orb';
+export type { SoundConfig } from '../core/orb';

package/dist/src/components/inline-call/index.d.ts

@@ -0,0 +1 @@
+export * from './inline-call';

package/dist/src/components/inline-call/inline-call.d.ts

@@ -0,0 +1,53 @@
+import { LitElement } from 'lit';
+import { OrbColors } from '../../core/orb';
+export declare class InlineCall extends LitElement {
+    static styles: import('lit').CSSResult;
+    private callManager;
+    private orbRenderer;
+    private audioAnalyzer;
+    private soundManager;
+    private orbContainerRef;
+    private animationId;
+    agentId: string;
+    voiceServiceUrl?: string;
+    private callStatus;
+    private microphoneEnabled;
+    buttonStartText: string;
+    buttonConnectingText: string;
+    size: number;
+    containerPadding: number;
+    theme: string;
+    themeMode: 'dark' | 'light' | 'auto';
+    orbColors: Partial<OrbColors>;
+    glowIntensity: number;
+    idleGlowMultiplier: number;
+    morphStrength: number;
+    noiseScale: number;
+    noiseSpeed: number;
+    fresnelPower: number;
+    rotationSpeed: number;
+    audioReactivity: number;
+    audioSmoothing: number;
+    idleMorphMultiplier: number;
+    colorContrast: number;
+    soundEnabled: boolean;
+    soundVolume: number;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    firstUpdated(): void;
+    updated(changedProperties: Map<string | number | symbol, unknown>): void;
+    private applyTheme;
+    private initializeOrb;
+    private cleanupOrb;
+    private startIdleAnimation;
+    private startRealAudioLoop;
+    private handleAudioTrack;
+    private handleLocalAudioTrack;
+    private handleMicrophoneEnabled;
+    private handleMicrophoneDisabled;
+    private handleStatusChange;
+    private toggleCall;
+    private getButtonIcon;
+    private get buttonText();
+    render(): import('lit-html').TemplateResult<1>;
+}

package/dist/src/components/orb-widget.d.ts

@@ -0,0 +1,59 @@
+import { LitElement } from 'lit';
+import { HancAiWidgetConfig, WidgetMode } from '../orb/components';
+type ColorPreset = 'indigo' | 'cyan' | 'emerald' | 'rose' | 'amber';
+type ThemeMode = 'auto' | 'dark' | 'light';
+export declare class HancAiOrbElement extends LitElement {
+    static styles: import('lit').CSSResult[];
+    agentId: string;
+    voiceServiceUrl?: string;
+    size: number;
+    mode: WidgetMode;
+    position: NonNullable<HancAiWidgetConfig['position']>;
+    buttonText?: string;
+    activeButtonText?: string;
+    connectingText?: string;
+    buttonStartText?: string;
+    buttonEndText?: string;
+    buttonConnectingText?: string;
+    enableSounds: boolean;
+    soundVolume: number;
+    colors?: string;
+    orbConfig?: string;
+    theme: ThemeMode;
+    colorPreset: ColorPreset;
+    private orbContainer?;
+    private currentState;
+    private widget;
+    private themeQuery;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    firstUpdated(): void;
+    protected updated(changedProperties: Map<string | number | symbol, unknown>): void;
+    render(): import('lit-html').TemplateResult<1>;
+    /**
+     * Programmatically start a call
+     */
+    startCall(): Promise<void>;
+    /**
+     * Programmatically end the call
+     */
+    endCall(): Promise<void>;
+    private initializeWidget;
+    private destroyWidget;
+    private buildConfig;
+    private resolveColors;
+    private parseColors;
+    private parseOrbConfig;
+    private applyHostStyles;
+    private getButtonText;
+    private getActiveButtonText;
+    private getConnectingText;
+    private applyThemeToWidget;
+    private setupThemeListener;
+    private teardownThemeListener;
+    private handleThemeChange;
+    private getResolvedTheme;
+}
+export declare class HancAiOrb extends HancAiOrbElement {
+}
+export {};

package/dist/src/components/pill-call/index.d.ts

@@ -0,0 +1 @@
+export { PillCall } from './pill-call';

package/dist/src/components/pill-call/pill-call.d.ts

@@ -0,0 +1,53 @@
+import { LitElement } from 'lit';
+import { OrbColors } from '../../core/orb';
+export declare class PillCall extends LitElement {
+    static styles: import('lit').CSSResult;
+    private callManager;
+    private orbRenderer;
+    private audioAnalyzer;
+    private soundManager;
+    private orbContainerRef;
+    private animationId;
+    agentId: string;
+    voiceServiceUrl?: string;
+    private callStatus;
+    private microphoneEnabled;
+    buttonStartText: string;
+    buttonConnectingText: string;
+    buttonEndText: string;
+    orbSize: number;
+    theme: string;
+    themeMode: 'dark' | 'light' | 'auto';
+    orbColors: Partial<OrbColors>;
+    glowIntensity: number;
+    idleGlowMultiplier: number;
+    morphStrength: number;
+    noiseScale: number;
+    noiseSpeed: number;
+    fresnelPower: number;
+    rotationSpeed: number;
+    audioReactivity: number;
+    audioSmoothing: number;
+    idleMorphMultiplier: number;
+    colorContrast: number;
+    soundEnabled: boolean;
+    soundVolume: number;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    firstUpdated(): void;
+    updated(changedProperties: Map<string | number | symbol, unknown>): void;
+    private applyTheme;
+    private initializeOrb;
+    private cleanupOrb;
+    private startIdleAnimation;
+    private startRealAudioLoop;
+    private handleAudioTrack;
+    private handleLocalAudioTrack;
+    private handleMicrophoneEnabled;
+    private handleMicrophoneDisabled;
+    private handleStatusChange;
+    private toggleCall;
+    private getButtonIcon;
+    private get buttonText();
+    render(): import('lit-html').TemplateResult<1>;
+}

package/dist/src/core/color-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function getRelativeLuminance(color: string): number | null;
+export declare function blendColors(base: string, target: string, ratio: number): string;
+export declare function colorWithAlpha(color: string, alpha: number): string;

package/dist/src/core/global-styles.d.ts

@@ -0,0 +1 @@
+export declare const globalStyles: import('lit').CSSResult;

package/dist/src/core/livekit-call-manager.d.ts

@@ -0,0 +1,74 @@
+import { Room } from 'livekit-client';
+type CallStatus = 'idle' | 'connecting' | 'connected' | 'agent-connected' | 'disconnecting' | 'disconnected' | 'error' | 'ringing';
+interface MakeCallOptions {
+    agentId: string;
+}
+export interface LiveKitCallManagerEvents {
+    'status-changed': CustomEvent<CallStatus>;
+    'room-connected': CustomEvent<{
+        roomName: string;
+        identity: string;
+    }>;
+    'agent-connected': CustomEvent<{
+        participant: string;
+    }>;
+    'agent-disconnected': CustomEvent<{
+        participant: string;
+    }>;
+    'participant-connected': CustomEvent<{
+        participant: string;
+        isAgent: boolean;
+    }>;
+    'participant-disconnected': CustomEvent<{
+        participant: string;
+        isAgent: boolean;
+    }>;
+    'audio-track-added': CustomEvent<{
+        participant: string;
+        element: HTMLMediaElement;
+    }>;
+    'audio-track-removed': CustomEvent<{
+        participant: string;
+    }>;
+    'audio-playback-status-changed': CustomEvent<{
+        canPlayback: boolean;
+    }>;
+    'microphone-enabled': Event;
+    'microphone-disabled': Event;
+    'audio-enabled': Event;
+    'call-ended': Event;
+    disconnected: Event;
+    error: CustomEvent<{
+        error: string | null;
+    }>;
+}
+export declare class LiveKitCallManager extends EventTarget {
+    private room;
+    private callStatus;
+    private isReady;
+    private error;
+    private _serviceUrl?;
+    private microphoneEnabled;
+    private connectedParticipants;
+    private userIdentity;
+    private roomName;
+    private audioPlaybackPrompt;
+    set serviceUrl(url: string | undefined);
+    get serviceUrl(): string;
+    get status(): CallStatus;
+    get ready(): boolean;
+    get currentError(): string | null;
+    get currentRoom(): Room | null;
+    get isMicrophoneEnabled(): boolean;
+    get participants(): string[];
+    get identity(): string;
+    get roomNameValue(): string;
+    get showAudioPrompt(): boolean;
+    private updateStatus;
+    makeCall({ agentId }: MakeCallOptions): Promise<void>;
+    private setupRoomEventListeners;
+    toggleMicrophone(): Promise<void>;
+    enableAudio(): Promise<void>;
+    hangUp(): Promise<void>;
+}
+export {};

package/dist/src/core/orb/AudioAnalyzer.d.ts

@@ -0,0 +1,78 @@
+export interface AudioData {
+    bass: number;
+    mid: number;
+    treble: number;
+    level: number;
+    waveform: Float32Array;
+    frequency: Uint8Array;
+}
+export interface AudioAnalyzerOptions {
+    fftSize?: number;
+    smoothingTimeConstant?: number;
+    minDecibels?: number;
+    maxDecibels?: number;
+}
+export declare class AudioAnalyzer {
+    private audioContext;
+    private analyser;
+    private source;
+    private localSource;
+    private mixer;
+    private frequencyData;
+    private waveformData;
+    private smoothedBass;
+    private smoothedMid;
+    private smoothedTreble;
+    private smoothedLevel;
+    private readonly smoothingFactor;
+    private readonly options;
+    constructor(options?: AudioAnalyzerOptions);
+    /**
+     * Initialize analyzer with a MediaStream (remote audio)
+     */
+    connectStream(stream: MediaStream): Promise<void>;
+    /**
+     * Connect local microphone stream
+     */
+    connectLocalStream(stream: MediaStream): Promise<void>;
+    /**
+     * Setup mixer and analyser nodes
+     */
+    private setupMixerAndAnalyser;
+    /**
+     * Connect to an audio element
+     */
+    connectAudioElement(element: HTMLAudioElement): Promise<void>;
+    /**
+     * Get current audio analysis data
+     */
+    getAudioData(): AudioData;
+    /**
+     * Calculate bass, mid, treble from frequency data
+     */
+    private calculateFrequencyBands;
+    /**
+     * Calculate overall audio level
+     */
+    private calculateOverallLevel;
+    /**
+     * Get peak level (useful for visualization spikes)
+     */
+    getPeakLevel(): number;
+    /**
+     * Check if audio context is active
+     */
+    isActive(): boolean;
+    /**
+     * Cleanup resources
+     */
+    disconnect(): void;
+    /**
+     * Get raw AudioContext for advanced usage
+     */
+    getAudioContext(): AudioContext | null;
+    /**
+     * Get raw AnalyserNode for advanced usage
+     */
+    getAnalyser(): AnalyserNode | null;
+}

package/dist/src/core/orb/OrbRenderer.d.ts

@@ -0,0 +1,86 @@
+import { AudioData } from './AudioAnalyzer';
+export interface OrbColors {
+    primary: string;
+    secondary: string;
+    accent: string;
+    glow: string;
+    atmosphere: string;
+    depth?: string;
+    highlight?: string;
+}
+export interface OrbConfig {
+    size?: number;
+    segments?: number;
+    colors?: Partial<OrbColors>;
+    morphStrength?: number;
+    noiseScale?: number;
+    noiseSpeed?: number;
+    glowIntensity?: number;
+    idleGlowMultiplier?: number;
+    fresnelPower?: number;
+    rotationSpeed?: number;
+    audioReactivity?: number;
+    audioSmoothing?: number;
+    idleMorphMultiplier?: number;
+    colorContrast?: number;
+}
+export declare class OrbRenderer {
+    private container;
+    private scene;
+    private camera;
+    private renderer;
+    private orb;
+    private glowMesh;
+    private orbMaterial;
+    private glowMaterial;
+    private config;
+    private animationId;
+    private clock;
+    private isActive;
+    private targetRotation;
+    private currentRotation;
+    private audioValues;
+    private readonly canvasPadding;
+    constructor(container: HTMLElement, config?: OrbConfig);
+    private createOrb;
+    /**
+     * Update audio data with smoothing
+     */
+    updateAudio(audioData: AudioData): void;
+    /**
+     * Set simulated audio values (for demo/testing)
+     */
+    setSimulatedAudio(bass: number, mid: number, treble: number, level: number): void;
+    /**
+     * Set active state
+     */
+    setActive(active: boolean): void;
+    /**
+     * Update colors
+     */
+    setColors(colors: Partial<OrbColors>): void;
+    /**
+     * Update glow intensity settings (useful for light/dark theme switching)
+     */
+    setGlowSettings(glowIntensity: number, idleGlowMultiplier: number): void;
+    /**
+     * Start animation loop
+     */
+    start(): void;
+    /**
+     * Stop animation loop
+     */
+    stop(): void;
+    private animate;
+    private handleResize;
+    private handleMouseMove;
+    private handleMouseLeave;
+    /**
+     * Get the canvas element
+     */
+    getCanvas(): HTMLCanvasElement;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}

package/dist/src/core/orb/SoundManager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * SoundManager - Programmatic melodic sound generation for call events
+ * Uses Web Audio API for zero-dependency sound synthesis
+ */
+export interface SoundConfig {
+    enabled: boolean;
+    volume: number;
+}
+export declare class SoundManager {
+    private audioContext;
+    private config;
+    constructor(config?: Partial<SoundConfig>);
+    /**
+     * Initialize audio context (must be called from user interaction)
+     */
+    private ensureContext;
+    /**
+     * Prewarm audio context on user interaction
+     * This helps avoid audio context suspension issues
+     */
+    prewarm(): Promise<void>;
+    /**
+     * Create an oscillator with envelope
+     */
+    private createTone;
+    /**
+     * Play pleasant notification sound for call start
+     * Two-tone ascending melody like messenger notifications
+     */
+    playCallStartSound(): Promise<void>;
+    /**
+     * Play gentle descending sound for call end
+     * Single soft tone
+     */
+    playCallEndSound(): Promise<void>;
+    /**
+     * Update configuration
+     */
+    setConfig(config: Partial<SoundConfig>): void;
+    /**
+     * Enable or disable sounds
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Set volume (0.0 - 1.0)
+     */
+    setVolume(volume: number): void;
+    /**
+     * Get current config
+     */
+    getConfig(): SoundConfig;
+    /**
+     * Check if sounds are enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Cleanup
+     */
+    destroy(): void;
+}

package/dist/src/core/orb/colorPresets.d.ts

@@ -0,0 +1,22 @@
+import { OrbColors } from './OrbRenderer';
+/**
+ * Dark theme color presets optimized for dark backgrounds
+ */
+export declare const darkPresets: Record<string, OrbColors>;
+/**
+ * Light theme color presets optimized for light backgrounds
+ */
+export declare const lightPresets: Record<string, OrbColors>;
+/**
+ * Get a color preset by name
+ * @param presetName - Name of the preset
+ * @param theme - 'dark' or 'light'
+ * @returns OrbColors object
+ */
+export declare function getColorPreset(presetName: string, theme?: 'dark' | 'light'): OrbColors;
+/**
+ * Get all available preset names for a theme
+ * @param theme - 'dark' or 'light'
+ * @returns Array of preset names
+ */
+export declare function getPresetNames(theme?: 'dark' | 'light'): string[];

package/dist/src/core/orb/glow.glsl.d.ts

@@ -0,0 +1,4 @@
+export declare const glowVertexShader = "\nvarying vec3 vNormal;\nvarying vec3 vPosition;\nvarying float vIntensity;\n\nvoid main() {\n  vNormal = normalize(normalMatrix * normal);\n  vPosition = (modelViewMatrix * vec4(position, 1.0)).xyz;\n\n  // Scale up for glow halo\n  vec3 pos = position * 1.3;\n\n  // Pre-calculate view intensity for smooth falloff\n  vec3 viewDir = normalize(-vPosition);\n  vIntensity = pow(1.0 - abs(dot(viewDir, vNormal)), 1.5);\n\n  gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);\n}\n";
+export declare const glowFragmentShader = "\nuniform float uTime;\nuniform float uAudioLevel;\nuniform vec3 uGlowColor;\nuniform float uGlowIntensity;\nuniform float uPulseSpeed;\n\nvarying vec3 vNormal;\nvarying vec3 vPosition;\nvarying float vIntensity;\n\nvoid main() {\n  // Pulsing effect\n  float pulse = sin(uTime * uPulseSpeed) * 0.1 + 0.9;\n  pulse += uAudioLevel * 0.4;\n\n  // Smooth radial glow using pre-calculated intensity\n  float glow = vIntensity * uGlowIntensity * pulse;\n\n  // Very soft falloff for diffuse glow\n  glow = pow(glow, 0.8);\n  glow *= smoothstep(0.0, 0.3, vIntensity);\n\n  // Color with audio reactivity\n  vec3 glowColor = uGlowColor * (1.0 + uAudioLevel * 0.5);\n\n  // Softer alpha for more diffuse appearance\n  gl_FragColor = vec4(glowColor, glow * 0.4);\n}\n";
+export declare const atmosphereVertexShader = "\nvarying vec3 vNormal;\nvarying vec3 vPosition;\n\nvoid main() {\n  vNormal = normalize(normalMatrix * normal);\n  vPosition = position;\n\n  // Scale for outer atmosphere\n  vec3 pos = position * 1.5;\n\n  gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);\n}\n";
+export declare const atmosphereFragmentShader = "\nuniform float uTime;\nuniform float uAudioLevel;\nuniform vec3 uAtmosphereColor;\nuniform float uAtmosphereIntensity;\n\nvarying vec3 vNormal;\nvarying vec3 vPosition;\n\nvoid main() {\n  vec3 viewDirection = normalize(cameraPosition - vPosition);\n\n  // Inverse fresnel for atmosphere (stronger at edges, fading to center)\n  float intensity = pow(1.0 - max(dot(viewDirection, vNormal), 0.0), 3.0);\n\n  // Audio pulsing\n  float pulse = 1.0 + uAudioLevel * 0.4;\n\n  // Breathing animation\n  float breathing = sin(uTime * 0.5) * 0.1 + 0.9;\n\n  float alpha = intensity * uAtmosphereIntensity * pulse * breathing;\n\n  // Fade out at very edges\n  alpha *= smoothstep(1.0, 0.3, intensity);\n\n  vec3 color = uAtmosphereColor * (1.0 + uAudioLevel * 0.3);\n\n  gl_FragColor = vec4(color, alpha * 0.4);\n}\n";

package/dist/src/core/orb/index.d.ts

@@ -0,0 +1,12 @@
+export { OrbRenderer } from './OrbRenderer';
+export type { OrbConfig, OrbColors } from './OrbRenderer';
+export { AudioAnalyzer } from './AudioAnalyzer';
+export type { AudioData, AudioAnalyzerOptions } from './AudioAnalyzer';
+export { SoundManager } from './SoundManager';
+export type { SoundConfig } from './SoundManager';
+export { darkPresets, lightPresets, getColorPreset, getPresetNames } from './colorPresets';
+export { themes, darkThemes, lightThemes, getTheme, getThemeNames, applyTheme, detectSystemTheme, watchSystemTheme } from './themes';
+export type { ThemeConfig, Theme } from './themes';
+export { orbVertexShader } from './orb.vert.glsl';
+export { orbFragmentShader } from './orb.frag.glsl';
+export { glowVertexShader, glowFragmentShader, atmosphereVertexShader, atmosphereFragmentShader, } from './glow.glsl';

package/dist/src/core/orb/orb.frag.glsl.d.ts

@@ -0,0 +1 @@
+export declare const orbFragmentShader = "\nuniform float uTime;\nuniform float uAudioBass;\nuniform float uAudioMid;\nuniform float uAudioTreble;\nuniform float uAudioLevel;\nuniform vec3 uColorPrimary;\nuniform vec3 uColorSecondary;\nuniform vec3 uColorAccent;\nuniform vec3 uColorDepth;\nuniform vec3 uColorHighlight;\nuniform float uFresnelPower;\nuniform float uGlowIntensity;\nuniform float uColorContrast;\n\nvarying vec3 vNormal;\nvarying vec3 vPosition;\nvarying vec2 vUv;\nvarying float vDisplacement;\nvarying float vElevation;\n\n// Simplex noise for fragment effects\nvec3 mod289(vec3 x) {\n  return x - floor(x * (1.0 / 289.0)) * 289.0;\n}\n\nvec4 mod289(vec4 x) {\n  return x - floor(x * (1.0 / 289.0)) * 289.0;\n}\n\nvec4 permute(vec4 x) {\n  return mod289(((x * 34.0) + 1.0) * x);\n}\n\nvec4 taylorInvSqrt(vec4 r) {\n  return 1.79284291400159 - 0.85373472095314 * r;\n}\n\nfloat snoise(vec3 v) {\n  const vec2 C = vec2(1.0 / 6.0, 1.0 / 3.0);\n  const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);\n\n  vec3 i = floor(v + dot(v, C.yyy));\n  vec3 x0 = v - i + dot(i, C.xxx);\n\n  vec3 g = step(x0.yzx, x0.xyz);\n  vec3 l = 1.0 - g;\n  vec3 i1 = min(g.xyz, l.zxy);\n  vec3 i2 = max(g.xyz, l.zxy);\n\n  vec3 x1 = x0 - i1 + C.xxx;\n  vec3 x2 = x0 - i2 + C.yyy;\n  vec3 x3 = x0 - D.yyy;\n\n  i = mod289(i);\n  vec4 p = permute(permute(permute(\n    i.z + vec4(0.0, i1.z, i2.z, 1.0))\n    + i.y + vec4(0.0, i1.y, i2.y, 1.0))\n    + i.x + vec4(0.0, i1.x, i2.x, 1.0));\n\n  float n_ = 1.0 / 7.0;\n  vec3 ns = n_ * D.wyz - D.xzx;\n\n  vec4 j = p - 49.0 * floor(p * ns.z * ns.z);\n\n  vec4 x_ = floor(j * ns.z);\n  vec4 y_ = floor(j - 7.0 * x_);\n\n  vec4 x = x_ * ns.x + ns.yyyy;\n  vec4 y = y_ * ns.x + ns.yyyy;\n  vec4 h = 1.0 - abs(x) - abs(y);\n\n  vec4 b0 = vec4(x.xy, y.xy);\n  vec4 b1 = vec4(x.zw, y.zw);\n\n  vec4 s0 = floor(b0) * 2.0 + 1.0;\n  vec4 s1 = floor(b1) * 2.0 + 1.0;\n  vec4 sh = -step(h, vec4(0.0));\n\n  vec4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;\n  vec4 a1 = b1.xzyw + s1.xzyw * sh.zzww;\n\n  vec3 p0 = vec3(a0.xy, h.x);\n  vec3 p1 = vec3(a0.zw, h.y);\n  vec3 p2 = vec3(a1.xy, h.z);\n  vec3 p3 = vec3(a1.zw, h.w);\n\n  vec4 norm = taylorInvSqrt(vec4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));\n  p0 *= norm.x;\n  p1 *= norm.y;\n  p2 *= norm.z;\n  p3 *= norm.w;\n\n  vec4 m = max(0.6 - vec4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), 0.0);\n  m = m * m;\n  return 42.0 * dot(m * m, vec4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));\n}\n\nvoid main() {\n  // View direction for fresnel\n  vec3 viewDirection = normalize(cameraPosition - vPosition);\n\n  // Fresnel effect - edge glow\n  float fresnel = pow(1.0 - max(dot(viewDirection, vNormal), 0.0), uFresnelPower);\n\n  // Dynamic color mixing based on audio - using multiple noise layers for smoke effect\n  float colorMix = snoise(vPosition * 2.0 + uTime * 0.5) * 0.5 + 0.5;\n  colorMix += vDisplacement * 2.0;\n\n  // Secondary noise layer for more complex smoke patterns\n  float smokeLayer = snoise(vPosition * 1.2 - uTime * 0.3) * 0.5 + 0.5;\n  colorMix = colorMix * 0.6 + smokeLayer * 0.4;\n\n  // Apply contrast to make smoke patterns more visible\n  colorMix = (colorMix - 0.5) * uColorContrast + 0.5;\n  colorMix = clamp(colorMix, 0.0, 1.0);\n\n  // Audio-reactive color shifts\n  float audioInfluence = uAudioBass * 0.4 + uAudioMid * 0.35 + uAudioTreble * 0.25;\n\n  // 4-color gradient for volumetric smoke effect:\n  // depth (0.0) -> primary (0.33) -> secondary (0.66) -> highlight (1.0)\n  vec3 gradientColor;\n  if (colorMix < 0.33) {\n    // Depth to Primary\n    float t = colorMix / 0.33;\n    gradientColor = mix(uColorDepth, uColorPrimary, t);\n  } else if (colorMix < 0.66) {\n    // Primary to Secondary\n    float t = (colorMix - 0.33) / 0.33;\n    gradientColor = mix(uColorPrimary, uColorSecondary, t);\n  } else {\n    // Secondary to Highlight\n    float t = (colorMix - 0.66) / 0.34;\n    gradientColor = mix(uColorSecondary, uColorHighlight, t);\n  }\n\n  // Add accent color based on audio peaks\n  gradientColor = mix(gradientColor, uColorAccent, audioInfluence * 0.5);\n\n  // Iridescent effect\n  float iridescence = snoise(vPosition * 3.0 + uTime * 0.3) * 0.15;\n  vec3 iridescentShift = vec3(\n    sin(iridescence * 6.28 + 0.0) * 0.1,\n    sin(iridescence * 6.28 + 2.09) * 0.1,\n    sin(iridescence * 6.28 + 4.18) * 0.1\n  );\n  gradientColor += iridescentShift * (0.5 + audioInfluence);\n\n  // Inner glow effect\n  float innerGlow = pow(1.0 - fresnel, 3.0) * 0.3;\n  vec3 glowColor = uColorAccent * innerGlow * (1.0 + uAudioLevel * 2.0);\n\n  // Edge glow (fresnel)\n  vec3 edgeGlow = mix(uColorSecondary, uColorAccent, audioInfluence) * fresnel * uGlowIntensity;\n\n  // Pulsing highlights\n  float pulse = sin(uTime * 2.0 + vPosition.y * 5.0) * 0.5 + 0.5;\n  pulse *= uAudioMid;\n  vec3 pulseHighlight = uColorAccent * pulse * 0.2;\n\n  // Subsurface scattering simulation\n  float sss = pow(max(dot(viewDirection, -vNormal), 0.0), 2.0) * 0.15;\n  vec3 sssColor = uColorPrimary * sss * (1.0 + uAudioBass);\n\n  // Combine all effects\n  vec3 finalColor = gradientColor + edgeGlow + glowColor + pulseHighlight + sssColor;\n\n  // Add depth variation\n  float depthFade = smoothstep(-1.0, 1.0, vPosition.z);\n  finalColor *= 0.8 + depthFade * 0.2;\n\n  // Tone mapping and gamma correction\n  finalColor = finalColor / (finalColor + vec3(1.0));\n  finalColor = pow(finalColor, vec3(1.0 / 2.2));\n\n  // Alpha based on fresnel for soft edges\n  float alpha = 0.9 + fresnel * 0.1;\n\n  gl_FragColor = vec4(finalColor, alpha);\n}\n";

package/dist/src/core/orb/orb.vert.glsl.d.ts

@@ -0,0 +1 @@
+export declare const orbVertexShader = "\nuniform float uTime;\nuniform float uAudioBass;\nuniform float uAudioMid;\nuniform float uAudioTreble;\nuniform float uAudioLevel;\nuniform float uMorphStrength;\nuniform float uNoiseScale;\nuniform float uNoiseSpeed;\nuniform float uAudioReactivity;\n\nvarying vec3 vNormal;\nvarying vec3 vPosition;\nvarying vec2 vUv;\nvarying float vDisplacement;\nvarying float vElevation;\n\n// Simplex 3D noise\nvec4 permute(vec4 x) {\n  return mod(((x * 34.0) + 1.0) * x, 289.0);\n}\n\nvec4 taylorInvSqrt(vec4 r) {\n  return 1.79284291400159 - 0.85373472095314 * r;\n}\n\nfloat snoise(vec3 v) {\n  const vec2 C = vec2(1.0 / 6.0, 1.0 / 3.0);\n  const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);\n\n  vec3 i = floor(v + dot(v, C.yyy));\n  vec3 x0 = v - i + dot(i, C.xxx);\n\n  vec3 g = step(x0.yzx, x0.xyz);\n  vec3 l = 1.0 - g;\n  vec3 i1 = min(g.xyz, l.zxy);\n  vec3 i2 = max(g.xyz, l.zxy);\n\n  vec3 x1 = x0 - i1 + C.xxx;\n  vec3 x2 = x0 - i2 + C.yyy;\n  vec3 x3 = x0 - D.yyy;\n\n  i = mod(i, 289.0);\n  vec4 p = permute(permute(permute(\n    i.z + vec4(0.0, i1.z, i2.z, 1.0))\n    + i.y + vec4(0.0, i1.y, i2.y, 1.0))\n    + i.x + vec4(0.0, i1.x, i2.x, 1.0));\n\n  float n_ = 1.0 / 7.0;\n  vec3 ns = n_ * D.wyz - D.xzx;\n\n  vec4 j = p - 49.0 * floor(p * ns.z * ns.z);\n\n  vec4 x_ = floor(j * ns.z);\n  vec4 y_ = floor(j - 7.0 * x_);\n\n  vec4 x = x_ * ns.x + ns.yyyy;\n  vec4 y = y_ * ns.x + ns.yyyy;\n  vec4 h = 1.0 - abs(x) - abs(y);\n\n  vec4 b0 = vec4(x.xy, y.xy);\n  vec4 b1 = vec4(x.zw, y.zw);\n\n  vec4 s0 = floor(b0) * 2.0 + 1.0;\n  vec4 s1 = floor(b1) * 2.0 + 1.0;\n  vec4 sh = -step(h, vec4(0.0));\n\n  vec4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;\n  vec4 a1 = b1.xzyw + s1.xzyw * sh.zzww;\n\n  vec3 p0 = vec3(a0.xy, h.x);\n  vec3 p1 = vec3(a0.zw, h.y);\n  vec3 p2 = vec3(a1.xy, h.z);\n  vec3 p3 = vec3(a1.zw, h.w);\n\n  vec4 norm = taylorInvSqrt(vec4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));\n  p0 *= norm.x;\n  p1 *= norm.y;\n  p2 *= norm.z;\n  p3 *= norm.w;\n\n  vec4 m = max(0.6 - vec4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), 0.0);\n  m = m * m;\n  return 42.0 * dot(m * m, vec4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));\n}\n\n// Fractal Brownian Motion\nfloat fbm(vec3 p, int octaves) {\n  float value = 0.0;\n  float amplitude = 0.5;\n  float frequency = 1.0;\n\n  for (int i = 0; i < 6; i++) {\n    if (i >= octaves) break;\n    value += amplitude * snoise(p * frequency);\n    amplitude *= 0.5;\n    frequency *= 2.0;\n  }\n\n  return value;\n}\n\nvoid main() {\n  vUv = uv;\n  vNormal = normalize(normalMatrix * normal);\n\n  vec3 pos = position;\n\n  // Time-based animation\n  float t = uTime * uNoiseSpeed;\n\n  // Multi-layered noise displacement\n  vec3 noisePos = pos * uNoiseScale + t * 0.3;\n\n  // Base organic movement\n  float baseNoise = fbm(noisePos, 4) * 0.15;\n\n  // Audio-reactive displacement layers (multiplied by audioReactivity)\n  float bassDisplacement = snoise(noisePos * 0.8 + t * 0.5) * uAudioBass * 0.25 * uAudioReactivity;\n  float midDisplacement = snoise(noisePos * 1.5 + t * 0.8) * uAudioMid * 0.18 * uAudioReactivity;\n  float trebleDisplacement = snoise(noisePos * 3.0 + t * 1.2) * uAudioTreble * 0.1 * uAudioReactivity;\n\n  // Combine all displacement\n  float totalDisplacement = baseNoise + bassDisplacement + midDisplacement + trebleDisplacement;\n\n  // Apply morphing strength\n  totalDisplacement *= uMorphStrength;\n\n  // Add breathing effect\n  float breathing = sin(uTime * 0.8) * 0.02 * (1.0 + uAudioLevel * 0.5);\n  totalDisplacement += breathing;\n\n  // Apply displacement along normal\n  pos += normal * totalDisplacement;\n\n  vDisplacement = totalDisplacement;\n  vElevation = pos.y;\n  vPosition = pos;\n\n  gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);\n}\n";

package/dist/src/core/orb/themes.d.ts

@@ -0,0 +1,53 @@
+import { OrbColors } from './OrbRenderer';
+/**
+ * Complete theme configuration including colors and glow settings
+ */
+export interface ThemeConfig {
+    colors: OrbColors;
+    glowIntensity: number;
+    idleGlowMultiplier: number;
+}
+/**
+ * Theme with both dark and light variants
+ */
+export interface Theme {
+    dark: ThemeConfig;
+    light: ThemeConfig;
+}
+/**
+ * All available themes with dark and light variants
+ */
+export declare const themes: Record<string, Theme>;
+export declare const darkThemes: Record<string, ThemeConfig>;
+export declare const lightThemes: Record<string, ThemeConfig>;
+/**
+ * Detect system color scheme preference
+ * @returns 'dark' or 'light' based on system preference
+ */
+export declare function detectSystemTheme(): 'dark' | 'light';
+/**
+ * Get a complete theme configuration by name
+ * @param themeName - Name of the theme (e.g., 'emerald', 'rose')
+ * @param mode - 'dark', 'light', or 'auto' (auto detects system preference)
+ * @returns ThemeConfig object with colors and glow settings
+ */
+export declare function getTheme(themeName: string, mode?: 'dark' | 'light' | 'auto'): ThemeConfig;
+/**
+ * Get all available theme names
+ * @returns Array of theme names
+ */
+export declare function getThemeNames(): string[];
+/**
+ * Apply a theme to a widget element
+ * @param element - The widget element
+ * @param themeName - Name of the theme
+ * @param mode - 'dark', 'light', or 'auto'
+ */
+export declare function applyTheme(element: any, themeName: string, mode?: 'dark' | 'light' | 'auto'): void;
+/**
+ * Watch for system theme changes and update widget
+ * @param element - The widget element
+ * @param themeName - Name of the theme
+ * @returns Cleanup function to stop watching
+ */
+export declare function watchSystemTheme(element: any, themeName: string): () => void;