craft-native 0.0.181 → 0.0.183

package/dist/android/templates/AndroidManifest.xml.template

@@ -35,8 +35,10 @@
         <activity
             android:name=".MainActivity"
             android:exported="true"
-            android:configChanges="orientation|screenSize|screenLayout|keyboardHidden|uiMode|fontScale"
+            android:configChanges="orientation|screenSize|smallestScreenSize|screenLayout|keyboardHidden|uiMode|fontScale"
             android:windowSoftInputMode="adjustResize"
+            android:supportsPictureInPicture="true"
+            android:resizeableActivity="true"
             android:launchMode="singleTask">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />

package/dist/android/templates/CraftNativeServices.kt.template

@@ -12,6 +12,7 @@ import android.os.Handler
 import android.os.Looper
 import android.provider.Settings
 import android.speech.tts.TextToSpeech
+import android.speech.tts.Voice
 import android.speech.tts.UtteranceProgressListener
 import android.util.Log
 import android.view.WindowManager
@@ -64,6 +65,8 @@ internal class CraftNativeServices(
 
     /** What this host adds to the capability names the screen sees. */
     fun names(): List<String> = buildList {
+        // `craft.animation.next`: the screen's next change animates (MainActivity).
+        add("animation")
         add("dialog")
         add("browser")
         add("linking")
@@ -524,11 +527,22 @@ internal class CraftNativeServices(
                 if (text.isBlank()) return done(failure("INVALID_ARGUMENT", "speech.speak needs some text to say"))
                 val options = args.optJSONObject(1) ?: JSONObject()
                 withSpeech { engine ->
-                    options.optString("language").takeIf { it.isNotBlank() }?.let { engine.language = Locale.forLanguageTag(it) }
-                    if (options.has("rate")) engine.setSpeechRate((options.optDouble("rate", 0.5) * 2).toFloat().coerceIn(0.1f, 4f))
+                    val language = options.optString("language").takeIf { it.isNotBlank() }?.let(Locale::forLanguageTag) ?: Locale.getDefault()
+                    val voice = bestVoice(engine, language)
+                    if (voice != null) engine.setVoice(voice) else engine.setLanguage(language)
+                    // The engine keeps its rate and pitch between calls: each
+                    // cue sets its own, 1 being the voice's normal (as on iOS).
+                    engine.setSpeechRate(speechNumber(options, "rate", 0.5, 2.0))
+                    engine.setPitch(speechNumber(options, "pitch", 0.5, 2.0))
                     val id = UUID.randomUUID().toString()
                     speeches[id] = done
-                    val queue = if (options.optBoolean("interrupt", false)) TextToSpeech.QUEUE_FLUSH else TextToSpeech.QUEUE_ADD
+                    // Interrupting stops everything said or waiting, as on iOS (the default there too).
+                    var queue = if (options.optBoolean("interrupt", true)) TextToSpeech.QUEUE_FLUSH else TextToSpeech.QUEUE_ADD
+                    val quietMs = (speechNumber(options, "preDelay", 0.0, 5.0) * 1000).toLong()
+                    if (quietMs > 0) {
+                        engine.playSilentUtterance(quietMs, queue, "$id-quiet")
+                        queue = TextToSpeech.QUEUE_ADD
+                    }
                     if (engine.speak(text, queue, null, id) != TextToSpeech.SUCCESS) speeches.remove(id)?.invoke(success(false))
                 }
             }
@@ -542,6 +556,30 @@ internal class CraftNativeServices(
         }
     }
 
+    /** A speech option clamped to its range, 1 when it is not given. */
+    private fun speechNumber(options: JSONObject, name: String, low: Double, high: Double): Float {
+        val fallback = if (name == "preDelay") 0.0 else 1.0
+        val value = options.optDouble(name, fallback).takeIf { it.isFinite() } ?: fallback
+        return value.coerceIn(low, high).toFloat()
+    }
+
+    private val voices = mutableMapOf<String, Voice?>()
+
+    /**
+     * The best installed voice for `language`: on the phone (never one that
+     * needs the network mid-workout), of the highest quality, then the
+     * quickest to answer. Remembered per language.
+     */
+    private fun bestVoice(engine: TextToSpeech, language: Locale): Voice? = voices.getOrPut(language.toLanguageTag()) {
+        val installed = runCatching { engine.voices }.getOrNull().orEmpty().filter { voice ->
+            !voice.isNetworkConnectionRequired &&
+                TextToSpeech.Engine.KEY_FEATURE_NOT_INSTALLED !in voice.features.orEmpty() &&
+                voice.locale.language == language.language
+        }
+        val sameCountry = installed.filter { language.country.isBlank() || it.locale.country == language.country }
+        (sameCountry.ifEmpty { installed }).maxWithOrNull(compareBy<Voice>({ it.quality }, { -it.latency }, { it.name }))
+    }
+
     private fun withSpeech(use: (TextToSpeech) -> Unit) {
         val engine = speech
         if (engine != null && speechReady) return use(engine)

package/dist/android/templates/MainActivityNative.kt.template

@@ -10,7 +10,9 @@ import android.content.res.ColorStateList
 import android.content.res.Configuration
 import android.database.ContentObserver
 import android.content.Intent
+import android.app.PictureInPictureParams
 import android.media.AudioAttributes
+import android.media.AudioManager
 import android.media.AudioFormat
 import android.media.MediaPlayer
 import android.media.AudioTrack
@@ -46,6 +48,13 @@ import android.text.SpannableString
 import android.text.style.ReplacementSpan
 import android.util.Log
 import android.util.Base64
+import android.transition.ChangeBounds
+import android.transition.ChangeTransform
+import android.transition.Fade
+import android.transition.Transition
+import android.transition.TransitionManager
+import android.transition.TransitionSet
+import android.util.Rational
 import android.util.TypedValue
 import android.view.Gravity
 import android.view.KeyEvent
@@ -58,6 +67,10 @@ import android.view.ViewGroup
 import android.view.ViewOutlineProvider
 import android.view.ViewParent
 import android.view.ViewTreeObserver
+import android.view.animation.LinearInterpolator
+import android.view.animation.PathInterpolator
+import android.view.SurfaceHolder
+import android.view.SurfaceView
 import android.widget.AdapterView
 import android.widget.ArrayAdapter
 import android.widget.Button
@@ -2390,6 +2403,17 @@ private class CraftNativeDatePickerView(context: Context) : FrameLayout(context)
     }
 }
 
+/**
+ * A native screen's `<Video>`: the platform's VideoView.
+ *
+ * It plays without taking audio focus, so the person's music carries on
+ * under it, as on iOS. `onLoad`, `onPlay`, `onPause`, `onEnd` and `onError`
+ * reach the screen in the web's names, from the controls as well as from
+ * props. With `pictureInPicture` the activity takes it into a floating
+ * window when the person leaves the app while it plays (MainActivity
+ * `updatePictureInPicture`), drawn there on a surface of the activity's own
+ * while this view keeps its place.
+ */
 private class CraftNativeVideoView(context: Context) : VideoView(context) {
     private var sourceUri = ""
     private var shouldLoop = false
@@ -2397,8 +2421,24 @@ private class CraftNativeVideoView(context: Context) : VideoView(context) {
     private var muted = false
     private var resizeMode = "contain"
     private var preparedPlayer: MediaPlayer? = null
+    /** The screen's handlers by event name, and how an event reaches them. */
+    var handlers: JSONObject = JSONObject()
+    var emit: ((handler: String, nativeEvent: JSONObject) -> Unit)? = null
+    /** May float in Picture in Picture while it plays. */
+    var pictureInPicture = false
+        private set
+    /** Playing now, by the controls or by props. */
+    var playing = false
+        private set
+    /** Playback started or stopped, or the choice changed: the activity's PiP params follow. */
+    var onPictureInPictureChanged: (() -> Unit)? = null
+
+    init {
+        // Mixed with the music rather than pausing it.
+        setAudioFocusRequest(AudioManager.AUDIOFOCUS_NONE)
+    }
 
-    fun configure(source: Any?, autoplay: Boolean, paused: Boolean, loop: Boolean, muted: Boolean, controls: Boolean, resizeMode: String?) {
+    fun configure(source: Any?, autoplay: Boolean, paused: Boolean, loop: Boolean, muted: Boolean, controls: Boolean, resizeMode: String?, pictureInPicture: Boolean = false) {
         val uri = when (source) {
             is String -> source
             is JSONObject -> craftNativeOptionalString(source.opt("uri")).orEmpty()
@@ -2407,12 +2447,18 @@ private class CraftNativeVideoView(context: Context) : VideoView(context) {
         shouldLoop = loop
         shouldPlay = autoplay && !paused
         this.muted = muted
+        val floating = pictureInPicture && !muted
+        if (floating != this.pictureInPicture) {
+            this.pictureInPicture = floating
+            onPictureInPictureChanged?.invoke()
+        }
         this.resizeMode = resizeMode?.lowercase()?.takeIf { it in setOf("cover", "contain", "stretch", "center") } ?: "contain"
         applyScalingMode()
         setMediaController(if (controls) MediaController(context).also { it.setAnchorView(this) } else null)
         if (uri != sourceUri) {
             sourceUri = uri
             stopPlayback()
+            setPlaying(false)
             preparedPlayer = null
             if (uri.isBlank()) return
             // A copy kept on the phone (craft.media.keep) plays in place of
@@ -2425,9 +2471,19 @@ private class CraftNativeVideoView(context: Context) : VideoView(context) {
                 mediaPlayer.isLooping = shouldLoop
                 val volume = if (this.muted) 0f else 1f
                 mediaPlayer.setVolume(volume, volume)
+                fire("onLoad", JSONObject().put("duration", duration / 1000.0))
                 if (shouldPlay) start()
             }
-            setOnCompletionListener { if (shouldLoop && !isPlaying) start() }
+            setOnCompletionListener {
+                if (shouldLoop && !isPlaying) start()
+                else setPlaying(false)
+                fire("onEnd")
+            }
+            setOnErrorListener { _, what, extra ->
+                setPlaying(false)
+                fire("onError", JSONObject().put("message", "The video could not be played ($what, $extra)"))
+                true
+            }
         }
         if (uri.isBlank()) return
         runCatching {
@@ -2436,10 +2492,55 @@ private class CraftNativeVideoView(context: Context) : VideoView(context) {
         }
     }
 
+    override fun start() {
+        super.start()
+        setPlaying(true)
+    }
+
+    override fun pause() {
+        super.pause()
+        setPlaying(false)
+    }
+
+    private fun setPlaying(value: Boolean) {
+        if (playing == value) return
+        playing = value
+        fire(if (value) "onPlay" else "onPause")
+        onPictureInPictureChanged?.invoke()
+    }
+
+    private fun fire(event: String, nativeEvent: JSONObject = JSONObject()) {
+        val handler = craftNativeEventName(handlers, event)
+        if (handler.isNotBlank()) emit?.invoke(handler, nativeEvent)
+    }
+
+    /** Its width over height once known, inside what Picture in Picture allows. */
+    fun aspectRatio(): Rational? {
+        val player = preparedPlayer ?: return null
+        val width = runCatching { player.videoWidth }.getOrDefault(0)
+        val height = runCatching { player.videoHeight }.getOrDefault(0)
+        if (width <= 0 || height <= 0) return null
+        val ratio = (width.toDouble() / height).coerceIn(1 / 2.39, 2.39)
+        return Rational((ratio * 1000).roundToInt(), 1000)
+    }
+
+    /** Draws on `holder` (the floating window's surface), or back on its own with null. */
+    fun showOn(holder: SurfaceHolder?): Boolean {
+        val player = preparedPlayer ?: return false
+        return runCatching { player.setDisplay(holder ?: this.holder) }.isSuccess
+    }
+
     fun stop() {
+        // Released with its screen: nothing more is told to it.
+        emit = null
         stopPlayback()
+        setPlaying(false)
         sourceUri = ""
         preparedPlayer = null
+        if (pictureInPicture) {
+            pictureInPicture = false
+            onPictureInPictureChanged?.invoke()
+        }
     }
 
     private fun applyScalingMode() {
@@ -3845,6 +3946,7 @@ class MainActivity : AppCompatActivity() {
                     if (visibleScreen === screen) applyChrome(screen)
                 }
             }
+            "ANIMATE_NEXT" -> if (screen !== appScreen && visibleScreen === screen) animateNextChange(screen, payload)
             "SYNC_WRITE" -> syncWrite(screen, payload)
             "TIMER" -> {
                 val id = payload.optInt("id")
@@ -4541,14 +4643,20 @@ class MainActivity : AppCompatActivity() {
                 reconcileChildren(screen, content, children, path, next, style, previousControls)
             }
             "Video" -> (previous as? CraftNativeVideoView ?: CraftNativeVideoView(this)).apply {
+                handlers = events
+                emit = { handler, nativeEvent ->
+                    send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", nativeEvent))
+                }
+                onPictureInPictureChanged = { updatePictureInPicture() }
                 configure(
-                    source = props.opt("source"),
+                    source = props.opt("source") ?: props.opt("src"),
                     autoplay = props.optBoolean("autoplay", props.optBoolean("autoPlay", false)),
                     paused = props.optBoolean("paused", false),
                     loop = props.optBoolean("loop", false),
                     muted = props.optBoolean("muted", false),
                     controls = props.optBoolean("controls", false),
                     resizeMode = craftNativeResizeMode(style, props),
+                    pictureInPicture = props.optBoolean("pictureInPicture", false),
                 )
             }
             "Map" -> (previous as? CraftNativeMapView ?: CraftNativeMapView(this)).apply {
@@ -4767,6 +4875,8 @@ class MainActivity : AppCompatActivity() {
             control.isLongClickable = false
         }
         applyAccessibility(control, props, type, explicitKey ?: protocolId ?: path)
+        // One element across an animated change (craft.animation.next).
+        control.transitionName = craftNativeOptionalString(props.opt("transitionID"))?.takeIf { it.isNotBlank() }
         val layoutHandler = craftNativeEventName(events, "onLayout")
         if (layoutHandler.isNotBlank()) {
             if (screen.layoutHandlers[control] != layoutHandler) screen.lastLayoutBounds.remove(control)
@@ -5914,6 +6024,114 @@ class MainActivity : AppCompatActivity() {
         .filterIsInstance<CraftNativeMapView>()
         .toSet()
 
+    // MARK: Animated changes
+
+    /**
+     * `craft.animation.next(options)`: the screen's next change animates,
+     * views that stay moving to their new places, new ones fading in and
+     * removed ones fading out, and two with the same `transitionID` moving as
+     * one. Android's own transitions, which follow the person's animation
+     * scale: with animations off it is a cut, as the system's own are.
+     */
+    private fun animateNextChange(screen: Screen, payload: JSONObject) {
+        val seconds = payload.optDouble("duration", 0.35).takeIf { it.isFinite() } ?: 0.35
+        val curve = payload.optString("curve", "spring")
+        val transition = TransitionSet()
+        transition.setOrdering(TransitionSet.ORDERING_TOGETHER)
+        listOf(ChangeBounds(), ChangeTransform(), Fade()).forEach { part ->
+            part.setMatchOrder(Transition.MATCH_NAME, Transition.MATCH_INSTANCE)
+            transition.addTransition(part)
+        }
+        transition.setDuration((seconds.coerceIn(0.1, 1.0) * 1000).toLong())
+        transition.setInterpolator(
+            when (curve) {
+                "linear" -> LinearInterpolator()
+                "easeInOut" -> PathInterpolator(0.42f, 0f, 0.58f, 1f)
+                // A spring with no bounce reads as a decelerating curve.
+                else -> PathInterpolator(0.2f, 0f, 0f, 1f)
+            },
+        )
+        TransitionManager.beginDelayedTransition(screen.view, transition)
+    }
+
+    // MARK: Picture in Picture
+
+    /** The floating window's own surface, over everything while it shows. */
+    private var pictureInPictureLayer: FrameLayout? = null
+    private var pictureInPictureVideo: CraftNativeVideoView? = null
+
+    /** A video that asked for Picture in Picture and is playing on a screen in view. */
+    private fun floatingVideo(): CraftNativeVideoView? = allScreens()
+        .filter { !it.headless }
+        .flatMap { retainedViews(it) }
+        .filterIsInstance<CraftNativeVideoView>()
+        .firstOrNull { it.pictureInPicture && it.playing && it.isShown }
+
+    private fun pictureInPictureAllowed(): Boolean =
+        packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)
+
+    /**
+     * Picture in Picture follows the playing video: on Android 12 and later
+     * the system floats it by itself as the person leaves the app (gesture
+     * navigation included); before that `onUserLeaveHint` asks.
+     */
+    private fun updatePictureInPicture() {
+        if (!pictureInPictureAllowed() || isInPictureInPictureMode) return
+        val video = floatingVideo()
+        val params = PictureInPictureParams.Builder()
+        video?.aspectRatio()?.let { params.setAspectRatio(it) }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) params.setAutoEnterEnabled(video != null)
+        runCatching { setPictureInPictureParams(params.build()) }
+    }
+
+    override fun onUserLeaveHint() {
+        super.onUserLeaveHint()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S || !pictureInPictureAllowed()) return
+        val video = floatingVideo() ?: return
+        val params = PictureInPictureParams.Builder()
+        video.aspectRatio()?.let { params.setAspectRatio(it) }
+        runCatching { enterPictureInPictureMode(params.build()) }
+    }
+
+    override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean, newConfig: Configuration) {
+        super.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig)
+        if (isInPictureInPictureMode) showVideoAlone() else putVideoBack()
+    }
+
+    /**
+     * The floating window shows the whole activity, so the video is drawn
+     * alone on a surface over it, black around it. The video keeps playing
+     * through the change: only where its frames go moves.
+     */
+    private fun showVideoAlone() {
+        val video = floatingVideo() ?: return
+        val host = window.decorView as? ViewGroup ?: return
+        val surface = SurfaceView(this).apply {
+            setZOrderMediaOverlay(true)
+            holder.addCallback(object : SurfaceHolder.Callback {
+                override fun surfaceCreated(holder: SurfaceHolder) { video.showOn(holder) }
+                override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) = Unit
+                override fun surfaceDestroyed(holder: SurfaceHolder) { video.showOn(null) }
+            })
+        }
+        val layer = FrameLayout(this).apply {
+            setBackgroundColor(Color.BLACK)
+            addView(surface, FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT, Gravity.CENTER))
+        }
+        host.addView(layer, ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+        pictureInPictureLayer = layer
+        pictureInPictureVideo = video
+    }
+
+    /** Back in the app: the video draws in its place again. */
+    private fun putVideoBack() {
+        pictureInPictureVideo?.showOn(null)
+        pictureInPictureVideo = null
+        pictureInPictureLayer?.let { (it.parent as? ViewGroup)?.removeView(it) }
+        pictureInPictureLayer = null
+        updatePictureInPicture()
+    }
+
     private fun releaseFlatList(
         screen: Screen,
         list: CraftNativeFlatList,

package/dist/api/mobile.d.ts

@@ -737,6 +737,13 @@ export interface SpeechOptions {
     language?: string;
     /** Stop whatever is being said first. Defaults to true; false queues behind it. */
     interrupt?: boolean;
+    /** Voice pitch, 0.5 to 2. 1 is the voice's own; lower sounds calmer. */
+    pitch?: number;
+    /**
+     * Seconds of quiet before the words (up to 5), after whatever was said
+     * before them: a pause between two queued cues.
+     */
+    preDelay?: number;
 }
 export declare const brightness: {
     isAvailable(): boolean;

package/dist/cli.js

@@ -3303,7 +3303,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.181";
+var version = "0.0.183";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/components/index.d.ts

@@ -417,6 +417,13 @@ export interface VideoProps extends BaseProps {
     muted?: boolean;
     paused?: boolean;
     resizeMode?: 'contain' | 'cover' | 'stretch';
+    /**
+     * Carries on in a floating window (Picture in Picture) when the app goes to
+     * the background or another app opens while it plays, and comes back into
+     * its place with the app. iOS needs `enableBackgroundAudio`. A video with
+     * sound plays mixed with the person's music either way.
+     */
+    pictureInPicture?: boolean;
     onLoad?: (event: {
         duration: number;
     }) => void;
@@ -430,6 +437,9 @@ export interface VideoProps extends BaseProps {
     onError?: (event: {
         message: string;
     }) => void;
+    /** It went into the floating window, and came back out (iOS). */
+    onPictureInPictureStart?: () => void;
+    onPictureInPictureStop?: () => void;
 }
 export interface MapRegion {
     center: {

package/dist/index.cjs

@@ -310,7 +310,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.181";
+var version = "0.0.183";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/index.js

@@ -58,7 +58,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.181";
+var version = "0.0.183";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/ios/src/index.js

@@ -197,7 +197,7 @@ function resolveCraftVersion(startDir = import.meta.dir) {
   while (true) {
     try {
       const packageJSON = JSON.parse(readFileSync2(join3(directory, "package.json"), "utf8"));
-      if (packageJSON.name === "@craft-native/ios" && typeof packageJSON.version === "string" && packageJSON.version.length > 0)
+      if ((packageJSON.name === "@craft-native/ios" || packageJSON.name === "craft-native") && typeof packageJSON.version === "string" && packageJSON.version.length > 0)
         return packageJSON.version;
     } catch {}
     const parent = dirname2(directory);

package/dist/ios/templates/CraftApp.swift

@@ -6812,14 +6812,16 @@ struct CraftWebView: UIViewRepresentable {
                     self.speechSynthesizer = fresh
                 }
 
-                let utterance = AVSpeechUtterance(string: text)
-                utterance.rate = Self.utteranceRate(body["rate"] as? Double ?? 1)
-                // An unknown language finds no voice, and a nil voice is the
-                // device's own, which is the default anyway.
-                if let language = body["language"] as? String, !language.isEmpty,
-                   let voice = AVSpeechSynthesisVoice(language: language) {
-                    utterance.voice = voice
-                }
+                // Set up as a native screen's is (CraftNativeServices.swift):
+                // the rate, the pitch, the quiet before it, and the best voice
+                // installed for the language.
+                let utterance = CraftNativeSpeech.utterance(
+                    text,
+                    language: body["language"] as? String,
+                    rate: (body["rate"] as? NSNumber)?.doubleValue,
+                    pitch: (body["pitch"] as? NSNumber)?.doubleValue,
+                    preDelay: (body["preDelay"] as? NSNumber)?.doubleValue
+                )
 
                 self.pendingUtterances.append((utterance, callbackId))
                 self.claimAudioSessionForSpeech {
@@ -6859,21 +6861,6 @@ struct CraftWebView: UIViewRepresentable {
             return wasSounding
         }
 
-        /// The page's rate, where 1 is normal, on AVSpeechUtterance's scale.
-        ///
-        /// Apple's scale is not linear in speed: the default sits at 0.5 and
-        /// the maximum is far faster than twice that. So a slower rate scales
-        /// the default down in proportion, and a faster one climbs toward the
-        /// maximum at half the slope, which keeps 2 brisk but intelligible.
-        private static func utteranceRate(_ rate: Double) -> Float {
-            let requested = Float(min(max(rate.isFinite ? rate : 1, 0.5), 2))
-            let normal = AVSpeechUtteranceDefaultSpeechRate
-            let mapped = requested <= 1
-                ? normal * requested
-                : normal + (AVSpeechUtteranceMaximumSpeechRate - normal) * (requested - 1) / 2
-            return min(max(mapped, AVSpeechUtteranceMinimumSpeechRate), AVSpeechUtteranceMaximumSpeechRate)
-        }
-
         /// Duck the music rather than stop it, and play through the silent
         /// switch.
         ///

package/dist/ios/templates/CraftHybrid.swift

@@ -1572,8 +1572,12 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         // title unless it asked for the bar; a pushed native screen gets the
         // bar and its Back.
         // A root screen that asked for its own bar (setOptions) keeps it.
-        let asksForBar = (viewController as? CraftNativeScreenController)?.wantsNavigationBar ?? false
-        let bare = viewController is CraftHybridWebSlot || (navigationController.viewControllers.first === viewController && !asksForBar)
+        // A screen that put its bar away (`hidden: true`, a tour drawing its
+        // own Back and Skip) stays bare, pushed or not.
+        let native = viewController as? CraftNativeScreenController
+        let asksForBar = native?.wantsNavigationBar ?? false
+        let bare = viewController is CraftHybridWebSlot || native?.navigationBarHidden == true
+            || (navigationController.viewControllers.first === viewController && !asksForBar)
         navigationController.setNavigationBarHidden(bare, animated: animated)
     }
 

package/dist/ios/templates/CraftNativeActions.swift

@@ -41,7 +41,7 @@ enum CraftNativeActions {
     static func capabilities(config: CraftConfig) -> [String] {
         // `speech`, `audio` (background sound) and `eventStream` (a fetch read
         // as it arrives) need nothing the app has to declare.
-        var values = ["device", "clipboard", "haptics", "storage", "lifecycle", "fetch", "dialog", "speech", "audio", "eventStream", "linking", "badge"]
+        var values = ["device", "clipboard", "haptics", "storage", "lifecycle", "fetch", "dialog", "speech", "audio", "eventStream", "linking", "badge", "animation"]
         if config.enableBiometric { values.append("biometric") }
         if config.enableSecureStorage { values.append("secureStorage") }
         if config.enableLocalDatabase { values.append("database") }
@@ -474,6 +474,8 @@ enum CraftNativeActions {
                     text,
                     language: options["language"] as? String,
                     rate: (options["rate"] as? NSNumber)?.doubleValue,
+                    pitch: (options["pitch"] as? NSNumber)?.doubleValue,
+                    preDelay: (options["preDelay"] as? NSNumber)?.doubleValue,
                     interrupt: options["interrupt"] as? Bool ?? true
                 ) { spoken in complete(requestToken, .success(spoken), completion) }
             }