@aippy/runtime 0.2.0-dev.1 → 0.2.0-dev.3

package/dist/audio/AudioSilenceDetector.d.ts

@@ -0,0 +1,52 @@
+import { AutoPauseOptions } from './types';
+/**
+ * Detects silence in an audio stream and automatically pauses/resumes media element
+ * to prevent iOS Safari audio buffer looping bug
+ */
+export declare class AudioSilenceDetector {
+    private audioContext;
+    private mediaElement;
+    private analyser;
+    private dataArray;
+    private rafId;
+    private silenceStartTime;
+    private isPaused;
+    private lastCheckTime;
+    private readonly silenceThreshold;
+    private readonly silenceDuration;
+    private readonly checkInterval;
+    private readonly debug;
+    constructor(audioContext: AudioContext, mediaElement: HTMLMediaElement, options: Required<AutoPauseOptions>, debug?: boolean);
+    /**
+     * Connect the detector to the audio stream
+     */
+    connect(source: AudioNode): void;
+    /**
+     * Start monitoring audio levels
+     */
+    start(): void;
+    /**
+     * Stop monitoring
+     */
+    stop(): void;
+    /**
+     * Cleanup resources
+     */
+    dispose(): void;
+    /**
+     * Check audio levels and pause/resume as needed
+     */
+    private check;
+    /**
+     * Get current audio level (0-1)
+     */
+    private getAudioLevel;
+    /**
+     * Pause media element to stop audio output
+     */
+    private pauseMedia;
+    /**
+     * Resume media element playback
+     */
+    private resumeMedia;
+}

package/dist/audio/index.d.ts

@@ -7,7 +7,7 @@
  * @module @aippy/runtime/audio
  */
 export { patchAudioContext } from './patchAudioContext';
-export type { AudioContextPatchOptions, MediaElementType, PatchedAudioContext, } from './types';
+export type { AudioContextPatchOptions, AutoPauseOptions, MediaElementType, PatchedAudioContext, } from './types';
 export { createHiddenMediaElement, createHiddenVideoElement, isIOSDevice, isMediaStreamAudioSupported, } from './utils';
 export { useAudioContext } from './useAudioContext';
 export type { UseAudioContextOptions, UseAudioContextReturn } from './useAudioContext';

package/dist/audio/index.js

@@ -1,4 +1,4 @@
-import { c, a, i, b, p, u } from "../useAudioContext-DSbHyklm.js";
+import { c, a, i, b, p, u } from "../useAudioContext-BrvG8DKk.js";
 export {
   c as createHiddenMediaElement,
   a as createHiddenVideoElement,

package/dist/audio/patchAudioContext.d.ts

@@ -6,6 +6,12 @@ import { AudioContextPatchOptions, PatchedAudioContext } from './types';
  * This function routes audio through a MediaStreamAudioDestinationNode
  * connected to a hidden video element, which bypasses the restriction.
  *
+ * Features:
+ * - Auto-pause: Automatically pauses MediaElement when audio becomes silent
+ *   to prevent iOS Safari audio buffer looping bug (~50ms latency)
+ * - Auto-resume: Automatically resumes playback when new audio is detected
+ * - Zero user code changes: Use standard Web Audio API after unlock
+ *
  * On non-iOS devices, this function returns the original context with
  * minimal modifications (zero overhead).
  *
@@ -25,6 +31,7 @@ import { AudioContextPatchOptions, PatchedAudioContext } from './types';
  * const osc = patchedCtx.createOscillator();
  * osc.connect(patchedCtx.destination); // Auto-routed on iOS
  * osc.start();
+ * osc.stop(); // Audio will auto-stop ~50ms after silence detected
  * ```
  */
 export declare function patchAudioContext(audioContext: AudioContext, options?: AudioContextPatchOptions): PatchedAudioContext;

package/dist/audio/types.d.ts

@@ -2,6 +2,31 @@
  * Media element type for MediaStream playback
  */
 export type MediaElementType = 'video' | 'audio';
+/**
+ * Options for automatic pause/resume behavior
+ */
+export interface AutoPauseOptions {
+    /**
+     * Enable automatic pause when audio becomes silent
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Silence threshold (0-1). Audio below this level is considered silent
+     * @default 0.001
+     */
+    silenceThreshold?: number;
+    /**
+     * Duration of silence (ms) before triggering auto-pause
+     * @default 50
+     */
+    silenceDuration?: number;
+    /**
+     * Interval (ms) for checking audio levels
+     * @default 16
+     */
+    checkInterval?: number;
+}
 /**
  * Options for patching AudioContext
  */
@@ -27,6 +52,12 @@ export interface AudioContextPatchOptions {
      * @default 'video'
      */
     mediaElementType?: MediaElementType;
+    /**
+     * Auto-pause configuration to prevent audio buffer looping on iOS
+     * When enabled, automatically pauses MediaElement when audio becomes silent
+     * @default { enabled: true, silenceThreshold: 0.001, silenceDuration: 50, checkInterval: 16 }
+     */
+    autoPause?: AutoPauseOptions;
 }
 /**
  * Extended AudioContext with iOS compatibility features

package/dist/audio/useAudioContext.d.ts

@@ -31,6 +31,7 @@ export interface UseAudioContextReturn {
  *
  * Automatically handles:
  * - AudioContext creation and patching
+ * - Auto-pause/resume to prevent iOS audio buffer looping (~50ms latency)
  * - Cleanup on unmount
  * - Optional auto-unlock on first user interaction
  *
@@ -52,11 +53,12 @@ export interface UseAudioContextReturn {
  *       await unlock();
  *     }
  *
- *     // Play sound using Web Audio API
+ *     // Play sound using Web Audio API - just use standard API!
  *     const osc = audioContext.createOscillator();
  *     osc.connect(audioContext.destination);
  *     osc.start();
  *     osc.stop(audioContext.currentTime + 0.3);
+ *     // Audio will auto-stop ~50ms after silence detected
  *   };
  *
  *   return <button onClick={playSound}>Play Sound</button>;

package/dist/core/index.js

@@ -33,7 +33,7 @@ function mergeConfig(userConfig) {
     }
   };
 }
-const version = "0.2.0-dev.1";
+const version = "0.2.0-dev.3";
 const packageJson = {
   version
 };

package/dist/index/index.js

@@ -3,7 +3,7 @@ import { A, E, c } from "../errors-DAz5_jDJ.js";
 import { CameraAPI, FileSystemAPI, GeolocationAPI, SensorsAPI, camera, fileSystem, geolocation, sensors, vibrate } from "../device/index.js";
 import { c as c2, a, P, b, p, d } from "../pwa-BkviTQoN.js";
 import { a as a2, b as b2 } from "../useTweaks-mK5PAWOs.js";
-import { c as c3, a as a3, i, b as b3, p as p2, u } from "../useAudioContext-DSbHyklm.js";
+import { c as c3, a as a3, i, b as b3, p as p2, u } from "../useAudioContext-BrvG8DKk.js";
 export {
   A as AippyRuntimeError,
   CameraAPI,

package/dist/useAudioContext-BrvG8DKk.js

@@ -0,0 +1,345 @@
+import { useState, useRef, useEffect } from "react";
+function isIOSDevice() {
+  const userAgent = navigator.userAgent;
+  if (/iPad|iPhone|iPod/.test(userAgent)) {
+    return true;
+  }
+  if (navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1) {
+    return true;
+  }
+  return false;
+}
+function isMediaStreamAudioSupported() {
+  try {
+    if (!window.AudioContext) {
+      return false;
+    }
+    const tempContext = new AudioContext();
+    const hasMethod = typeof tempContext.createMediaStreamDestination === "function";
+    tempContext.close();
+    return hasMethod;
+  } catch {
+    return false;
+  }
+}
+function createHiddenMediaElement(type = "video", debug = false) {
+  const element = document.createElement(type);
+  element.muted = false;
+  element.autoplay = true;
+  if (type === "video") {
+    element.playsInline = true;
+  }
+  if (debug) {
+    element.style.cssText = "position:fixed;bottom:10px;right:10px;width:200px;background:#ff0000;z-index:9999;";
+  } else {
+    element.style.cssText = "position:fixed;width:1px;height:1px;opacity:0;pointer-events:none;";
+  }
+  return element;
+}
+function createHiddenVideoElement(debug = false) {
+  return createHiddenMediaElement("video", debug);
+}
+class AudioSilenceDetector {
+  constructor(audioContext, mediaElement, options, debug = false) {
+    this.audioContext = audioContext;
+    this.mediaElement = mediaElement;
+    this.silenceThreshold = options.silenceThreshold;
+    this.silenceDuration = options.silenceDuration;
+    this.checkInterval = options.checkInterval;
+    this.debug = debug;
+    this.analyser = audioContext.createAnalyser();
+    this.analyser.fftSize = 512;
+    this.analyser.smoothingTimeConstant = 0.3;
+    this.dataArray = new Uint8Array(this.analyser.frequencyBinCount);
+  }
+  analyser;
+  dataArray;
+  rafId = null;
+  silenceStartTime = 0;
+  isPaused = false;
+  lastCheckTime = 0;
+  silenceThreshold;
+  silenceDuration;
+  checkInterval;
+  debug;
+  /**
+   * Connect the detector to the audio stream
+   */
+  connect(source) {
+    source.connect(this.analyser);
+  }
+  /**
+   * Start monitoring audio levels
+   */
+  start() {
+    if (this.rafId !== null) return;
+    this.lastCheckTime = performance.now();
+    this.check();
+    if (this.debug) {
+      console.log("[AudioSilenceDetector] Started monitoring");
+    }
+  }
+  /**
+   * Stop monitoring
+   */
+  stop() {
+    if (this.rafId !== null) {
+      cancelAnimationFrame(this.rafId);
+      this.rafId = null;
+    }
+    if (this.debug) {
+      console.log("[AudioSilenceDetector] Stopped monitoring");
+    }
+  }
+  /**
+   * Cleanup resources
+   */
+  dispose() {
+    this.stop();
+    this.analyser.disconnect();
+  }
+  /**
+   * Check audio levels and pause/resume as needed
+   */
+  check = () => {
+    const now = performance.now();
+    const elapsed = now - this.lastCheckTime;
+    if (elapsed >= this.checkInterval) {
+      this.lastCheckTime = now;
+      const volume = this.getAudioLevel();
+      if (volume < this.silenceThreshold) {
+        if (this.silenceStartTime === 0) {
+          this.silenceStartTime = now;
+        } else {
+          const silenceDuration = now - this.silenceStartTime;
+          if (silenceDuration >= this.silenceDuration && !this.isPaused) {
+            this.pauseMedia();
+          }
+        }
+      } else {
+        this.silenceStartTime = 0;
+        if (this.isPaused) {
+          this.resumeMedia();
+        }
+      }
+    }
+    this.rafId = requestAnimationFrame(this.check);
+  };
+  /**
+   * Get current audio level (0-1)
+   */
+  getAudioLevel() {
+    this.analyser.getByteTimeDomainData(this.dataArray);
+    let sum = 0;
+    for (let i = 0; i < this.dataArray.length; i++) {
+      const normalized = (this.dataArray[i] - 128) / 128;
+      sum += normalized * normalized;
+    }
+    return Math.sqrt(sum / this.dataArray.length);
+  }
+  /**
+   * Pause media element to stop audio output
+   */
+  pauseMedia() {
+    try {
+      this.mediaElement.pause();
+      this.isPaused = true;
+      if (this.debug) {
+        console.log("[AudioSilenceDetector] Paused media element (silence detected)");
+      }
+    } catch (error) {
+      console.error("[AudioSilenceDetector] Failed to pause:", error);
+    }
+  }
+  /**
+   * Resume media element playback
+   */
+  resumeMedia() {
+    try {
+      if (this.audioContext.state === "running") {
+        this.mediaElement.play().catch((error) => {
+          if (this.debug) {
+            console.warn("[AudioSilenceDetector] Failed to resume:", error);
+          }
+        });
+      }
+      this.isPaused = false;
+      if (this.debug) {
+        console.log("[AudioSilenceDetector] Resumed media element (audio detected)");
+      }
+    } catch (error) {
+      console.error("[AudioSilenceDetector] Failed to resume:", error);
+    }
+  }
+}
+function patchAudioContext(audioContext, options = {}) {
+  const {
+    forceEnable = false,
+    autoCleanup = true,
+    debug = false,
+    mediaElementType = "video",
+    autoPause = {}
+  } = options;
+  const autoPauseOptions = {
+    enabled: autoPause.enabled ?? true,
+    silenceThreshold: autoPause.silenceThreshold ?? 1e-3,
+    silenceDuration: autoPause.silenceDuration ?? 50,
+    checkInterval: autoPause.checkInterval ?? 16
+  };
+  const needsPatch = forceEnable || isIOSDevice();
+  if (!needsPatch) {
+    return Object.assign(audioContext, {
+      unlock: async () => {
+        if (audioContext.state === "suspended") {
+          await audioContext.resume();
+        }
+      },
+      cleanup: () => {
+      },
+      isPatched: false,
+      originalDestination: audioContext.destination
+    });
+  }
+  if (!isMediaStreamAudioSupported()) {
+    console.warn(
+      "[AudioContext] MediaStreamAudioDestinationNode not supported, falling back to native"
+    );
+    return Object.assign(audioContext, {
+      unlock: async () => audioContext.resume(),
+      cleanup: () => {
+      },
+      isPatched: false,
+      originalDestination: audioContext.destination
+    });
+  }
+  const originalDestination = audioContext.destination;
+  const streamDestination = audioContext.createMediaStreamDestination();
+  const mediaElement = createHiddenMediaElement(mediaElementType, debug);
+  mediaElement.srcObject = streamDestination.stream;
+  document.body.appendChild(mediaElement);
+  let silenceDetector = null;
+  if (autoPauseOptions.enabled) {
+    silenceDetector = new AudioSilenceDetector(
+      audioContext,
+      mediaElement,
+      autoPauseOptions,
+      debug
+    );
+    silenceDetector.connect(streamDestination);
+  }
+  Object.defineProperty(audioContext, "destination", {
+    get: () => streamDestination,
+    enumerable: true,
+    configurable: true
+  });
+  if (!("maxChannelCount" in streamDestination)) {
+    Object.defineProperty(streamDestination, "maxChannelCount", {
+      get: () => originalDestination.maxChannelCount,
+      enumerable: true
+    });
+  }
+  let isUnlocked = false;
+  const unlock = async () => {
+    if (isUnlocked) {
+      return;
+    }
+    try {
+      await mediaElement.play();
+      if (audioContext.state === "suspended") {
+        await audioContext.resume();
+      }
+      if (silenceDetector) {
+        silenceDetector.start();
+      }
+      isUnlocked = true;
+      if (debug) {
+        console.log("[AudioContext] iOS unlock successful");
+      }
+    } catch (error) {
+      console.error("[AudioContext] Unlock failed:", error);
+      throw error;
+    }
+  };
+  const cleanup = () => {
+    try {
+      if (silenceDetector) {
+        silenceDetector.dispose();
+        silenceDetector = null;
+      }
+      mediaElement.pause();
+      mediaElement.srcObject = null;
+      mediaElement.remove();
+      if (debug) {
+        console.log("[AudioContext] Cleanup completed");
+      }
+    } catch (error) {
+      console.error("[AudioContext] Cleanup error:", error);
+    }
+  };
+  if (autoCleanup) {
+    const originalClose = audioContext.close.bind(audioContext);
+    audioContext.close = async () => {
+      cleanup();
+      return originalClose();
+    };
+  }
+  return Object.assign(audioContext, {
+    unlock,
+    cleanup,
+    isPatched: true,
+    originalDestination
+  });
+}
+function useAudioContext(options = {}) {
+  const { autoUnlock = true, ...patchOptions } = options;
+  const [audioContext, setAudioContext] = useState(null);
+  const [isUnlocked, setIsUnlocked] = useState(false);
+  const unlockFnRef = useRef(null);
+  useEffect(() => {
+    const ctx = new AudioContext();
+    const patchedCtx = patchAudioContext(ctx, patchOptions);
+    setAudioContext(patchedCtx);
+    return () => {
+      patchedCtx.cleanup();
+      patchedCtx.close();
+    };
+  }, []);
+  useEffect(() => {
+    if (!audioContext) return;
+    unlockFnRef.current = async () => {
+      if (isUnlocked) return;
+      try {
+        await audioContext.unlock();
+        setIsUnlocked(true);
+      } catch (error) {
+        console.warn("Failed to unlock audio:", error);
+      }
+    };
+  }, [audioContext, isUnlocked]);
+  useEffect(() => {
+    if (!autoUnlock || !audioContext) return;
+    const handleInteraction = async () => {
+      await unlockFnRef.current?.();
+    };
+    document.addEventListener("click", handleInteraction, { once: true });
+    document.addEventListener("touchstart", handleInteraction, { once: true });
+    return () => {
+      document.removeEventListener("click", handleInteraction);
+      document.removeEventListener("touchstart", handleInteraction);
+    };
+  }, [autoUnlock, audioContext]);
+  return {
+    audioContext,
+    isUnlocked,
+    unlock: unlockFnRef.current || (async () => {
+    })
+  };
+}
+export {
+  createHiddenVideoElement as a,
+  isMediaStreamAudioSupported as b,
+  createHiddenMediaElement as c,
+  isIOSDevice as i,
+  patchAudioContext as p,
+  useAudioContext as u
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aippy/runtime",
-  "version": "0.2.0-dev.1",
+  "version": "0.2.0-dev.3",
   "description": "Aippy Runtime SDK - Runtime SDK for Aippy projects",
   "private": false,
   "type": "module",
@@ -55,6 +55,7 @@
     "url": "https://discord.com/invite/G94ZAx6gVq"
   },
   "devDependencies": {
+    "@eslint/js": "^9.36.0",
     "@types/node": "^24.5.2",
     "@types/react": "^19.2.2",
     "@types/ua-parser-js": "^0.7.39",

package/dist/useAudioContext-DSbHyklm.js

@@ -1,186 +0,0 @@
-import { useRef, useEffect } from "react";
-function isIOSDevice() {
-  const userAgent = navigator.userAgent;
-  if (/iPad|iPhone|iPod/.test(userAgent)) {
-    return true;
-  }
-  if (navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1) {
-    return true;
-  }
-  return false;
-}
-function isMediaStreamAudioSupported() {
-  try {
-    if (!window.AudioContext) {
-      return false;
-    }
-    const tempContext = new AudioContext();
-    const hasMethod = typeof tempContext.createMediaStreamDestination === "function";
-    tempContext.close();
-    return hasMethod;
-  } catch {
-    return false;
-  }
-}
-function createHiddenMediaElement(type = "video", debug = false) {
-  const element = document.createElement(type);
-  element.muted = false;
-  element.autoplay = true;
-  if (type === "video") {
-    element.playsInline = true;
-  }
-  if (debug) {
-    element.style.cssText = "position:fixed;bottom:10px;right:10px;width:200px;background:#ff0000;z-index:9999;";
-  } else {
-    element.style.cssText = "position:fixed;width:1px;height:1px;opacity:0;pointer-events:none;";
-  }
-  return element;
-}
-function createHiddenVideoElement(debug = false) {
-  return createHiddenMediaElement("video", debug);
-}
-function patchAudioContext(audioContext, options = {}) {
-  const {
-    forceEnable = false,
-    autoCleanup = true,
-    debug = false,
-    mediaElementType = "video"
-  } = options;
-  const needsPatch = forceEnable || isIOSDevice();
-  if (!needsPatch) {
-    return Object.assign(audioContext, {
-      unlock: async () => {
-        if (audioContext.state === "suspended") {
-          await audioContext.resume();
-        }
-      },
-      cleanup: () => {
-      },
-      isPatched: false,
-      originalDestination: audioContext.destination
-    });
-  }
-  if (!isMediaStreamAudioSupported()) {
-    console.warn(
-      "[AudioContext] MediaStreamAudioDestinationNode not supported, falling back to native"
-    );
-    return Object.assign(audioContext, {
-      unlock: async () => audioContext.resume(),
-      cleanup: () => {
-      },
-      isPatched: false,
-      originalDestination: audioContext.destination
-    });
-  }
-  const originalDestination = audioContext.destination;
-  const streamDestination = audioContext.createMediaStreamDestination();
-  const mediaElement = createHiddenMediaElement(mediaElementType, debug);
-  mediaElement.srcObject = streamDestination.stream;
-  document.body.appendChild(mediaElement);
-  Object.defineProperty(audioContext, "destination", {
-    get: () => streamDestination,
-    enumerable: true,
-    configurable: true
-  });
-  if (!("maxChannelCount" in streamDestination)) {
-    Object.defineProperty(streamDestination, "maxChannelCount", {
-      get: () => originalDestination.maxChannelCount,
-      enumerable: true
-    });
-  }
-  let isUnlocked = false;
-  const unlock = async () => {
-    if (isUnlocked) {
-      return;
-    }
-    try {
-      await mediaElement.play();
-      if (audioContext.state === "suspended") {
-        await audioContext.resume();
-      }
-      isUnlocked = true;
-      if (debug) {
-        console.log("[AudioContext] iOS unlock successful");
-      }
-    } catch (error) {
-      console.error("[AudioContext] Unlock failed:", error);
-      throw error;
-    }
-  };
-  const cleanup = () => {
-    try {
-      mediaElement.pause();
-      mediaElement.srcObject = null;
-      mediaElement.remove();
-      if (debug) {
-        console.log("[AudioContext] Cleanup completed");
-      }
-    } catch (error) {
-      console.error("[AudioContext] Cleanup error:", error);
-    }
-  };
-  if (autoCleanup) {
-    const originalClose = audioContext.close.bind(audioContext);
-    audioContext.close = async () => {
-      cleanup();
-      return originalClose();
-    };
-  }
-  return Object.assign(audioContext, {
-    unlock,
-    cleanup,
-    isPatched: true,
-    originalDestination
-  });
-}
-function useAudioContext(options = {}) {
-  const { autoUnlock = true, ...patchOptions } = options;
-  const audioContextRef = useRef(null);
-  const isUnlockedRef = useRef(false);
-  const unlockFnRef = useRef(null);
-  useEffect(() => {
-    const ctx = new AudioContext();
-    audioContextRef.current = patchAudioContext(ctx, patchOptions);
-    return () => {
-      audioContextRef.current?.cleanup();
-      audioContextRef.current?.close();
-    };
-  }, []);
-  if (!unlockFnRef.current) {
-    unlockFnRef.current = async () => {
-      const ctx = audioContextRef.current;
-      if (!ctx || isUnlockedRef.current) return;
-      try {
-        await ctx.unlock();
-        isUnlockedRef.current = true;
-      } catch (error) {
-        console.warn("Failed to unlock audio:", error);
-      }
-    };
-  }
-  useEffect(() => {
-    if (!autoUnlock) return;
-    const handleInteraction = async () => {
-      await unlockFnRef.current?.();
-    };
-    document.addEventListener("click", handleInteraction, { once: true });
-    document.addEventListener("touchstart", handleInteraction, { once: true });
-    return () => {
-      document.removeEventListener("click", handleInteraction);
-      document.removeEventListener("touchstart", handleInteraction);
-    };
-  }, [autoUnlock]);
-  return {
-    audioContext: audioContextRef.current,
-    isUnlocked: isUnlockedRef.current,
-    unlock: unlockFnRef.current
-  };
-}
-export {
-  createHiddenVideoElement as a,
-  isMediaStreamAudioSupported as b,
-  createHiddenMediaElement as c,
-  isIOSDevice as i,
-  patchAudioContext as p,
-  useAudioContext as u
-};