hanc-webrtc-widgets 2.0.2 → 2.1.0

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

@@ -1,74 +1,5 @@
-import { LitElement } from 'lit';
-import { ThemeName, VisualStyle, WidgetPosition, ButtonPosition } from '../../types/config';
-export declare class FloatingCall extends LitElement {
-    static styles: import('lit').CSSResult[];
-    private callManager;
-    agentId: string;
-    voiceServiceUrl?: string;
-    /** New design API (optional, non-breaking) */
-    theme: ThemeName | 'custom';
-    visualStyle: VisualStyle;
-    position: WidgetPosition;
-    offsetX: number;
-    offsetY: number;
-    orbSize: number;
-    orbColor?: string;
-    orbColorLight?: string;
-    orbColorDark?: string;
-    hideButton: boolean;
-    buttonPosition: ButtonPosition;
-    activeOrbColor?: string;
-    activeOrbColorLight?: string;
-    activeOrbColorDark?: string;
-    buttonColor?: string;
-    buttonHoverColor?: string;
-    buttonActiveColor?: string;
-    buttonTextColor?: string;
-    minimized: boolean;
-    private callStatus;
-    private prefersLightScheme;
-    private colorSchemeQuery;
-    private renderer;
-    private audioSimTimer;
-    private audioSimFrameId;
-    private audioSimPhase;
-    private simulatedTargetLevel;
-    private simulatedCurrentLevel;
-    private baseColors;
-    private themeColors;
-    private baseAnimation;
-    private get callState();
+import { HancAiOrbElement } from '../orb-widget';
+export declare class FloatingCall extends HancAiOrbElement {
     labelText: string;
-    buttonStartText: string;
-    buttonConnectingText: string;
-    buttonEndText: string;
-    private handleColorSchemeChange;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    updated(changedProperties: Map<string | number | symbol, unknown>): void;
-    firstUpdated(): void;
-    private setupRenderer;
-    private setupColorSchemeListener;
-    private teardownColorSchemeListener;
-    private clamp;
-    private resolveColorValue;
-    private buildOrbPalette;
-    private getBaseOrbColors;
-    private getActiveSeedColor;
-    private getActiveColors;
-    private getButtonColors;
-    private updateButtonThemeVars;
-    private getAnimationForState;
-    private syncOrbAppearance;
-    private handleStatusChange;
-    /**
-     * Audio animation (MVP): simulate audio level while connected.
-     * Later you can replace this with real RMS from mic/remote track.
-     */
-    private startAudioSimulation;
-    private stopAudioSimulation;
-    private toggleCall;
-    private get isActive();
-    private get buttonText();
-    render(): import('lit').TemplateResult<1>;
+    constructor();
 }

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

@@ -1,2 +1,5 @@
+export * from './orb-widget';
 export * from './inline-call';
 export * from './floating-call';
+export * from './pill-call';
+export * from '../orb';

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

@@ -1,66 +1,4 @@
-import { LitElement } from 'lit';
-import { ThemeName, VisualStyle, ButtonPosition } from '../../types/config';
-export declare class InlineCall extends LitElement {
-    static styles: import('lit').CSSResult[];
-    private callManager;
-    agentId: string;
-    voiceServiceUrl?: string;
-    /** New design API (optional, non-breaking) */
-    theme: ThemeName | 'custom';
-    visualStyle: VisualStyle;
-    orbSize: number;
-    orbColor?: string;
-    orbColorLight?: string;
-    orbColorDark?: string;
-    hideButton: boolean;
-    buttonPosition: ButtonPosition;
-    activeOrbColor?: string;
-    activeOrbColorLight?: string;
-    activeOrbColorDark?: string;
-    buttonColor?: string;
-    buttonHoverColor?: string;
-    buttonActiveColor?: string;
-    buttonTextColor?: string;
-    private callStatus;
-    private prefersLightScheme;
-    private colorSchemeQuery;
-    private renderer;
-    private audioSimTimer;
-    private audioSimFrameId;
-    private audioSimPhase;
-    private simulatedTargetLevel;
-    private simulatedCurrentLevel;
-    private baseColors;
-    private themeColors;
-    private baseAnimation;
-    private get callState();
-    buttonStartText: string;
-    buttonConnectingText: string;
-    buttonEndText: string;
-    private handleColorSchemeChange;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    updated(changedProperties: Map<string | number | symbol, unknown>): void;
-    firstUpdated(): void;
-    private setupRenderer;
-    private setupColorSchemeListener;
-    private teardownColorSchemeListener;
-    private clamp;
-    private resolveColorValue;
-    private buildOrbPalette;
-    private getBaseOrbColors;
-    private getActiveSeedColor;
-    private getActiveColors;
-    private getButtonColors;
-    private updateButtonThemeVars;
-    private getAnimationForState;
-    private syncOrbAppearance;
-    private applyNeuralNetworkTuning;
-    private startAudioSimulation;
-    private stopAudioSimulation;
-    private handleStatusChange;
-    private toggleCall;
-    private get isActive();
-    private get buttonText();
-    render(): import('lit').TemplateResult<1>;
+import { HancAiOrbElement } from '../orb-widget';
+export declare class InlineCall extends HancAiOrbElement {
+    constructor();
 }

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').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 * from './pill-call';

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

@@ -0,0 +1,4 @@
+import { HancAiOrbElement } from '../orb-widget';
+export declare class PillCall extends HancAiOrbElement {
+    constructor();
+}

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

@@ -3,6 +3,45 @@ type CallStatus = 'idle' | 'connecting' | 'connected' | 'agent-connected' | 'dis
 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;

package/dist/src/orb/components/HancAiWidget.d.ts

@@ -0,0 +1,120 @@
+import { OrbColors, OrbConfig } from '../core/OrbRenderer';
+import { CallState, CallStartEvent, CallEndEvent } from '../core/LiveKitManager';
+export type WidgetMode = 'inline' | 'float' | 'pill';
+export type WidgetState = CallState;
+export interface HancAiWidgetConfig {
+    agentId?: string;
+    voiceServiceUrl?: string;
+    size?: number;
+    colors?: Partial<OrbColors>;
+    buttonText?: string;
+    activeButtonText?: string;
+    connectingText?: string;
+    position?: 'center' | 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    mode?: WidgetMode;
+    orbConfig?: Partial<OrbConfig>;
+    enableSounds?: boolean;
+    soundVolume?: number;
+    onCallStart?: (event: CallStartEvent) => void;
+    onCallEnd?: (event: CallEndEvent) => void;
+    onStateChange?: (state: CallState, previousState: CallState) => void;
+    onError?: (error: Error) => void;
+}
+export declare class HancAiWidget {
+    private container;
+    private orbContainer;
+    private button;
+    private buttonIcon;
+    private buttonText;
+    private orbRenderer;
+    private audioAnalyzer;
+    private liveKitManager;
+    private soundManager;
+    private config;
+    private state;
+    private animationId;
+    private audioSimPhase;
+    private isAgentMode;
+    private readonly defaultConfig;
+    constructor(container: HTMLElement | string, config?: HancAiWidgetConfig);
+    private initializeLiveKit;
+    private dispatchEvent;
+    private createWidget;
+    private getFloatOffsets;
+    private createStandardWidget;
+    private createPillWidget;
+    private handlePillMouseEnter;
+    private handlePillMouseLeave;
+    private createButton;
+    private getLogoIcon;
+    private getPhoneOffIcon;
+    private handleButtonHover;
+    private handleButtonLeave;
+    private handleMouseEnter;
+    private handleMouseLeave;
+    private handleClick;
+    /**
+     * Start a call to the AI agent
+     */
+    startCall(): Promise<void>;
+    /**
+     * End the current call
+     */
+    endCall(): Promise<void>;
+    /**
+     * Connect to a real audio stream (for external WebRTC integration)
+     */
+    connectAudioStream(stream: MediaStream): Promise<void>;
+    /**
+     * Disconnect external audio stream
+     */
+    disconnectAudioStream(): void;
+    private setState;
+    private updateUI;
+    private updatePillUI;
+    private addSpinnerAnimation;
+    private startIdleAnimation;
+    private startAudioSimulation;
+    private stopAudioSimulation;
+    private startRealAudioLoop;
+    /**
+     * Get current call state
+     */
+    getState(): CallState;
+    /**
+     * Check if connected to an agent
+     */
+    isConnected(): boolean;
+    /**
+     * Set widget colors
+     */
+    setColors(colors: Partial<OrbColors>): void;
+    /**
+     * Set glow settings (useful for light/dark theme switching)
+     */
+    setGlowSettings(glowIntensity: number, idleGlowMultiplier: number): void;
+    /**
+     * Enable or disable call sounds
+     */
+    setSoundsEnabled(enabled: boolean): void;
+    /**
+     * Set sound volume (0.0 - 1.0)
+     */
+    setSoundVolume(volume: number): void;
+    /**
+     * Check if sounds are enabled
+     */
+    isSoundsEnabled(): boolean;
+    /**
+     * Connect microphone for real audio input (demo mode)
+     */
+    connectMicrophone(): Promise<void>;
+    /**
+     * Disconnect microphone
+     */
+    disconnectMicrophone(): void;
+    /**
+     * Cleanup
+     */
+    destroy(): void;
+}

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

@@ -0,0 +1,3 @@
+export { HancAiWidget } from './HancAiWidget';
+export type { HancAiWidgetConfig, WidgetState, WidgetMode } from './HancAiWidget';
+export type { CallStartEvent, CallEndEvent, CallState } from '../core/LiveKitManager';

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

@@ -0,0 +1,68 @@
+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 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
+     */
+    connectStream(stream: MediaStream): Promise<void>;
+    /**
+     * 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/orb/core/LiveKitManager.d.ts

@@ -0,0 +1,46 @@
+export type CallState = 'idle' | 'connecting' | 'active' | 'ending' | 'error';
+export interface CallStartEvent {
+    agentId: string;
+    timestamp: number;
+}
+export interface CallEndEvent {
+    agentId: string;
+    duration: number;
+    reason: 'user' | 'agent' | 'error';
+    timestamp: number;
+}
+export interface LiveKitConfig {
+    agentId: string;
+    voiceServiceUrl: string;
+}
+export interface LiveKitManagerCallbacks {
+    onStateChange?: (state: CallState, previousState: CallState) => void;
+    onCallStart?: (event: CallStartEvent) => void;
+    onCallEnd?: (event: CallEndEvent) => void;
+    onAudioTrack?: (stream: MediaStream) => void;
+    onError?: (error: Error) => void;
+}
+export declare class LiveKitManager {
+    private callManager;
+    private config;
+    private callbacks;
+    private state;
+    private callStartTime;
+    private callEndReason;
+    private hasStarted;
+    private hasFinished;
+    private readonly eventHandlers;
+    constructor(callbacks?: LiveKitManagerCallbacks);
+    configure(config: LiveKitConfig): void;
+    getState(): CallState;
+    isConnected(): boolean;
+    connect(): Promise<void>;
+    disconnect(reason?: CallEndEvent['reason']): Promise<void>;
+    destroy(): void;
+    private attachEventHandlers;
+    private detachEventHandlers;
+    private handleStatus;
+    private handleError;
+    private finishCall;
+    private setState;
+}

package/dist/src/orb/core/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/orb/core/SoundManager.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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;
+    /**
+     * Create an oscillator with envelope
+     */
+    private createTone;
+    /**
+     * Play ascending melodic sound for call start
+     * C4 → E4 → G4 (C major chord arpeggio)
+     */
+    playCallStartSound(): Promise<void>;
+    /**
+     * Play descending melodic sound for call end
+     * G4 → E4 → C4 (descending C major arpeggio)
+     */
+    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/orb/core/index.d.ts

@@ -0,0 +1,8 @@
+export { AudioAnalyzer } from './AudioAnalyzer';
+export type { AudioData, AudioAnalyzerOptions } from './AudioAnalyzer';
+export { OrbRenderer } from './OrbRenderer';
+export type { OrbConfig, OrbColors } from './OrbRenderer';
+export { LiveKitManager } from './LiveKitManager';
+export type { CallState, CallStartEvent, CallEndEvent, LiveKitConfig, LiveKitManagerCallbacks } from './LiveKitManager';
+export { SoundManager } from './SoundManager';
+export type { SoundConfig } from './SoundManager';

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

@@ -0,0 +1,5 @@
+export { AudioAnalyzer, OrbRenderer, SoundManager } from './core';
+export type { AudioData, AudioAnalyzerOptions, OrbConfig, OrbColors, SoundConfig } from './core';
+export { HancAiWidget } from './components';
+export type { HancAiWidgetConfig, WidgetState, WidgetMode } from './components';
+export * from './shaders';

package/dist/src/orb/shaders/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/orb/shaders/index.d.ts

@@ -0,0 +1,3 @@
+export { orbVertexShader } from './orb.vert.glsl.ts';
+export { orbFragmentShader } from './orb.frag.glsl.ts';
+export { glowVertexShader, glowFragmentShader, atmosphereVertexShader, atmosphereFragmentShader, } from './glow.glsl.ts';