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

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-2R1HNn6s.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.2";
 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-2R1HNn6s.js";
 export {
   A as AippyRuntimeError,
   CameraAPI,

package/dist/{useAudioContext-DSbHyklm.js → useAudioContext-2R1HNn6s.js}

@@ -39,13 +39,153 @@ function createHiddenMediaElement(type = "video", debug = false) {
 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"
+    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, {
@@ -77,6 +217,16 @@ function patchAudioContext(audioContext, options = {}) {
   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,
@@ -98,6 +248,9 @@ function patchAudioContext(audioContext, options = {}) {
       if (audioContext.state === "suspended") {
         await audioContext.resume();
       }
+      if (silenceDetector) {
+        silenceDetector.start();
+      }
       isUnlocked = true;
       if (debug) {
         console.log("[AudioContext] iOS unlock successful");
@@ -109,6 +262,10 @@ function patchAudioContext(audioContext, options = {}) {
   };
   const cleanup = () => {
     try {
+      if (silenceDetector) {
+        silenceDetector.dispose();
+        silenceDetector = null;
+      }
       mediaElement.pause();
       mediaElement.srcObject = null;
       mediaElement.remove();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aippy/runtime",
-  "version": "0.2.0-dev.1",
+  "version": "0.2.0-dev.2",
   "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",