@shogo-ai/voice 1.4.1

package/dist/native/index.js

@@ -0,0 +1,949 @@
+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/native/ShogoVoiceProvider.tsx
+import { ConversationProvider as ElevenLabsConversationProvider } from "@elevenlabs/react-native";
+import { jsx } from "react/jsx-runtime";
+function ShogoVoiceProvider(props) {
+  const { agentId, children } = props;
+  return /* @__PURE__ */ jsx(ElevenLabsConversationProvider, { agentId, children });
+}
+
+// src/native/useVoiceConversation.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+import { AppState } from "react-native";
+import { useConversation } from "@elevenlabs/react-native";
+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,
+    // RN fetch has no real "same-origin" — apps are always cross-
+    // origin to the backend. Default to `'omit'` for the bearer
+    // path and `'include'` for the cookie path so the cookie jar
+    // gets used when the consumer set up auth that way.
+    fetchCredentials = shogoApiKey ? "omit" : "include",
+    onError,
+    onMessage,
+    requestPermissions,
+    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 isRestartingRef = useRef(false);
+  const [convaiConversationId, setConvaiConversationId] = useState(null);
+  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 sub = AppState.addEventListener(
+      "change",
+      (nextState) => {
+        if (nextState !== "background" && nextState !== "inactive") return;
+        if (!weStartedSessionRef.current || transcriptRef.current.length === 0) return;
+        const transcript = transcriptRef.current.join("\n").trim();
+        transcriptRef.current = [];
+        if (transcript.length < 20) return;
+        void postJson(transcriptIngestPath, { transcript }).catch(() => {
+        });
+      }
+    );
+    return () => {
+      sub.remove();
+    };
+  }, [postJson, transcriptIngestPath]);
+  const startInternal = useCallback(
+    async (opts) => {
+      if (status === "connected" || status === "connecting") {
+        try {
+          endSession();
+          await new Promise((r) => setTimeout(r, 120));
+        } catch {
+        }
+      }
+      if (requestPermissions) {
+        await requestPermissions();
+      }
+      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,
+      requestPermissions,
+      optionConversationId
+    ]
+  );
+  const start = useCallback(
+    async (opts) => {
+      await startInternal(opts);
+    },
+    [startInternal]
+  );
+  const end = useCallback(() => {
+    endSession();
+  }, [endSession]);
+  const restart = useCallback(
+    async (opts) => {
+      const suppress = opts?.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/native/useShogoVoice.ts
+function useShogoVoice(opts = {}) {
+  return useVoiceConversation({
+    characterName: opts.characterName ?? "Shogo",
+    signedUrlPath: opts.signedUrlPath ?? "/api/voice/signed-url",
+    fetchCredentials: opts.fetchCredentials ?? "include",
+    ...opts
+  });
+}
+
+// src/native/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,
+    // RN fetch has no real "same-origin" — apps are always cross-
+    // origin to the backend. Default to `'omit'` for the bearer
+    // path and `'include'` for the cookie path so the cookie jar
+    // gets used when the consumer set up auth that way.
+    fetchCredentials = shogoApiKey ? "omit" : "include",
+    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/native/useShogoChat.ts
+function useShogoChat(opts = {}) {
+  return useChatConversation({
+    api: opts.api ?? "/api/chat/turn",
+    fetchCredentials: opts.fetchCredentials ?? "include",
+    ...opts
+  });
+}
+
+// src/native/OrganicSphere.tsx
+import { useEffect as useEffect2, useMemo as useMemo2, useRef as useRef3 } from "react";
+import { PixelRatio } from "react-native";
+import { GLView } from "expo-gl";
+import { Renderer } from "expo-three";
+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,
+  style
+}) {
+  const resolvedConfig = useMemo2(
+    () => resolveOrganicSphereConfig(configProp),
+    [configProp]
+  );
+  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 disposeRef = useRef3(null);
+  useEffect2(() => {
+    return () => {
+      disposeRef.current?.();
+      disposeRef.current = null;
+    };
+  }, []);
+  const initSubdivisions = resolvedConfig.subdivisions;
+  const initMaxPixelRatio = resolvedConfig.maxPixelRatio;
+  const initBackgroundColor = resolvedConfig.backgroundColor;
+  const onContextCreate = useMemo2(
+    () => async (gl) => {
+      const cfg0 = configRef.current;
+      const width = gl.drawingBufferWidth;
+      const height = gl.drawingBufferHeight;
+      const pixelRatio = Math.min(initMaxPixelRatio ?? PixelRatio.get(), 2);
+      const scene = new THREE.Scene();
+      if (initBackgroundColor) scene.background = new THREE.Color(initBackgroundColor);
+      const camera = new THREE.PerspectiveCamera(
+        cfg0.fov,
+        width / height || 1,
+        0.1,
+        100
+      );
+      camera.position.set(0, 0, cfg0.cameraZ);
+      scene.add(camera);
+      const renderer = new Renderer({
+        gl,
+        antialias: true,
+        alpha: initBackgroundColor === null,
+        powerPreference: "high-performance"
+      });
+      renderer.setSize(width / pixelRatio, height / pixelRatio, false);
+      renderer.setPixelRatio(pixelRatio);
+      renderer.setClearColor(0, initBackgroundColor === null ? 0 : 1);
+      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 = Date.now();
+      let disposed = false;
+      let wasActive = activeRef.current;
+      let lastSeed = cfg0.seed;
+      const render = () => {
+        if (disposed) return;
+        const now = Date.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);
+        gl.endFrameEXP();
+        rafId = requestAnimationFrame(render);
+      };
+      rafId = requestAnimationFrame(render);
+      const dispose = () => {
+        if (disposed) return;
+        disposed = true;
+        cancelAnimationFrame(rafId);
+        geometry.dispose();
+        material.dispose();
+        renderer.dispose();
+      };
+      disposeRef.current = dispose;
+    },
+    [initSubdivisions, initMaxPixelRatio, initBackgroundColor]
+  );
+  return /* @__PURE__ */ jsx2(
+    GLView,
+    {
+      style,
+      onContextCreate
+    },
+    `${initSubdivisions}-${initMaxPixelRatio ?? "auto"}-${initBackgroundColor ?? "transparent"}`
+  );
+}
+
+// src/native/OrganicParticles.tsx
+import { useEffect as useEffect3, useMemo as useMemo3, useRef as useRef4 } from "react";
+import { PixelRatio as PixelRatio2 } from "react-native";
+import { GLView as GLView2 } from "expo-gl";
+import { Renderer as Renderer2 } from "expo-three";
+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,
+  style
+}) {
+  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 disposeRef = useRef4(null);
+  useEffect3(() => {
+    return () => {
+      disposeRef.current?.();
+      disposeRef.current = null;
+    };
+  }, []);
+  const initCount = resolvedConfig.count;
+  const initInnerRadius = resolvedConfig.innerRadius;
+  const initOuterRadius = resolvedConfig.outerRadius;
+  const initSeed = resolvedConfig.seed;
+  const initMaxPixelRatio = resolvedConfig.maxPixelRatio;
+  const initBackgroundColor = resolvedConfig.backgroundColor;
+  const onContextCreate = useMemo3(
+    () => async (gl) => {
+      const cfg0 = configRef.current;
+      const width = gl.drawingBufferWidth;
+      const height = gl.drawingBufferHeight;
+      const pixelRatio = Math.min(initMaxPixelRatio ?? PixelRatio2.get(), 2);
+      const scene = new THREE2.Scene();
+      if (initBackgroundColor) scene.background = new THREE2.Color(initBackgroundColor);
+      const camera = new THREE2.PerspectiveCamera(
+        cfg0.fov,
+        width / height || 1,
+        0.1,
+        100
+      );
+      camera.position.set(0, 0, cfg0.cameraZ);
+      scene.add(camera);
+      const renderer = new Renderer2({
+        gl,
+        antialias: true,
+        alpha: initBackgroundColor === null,
+        powerPreference: "high-performance"
+      });
+      renderer.setSize(width / pixelRatio, height / pixelRatio, false);
+      renderer.setPixelRatio(pixelRatio);
+      renderer.setClearColor(0, initBackgroundColor === null ? 0 : 1);
+      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 = Date.now();
+      let disposed = false;
+      let wasActive = activeRef.current;
+      const render = () => {
+        if (disposed) return;
+        const now = Date.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);
+        gl.endFrameEXP();
+        rafId = requestAnimationFrame(render);
+      };
+      rafId = requestAnimationFrame(render);
+      const dispose = () => {
+        if (disposed) return;
+        disposed = true;
+        cancelAnimationFrame(rafId);
+        geometry.dispose();
+        material.dispose();
+        renderer.dispose();
+      };
+      disposeRef.current = dispose;
+    },
+    [initCount, initInnerRadius, initOuterRadius, initSeed, initMaxPixelRatio, initBackgroundColor]
+  );
+  return /* @__PURE__ */ jsx3(
+    GLView2,
+    {
+      style,
+      onContextCreate
+    },
+    `${initCount}-${initInnerRadius}-${initOuterRadius}-${initSeed}-${initMaxPixelRatio ?? "auto"}-${initBackgroundColor ?? "transparent"}`
+  );
+}
+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