@grame/faustwasm 0.16.4 → 0.16.6

package/assets/standalone/faust-pwa.js

@@ -53,7 +53,7 @@ export class FaustPWA {
         /** @type {FaustPWAOptions} */
         this.fOptions = {
             voices: 0,
-            useScriptProcessor: false,
+            useScriptProcessor: undefined,
             bufferSize: 512,
             uiContainer: null,
             ...options,
@@ -74,6 +74,7 @@ export class FaustPWA {
         // MIDI and Sensor handlers state
         this.fActive.sensors = false;
         this.fActive.midi = false;
+        this.fActive.audioConnected = false;
 
         // Keyboard to MIDI handing
         this.fKeyboard2MIDI = null;
@@ -187,15 +188,59 @@ export class FaustPWA {
         return this.fFaustNode;
     }
 
+    /**
+     * Choose the default audio backend for the current runtime.
+     *
+     * AudioWorklet is always preferred. ScriptProcessor is only requested up
+     * front when the runtime has no AudioWorklet support at all. iOS/WebKit
+     * cases where an AudioWorklet graph is created but stays silent are handled
+     * at node-creation time by the AudioWorklet→ScriptProcessor retry in
+     * `createFaustNode`, so no preemptive iOS heuristic is needed here. The
+     * explicit `useScriptProcessor` option still overrides this default.
+     *
+     * @returns {boolean} True only when AudioWorklet is unavailable.
+     */
+    shouldUseScriptProcessor() {
+        return !this.fAudioContext.audioWorklet;
+    }
+
+    /**
+     * Prime iOS audio output inside the same user gesture used to resume audio.
+     *
+     * Some iOS versions report a resumed AudioContext while the hardware output
+     * path remains locked until a source node is started from the activation
+     * gesture. A one-sample silent buffer is enough to unlock that path without
+     * producing audible sound. Failure is non-fatal because this is only a
+     * compatibility assist.
+     */
+    unlockAudioOutput() {
+        try {
+            const buffer = this.fAudioContext.createBuffer(1, 1, this.fAudioContext.sampleRate);
+            const source = this.fAudioContext.createBufferSource();
+            const gain = this.fAudioContext.createGain();
+            gain.gain.value = 0;
+            source.buffer = buffer;
+            source.connect(gain).connect(this.fAudioContext.destination);
+            source.start(0);
+            source.stop(this.fAudioContext.currentTime + 0.01);
+        } catch (error) {
+            console.warn("Silent audio unlock failed.", error);
+        }
+    }
+
     // Synchronous function to resume AudioContext, to be called first in the synchronous event listener
     resumeAudioContext() {
+        this.unlockAudioOutput();
         if (this.fAudioContext.state === 'suspended') {
-            this.fAudioContext.resume().then(() => {
+            return this.fAudioContext.resume().then(() => {
                 console.log('AudioContext resumed successfully');
+                return this.fAudioContext.state;
             }).catch(error => {
                 console.error('Error when resuming AudioContext:', error);
+                throw error;
             });
         }
+        return Promise.resolve(this.fAudioContext.state);
     }
 
     // Asynchronous function to suspend AudioContext
@@ -212,6 +257,13 @@ export class FaustPWA {
         // Import the create-node module
         const { connectToAudioInput, requestPermissions } = await import("./create-node.js");
 
+        // Connect the Faust node to the audio output before optional permissions
+        // so a denied MIDI/sensor/input permission cannot leave a synth silent.
+        if (!this.fActive.audioConnected) {
+            this.fFaustNode.connect(this.fAudioContext.destination);
+            this.fActive.audioConnected = true;
+        }
+
         // Request permission for sensors
         await requestPermissions();
 
@@ -228,12 +280,13 @@ export class FaustPWA {
             this.fActive.midi = true;
         }
 
-        // Connect the Faust node to the audio output@
-        this.fFaustNode.connect(this.fAudioContext.destination);
-
         // Connect the Faust node to the audio input
         if (this.fFaustNode.numberOfInputs > 0) {
-            await connectToAudioInput(this.fAudioContext, null, this.fFaustNode, null);
+            try {
+                await connectToAudioInput(this.fAudioContext, null, this.fFaustNode, null);
+            } catch (error) {
+                console.error("Error when connecting audio input:", error);
+            }
         }
     }
 
@@ -268,7 +321,7 @@ export class FaustPWA {
                 this.fAudioContext,
                 this.fOptions.dspName,
                 this.fOptions.voices ?? 0,
-                this.fOptions.useScriptProcessor ?? false,
+                this.fOptions.useScriptProcessor ?? this.shouldUseScriptProcessor(),
                 this.fOptions.bufferSize ?? 512
             );
 
@@ -307,12 +360,10 @@ export class FaustPWA {
     */
     async start() {
         // Resume AudioContext synchronously
-        this.resumeAudioContext();
-
+        await this.resumeAudioContext();
+        
         // Launch the activation of MIDI and Sensors
-        this.activateMIDISensors().catch(error => {
-            console.error('Error when activating audio, MIDI and sensors:', error);
-        });
+        await this.activateMIDISensors();
 
         // Dispatch the started event
         this.dispatch('started', { when: this.audioContext.currentTime });

package/assets/standalone/index-pwa.js

@@ -40,19 +40,26 @@ const FAUST_DSP_VOICES = 0;
     // Create PWA and UI
     await pwa.create();
 
-    // Event listener to handle user interaction
+    // Event listener to handle user interaction. The whole start sequence is
+    // launched from the event handler rather than split across delayed tasks so
+    // iOS keeps it associated with the user activation.
     function handleUserInteraction() {
-
+     
         // Resume AudioContext synchronously
         pwa.resumeAudioContext();
 
         // Activate MIDI and Sensors
-        pwa.activateMIDISensors()
-    }
+        pwa.activateMIDISensors();
+   }
 
-    // Activate AudioContext, MIDI and Sensors on user interaction
+    // Register several activation events because iOS standalone PWAs do not
+    // behave identically across versions: some fire pointer events reliably,
+    // others are more consistent with touchend or click.
+    window.addEventListener('pointerdown', handleUserInteraction, { passive: true });
+    window.addEventListener('touchend', handleUserInteraction, { passive: true });
     window.addEventListener('click', handleUserInteraction);
     window.addEventListener('touchstart', handleUserInteraction);
+    window.addEventListener('keydown', handleUserInteraction);
 
     // Deactivate AudioContext, MIDI and Sensors on user interaction
     window.addEventListener('visibilitychange', function () {