@shogo-ai/voice 1.4.1

package/dist/react/index.js

@@ -0,0 +1,952 @@
+import {
+  DEFAULT_ORGANIC_PARTICLES_CONFIG,
+  DEFAULT_ORGANIC_SPHERE_CONFIG,
+  ORGANIC_PARTICLES_FRAGMENT_SHADER,
+  ORGANIC_PARTICLES_VERTEX_SHADER,
+  ORGANIC_SPHERE_FRAGMENT_SHADER,
+  ORGANIC_SPHERE_VERTEX_SHADER,
+  PERLIN_4D,
+  appendChatQuery,
+  appendTranscriptLine,
+  buildSessionPayload,
+  createMemoryAddTool,
+  createMemoryContextInjector,
+  createPostJson,
+  createTranscriptDisconnectHandler,
+  fetchSignedUrl,
+  resolveOrganicParticlesConfig,
+  resolveOrganicSphereConfig,
+  withProjectQuery
+} from "../chunk-S3S2RNO6.js";
+import "../chunk-Q3TJAJ54.js";
+
+// src/react/useVoiceConversation.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useConversation } from "@elevenlabs/react";
+function useVoiceConversation(options) {
+  const {
+    characterName,
+    signedUrlPath = "/api/voice/signed-url",
+    memoryAddPath = "/api/memory/add",
+    memoryRetrievePath = "/api/memory/retrieve",
+    transcriptIngestPath = "/api/memory/ingest",
+    autoInjectMemory = true,
+    includeMemoryTool = true,
+    clientTools = {},
+    onTranscript,
+    shogoApiKey,
+    projectId,
+    agentName,
+    fetchCredentials = shogoApiKey ? "omit" : "same-origin",
+    onError,
+    onMessage,
+    conversationId: optionConversationId,
+    dynamicVariables
+  } = options;
+  const authHeaders = useCallback(() => {
+    return shogoApiKey ? { authorization: `Bearer ${shogoApiKey}` } : {};
+  }, [shogoApiKey]);
+  const resolvedSignedUrlPath = withProjectQuery(signedUrlPath, { projectId, agentName });
+  const transcriptRef = useRef([]);
+  const lastInjectedRef = useRef("");
+  const weStartedSessionRef = useRef(false);
+  const [convaiConversationId, setConvaiConversationId] = useState(null);
+  const isRestartingRef = useRef(false);
+  const conversationRef = useRef(null);
+  const postJson = useCallback(
+    createPostJson({ authHeaders, fetchCredentials }),
+    [fetchCredentials, authHeaders]
+  );
+  const injectMemoryContext = useCallback(
+    createMemoryContextInjector({
+      postJson,
+      memoryRetrievePath,
+      conversationRef,
+      enabled: autoInjectMemory,
+      lastInjectedRef
+    }),
+    [autoInjectMemory, memoryRetrievePath, postJson]
+  );
+  const handleTranscriptOnDisconnect = useCallback(
+    createTranscriptDisconnectHandler({
+      isRestartingRef,
+      weStartedSessionRef,
+      transcriptRef,
+      onTranscript,
+      transcriptIngestPath,
+      postJson
+    }),
+    [onTranscript, postJson, transcriptIngestPath]
+  );
+  const builtInTools = includeMemoryTool ? { add_memory: createMemoryAddTool({ postJson, memoryAddPath }) } : {};
+  const mergedClientTools = { ...builtInTools, ...clientTools };
+  const conversation = useConversation({
+    clientTools: mergedClientTools,
+    onConnect: (info) => {
+      const id = info?.conversationId;
+      if (typeof id === "string" && id.length > 0) {
+        setConvaiConversationId(id);
+      }
+      if (!isRestartingRef.current) {
+        transcriptRef.current = [];
+        lastInjectedRef.current = "";
+      }
+    },
+    onDisconnect: () => {
+      handleTranscriptOnDisconnect();
+      if (!isRestartingRef.current) {
+        setConvaiConversationId(null);
+      }
+    },
+    onError: (e) => {
+      onError?.(e);
+    },
+    onMessage: (m) => {
+      const msg = m;
+      if (!msg?.message || !msg?.source) return;
+      appendTranscriptLine(msg, { transcriptRef, weStartedSessionRef });
+      onMessage?.({ source: msg.source, message: msg.message });
+      if (autoInjectMemory && msg.source === "user" && msg.message.trim().length >= 3 && weStartedSessionRef.current) {
+        void injectMemoryContext(msg.message);
+      }
+    }
+  });
+  const { status, isSpeaking, isListening, isMuted, setMuted, startSession, endSession } = conversation;
+  conversationRef.current = conversation;
+  useEffect(() => {
+    const onHide = () => {
+      if (!weStartedSessionRef.current || transcriptRef.current.length === 0) return;
+      const transcript = transcriptRef.current.join("\n").trim();
+      transcriptRef.current = [];
+      if (transcript.length < 20) return;
+      try {
+        const blob = new Blob([JSON.stringify({ transcript })], { type: "application/json" });
+        navigator.sendBeacon(transcriptIngestPath, blob);
+      } catch {
+      }
+    };
+    window.addEventListener("pagehide", onHide);
+    return () => window.removeEventListener("pagehide", onHide);
+  }, [transcriptIngestPath]);
+  const startInternal = useCallback(
+    async (opts) => {
+      if (status === "connected" || status === "connecting") {
+        try {
+          endSession();
+          await new Promise((r) => setTimeout(r, 120));
+        } catch {
+        }
+      }
+      await navigator.mediaDevices.getUserMedia({ audio: true });
+      const data = await fetchSignedUrl({
+        path: resolvedSignedUrlPath,
+        fetchCredentials,
+        authHeaders
+      });
+      const ctx = data.userContext || "No prior memories yet.";
+      weStartedSessionRef.current = true;
+      const sessionPayload = buildSessionPayload({
+        signedUrl: data.signedUrl,
+        characterName,
+        userContext: ctx,
+        agentPromptOverride: data.agentPromptOverride,
+        suppressFirstMessage: opts?.suppressFirstMessage,
+        conversationId: optionConversationId,
+        dynamicVariables
+      });
+      await startSession(sessionPayload);
+    },
+    [
+      status,
+      endSession,
+      resolvedSignedUrlPath,
+      fetchCredentials,
+      dynamicVariables,
+      startSession,
+      characterName,
+      authHeaders,
+      optionConversationId
+    ]
+  );
+  const start = useCallback(
+    async (options2) => {
+      await startInternal(options2);
+    },
+    [startInternal]
+  );
+  const end = useCallback(() => {
+    endSession();
+  }, [endSession]);
+  const restart = useCallback(
+    async (options2) => {
+      const suppress = options2?.suppressFirstMessage ?? true;
+      isRestartingRef.current = true;
+      try {
+        try {
+          endSession();
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, 120));
+        await startInternal({ suppressFirstMessage: suppress });
+      } finally {
+        isRestartingRef.current = false;
+      }
+    },
+    [endSession, startInternal]
+  );
+  const sendContextualUpdate = useCallback((text) => {
+    conversationRef.current?.sendContextualUpdate(text);
+  }, []);
+  const sendUserMessage = useCallback((text) => {
+    const ref = conversationRef.current;
+    if (!ref) return;
+    if (typeof ref.sendUserMessage === "function") {
+      ref.sendUserMessage(text);
+      return;
+    }
+    ref.sendContextualUpdate(text);
+    try {
+      ref.sendUserActivity?.();
+    } catch {
+    }
+  }, []);
+  const sendUserActivity = useCallback(() => {
+    conversationRef.current?.sendUserActivity?.();
+  }, []);
+  const getOutputByteFrequencyData = useCallback(() => {
+    try {
+      const fn = conversation.getOutputByteFrequencyData;
+      return fn ? fn() : null;
+    } catch {
+      return null;
+    }
+  }, [conversation]);
+  return {
+    start,
+    end,
+    restart,
+    status,
+    isSpeaking,
+    isListening,
+    isMuted,
+    setMuted,
+    getOutputByteFrequencyData,
+    sendContextualUpdate,
+    sendUserMessage,
+    sendUserActivity,
+    conversationId: optionConversationId ?? convaiConversationId,
+    convaiConversationId
+  };
+}
+
+// src/react/useShogoVoice.ts
+function useShogoVoice(opts = {}) {
+  return useVoiceConversation({
+    characterName: opts.characterName ?? "Shogo",
+    signedUrlPath: opts.signedUrlPath ?? "/api/voice/signed-url",
+    fetchCredentials: opts.fetchCredentials ?? "same-origin",
+    ...opts
+  });
+}
+
+// src/react/useChatConversation.ts
+import { useCallback as useCallback2, useMemo, useRef as useRef2 } from "react";
+import { useChat } from "@ai-sdk/react";
+import { DefaultChatTransport } from "ai";
+var DEFAULT_API_PATH = "/api/chat/turn";
+var DEFAULT_CHAT_ID = "shogo-chat";
+function syntheticId(prefix) {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function useChatConversation(options = {}) {
+  const {
+    api = DEFAULT_API_PATH,
+    shogoApiKey,
+    projectId,
+    agentName,
+    conversationId,
+    initialMessages,
+    clientTools = {},
+    tools,
+    fetchCredentials = shogoApiKey ? "omit" : "same-origin",
+    id,
+    onError,
+    dynamicVariables
+  } = options;
+  const resolvedApi = useMemo(
+    () => appendChatQuery(api, { projectId, conversationId, agentName }),
+    [api, projectId, conversationId, agentName]
+  );
+  const headers = useMemo(() => {
+    const h = {};
+    if (shogoApiKey) h.authorization = `Bearer ${shogoApiKey}`;
+    return h;
+  }, [shogoApiKey]);
+  const body = useMemo(() => {
+    const b = {};
+    if (projectId) b.projectId = projectId;
+    if (agentName) b.agentName = agentName;
+    if (conversationId) b.conversationId = conversationId;
+    if (tools && tools.length > 0) b.tools = tools;
+    if (dynamicVariables && Object.keys(dynamicVariables).length > 0) {
+      b.dynamicVariables = dynamicVariables;
+    }
+    return b;
+  }, [projectId, agentName, conversationId, tools, dynamicVariables]);
+  const transport = useMemo(
+    () => new DefaultChatTransport({
+      api: resolvedApi,
+      credentials: fetchCredentials,
+      headers,
+      body
+    }),
+    [resolvedApi, fetchCredentials, headers, body]
+  );
+  const toolsRef = useRef2(clientTools);
+  toolsRef.current = clientTools;
+  const chatRef = useRef2(null);
+  const resolvedId = id ?? (conversationId ? `shogo-chat:${conversationId}` : DEFAULT_CHAT_ID);
+  const chat = useChat({
+    id: resolvedId,
+    transport,
+    messages: initialMessages,
+    async onToolCall({ toolCall }) {
+      const name = toolCall.toolName;
+      const fn = toolsRef.current[name];
+      const current = chatRef.current;
+      if (!current) return;
+      if (!fn) {
+        await current.addToolOutput({
+          state: "output-error",
+          tool: name,
+          toolCallId: toolCall.toolCallId,
+          errorText: `Unknown chat tool: ${String(name)}`
+        });
+        return;
+      }
+      try {
+        const params = typeof toolCall.input === "object" && toolCall.input !== null ? toolCall.input : {};
+        const output = await fn(params);
+        await current.addToolOutput({
+          tool: name,
+          toolCallId: toolCall.toolCallId,
+          output
+        });
+      } catch (err) {
+        await current.addToolOutput({
+          state: "output-error",
+          tool: name,
+          toolCallId: toolCall.toolCallId,
+          errorText: err?.message ?? String(err)
+        });
+      }
+    },
+    onError(err) {
+      onError?.(err);
+    }
+  });
+  chatRef.current = chat;
+  const sendMessage = useCallback2(
+    async (text) => {
+      if (!text.trim()) return;
+      await chatRef.current?.sendMessage({ text });
+    },
+    []
+  );
+  const setMessages = useCallback2((messages) => {
+    chatRef.current?.setMessages?.(messages);
+  }, []);
+  const appendAssistantMessage = useCallback2((text) => {
+    const next = {
+      id: syntheticId("synthetic-assistant"),
+      role: "assistant",
+      parts: [{ type: "text", text }]
+    };
+    const current = chatRef.current;
+    if (!current) return;
+    const nextList = [...current.messages, next];
+    current.setMessages?.(nextList);
+  }, []);
+  const appendUserMessage = useCallback2((text) => {
+    const next = {
+      id: syntheticId("synthetic-user"),
+      role: "user",
+      parts: [{ type: "text", text }]
+    };
+    const current = chatRef.current;
+    if (!current) return;
+    const nextList = [...current.messages, next];
+    current.setMessages?.(nextList);
+  }, []);
+  const status = chat.status;
+  return {
+    messages: chat.messages,
+    sendMessage,
+    setMessages,
+    appendAssistantMessage,
+    appendUserMessage,
+    status,
+    conversationId: conversationId ?? null
+  };
+}
+
+// src/react/useShogoChat.ts
+function useShogoChat(opts = {}) {
+  return useChatConversation({
+    api: opts.api ?? "/api/chat/turn",
+    fetchCredentials: opts.fetchCredentials ?? "same-origin",
+    ...opts
+  });
+}
+
+// src/react/ShogoVoiceProvider.tsx
+import { ConversationProvider as ElevenLabsConversationProvider } from "@elevenlabs/react";
+import { jsx } from "react/jsx-runtime";
+function ShogoVoiceProvider(props) {
+  return /* @__PURE__ */ jsx(ElevenLabsConversationProvider, { children: props.children });
+}
+
+// src/react/OrganicSphere.tsx
+import { useEffect as useEffect2, useMemo as useMemo2, useRef as useRef3 } from "react";
+import * as THREE from "three";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function seededUnit(seed, salt) {
+  const s = Math.sin((seed + salt * 7919) * 12.9898 + salt * 78.233) * 43758.5453;
+  return s - Math.floor(s);
+}
+function OrganicSphere({
+  getFrequencyData,
+  active = true,
+  config: configProp,
+  lightAColor,
+  lightBColor,
+  rimColor,
+  rimThreshold,
+  rimPower,
+  backgroundColor,
+  subdivisions,
+  maxPixelRatio,
+  className,
+  style
+}) {
+  const containerRef = useRef3(null);
+  const resolvedConfig = useMemo2(() => {
+    const base = resolveOrganicSphereConfig(configProp);
+    const overrides = {};
+    if (lightAColor !== void 0) overrides.lightAColor = lightAColor;
+    if (lightBColor !== void 0) overrides.lightBColor = lightBColor;
+    if (rimColor !== void 0) overrides.rimColor = rimColor;
+    if (rimThreshold !== void 0) overrides.rimThreshold = rimThreshold;
+    if (rimPower !== void 0) overrides.rimPower = rimPower;
+    if (backgroundColor !== void 0) overrides.backgroundColor = backgroundColor;
+    if (subdivisions !== void 0) overrides.subdivisions = subdivisions;
+    if (maxPixelRatio !== void 0) overrides.maxPixelRatio = maxPixelRatio;
+    return { ...base, ...overrides };
+  }, [
+    configProp,
+    lightAColor,
+    lightBColor,
+    rimColor,
+    rimThreshold,
+    rimPower,
+    backgroundColor,
+    subdivisions,
+    maxPixelRatio
+  ]);
+  const configRef = useRef3(resolvedConfig);
+  useEffect2(() => {
+    configRef.current = resolvedConfig;
+  }, [resolvedConfig]);
+  const getFrequencyDataRef = useRef3(getFrequencyData);
+  const activeRef = useRef3(active);
+  useEffect2(() => {
+    getFrequencyDataRef.current = getFrequencyData;
+  }, [getFrequencyData]);
+  useEffect2(() => {
+    activeRef.current = active;
+  }, [active]);
+  const initSubdivisions = resolvedConfig.subdivisions;
+  const initMaxPixelRatio = resolvedConfig.maxPixelRatio;
+  const initBackgroundColor = resolvedConfig.backgroundColor;
+  useEffect2(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const cfg0 = configRef.current;
+    const width = container.clientWidth || 1;
+    const height = container.clientHeight || 1;
+    const pixelRatio = Math.min(
+      initMaxPixelRatio ?? (typeof window !== "undefined" ? window.devicePixelRatio : 1),
+      2
+    );
+    const scene = new THREE.Scene();
+    if (initBackgroundColor) scene.background = new THREE.Color(initBackgroundColor);
+    const camera = new THREE.PerspectiveCamera(cfg0.fov, width / height, 0.1, 100);
+    camera.position.set(0, 0, cfg0.cameraZ);
+    scene.add(camera);
+    const renderer = new THREE.WebGLRenderer({
+      antialias: true,
+      alpha: initBackgroundColor === null,
+      powerPreference: "high-performance"
+    });
+    renderer.setSize(width, height, false);
+    renderer.setPixelRatio(pixelRatio);
+    renderer.setClearColor(0, initBackgroundColor === null ? 0 : 1);
+    container.appendChild(renderer.domElement);
+    renderer.domElement.style.display = "block";
+    renderer.domElement.style.width = "100%";
+    renderer.domElement.style.height = "100%";
+    const geometry = new THREE.SphereGeometry(1, initSubdivisions, initSubdivisions);
+    geometry.computeTangents();
+    const lightAPos = new THREE.Vector3().setFromSpherical(
+      new THREE.Spherical(1, 0.615, 2.049)
+    );
+    const lightBPos = new THREE.Vector3().setFromSpherical(
+      new THREE.Spherical(1, 2.561, -1.844)
+    );
+    const lightAColorObj = new THREE.Color(cfg0.lightAColor);
+    const lightBColorObj = new THREE.Color(cfg0.lightBColor);
+    const rimColorObj = new THREE.Color(cfg0.rimColor ?? cfg0.lightBColor);
+    const material = new THREE.ShaderMaterial({
+      uniforms: {
+        uLightAColor: { value: lightAColorObj },
+        uLightAPosition: { value: lightAPos },
+        uLightAIntensity: { value: cfg0.lightAIntensity },
+        uLightBColor: { value: lightBColorObj },
+        uLightBPosition: { value: lightBPos },
+        uLightBIntensity: { value: cfg0.lightBIntensity },
+        uSubdivision: {
+          value: new THREE.Vector2(initSubdivisions, initSubdivisions)
+        },
+        uOffset: { value: new THREE.Vector3() },
+        uDistortionFrequency: { value: cfg0.distortionFrequency },
+        uDistortionStrength: { value: cfg0.high.idle },
+        uDisplacementFrequency: { value: cfg0.displacementFrequency },
+        uDisplacementStrength: { value: cfg0.volume.idle },
+        uFresnelOffset: { value: cfg0.fresnelOffset },
+        uFresnelMultiplier: { value: cfg0.medium.idle },
+        uFresnelPower: { value: cfg0.fresnelPower },
+        uRimColor: { value: rimColorObj },
+        uRimThreshold: { value: cfg0.rimThreshold },
+        uRimPower: { value: cfg0.rimPower },
+        uTime: { value: 0 }
+      },
+      defines: { USE_TANGENT: "" },
+      vertexShader: ORGANIC_SPHERE_VERTEX_SHADER,
+      fragmentShader: ORGANIC_SPHERE_FRAGMENT_SHADER
+    });
+    const mesh = new THREE.Mesh(geometry, material);
+    scene.add(mesh);
+    const seedInitialPhase = (seed) => ({
+      phi: seededUnit(seed, 1) * Math.PI,
+      theta: seededUnit(seed, 2) * Math.PI * 2
+    });
+    const initialPhase = seedInitialPhase(cfg0.seed);
+    const offsetSpherical = new THREE.Spherical(1, initialPhase.phi, initialPhase.theta);
+    const offsetDirection = new THREE.Vector3().setFromSpherical(offsetSpherical);
+    const variations = {
+      volume: { target: 0, current: cfg0.volume.idle },
+      medium: { target: 0, current: cfg0.medium.idle },
+      high: { target: 0, current: cfg0.high.idle },
+      low: { target: 0, current: cfg0.low.idle }
+    };
+    const resetAnimationState = (cfg) => {
+      material.uniforms.uTime.value = 0;
+      material.uniforms.uOffset.value.set(0, 0, 0);
+      const phase = seedInitialPhase(cfg.seed);
+      offsetSpherical.radius = 1;
+      offsetSpherical.phi = phase.phi;
+      offsetSpherical.theta = phase.theta;
+      variations.volume.current = cfg.volume.idle;
+      variations.medium.current = cfg.medium.idle;
+      variations.high.current = cfg.high.idle;
+      variations.low.current = cfg.low.idle;
+      variations.volume.target = cfg.volume.idle;
+      variations.medium.target = cfg.medium.idle;
+      variations.high.target = cfg.high.idle;
+      variations.low.target = cfg.low.idle;
+    };
+    const LEVEL_COUNT = 8;
+    function computeLevels(buf) {
+      const bins = Math.floor(buf.length / LEVEL_COUNT);
+      const levels = new Array(LEVEL_COUNT).fill(0);
+      if (bins <= 0) return levels;
+      for (let i = 0; i < LEVEL_COUNT; i++) {
+        let sum = 0;
+        for (let j = 0; j < bins; j++) sum += buf[i * bins + j];
+        levels[i] = sum / bins / 256;
+      }
+      return levels;
+    }
+    function bandTarget(reactivity, levels, sourceLevel) {
+      if (!levels) return reactivity.idle;
+      return Math.max(reactivity.floor, reactivity.floor + sourceLevel * reactivity.gain);
+    }
+    let rafId = 0;
+    let lastTs = performance.now();
+    let disposed = false;
+    let wasActive = activeRef.current;
+    let lastSeed = cfg0.seed;
+    const render = () => {
+      if (disposed) return;
+      const now = performance.now();
+      const delta = Math.min(now - lastTs, 100);
+      lastTs = now;
+      const cfg = configRef.current;
+      lightAColorObj.set(cfg.lightAColor);
+      lightBColorObj.set(cfg.lightBColor);
+      rimColorObj.set(cfg.rimColor ?? cfg.lightBColor);
+      material.uniforms.uLightAIntensity.value = cfg.lightAIntensity;
+      material.uniforms.uLightBIntensity.value = cfg.lightBIntensity;
+      material.uniforms.uDistortionFrequency.value = cfg.distortionFrequency;
+      material.uniforms.uDisplacementFrequency.value = cfg.displacementFrequency;
+      material.uniforms.uFresnelOffset.value = cfg.fresnelOffset;
+      material.uniforms.uFresnelPower.value = cfg.fresnelPower;
+      material.uniforms.uRimThreshold.value = cfg.rimThreshold;
+      material.uniforms.uRimPower.value = cfg.rimPower;
+      if (camera.position.z !== cfg.cameraZ) camera.position.z = cfg.cameraZ;
+      if (camera.fov !== cfg.fov) {
+        camera.fov = cfg.fov;
+        camera.updateProjectionMatrix();
+      }
+      const isActive = activeRef.current;
+      if (isActive && !wasActive || cfg.seed !== lastSeed) {
+        resetAnimationState(cfg);
+        lastSeed = cfg.seed;
+      }
+      wasActive = isActive;
+      if (isActive) {
+        let levels = null;
+        if (getFrequencyDataRef.current) {
+          try {
+            const buf = getFrequencyDataRef.current();
+            if (buf && buf.length > 0) levels = computeLevels(buf);
+          } catch {
+            levels = null;
+          }
+        }
+        const l0 = levels ? levels[0] || 0 : 0;
+        const l1 = levels ? levels[1] || 0 : 0;
+        const l2 = levels ? levels[2] || 0 : 0;
+        const loudest = Math.max(l0, l1, l2);
+        const update = (variation, reactivity, sourceLevel) => {
+          variation.target = bandTarget(reactivity, levels, sourceLevel);
+          const easing = variation.target > variation.current ? reactivity.attack : reactivity.decay;
+          variation.current += (variation.target - variation.current) * easing * delta;
+        };
+        update(variations.volume, cfg.volume, loudest);
+        update(variations.medium, cfg.medium, l1);
+        update(variations.high, cfg.high, l2);
+        update(variations.low, cfg.low, l0);
+        const timeFrequency = variations.low.current;
+        const elapsed = delta * timeFrequency;
+        material.uniforms.uDisplacementStrength.value = variations.volume.current;
+        material.uniforms.uDistortionStrength.value = variations.high.current;
+        material.uniforms.uFresnelMultiplier.value = variations.medium.current;
+        const offsetTime = (material.uniforms.uTime.value + elapsed) * 0.3;
+        offsetSpherical.phi = (Math.sin(offsetTime * 1e-3) * Math.sin(offsetTime * 321e-5) * 0.5 + 0.5) * Math.PI;
+        offsetSpherical.theta = (Math.sin(offsetTime * 1e-4) * Math.sin(offsetTime * 321e-6) * 0.5 + 0.5) * Math.PI * 2;
+        offsetDirection.setFromSpherical(offsetSpherical);
+        offsetDirection.multiplyScalar(timeFrequency * 2);
+        material.uniforms.uOffset.value.add(offsetDirection);
+        material.uniforms.uTime.value += elapsed;
+      }
+      renderer.render(scene, camera);
+      rafId = requestAnimationFrame(render);
+    };
+    rafId = requestAnimationFrame(render);
+    const resizeObserver = typeof ResizeObserver !== "undefined" ? new ResizeObserver(() => {
+      const w = container.clientWidth || 1;
+      const h = container.clientHeight || 1;
+      camera.aspect = w / h;
+      camera.updateProjectionMatrix();
+      renderer.setSize(w, h, false);
+    }) : null;
+    resizeObserver?.observe(container);
+    return () => {
+      disposed = true;
+      cancelAnimationFrame(rafId);
+      resizeObserver?.disconnect();
+      geometry.dispose();
+      material.dispose();
+      renderer.dispose();
+      if (renderer.domElement.parentNode === container) {
+        container.removeChild(renderer.domElement);
+      }
+    };
+  }, [initSubdivisions, initMaxPixelRatio, initBackgroundColor]);
+  return /* @__PURE__ */ jsx2("div", { ref: containerRef, className, style });
+}
+
+// src/react/OrganicParticles.tsx
+import { useEffect as useEffect3, useMemo as useMemo3, useRef as useRef4 } from "react";
+import * as THREE2 from "three";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function seededUnit2(seed, salt) {
+  const s = Math.sin((seed + salt * 7919) * 12.9898 + salt * 78.233) * 43758.5453;
+  return s - Math.floor(s);
+}
+function buildParticleAttributes(count, innerRadius, outerRadius, seed) {
+  const positions = new Float32Array(count * 3);
+  const seeds = new Float32Array(count);
+  for (let i = 0; i < count; i++) {
+    const u = seededUnit2(seed, i * 4 + 1);
+    const v = seededUnit2(seed, i * 4 + 2);
+    const w = seededUnit2(seed, i * 4 + 3);
+    const s = seededUnit2(seed, i * 4 + 4);
+    const theta = v * Math.PI * 2;
+    const phi = Math.acos(2 * w - 1);
+    const r = innerRadius + u * Math.max(0, outerRadius - innerRadius);
+    const sinPhi = Math.sin(phi);
+    positions[i * 3 + 0] = r * sinPhi * Math.cos(theta);
+    positions[i * 3 + 1] = r * sinPhi * Math.sin(theta);
+    positions[i * 3 + 2] = r * Math.cos(phi);
+    seeds[i] = s;
+  }
+  return { positions, seeds };
+}
+function OrganicParticles({
+  getFrequencyData,
+  active = true,
+  config: configProp,
+  className,
+  style
+}) {
+  const containerRef = useRef4(null);
+  const resolvedConfig = useMemo3(
+    () => resolveOrganicParticlesConfig(configProp),
+    [configProp]
+  );
+  const configRef = useRef4(resolvedConfig);
+  useEffect3(() => {
+    configRef.current = resolvedConfig;
+  }, [resolvedConfig]);
+  const getFrequencyDataRef = useRef4(getFrequencyData);
+  const activeRef = useRef4(active);
+  useEffect3(() => {
+    getFrequencyDataRef.current = getFrequencyData;
+  }, [getFrequencyData]);
+  useEffect3(() => {
+    activeRef.current = active;
+  }, [active]);
+  const initCount = resolvedConfig.count;
+  const initInnerRadius = resolvedConfig.innerRadius;
+  const initOuterRadius = resolvedConfig.outerRadius;
+  const initSeed = resolvedConfig.seed;
+  const initMaxPixelRatio = resolvedConfig.maxPixelRatio;
+  const initBackgroundColor = resolvedConfig.backgroundColor;
+  useEffect3(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const cfg0 = configRef.current;
+    const width = container.clientWidth || 1;
+    const height = container.clientHeight || 1;
+    const pixelRatio = Math.min(
+      initMaxPixelRatio ?? (typeof window !== "undefined" ? window.devicePixelRatio : 1),
+      2
+    );
+    const scene = new THREE2.Scene();
+    if (initBackgroundColor) scene.background = new THREE2.Color(initBackgroundColor);
+    const camera = new THREE2.PerspectiveCamera(cfg0.fov, width / height, 0.1, 100);
+    camera.position.set(0, 0, cfg0.cameraZ);
+    scene.add(camera);
+    const renderer = new THREE2.WebGLRenderer({
+      antialias: true,
+      alpha: initBackgroundColor === null,
+      powerPreference: "high-performance"
+    });
+    renderer.setSize(width, height, false);
+    renderer.setPixelRatio(pixelRatio);
+    renderer.setClearColor(0, initBackgroundColor === null ? 0 : 1);
+    container.appendChild(renderer.domElement);
+    renderer.domElement.style.display = "block";
+    renderer.domElement.style.width = "100%";
+    renderer.domElement.style.height = "100%";
+    const { positions, seeds } = buildParticleAttributes(
+      initCount,
+      initInnerRadius,
+      initOuterRadius,
+      initSeed
+    );
+    const geometry = new THREE2.BufferGeometry();
+    geometry.setAttribute("aBasePosition", new THREE2.BufferAttribute(positions, 3));
+    geometry.setAttribute("aSeed", new THREE2.BufferAttribute(seeds, 1));
+    geometry.setAttribute("position", new THREE2.BufferAttribute(positions, 3));
+    const colorCoolObj = new THREE2.Color(cfg0.colorCool);
+    const colorHotObj = new THREE2.Color(cfg0.colorHot);
+    const material = new THREE2.ShaderMaterial({
+      uniforms: {
+        uTime: { value: 0 },
+        uNoiseFrequency: { value: cfg0.noiseFrequency },
+        uNoiseStrength: { value: cfg0.noiseStrength },
+        uDisplacement: { value: cfg0.volume.idle },
+        uSwirl: { value: cfg0.high.idle },
+        uSwirlTimeRate: { value: cfg0.swirlTimeRate },
+        uSizeBase: { value: cfg0.sizeBase },
+        uSizeAudio: { value: cfg0.medium.idle },
+        uPixelRatio: { value: pixelRatio },
+        uColorCool: { value: colorCoolObj },
+        uColorHot: { value: colorHotObj },
+        uOpacity: { value: cfg0.opacity },
+        uSoftness: { value: cfg0.softness }
+      },
+      vertexShader: ORGANIC_PARTICLES_VERTEX_SHADER,
+      fragmentShader: ORGANIC_PARTICLES_FRAGMENT_SHADER,
+      transparent: true,
+      depthWrite: false,
+      blending: THREE2.AdditiveBlending
+    });
+    const points = new THREE2.Points(geometry, material);
+    scene.add(points);
+    const variations = {
+      volume: { target: 0, current: cfg0.volume.idle },
+      medium: { target: 0, current: cfg0.medium.idle },
+      high: { target: 0, current: cfg0.high.idle },
+      low: { target: 0, current: cfg0.low.idle }
+    };
+    const LEVEL_COUNT = 8;
+    function computeLevels(buf) {
+      const bins = Math.floor(buf.length / LEVEL_COUNT);
+      const levels = new Array(LEVEL_COUNT).fill(0);
+      if (bins <= 0) return levels;
+      for (let i = 0; i < LEVEL_COUNT; i++) {
+        let sum = 0;
+        for (let j = 0; j < bins; j++) sum += buf[i * bins + j];
+        levels[i] = sum / bins / 256;
+      }
+      return levels;
+    }
+    function bandTarget(reactivity, levels, sourceLevel) {
+      if (!levels) return reactivity.idle;
+      return Math.max(
+        reactivity.floor,
+        reactivity.floor + sourceLevel * reactivity.gain
+      );
+    }
+    const rotationState = { y: 0 };
+    const resetAnimationState = (cfg) => {
+      material.uniforms.uTime.value = 0;
+      rotationState.y = 0;
+      points.rotation.set(0, 0, 0);
+      variations.volume.current = cfg.volume.idle;
+      variations.medium.current = cfg.medium.idle;
+      variations.high.current = cfg.high.idle;
+      variations.low.current = cfg.low.idle;
+      variations.volume.target = cfg.volume.idle;
+      variations.medium.target = cfg.medium.idle;
+      variations.high.target = cfg.high.idle;
+      variations.low.target = cfg.low.idle;
+    };
+    let rafId = 0;
+    let lastTs = performance.now();
+    let disposed = false;
+    let wasActive = activeRef.current;
+    const render = () => {
+      if (disposed) return;
+      const now = performance.now();
+      const delta = Math.min(now - lastTs, 100);
+      lastTs = now;
+      const cfg = configRef.current;
+      colorCoolObj.set(cfg.colorCool);
+      colorHotObj.set(cfg.colorHot);
+      material.uniforms.uNoiseFrequency.value = cfg.noiseFrequency;
+      material.uniforms.uNoiseStrength.value = cfg.noiseStrength;
+      material.uniforms.uSwirlTimeRate.value = cfg.swirlTimeRate;
+      material.uniforms.uSizeBase.value = cfg.sizeBase;
+      material.uniforms.uOpacity.value = cfg.opacity;
+      material.uniforms.uSoftness.value = cfg.softness;
+      if (camera.position.z !== cfg.cameraZ) camera.position.z = cfg.cameraZ;
+      if (camera.fov !== cfg.fov) {
+        camera.fov = cfg.fov;
+        camera.updateProjectionMatrix();
+      }
+      const isActive = activeRef.current;
+      if (isActive && !wasActive) {
+        resetAnimationState(cfg);
+      }
+      wasActive = isActive;
+      if (isActive) {
+        let levels = null;
+        if (getFrequencyDataRef.current) {
+          try {
+            const buf = getFrequencyDataRef.current();
+            if (buf && buf.length > 0) levels = computeLevels(buf);
+          } catch {
+            levels = null;
+          }
+        }
+        const l0 = levels ? levels[0] || 0 : 0;
+        const l1 = levels ? levels[1] || 0 : 0;
+        const l2 = levels ? levels[2] || 0 : 0;
+        const loudest = Math.max(l0, l1, l2);
+        const update = (variation, reactivity, sourceLevel) => {
+          variation.target = bandTarget(reactivity, levels, sourceLevel);
+          const easing = variation.target > variation.current ? reactivity.attack : reactivity.decay;
+          variation.current += (variation.target - variation.current) * easing * delta;
+        };
+        update(variations.volume, cfg.volume, loudest);
+        update(variations.medium, cfg.medium, l1);
+        update(variations.high, cfg.high, l2);
+        update(variations.low, cfg.low, l0);
+        const timeFrequency = variations.low.current;
+        const elapsed = delta * timeFrequency;
+        material.uniforms.uDisplacement.value = variations.volume.current;
+        material.uniforms.uSizeAudio.value = variations.medium.current;
+        material.uniforms.uSwirl.value = variations.high.current;
+        material.uniforms.uTime.value += elapsed;
+        rotationState.y += delta * cfg.rotationBias + variations.high.current * delta * 8e-4;
+        points.rotation.y = rotationState.y;
+      } else {
+        material.uniforms.uTime.value += delta * cfg.idleNoiseRate;
+      }
+      renderer.render(scene, camera);
+      rafId = requestAnimationFrame(render);
+    };
+    rafId = requestAnimationFrame(render);
+    const resizeObserver = typeof ResizeObserver !== "undefined" ? new ResizeObserver(() => {
+      const w = container.clientWidth || 1;
+      const h = container.clientHeight || 1;
+      camera.aspect = w / h;
+      camera.updateProjectionMatrix();
+      renderer.setSize(w, h, false);
+    }) : null;
+    resizeObserver?.observe(container);
+    return () => {
+      disposed = true;
+      cancelAnimationFrame(rafId);
+      resizeObserver?.disconnect();
+      geometry.dispose();
+      material.dispose();
+      renderer.dispose();
+      if (renderer.domElement.parentNode === container) {
+        container.removeChild(renderer.domElement);
+      }
+    };
+  }, [
+    initCount,
+    initInnerRadius,
+    initOuterRadius,
+    initSeed,
+    initMaxPixelRatio,
+    initBackgroundColor
+  ]);
+  return /* @__PURE__ */ jsx3("div", { ref: containerRef, className, style });
+}
+export {
+  DEFAULT_ORGANIC_PARTICLES_CONFIG,
+  DEFAULT_ORGANIC_SPHERE_CONFIG,
+  ORGANIC_PARTICLES_FRAGMENT_SHADER,
+  ORGANIC_PARTICLES_VERTEX_SHADER,
+  ORGANIC_SPHERE_FRAGMENT_SHADER,
+  ORGANIC_SPHERE_VERTEX_SHADER,
+  OrganicParticles,
+  OrganicSphere,
+  PERLIN_4D,
+  ShogoVoiceProvider,
+  resolveOrganicParticlesConfig,
+  resolveOrganicSphereConfig,
+  useChatConversation,
+  useShogoChat,
+  useShogoVoice,
+  useVoiceConversation
+};
+//# sourceMappingURL=index.js.map