diff --git a/apps/playground/CHANGELOG.md b/apps/playground/CHANGELOG.md
index 689e75309..f14b4e55d 100644
--- a/apps/playground/CHANGELOG.md
+++ b/apps/playground/CHANGELOG.md
@@ -4,6 +4,9 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+### Fixed
+- `yarn build:deps` now also builds `@siteed/sherpa-onnx.rn` and `@siteed/moonshine.rn`. Yarn 4 skips workspace `prepare` scripts, so the playground bundled stale `lib/` output for both, and web runs missed source fixes.
+
 ## [2.4.0] - 2026-11-01
 
 ### Added
diff --git a/apps/playground/config/build-deps.test.ts b/apps/playground/config/build-deps.test.ts
new file mode 100644
index 000000000..35bd02794
--- /dev/null
+++ b/apps/playground/config/build-deps.test.ts
@@ -0,0 +1,42 @@
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import path from 'node:path'
+import test from 'node:test'
+
+const appRoot = path.resolve(__dirname, '..')
+
+function readJson(file: string) {
+    return JSON.parse(readFileSync(file, 'utf8'))
+}
+
+// Resolve each `cd <dir> && yarn <script>` step of build:deps to the package it runs in.
+function buildDepsSteps() {
+    const script: string = readJson(path.join(appRoot, 'package.json')).scripts['build:deps']
+    let cwd = appRoot
+    const steps: { dir: string; script: string }[] = []
+    for (const part of script.split('&&').map((step) => step.trim())) {
+        const cd = part.match(/^cd (.+)$/)
+        if (cd) {
+            cwd = path.resolve(cwd, cd[1])
+            continue
+        }
+        const run = part.match(/^yarn (\S+)$/)
+        assert.ok(run, `unexpected build:deps step: ${part}`)
+        steps.push({ dir: cwd, script: run[1] })
+    }
+    return steps
+}
+
+// The web bundle imports these packages' lib/ output. Yarn 4 skips workspace
+// prepare scripts on install, so build:deps is the only thing that rebuilds it.
+for (const name of ['sherpa-onnx.rn', 'moonshine.rn']) {
+    test(`build:deps rebuilds the ${name} lib/ the playground imports`, () => {
+        const dir = path.resolve(appRoot, '../../packages', name)
+        const manifest = readJson(path.join(dir, 'package.json'))
+        const step = buildDepsSteps().find((entry) => entry.dir === dir)
+
+        assert.ok(step, `build:deps never builds packages/${name}`)
+        assert.match(manifest.scripts[step.script], /\bbob build\b/)
+        assert.match(manifest.main, /^\.\/lib\//)
+    })
+}
diff --git a/apps/playground/package.json b/apps/playground/package.json
index e5ae432fb..51339b321 100644
--- a/apps/playground/package.json
+++ b/apps/playground/package.json
@@ -5,7 +5,7 @@
     "scripts": {
         "eas-build-pre-install": "bash scripts/eas-build-pre-install.sh",
         "postinstall": "patch-package",
-        "build:deps": "cd ../../packages/audio-studio && yarn build && yarn build:plugin && cd ../playgroundapi && yarn build && cd ../react-native-essentia && yarn prepare",
+        "build:deps": "cd ../../packages/audio-studio && yarn build && yarn build:plugin && cd ../playgroundapi && yarn build && cd ../react-native-essentia && yarn prepare && cd ../sherpa-onnx.rn && yarn prepare && cd ../moonshine.rn && yarn prepare",
         "start": "NODE_ENV=development APP_VARIANT=development bash scripts/agentic/start-metro.sh && node scripts/agentic/start-interactive.mjs",
         "stop": "bash scripts/agentic/stop-metro.sh",
         "android": "APP_VARIANT=development PLATFORM=android HEADLESS=0 REBUILD=1 bash scripts/agentic/preflight.sh",
@@ -26,7 +26,7 @@
         "debug": "bash scripts/agentic/device-cmd.sh debug",
         "dev-menu": "bash scripts/agentic/device-cmd.sh dev-menu",
         "typecheck": "bash scripts/typecheck.sh",
-        "test:config": "TS_NODE_COMPILER_OPTIONS='{\"module\":\"commonjs\"}' node -r ts-node/register --test config/validate-env.test.ts src/utils/moonshineDiarizationRuntime.test.ts src/utils/moonshineIntentModelFiles.test.ts src/utils/recordingAudioStream.test.ts",
+        "test:config": "TS_NODE_COMPILER_OPTIONS='{\"module\":\"commonjs\"}' node -r ts-node/register --test config/validate-env.test.ts config/build-deps.test.ts src/utils/moonshineDiarizationRuntime.test.ts src/utils/moonshineIntentModelFiles.test.ts src/utils/recordingAudioStream.test.ts",
         "lint": "eslint src",
         "lint:fix": "eslint src --fix",
         "lint:fix-nullish": "bash scripts/fix-nullish-coalescing.sh",
diff --git a/apps/sherpa-voice/CHANGELOG.md b/apps/sherpa-voice/CHANGELOG.md
index 31caba120..23a08fa58 100644
--- a/apps/sherpa-voice/CHANGELOG.md
+++ b/apps/sherpa-voice/CHANGELOG.md
@@ -7,6 +7,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+- Web: the ASR, speaker ID and audio tagging sample cards show the file size and duration instead of `0 Bytes` and `0:00`. `getInfoAsync` has no web implementation, so web now fetches the file to measure it.
+
 ## [1.2.0] - 2026-11-02
 
 ### Changed
diff --git a/apps/sherpa-voice/src/hooks/useAsr.ts b/apps/sherpa-voice/src/hooks/useAsr.ts
index 7e9b43e4e..3bfdb90bb 100644
--- a/apps/sherpa-voice/src/hooks/useAsr.ts
+++ b/apps/sherpa-voice/src/hooks/useAsr.ts
@@ -5,7 +5,7 @@ import {
     type AudioDataEvent,
 } from '@siteed/audio-studio'
 import { baseLogger } from '../config'
-import { resolveModelDir } from '../utils/fileUtils'
+import { getFileSize, resolveModelDir } from '../utils/fileUtils'
 import { SAMPLE_AUDIO_FILES } from '../utils/asrSamples'
 export { SAMPLE_AUDIO_FILES } from '../utils/asrSamples'
 
@@ -14,7 +14,6 @@ import { makeWebProgressHandler, getWebModelBaseUrl } from '../utils/webModelUti
 import { getWebAsrBackend } from '../config/webFeatures'
 import { Asset } from 'expo-asset'
 import { createAudioPlayer } from 'expo-audio'
-import * as FileSystem from 'expo-file-system/legacy'
 import { useLocalSearchParams } from 'expo-router'
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { useAsrModels, useAsrModelWithConfig } from './useModelWithConfig'
@@ -239,7 +238,7 @@ export function useAsr() {
         setSelectedAudio(audioItem)
         setAudioMetadata({ isLoading: true })
         try {
-            const info = await FileSystem.getInfoAsync(audioItem.localUri)
+            const size = await getFileSize(audioItem.localUri)
             let duration = 0
             try {
                 const tempPlayer = createAudioPlayer({
@@ -250,7 +249,7 @@ export function useAsr() {
                 tempPlayer.remove()
             } catch (_) {}
             setAudioMetadata({
-                size: info.exists ? info.size : 0,
+                size,
                 duration,
                 isLoading: false,
             })
diff --git a/apps/sherpa-voice/src/hooks/useAudioTagging.ts b/apps/sherpa-voice/src/hooks/useAudioTagging.ts
index 6faf44084..20c7d58c0 100644
--- a/apps/sherpa-voice/src/hooks/useAudioTagging.ts
+++ b/apps/sherpa-voice/src/hooks/useAudioTagging.ts
@@ -8,6 +8,7 @@ import { createAudioPlayer } from 'expo-audio'
 import * as FileSystem from 'expo-file-system/legacy'
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { Alert } from 'react-native'
+import { getFileSize } from '../utils/fileUtils'
 import { makeWebProgressHandler, getWebModelBaseUrl } from '../utils/webModelUtils'
 import {
     useAudioTaggingModels,
@@ -343,12 +344,7 @@ export function useAudioTagging() {
 
             if (audioItem.localUri) {
                 try {
-                    const fileInfo = await FileSystem.getInfoAsync(
-                        audioItem.localUri
-                    )
-                    const size = fileInfo.exists
-                        ? (fileInfo as any).size || 0
-                        : 0
+                    const size = await getFileSize(audioItem.localUri)
                     const tempPlayer = createAudioPlayer({
                         uri: audioItem.localUri,
                     })
diff --git a/apps/sherpa-voice/src/hooks/useSpeakerId.ts b/apps/sherpa-voice/src/hooks/useSpeakerId.ts
index 31ef8948a..cca91057d 100644
--- a/apps/sherpa-voice/src/hooks/useSpeakerId.ts
+++ b/apps/sherpa-voice/src/hooks/useSpeakerId.ts
@@ -6,9 +6,9 @@ import {
 } from '@siteed/sherpa-onnx.rn'
 import { Asset } from 'expo-asset'
 import { createAudioPlayer } from 'expo-audio'
-import * as FileSystem from 'expo-file-system/legacy'
 import { useEffect, useState } from 'react'
 import { Alert } from 'react-native'
+import { getFileSize } from '../utils/fileUtils'
 import { makeWebProgressHandler, getWebModelBaseUrl } from '../utils/webModelUtils'
 import {
     useSpeakerIdModelWithConfig,
@@ -341,8 +341,7 @@ export function useSpeakerId() {
         setIdentifyResult(null)
         setAudioMetadata({ isLoading: true })
         try {
-            const fileInfo = await FileSystem.getInfoAsync(audioItem.localUri)
-            const fileSize = fileInfo.exists ? (fileInfo as any).size || 0 : 0
+            const fileSize = await getFileSize(audioItem.localUri)
             const tempPlayer = createAudioPlayer({ uri: audioItem.localUri })
             await new Promise((r) => setTimeout(r, 500))
             const durationMs = (tempPlayer.duration || 0) * 1000
diff --git a/apps/sherpa-voice/src/utils/__tests__/fileUtils.test.ts b/apps/sherpa-voice/src/utils/__tests__/fileUtils.test.ts
new file mode 100644
index 000000000..677c6d5d9
--- /dev/null
+++ b/apps/sherpa-voice/src/utils/__tests__/fileUtils.test.ts
@@ -0,0 +1,62 @@
+/// <reference types="jest" />
+import { Platform } from 'react-native'
+import * as FileSystem from 'expo-file-system/legacy'
+import { getFileSize } from '../fileUtils'
+
+jest.mock('react-native', () => ({ Platform: { OS: 'ios' } }))
+jest.mock('../../config', () => ({
+    baseLogger: { extend: () => ({ info: jest.fn(), warn: jest.fn() }) },
+}))
+jest.mock('expo-file-system/legacy', () => ({ getInfoAsync: jest.fn() }))
+
+const getInfoAsync = FileSystem.getInfoAsync as jest.Mock
+const SAMPLE = '/assets/?unstable_path=.%2Fassets%2Fjfk.wav'
+
+describe('getFileSize', () => {
+    afterEach(() => {
+        jest.resetAllMocks()
+        Platform.OS = 'ios'
+    })
+
+    describe('on web', () => {
+        beforeEach(() => {
+            Platform.OS = 'web'
+            // expo-file-system has no web implementation of getInfoAsync.
+            getInfoAsync.mockRejectedValue(
+                new Error('ExponentFileSystem.getInfoAsync is not available on web')
+            )
+        })
+
+        it('measures the fetched body instead of calling getInfoAsync', async () => {
+            global.fetch = jest.fn().mockResolvedValue({
+                ok: true,
+                blob: () => Promise.resolve({ size: 352044 }),
+            })
+
+            await expect(getFileSize(SAMPLE)).resolves.toBe(352044)
+            expect(global.fetch).toHaveBeenCalledWith(SAMPLE)
+            expect(getInfoAsync).not.toHaveBeenCalled()
+        })
+
+        it('returns 0 when the file is missing', async () => {
+            global.fetch = jest.fn().mockResolvedValue({ ok: false, status: 404 })
+
+            await expect(getFileSize(SAMPLE)).resolves.toBe(0)
+        })
+    })
+
+    describe('on native', () => {
+        it('reads the size from getInfoAsync', async () => {
+            getInfoAsync.mockResolvedValue({ exists: true, size: 1234 })
+
+            await expect(getFileSize('file:///data/jfk.wav')).resolves.toBe(1234)
+            expect(getInfoAsync).toHaveBeenCalledWith('file:///data/jfk.wav')
+        })
+
+        it('returns 0 when the file is missing', async () => {
+            getInfoAsync.mockResolvedValue({ exists: false })
+
+            await expect(getFileSize('file:///data/missing.wav')).resolves.toBe(0)
+        })
+    })
+})
diff --git a/apps/sherpa-voice/src/utils/fileUtils.ts b/apps/sherpa-voice/src/utils/fileUtils.ts
index 3b7ae2c56..2d06e35b7 100644
--- a/apps/sherpa-voice/src/utils/fileUtils.ts
+++ b/apps/sherpa-voice/src/utils/fileUtils.ts
@@ -77,6 +77,21 @@ export async function fileExists(uri: string): Promise<boolean> {
   return info.exists;
 }
 
+/**
+ * Size of a file in bytes, or 0 when it is missing.
+ * On web: fetch the URL and measure the body (getInfoAsync is not available).
+ * On native: FileSystem.getInfoAsync.
+ */
+export async function getFileSize(uri: string): Promise<number> {
+  if (Platform.OS === 'web') {
+    const response = await fetch(uri);
+    if (!response.ok) return 0;
+    return (await response.blob()).size;
+  }
+  const info = await FileSystem.getInfoAsync(uri);
+  return info.exists ? info.size : 0;
+}
+
 /**
  * Resolve the effective model directory path.
  * Sherpa-onnx tarballs extract into a `sherpa-onnx-*` subdirectory — descend
diff --git a/packages/sherpa-onnx.rn/CHANGELOG.md b/packages/sherpa-onnx.rn/CHANGELOG.md
index e0c720625..a088661c3 100644
--- a/packages/sherpa-onnx.rn/CHANGELOG.md
+++ b/packages/sherpa-onnx.rn/CHANGELOG.md
@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- Web `initTts` fails with `Failed to load TTS model files: <url>` when `model.onnx`, `tokens.txt` or a configured `lexiconFile` cannot be fetched, including when none of them loads, and removes the files that did load along with their directory. Before, a missing lexicon aborted engine creation with `RuntimeError: memory access out of bounds`, a missing model or tokens file gave `Missing required files for VITS model configuration` without naming it, and a total download failure gave a bare `Failed to load TTS model files`.
+- Web `initTts` rejects non-VITS models with `Web TTS supports VITS models only, not <type>`. The WASM glue builds no engine config for matcha or kokoro, so those crashed during engine creation.
+- Web `FileSystem.removePath` removes directories. `isDirectory` read an `isDir` flag that Emscripten `stat` results do not have, so every directory was treated as a file and could not be removed.
+- The web loader no longer logs `Module loading timeout reached` 30 s after the modules loaded. It now clears its backup timer once loading settles, and a load that really times out warns once instead of twice.
+
 ## [2.0.0] - 2026-11-02
 
 ### Migration
diff --git a/packages/sherpa-onnx.rn/README.md b/packages/sherpa-onnx.rn/README.md
index 6d4dc9bab..c2c8ad777 100644
--- a/packages/sherpa-onnx.rn/README.md
+++ b/packages/sherpa-onnx.rn/README.md
@@ -78,6 +78,8 @@ if (Platform.OS === 'web') {
 
 Self-hosting (optional): copy files from `node_modules/@siteed/sherpa-onnx.rn/wasm/` and call `configureSherpaOnnx({ wasmBasePath: '/your/wasm/path/' })`.
 
+Web TTS supports VITS models only; matcha and kokoro need iOS or Android. It fetches `model.onnx`, `tokens.txt` and `lexiconFile` from `modelBaseUrl`, so host the lexicon (for English, upstream `tts-models/lexicon-en-us.txt`) next to the voice files. The browser fetch needs the same origin or CORS headers; GitHub release download URLs send none. If a file is missing, `initTts` fails with `Failed to load TTS model files: <url>`.
+
 See **[Getting Started: Web](docs/GETTING_STARTED_WEB.md)** for the full guide including `onProgress`, loading indicators, and model configuration.
 
 ## Usage
diff --git a/packages/sherpa-onnx.rn/src/__tests__/webCombinedLoader.test.ts b/packages/sherpa-onnx.rn/src/__tests__/webCombinedLoader.test.ts
new file mode 100644
index 000000000..3cf363db2
--- /dev/null
+++ b/packages/sherpa-onnx.rn/src/__tests__/webCombinedLoader.test.ts
@@ -0,0 +1,79 @@
+const TIMEOUT_WARNING = 'Module loading timeout reached';
+
+type FakeScript = { src?: string; onload?: () => void; onerror?: () => void };
+type LoaderGlobals = {
+  window?: unknown;
+  document?: unknown;
+  SherpaOnnx?: unknown;
+  Module?: unknown;
+  sherpaOnnxModulePaths?: string[];
+  onModuleReady?: () => void;
+};
+
+const g = globalThis as unknown as LoaderGlobals;
+
+// Load the browser loader with a fake DOM whose <script> tags either load at
+// once or never settle.
+function loadCombinedLoader(scriptsSettle: boolean) {
+  g.window = globalThis;
+  g.sherpaOnnxModulePaths = ['core.js', 'tts.js'];
+  g.document = {
+    getElementsByTagName: () => [],
+    createElement: (): FakeScript => ({}),
+    head: {
+      appendChild: (script: FakeScript) => {
+        if (!scriptsSettle) return;
+        if (script.src === 'core.js') g.SherpaOnnx = {};
+        script.onload?.();
+      },
+    },
+  };
+  jest.isolateModules(() => {
+    require('../../wasm-src/sherpa-onnx-combined.js');
+  });
+}
+
+function timeoutWarnings(warn: jest.SpyInstance) {
+  return warn.mock.calls.filter(([message]) =>
+    String(message).includes(TIMEOUT_WARNING)
+  );
+}
+
+describe('web combined loader backup timeout', () => {
+  let warn: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    jest.spyOn(console, 'log').mockImplementation(() => {});
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+    delete g.document;
+    delete g.SherpaOnnx;
+    delete g.Module;
+    delete g.sherpaOnnxModulePaths;
+    delete g.onModuleReady;
+  });
+
+  it('does not warn after the modules finished loading', async () => {
+    loadCombinedLoader(true);
+
+    g.onModuleReady?.();
+    await jest.advanceTimersByTimeAsync(31000);
+
+    expect(timeoutWarnings(warn)).toHaveLength(0);
+  });
+
+  it('still warns when loading takes longer than 30 seconds', async () => {
+    loadCombinedLoader(false);
+
+    g.onModuleReady?.();
+    await jest.advanceTimersByTimeAsync(31000);
+
+    expect(timeoutWarnings(warn)).toHaveLength(1);
+  });
+});
diff --git a/packages/sherpa-onnx.rn/src/__tests__/webFileSystem.test.ts b/packages/sherpa-onnx.rn/src/__tests__/webFileSystem.test.ts
new file mode 100644
index 000000000..b27fc552b
--- /dev/null
+++ b/packages/sherpa-onnx.rn/src/__tests__/webFileSystem.test.ts
@@ -0,0 +1,88 @@
+// A module, so these globals do not clash with the other glue tests.
+export {};
+
+type CoreGlobals = {
+  window?: unknown;
+  Module?: unknown;
+  SherpaOnnx?: {
+    FileSystem: {
+      isDirectory: (path: string) => boolean;
+      removePath: (path: string) => boolean;
+    };
+  };
+};
+
+const g = globalThis as unknown as CoreGlobals;
+const S_IFDIR = 0o040000;
+const S_IFREG = 0o100000;
+
+// MEMFS with Emscripten's semantics: stat returns a mode (no isDir flag),
+// unlink refuses directories and rmdir refuses non-empty ones.
+function memfs(entries: Record<string, 'dir' | 'file'>) {
+  const nodes = new Map(Object.entries(entries));
+  const fail = (code: string) => Object.assign(new Error(code), { code });
+  const hasChildren = (path: string) =>
+    [...nodes.keys()].some((key) => key.startsWith(`${path}/`));
+  return {
+    nodes,
+    stat: (path: string) => {
+      if (!nodes.has(path)) throw fail('ENOENT');
+      return { mode: nodes.get(path) === 'dir' ? S_IFDIR : S_IFREG };
+    },
+    isDir: (mode: number) => (mode & 0o170000) === S_IFDIR,
+    rmdir: (path: string) => {
+      if (nodes.get(path) !== 'dir') throw fail('ENOTDIR');
+      if (hasChildren(path)) throw fail('ENOTEMPTY');
+      nodes.delete(path);
+    },
+    unlink: (path: string) => {
+      if (!nodes.has(path)) throw fail('ENOENT');
+      if (nodes.get(path) === 'dir') throw fail('EISDIR');
+      nodes.delete(path);
+    },
+  };
+}
+
+function loadCore(fs: ReturnType<typeof memfs>) {
+  g.window = globalThis;
+  g.Module = { FS: fs };
+  jest.isolateModules(() => {
+    require('../../wasm-src/sherpa-onnx-core.js');
+  });
+  return g.SherpaOnnx!.FileSystem;
+}
+
+describe('web FileSystem.removePath', () => {
+  beforeEach(() => {
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+  });
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('removes an empty directory', () => {
+    const fs = memfs({ '/wasm': 'dir', '/wasm/tts-abc': 'dir' });
+    const FileSystem = loadCore(fs);
+
+    expect(FileSystem.isDirectory('/wasm/tts-abc')).toBe(true);
+    expect(FileSystem.removePath('/wasm/tts-abc')).toBe(true);
+    expect(fs.nodes.has('/wasm/tts-abc')).toBe(false);
+  });
+
+  it('removes a file', () => {
+    const fs = memfs({ '/wasm': 'dir', '/wasm/model.onnx': 'file' });
+    const FileSystem = loadCore(fs);
+
+    expect(FileSystem.isDirectory('/wasm/model.onnx')).toBe(false);
+    expect(FileSystem.removePath('/wasm/model.onnx')).toBe(true);
+    expect(fs.nodes.has('/wasm/model.onnx')).toBe(false);
+  });
+
+  it('keeps a directory that still has files', () => {
+    const fs = memfs({ '/wasm/tts-abc': 'dir', '/wasm/tts-abc/model.onnx': 'file' });
+    const FileSystem = loadCore(fs);
+
+    expect(FileSystem.removePath('/wasm/tts-abc')).toBe(false);
+    expect(fs.nodes.has('/wasm/tts-abc/model.onnx')).toBe(true);
+  });
+});
diff --git a/packages/sherpa-onnx.rn/src/__tests__/webTtsInit.test.ts b/packages/sherpa-onnx.rn/src/__tests__/webTtsInit.test.ts
new file mode 100644
index 000000000..585efe937
--- /dev/null
+++ b/packages/sherpa-onnx.rn/src/__tests__/webTtsInit.test.ts
@@ -0,0 +1,137 @@
+import { TtsMixin } from '../web/features/tts';
+import type { TtsModelConfig } from '../types/interfaces';
+
+jest.mock('../web/wasmLoader', () => ({
+  loadCombinedWasm: jest.fn().mockResolvedValue(undefined),
+}));
+jest.mock('../web/audioUtils', () => ({
+  samplesToWav: jest.fn(),
+  playAudioSamples: jest.fn(),
+  stopAudioPlayback: jest.fn(),
+}));
+
+const BASE = 'https://models.example/tts';
+
+// MEMFS stand-in with the real removePath semantics: files are unlinked, and
+// a directory is only rmdir'd, which fails while it still has entries.
+function memfs(files: Record<string, string>) {
+  const entries = new Set(['/m', ...Object.values(files)]);
+  const removePath = jest.fn((path: string) => {
+    if ([...entries].some((entry) => entry.startsWith(`${path}/`))) return false;
+    entries.delete(path);
+    return true;
+  });
+  return { entries, removePath };
+}
+
+function installSherpa(files: Record<string, string>, loadError?: Error) {
+  const engine = { sampleRate: 22050, numSpeakers: 1 };
+  const TTS = {
+    loadModel: loadError
+      ? jest.fn().mockRejectedValue(loadError)
+      : jest.fn().mockResolvedValue({ modelDir: '/m', type: 'vits', files }),
+    createOfflineTts: jest.fn().mockReturnValue(engine),
+  };
+  const FileSystem = memfs(files);
+  (globalThis as unknown as { window: Record<string, unknown> }).window.SherpaOnnx = { TTS, FileSystem };
+  return { TTS, FileSystem };
+}
+
+const Tts = TtsMixin(class {});
+
+function config(extra: Partial<TtsModelConfig> = {}): TtsModelConfig {
+  return {
+    modelDir: '/wasm/tts',
+    modelBaseUrl: BASE,
+    ttsModelType: 'vits',
+    modelFile: 'model.onnx',
+    tokensFile: 'tokens.txt',
+    ...extra,
+  };
+}
+
+describe('web initTts', () => {
+  it('fails with the lexicon URL instead of creating the engine when the lexicon did not load', async () => {
+    // The WASM loader reports success while dropping the 404 lexicon.
+    const { TTS, FileSystem } = installSherpa({ model: '/m/model.onnx', tokens: '/m/tokens.txt' });
+
+    const result = await new Tts().initTts(config({ lexiconFile: 'lexicon-en-us.txt' }));
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe(
+      `Failed to load TTS model files: ${BASE}/lexicon-en-us.txt`
+    );
+    expect(TTS.createOfflineTts).not.toHaveBeenCalled();
+    // The downloaded model and tokens are gone, then their directory.
+    expect([...FileSystem.entries]).toEqual([]);
+  });
+
+  it('names every file that did not load when only some loaded', async () => {
+    const { TTS, FileSystem } = installSherpa({ tokens: '/m/tokens.txt' });
+
+    const result = await new Tts().initTts(config({ lexiconFile: 'lexicon-en-us.txt' }));
+
+    expect(result).toMatchObject({
+      success: false,
+      error: `Failed to load TTS model files: ${BASE}/model.onnx, ${BASE}/lexicon-en-us.txt`,
+    });
+    expect(TTS.createOfflineTts).not.toHaveBeenCalled();
+    expect([...FileSystem.entries]).toEqual([]);
+  });
+
+  it('names the requested URLs when no file loaded', async () => {
+    // TTS.loadModel rejects with this generic message when every fetch fails.
+    const { TTS } = installSherpa({}, new Error('Failed to load TTS model files'));
+
+    const result = await new Tts().initTts(config({ lexiconFile: 'lexicon-en-us.txt' }));
+
+    expect(result).toMatchObject({
+      success: false,
+      error:
+        `Failed to load TTS model files: ${BASE}/model.onnx, ${BASE}/tokens.txt, ` +
+        `${BASE}/lexicon-en-us.txt (Failed to load TTS model files)`,
+    });
+    expect(TTS.createOfflineTts).not.toHaveBeenCalled();
+  });
+
+  it('creates the engine when every requested file loaded', async () => {
+    const { TTS, FileSystem } = installSherpa({
+      model: '/m/model.onnx',
+      tokens: '/m/tokens.txt',
+      lexicon: '/m/lexicon.txt',
+    });
+
+    const result = await new Tts().initTts(config({ lexiconFile: 'lexicon-en-us.txt' }));
+
+    expect(TTS.loadModel).toHaveBeenCalledWith(
+      expect.objectContaining({ lexicon: `${BASE}/lexicon-en-us.txt` })
+    );
+    expect(result).toEqual({ success: true, sampleRate: 22050, numSpeakers: 1 });
+    expect(FileSystem.removePath).not.toHaveBeenCalled();
+  });
+
+  it('does not require a lexicon the config does not name', async () => {
+    const { TTS } = installSherpa({ model: '/m/model.onnx', tokens: '/m/tokens.txt' });
+
+    const result = await new Tts().initTts(config());
+
+    expect(TTS.loadModel).toHaveBeenCalledWith(
+      expect.objectContaining({ lexicon: undefined })
+    );
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects model types the web engine cannot build', async () => {
+    const { TTS } = installSherpa({});
+
+    const result = await new Tts().initTts(
+      config({ ttsModelType: 'kokoro', lexiconFile: 'lexicon-us-en.txt' })
+    );
+
+    expect(result).toMatchObject({
+      success: false,
+      error: 'Web TTS supports VITS models only, not kokoro',
+    });
+    expect(TTS.loadModel).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/sherpa-onnx.rn/src/web/features/tts.ts b/packages/sherpa-onnx.rn/src/web/features/tts.ts
index 0ebce1f7f..20b667343 100644
--- a/packages/sherpa-onnx.rn/src/web/features/tts.ts
+++ b/packages/sherpa-onnx.rn/src/web/features/tts.ts
@@ -17,33 +17,68 @@ export function TtsMixin<TBase extends Constructor>(Base: TBase) {
 
     async initTts(config: TtsModelConfig): Promise<TtsInitResult> {
       try {
+        const type = config.ttsModelType || 'vits';
+        // The WASM glue builds an engine config for VITS only; its matcha and
+        // kokoro branches are empty, so createOfflineTts would crash on them.
+        if (type !== 'vits') {
+          throw new Error(`Web TTS supports VITS models only, not ${type}`);
+        }
+
         await loadCombinedWasm();
 
         const debug = config.debug ? 1 : 0;
         const numThreads = 1; // WASM is single-threaded
 
         console.log(
-          `[TTS] Loading ${config.ttsModelType || 'vits'} model (threads=${numThreads}, debug=${debug})...`
+          `[TTS] Loading ${type} model (threads=${numThreads}, debug=${debug})...`
         );
         // Web-only: config.modelDir is set to '/wasm/tts' by ModelManagement
         // (createWebTtsModelState in constants.ts), pointing to model files
         // pre-served by download-web-models.sh. Native TTS uses the TurboModule.
         const modelDir = config.modelDir || '/wasm/tts';
         const fetchBase = config.modelBaseUrl || modelDir;
+        const model = `${fetchBase}/model.onnx`;
+        const tokens = `${fetchBase}/tokens.txt`;
+        // sherpa-onnx v2.0 removed espeak-ng; the lexicon replaces espeak-ng-data.zip.
+        const lexicon = config.lexiconFile
+          ? `${fetchBase}/${config.lexiconFile}`
+          : undefined;
 
-        const loadedModel = await withDownloadProgress(config.onProgress, () =>
-          window.SherpaOnnx.TTS.loadModel({
-            type: config.ttsModelType || 'vits',
-            model: `${fetchBase}/model.onnx`,
-            tokens: `${fetchBase}/tokens.txt`,
-            // sherpa-onnx v2.0 removed espeak-ng; the lexicon replaces espeak-ng-data.zip.
-            lexicon: config.lexiconFile
-              ? `${fetchBase}/${config.lexiconFile}`
-              : undefined,
-            modelDir,
-            debug,
-          })
-        );
+        let loadedModel;
+        try {
+          loadedModel = await withDownloadProgress(config.onProgress, () =>
+            window.SherpaOnnx.TTS.loadModel({
+              type,
+              model,
+              tokens,
+              lexicon,
+              modelDir,
+              debug,
+            })
+          );
+        } catch (error) {
+          // The loader rejects with a generic message when no file loaded.
+          const requested = [model, tokens, lexicon].filter(Boolean);
+          throw new Error(
+            `Failed to load TTS model files: ${requested.join(', ')} (${(error as Error).message})`
+          );
+        }
+
+        // The WASM loader drops files it fails to fetch and still reports
+        // success. Creating the engine without them aborts inside WASM with
+        // "memory access out of bounds", so name the missing files instead.
+        const missing = [
+          !loadedModel.files.model && model,
+          !loadedModel.files.tokens && tokens,
+          lexicon && !loadedModel.files.lexicon && lexicon,
+        ].filter(Boolean);
+        if (missing.length > 0) {
+          // removePath only rmdirs, so the directory must be empty first.
+          const fs = window.SherpaOnnx.FileSystem;
+          Object.values(loadedModel.files).forEach((path) => fs.removePath(path));
+          fs.removePath(loadedModel.modelDir);
+          throw new Error(`Failed to load TTS model files: ${missing.join(', ')}`);
+        }
 
         this.tts = window.SherpaOnnx.TTS.createOfflineTts(loadedModel, {
           numThreads,
diff --git a/packages/sherpa-onnx.rn/wasm-src/sherpa-onnx-combined.js b/packages/sherpa-onnx.rn/wasm-src/sherpa-onnx-combined.js
index 7d41aa028..05ae3a5b5 100644
--- a/packages/sherpa-onnx.rn/wasm-src/sherpa-onnx-combined.js
+++ b/packages/sherpa-onnx.rn/wasm-src/sherpa-onnx-combined.js
@@ -213,22 +213,25 @@
     // Browser environment: load scripts
     if (typeof window !== 'undefined') {
       // Set up a backup timeout to ensure callback is called even if loading fails
+      let timeoutId;
       const timeoutPromise = new Promise((resolve) => {
-        setTimeout(() => {
+        timeoutId = setTimeout(() => {
           console.warn("Module loading timeout reached - some modules may not have loaded correctly");
           resolve();
         }, 30000); // 30 second timeout
       });
-      
+
       // Load modules with timeout protection
       Promise.race([loadModulesSequentially(), timeoutPromise])
         .catch(error => {
           console.error("Module loading failed:", error);
-          
+
           if (global.onSherpaOnnxReady) {
             global.onSherpaOnnxReady(false);
           }
-        });
+        })
+        // Loading finished first: drop the backup timer so it cannot warn later.
+        .finally(() => clearTimeout(timeoutId));
     }
   };
   
diff --git a/packages/sherpa-onnx.rn/wasm-src/sherpa-onnx-core.js b/packages/sherpa-onnx.rn/wasm-src/sherpa-onnx-core.js
index ededfa4fc..fd2af359b 100644
--- a/packages/sherpa-onnx.rn/wasm-src/sherpa-onnx-core.js
+++ b/packages/sherpa-onnx.rn/wasm-src/sherpa-onnx-core.js
@@ -201,7 +201,8 @@
     isDirectory: function(path) {
       try {
         const stat = global.Module.FS.stat(path);
-        return stat.isDir;
+        // Emscripten stat results carry a mode, not an isDir flag.
+        return global.Module.FS.isDir(stat.mode);
       } catch (e) {
         return false;
       }
diff --git a/scripts/agentic/recipe/cli.test.mjs b/scripts/agentic/recipe/cli.test.mjs
index d3035daf2..5e48d4cf4 100644
--- a/scripts/agentic/recipe/cli.test.mjs
+++ b/scripts/agentic/recipe/cli.test.mjs
@@ -125,7 +125,7 @@ test('web preflight launches Metro and a headless browser', async t => {
   const configDir = path.join(root, 'scripts/agentic/lib');
   await fs.mkdir(configDir, { recursive: true });
   await fs.copyFile(path.join(repoRoot, 'scripts/agentic/lib/runtime-config.cjs'), path.join(configDir, 'runtime-config.cjs'));
-  const { stdout } = await execute('bash', [path.join(repoRoot, 'farmslot/projects/audiolab-farm/scripts/runtime.sh'), 'launch', root, '7466', '7676', 'web'], { env: { ...process.env, AUDIOLAB_NODE_BIN: path.dirname(process.execPath), AUDIOLAB_NPM_TOKEN: 'fixture', EAS_PROJECT_ID: 'fixture', APPLE_TEAM_ID: 'fixture' } });
+  const { stdout } = await execute('bash', [path.join(repoRoot, 'farmslot/projects/audiolab-farm/scripts/runtime.sh'), 'launch', root, '7466', '7676', 'web'], { env: { ...process.env, AUDIOLAB_APP: 'playground', AUDIOLAB_NODE_BIN: path.dirname(process.execPath), AUDIOLAB_NPM_TOKEN: 'fixture', EAS_PROJECT_ID: 'fixture', APPLE_TEAM_ID: 'fixture' } });
   assert.equal(stdout.split('\n')[0], 'metro-started');
   assert.deepEqual(JSON.parse(stdout.split('\n')[1]), { stage: 'browser', headless: 'true', channel: 'chrome', port: '7466' });
   assert.ok(!stdout.includes('native-called'));
diff --git a/scripts/agentic/recipe/provider.test.mjs b/scripts/agentic/recipe/provider.test.mjs
index 29d9f0982..fbf5f5f15 100644
--- a/scripts/agentic/recipe/provider.test.mjs
+++ b/scripts/agentic/recipe/provider.test.mjs
@@ -117,7 +117,11 @@ test('native preflight retains an explicitly selected simulator UUID', async t =
   assert.equal(stdout.trim(), `simulator-boot\n120\ndevice=${udid}`);
 });
 
-test('the declared factory resolves through the public shared host and default engine', async () => {
+test('the declared factory resolves through the public shared host and default engine', async t => {
+  // A slot's RECIPE_LIBRARY_PATH adds an untrusted library, which blocks the trusted plan.
+  const libraryPath = process.env.RECIPE_LIBRARY_PATH;
+  delete process.env.RECIPE_LIBRARY_PATH;
+  t.after(() => { if (libraryPath !== undefined) process.env.RECIPE_LIBRARY_PATH = libraryPath; });
   await withProjectRecipeHost({ tokens: ['--project', 'audiolab-farm', '--target', repoRoot, '--app', 'apps/playground', '--adapter', 'web', '--watcher-port', '19746', '--cdp-port', '19767'],
     projectsDir: path.join(repoRoot, 'farmslot/projects'), command: 'run', options: { plan: true, watcherPort: '19746', cdpPort: '19767' } }, async host => {
     assert.equal(host.context.project.provider.module, path.join(repoRoot, 'scripts/agentic/recipe/provider.mjs'));
diff --git a/scripts/agentic/recipe/recipes/playground/audio-studio-web-validation.recipe.json b/scripts/agentic/recipe/recipes/playground/audio-studio-web-validation.recipe.json
new file mode 100644
index 000000000..e587a0b21
--- /dev/null
+++ b/scripts/agentic/recipe/recipes/playground/audio-studio-web-validation.recipe.json
@@ -0,0 +1,767 @@
+{
+  "$schema": "https://farmslot.io/schemas/recipe-v1.schema.json",
+  "title": "Playground audio-studio web validation",
+  "description": "Records from the Record tab buttons with a pause/resume cycle (duration must hold while paused and grow after resume), stops and opens the saved take, plays and pauses it (the browser media clock must advance), then runs the waveform preview, PCM decode, mel spectrogram, audio features and trim probes on the bundled JFK sample. Written for web; the UI steps also apply to native.",
+  "proofTargets": [
+    {
+      "id": "record",
+      "claim": "A recording started and stopped from the Record tab buttons captures audio and opens the saved take.",
+      "proofMode": "mixed"
+    },
+    {
+      "id": "pause-resume",
+      "claim": "Pause holds the recorded duration and resume makes it grow again.",
+      "proofMode": "mixed"
+    },
+    {
+      "id": "playback",
+      "claim": "The saved take plays in the browser from its Play button and pauses from Pause.",
+      "proofMode": "mixed"
+    },
+    {
+      "id": "extraction",
+      "claim": "Preview, PCM decode, mel spectrogram, features and trim return real results for the bundled sample.",
+      "proofMode": "state"
+    },
+    {
+      "id": "restored",
+      "claim": "The run ends on the route it started from."
+    }
+  ],
+  "workflow": {
+    "entry": "prepare-ready",
+    "nodes": {
+      "prepare-ready": {
+        "action": "audiolab.query",
+        "ref": "playground.agentic_ready",
+        "assert": {
+          "operator": "not_null",
+          "field": "pathname"
+        },
+        "intent": "The playground app is running with the agentic bridge installed.",
+        "next": "status"
+      },
+      "status": {
+        "action": "app.status",
+        "intent": "Read the starting route so teardown can restore it.",
+        "next": "nav-record"
+      },
+      "nav-record": {
+        "action": "ui.navigate",
+        "path": "/(tabs)/record",
+        "intent": "Open the Record tab.",
+        "next": "wait-record-screen"
+      },
+      "wait-record-screen": {
+        "action": "audiolab.query",
+        "ref": "playground.record_screen_visible",
+        "assert": {
+          "operator": "eq",
+          "field": "visible",
+          "value": true
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "The Record tab is rendered.",
+        "next": "read-record-page"
+      },
+      "read-record-page": {
+        "action": "audiolab.query",
+        "ref": "record-page-state",
+        "assert": {
+          "operator": "eq",
+          "field": "route",
+          "value": "/record"
+        },
+        "poll": true,
+        "timeout_ms": 10000,
+        "intent": "Read whether an earlier take is still shown.",
+        "next": "choose-reset"
+      },
+      "choose-reset": {
+        "action": "audiolab.choose",
+        "intent": "Clear an earlier take so the start button is shown.",
+        "rules": [
+          {
+            "operator": "eq",
+            "field": "last.hasRecordingResult",
+            "value": true
+          }
+        ],
+        "cases": {
+          "case-0": "press-record-again"
+        },
+        "default": "assert-idle"
+      },
+      "press-record-again": {
+        "action": "ui.press",
+        "test_id": "record-again-button",
+        "intent": "Dismiss the earlier take.",
+        "next": "assert-idle"
+      },
+      "assert-idle": {
+        "action": "audiolab.query",
+        "ref": "recording-state",
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "isRecording",
+              "value": false
+            },
+            {
+              "operator": "eq",
+              "field": "isPaused",
+              "value": false
+            }
+          ]
+        },
+        "poll": true,
+        "timeout_ms": 10000,
+        "intent": "The recorder starts idle and unpaused.",
+        "next": "wait-start-button"
+      },
+      "wait-start-button": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify({visible: !!globalThis.__AGENTIC__?.findFiberByTestId?.('start-recording-button')})",
+        "assert": {
+          "operator": "eq",
+          "field": "visible",
+          "value": true
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "The start button is visible.",
+        "next": "press-start"
+      },
+      "press-start": {
+        "action": "ui.press",
+        "test_id": "start-recording-button",
+        "intent": "Start recording from the Record tab.",
+        "next": "wait-recording"
+      },
+      "wait-recording": {
+        "action": "audiolab.query",
+        "ref": "recording-state",
+        "assert": {
+          "operator": "eq",
+          "field": "isRecording",
+          "value": true
+        },
+        "poll": true,
+        "timeout_ms": 30000,
+        "intent": "The recorder reports it is recording.",
+        "next": "record-window"
+      },
+      "record-window": {
+        "action": "wait",
+        "duration_ms": 2500,
+        "intent": "Record for two and a half seconds.",
+        "next": "assert-recording"
+      },
+      "assert-recording": {
+        "action": "audiolab.query",
+        "ref": "recording-state",
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "isRecording",
+              "value": true
+            },
+            {
+              "operator": "gte",
+              "field": "durationMs",
+              "value": 1500
+            },
+            {
+              "operator": "gt",
+              "field": "size",
+              "value": 0
+            }
+          ]
+        },
+        "poll": true,
+        "timeout_ms": 10000,
+        "intent": "Duration and captured bytes grow while recording.",
+        "next": "prove-recording"
+      },
+      "prove-recording": {
+        "action": "assert_output",
+        "source": "assert-recording",
+        "assert": {
+          "path": "$.size",
+          "operator": "gt",
+          "value": 0
+        },
+        "proves": [
+          "record"
+        ],
+        "intent": "The recorder captured bytes before the pause.",
+        "next": "press-pause"
+      },
+      "press-pause": {
+        "action": "ui.press",
+        "test_id": "pause-recording-button",
+        "intent": "Pause recording with the Record tab pause button.",
+        "next": "readPaused"
+      },
+      "readPaused": {
+        "action": "audiolab.query",
+        "ref": "recording-state",
+        "assert": {
+          "operator": "eq",
+          "field": "isPaused",
+          "value": true
+        },
+        "poll": true,
+        "timeout_ms": 10000,
+        "intent": "The recorder reports it is paused.",
+        "next": "pause-window"
+      },
+      "pause-window": {
+        "action": "wait",
+        "duration_ms": 2000,
+        "intent": "Stay paused for two seconds.",
+        "next": "assert-paused-holds"
+      },
+      "assert-paused-holds": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){var s=globalThis.__AGENTIC__.getState();return {isRecording:s.isRecording,isPaused:s.isPaused,durationMs:s.durationMs,deltaMs:s.durationMs-Number('{{outputs.readPaused.durationMs}}')};})())",
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "isPaused",
+              "value": true
+            },
+            {
+              "operator": "lte",
+              "field": "deltaMs",
+              "value": 300
+            }
+          ]
+        },
+        "intent": "The recorded duration does not advance while paused.",
+        "next": "prove-paused"
+      },
+      "prove-paused": {
+        "action": "assert_output",
+        "source": "assert-paused-holds",
+        "assert": {
+          "path": "$.deltaMs",
+          "operator": "lte",
+          "value": 300
+        },
+        "proves": [
+          "pause-resume"
+        ],
+        "intent": "Duration held still for two seconds of pause.",
+        "next": "shot-paused"
+      },
+      "shot-paused": {
+        "action": "ui.screenshot",
+        "path": "screenshots/audio-studio-web-paused.png",
+        "covers": [
+          "pause-resume"
+        ],
+        "label": "Record tab while paused",
+        "intent": "Show the paused recording view with the resume button.",
+        "next": "press-resume"
+      },
+      "press-resume": {
+        "action": "ui.press",
+        "test_id": "resume-recording-button",
+        "intent": "Resume recording with the Record tab resume button.",
+        "next": "wait-resumed"
+      },
+      "wait-resumed": {
+        "action": "audiolab.query",
+        "ref": "recording-state",
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "isRecording",
+              "value": true
+            },
+            {
+              "operator": "eq",
+              "field": "isPaused",
+              "value": false
+            }
+          ]
+        },
+        "poll": true,
+        "timeout_ms": 10000,
+        "intent": "The recorder reports it is recording again.",
+        "next": "resume-window"
+      },
+      "resume-window": {
+        "action": "wait",
+        "duration_ms": 2000,
+        "intent": "Record two more seconds after resuming.",
+        "next": "assert-resumed-progress"
+      },
+      "assert-resumed-progress": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){var s=globalThis.__AGENTIC__.getState();return {isRecording:s.isRecording,isPaused:s.isPaused,durationMs:s.durationMs,deltaMs:s.durationMs-Number('{{outputs.readPaused.durationMs}}')};})())",
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "isPaused",
+              "value": false
+            },
+            {
+              "operator": "gte",
+              "field": "deltaMs",
+              "value": 1000
+            }
+          ]
+        },
+        "poll": true,
+        "timeout_ms": 10000,
+        "intent": "The recorded duration advances again after resume.",
+        "next": "prove-resumed"
+      },
+      "prove-resumed": {
+        "action": "assert_output",
+        "source": "assert-resumed-progress",
+        "assert": {
+          "path": "$.deltaMs",
+          "operator": "gte",
+          "value": 1000
+        },
+        "proves": [
+          "pause-resume"
+        ],
+        "intent": "Duration grew by at least a second after resume.",
+        "next": "shot-recording"
+      },
+      "shot-recording": {
+        "action": "ui.screenshot",
+        "path": "screenshots/audio-studio-web-recording.png",
+        "covers": [
+          "pause-resume"
+        ],
+        "label": "Record tab after resume",
+        "intent": "Show the active recording view after resume.",
+        "next": "press-stop"
+      },
+      "press-stop": {
+        "action": "ui.press",
+        "test_id": "stop-recording-button",
+        "intent": "Stop recording from the Record tab.",
+        "next": "wait-stopped"
+      },
+      "wait-stopped": {
+        "action": "audiolab.query",
+        "ref": "recording-state",
+        "assert": {
+          "operator": "eq",
+          "field": "isRecording",
+          "value": false
+        },
+        "poll": true,
+        "timeout_ms": 30000,
+        "intent": "The recorder reports it stopped.",
+        "next": "wait-saved"
+      },
+      "wait-saved": {
+        "action": "audiolab.query",
+        "ref": "route",
+        "assert": {
+          "operator": "contains",
+          "field": "segments",
+          "value": "(recordings)"
+        },
+        "poll": true,
+        "timeout_ms": 30000,
+        "intent": "Stopping saves the take and opens its page.",
+        "next": "prove-saved"
+      },
+      "prove-saved": {
+        "action": "assert_output",
+        "source": "wait-saved",
+        "assert": {
+          "path": "$.segments",
+          "operator": "contains",
+          "value": "(recordings)"
+        },
+        "proves": [
+          "record"
+        ],
+        "intent": "The app opened the saved take page.",
+        "next": "shot-saved"
+      },
+      "shot-saved": {
+        "action": "ui.screenshot",
+        "path": "screenshots/audio-studio-web-saved.png",
+        "covers": [
+          "record"
+        ],
+        "label": "Saved take page",
+        "intent": "Show the saved take with its waveform.",
+        "next": "arm-playback"
+      },
+      "arm-playback": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof HTMLMediaElement==='undefined')return {armed:false};var p=HTMLMediaElement.prototype;if(!p.__agenticPlayWrapped){var o=p.play;p.play=function(){globalThis.__agenticMedia=this;return o.apply(this,arguments);};p.__agenticPlayWrapped=true;}globalThis.__agenticMedia=null;return {armed:true};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "armed",
+          "value": true
+        },
+        "intent": "Watch which media element starts playing.",
+        "next": "press-play"
+      },
+      "press-play": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {status:'no-dom'};var els=[].slice.call(document.querySelectorAll('[role=button],button')).filter(function(e){return (e.textContent||'').replace(/[\\uE000-\\uF8FF]|[\\uDB80-\\uDBFF][\\uDC00-\\uDFFF]/g,'').trim()==='Play'&&e.offsetParent!==null;});if(!els.length)return {status:'missing',label:'Play'};els[0].click();return {status:'clicked',label:'Play'};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "clicked"
+        },
+        "poll": true,
+        "timeout_ms": 10000,
+        "intent": "Press Play on the saved take.",
+        "next": "wait-playing"
+      },
+      "wait-playing": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){var m=globalThis.__agenticMedia;if(!m)return {found:false,playing:false};return {found:true,playing:!m.paused&&m.currentTime>0.5,paused:m.paused,currentTime:m.currentTime,duration:m.duration,srcScheme:String(m.src).split(':')[0]};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "playing",
+          "value": true
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "The browser media clock advances past half a second.",
+        "next": "prove-playing"
+      },
+      "prove-playing": {
+        "action": "assert_output",
+        "source": "wait-playing",
+        "assert": {
+          "path": "$.currentTime",
+          "operator": "gt",
+          "value": 0.5
+        },
+        "proves": [
+          "playback"
+        ],
+        "intent": "The saved take is playing in the browser.",
+        "next": "shot-playing"
+      },
+      "shot-playing": {
+        "action": "ui.screenshot",
+        "path": "screenshots/audio-studio-web-playing.png",
+        "covers": [
+          "playback"
+        ],
+        "label": "Saved take playing",
+        "intent": "Show the take with the Pause button while it plays.",
+        "next": "press-pause-playback"
+      },
+      "press-pause-playback": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {status:'no-dom'};var els=[].slice.call(document.querySelectorAll('[role=button],button')).filter(function(e){return (e.textContent||'').replace(/[\\uE000-\\uF8FF]|[\\uDB80-\\uDBFF][\\uDC00-\\uDFFF]/g,'').trim()==='Pause'&&e.offsetParent!==null;});if(!els.length)return {status:'missing',label:'Pause'};els[0].click();return {status:'clicked',label:'Pause'};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "clicked"
+        },
+        "poll": true,
+        "timeout_ms": 5000,
+        "intent": "Pause playback.",
+        "next": "wait-playback-paused"
+      },
+      "wait-playback-paused": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){var m=globalThis.__agenticMedia;if(!m)return {found:false,playing:false};return {found:true,playing:!m.paused&&m.currentTime>0.5,paused:m.paused,currentTime:m.currentTime,duration:m.duration,srcScheme:String(m.src).split(':')[0]};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "paused",
+          "value": true
+        },
+        "poll": true,
+        "timeout_ms": 5000,
+        "intent": "The media element reports paused.",
+        "next": "reveal-waveform"
+      },
+      "reveal-waveform": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {visible:false};var b=[].slice.call(document.querySelectorAll('[role=button],button')).find(function(e){return (e.textContent||'').trim()==='Waveform'&&e.offsetParent!==null;});if(!b)return {visible:false};b.scrollIntoView({block:'start'});var s=[].slice.call(document.querySelectorAll('div,span')).map(function(d){return (d.textContent||'').trim();}).filter(function(t){return /^[\\d,]+ audio samples$/.test(t);})[0]||'';var c=[].slice.call(document.querySelectorAll('canvas')).filter(function(x){return x.offsetParent!==null;});return {visible:true,samples:Number(s.split(' ')[0].replace(/,/g,''))||0,canvases:c.length,melCanvas:c.some(function(x){return x.clientHeight===200;})};})())",
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "visible",
+              "value": true
+            },
+            {
+              "operator": "gt",
+              "field": "samples",
+              "value": 0
+            },
+            {
+              "operator": "gt",
+              "field": "canvases",
+              "value": 0
+            }
+          ]
+        },
+        "poll": true,
+        "timeout_ms": 30000,
+        "intent": "Scroll to the waveform the take's analysis drew.",
+        "next": "prove-waveform"
+      },
+      "prove-waveform": {
+        "action": "assert_output",
+        "source": "reveal-waveform",
+        "assert": {
+          "path": "$.samples",
+          "operator": "gt",
+          "value": 0
+        },
+        "proves": [
+          "extraction"
+        ],
+        "intent": "The saved take shows a waveform built from its decoded samples.",
+        "next": "shot-waveform"
+      },
+      "shot-waveform": {
+        "action": "ui.screenshot",
+        "path": "screenshots/audio-studio-web-waveform.png",
+        "covers": [
+          "extraction"
+        ],
+        "label": "Saved take waveform",
+        "intent": "Show the extracted waveform of the recorded take.",
+        "next": "press-mel-tab"
+      },
+      "press-mel-tab": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {status:'no-dom'};var els=[].slice.call(document.querySelectorAll('[role=button],button')).filter(function(e){return (e.textContent||'').replace(/[\\uE000-\\uF8FF]|[\\uDB80-\\uDBFF][\\uDC00-\\uDFFF]/g,'').trim()===\"Mel Spectrogram\"&&e.offsetParent!==null&&e.getAttribute('aria-disabled')!=='true';});if(!els.length)return {status:'missing',label:\"Mel Spectrogram\"};els[0].click();return {status:'clicked',label:\"Mel Spectrogram\"};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "clicked"
+        },
+        "poll": true,
+        "timeout_ms": 30000,
+        "intent": "Switch to the mel spectrogram, enabled once mel data is extracted.",
+        "next": "wait-mel-view"
+      },
+      "wait-mel-view": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {visible:false};var b=[].slice.call(document.querySelectorAll('[role=button],button')).find(function(e){return (e.textContent||'').trim()==='Waveform'&&e.offsetParent!==null;});if(!b)return {visible:false};b.scrollIntoView({block:'start'});var s=[].slice.call(document.querySelectorAll('div,span')).map(function(d){return (d.textContent||'').trim();}).filter(function(t){return /^[\\d,]+ audio samples$/.test(t);})[0]||'';var c=[].slice.call(document.querySelectorAll('canvas')).filter(function(x){return x.offsetParent!==null;});return {visible:true,samples:Number(s.split(' ')[0].replace(/,/g,''))||0,canvases:c.length,melCanvas:c.some(function(x){return x.clientHeight===200;})};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "melCanvas",
+          "value": true
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "The mel spectrogram canvas is drawn.",
+        "next": "prove-mel-view"
+      },
+      "prove-mel-view": {
+        "action": "assert_output",
+        "source": "wait-mel-view",
+        "assert": {
+          "path": "$.melCanvas",
+          "operator": "eq",
+          "value": true
+        },
+        "proves": [
+          "extraction"
+        ],
+        "intent": "The saved take shows its extracted mel spectrogram.",
+        "next": "shot-mel"
+      },
+      "shot-mel": {
+        "action": "ui.screenshot",
+        "path": "screenshots/audio-studio-web-mel.png",
+        "covers": [
+          "extraction"
+        ],
+        "label": "Saved take mel spectrogram",
+        "intent": "Show the extracted mel spectrogram of the recorded take.",
+        "next": "preview"
+      },
+      "preview": {
+        "action": "audiolab.query",
+        "expression": "(function(){var A=globalThis.__AGENTIC__;if(!A||!A.testExtractPreview||!A.getLastResult){return Promise.resolve({status:'error',error:'agentic bridge missing testExtractPreview'});}A.testExtractPreview();return new Promise(function(resolve){var i=0;function tick(){var r=A.getLastResult();if(r&&r.op==='extractPreview'&&r.status!=='pending'){resolve(r);return;}if(++i>=240){resolve({status:'timeout',last:r});return;}setTimeout(tick,500);}tick();});})()",
+        "async": true,
+        "timeout_ms": 130000,
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "success"
+        },
+        "intent": "Extract a 50-point waveform preview from the bundled JFK sample.",
+        "next": "prove-preview"
+      },
+      "prove-preview": {
+        "action": "assert_output",
+        "source": "preview",
+        "assert": {
+          "path": "$.result.dataPointCount",
+          "operator": "eq",
+          "value": 50
+        },
+        "proves": [
+          "extraction"
+        ],
+        "intent": "The preview returned the 50 requested waveform points.",
+        "next": "audio-data"
+      },
+      "audio-data": {
+        "action": "audiolab.query",
+        "expression": "(function(){var A=globalThis.__AGENTIC__;if(!A||!A.testExtractAudioData||!A.getLastResult){return Promise.resolve({status:'error',error:'agentic bridge missing testExtractAudioData'});}A.testExtractAudioData();return new Promise(function(resolve){var i=0;function tick(){var r=A.getLastResult();if(r&&r.op==='extractAudioData'&&r.status!=='pending'){resolve(r);return;}if(++i>=240){resolve({status:'timeout',last:r});return;}setTimeout(tick,500);}tick();});})()",
+        "async": true,
+        "timeout_ms": 130000,
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "success"
+        },
+        "intent": "Decode the first five seconds of the sample to PCM.",
+        "next": "prove-audio-data"
+      },
+      "prove-audio-data": {
+        "action": "assert_output",
+        "source": "audio-data",
+        "assert": {
+          "path": "$.result.samples",
+          "operator": "gt",
+          "value": 0
+        },
+        "proves": [
+          "extraction"
+        ],
+        "intent": "Decoded PCM holds samples.",
+        "next": "mel"
+      },
+      "mel": {
+        "action": "audiolab.query",
+        "expression": "(function(){var A=globalThis.__AGENTIC__;if(!A||!A.testExtractMelSpectrogram||!A.getLastResult){return Promise.resolve({status:'error',error:'agentic bridge missing testExtractMelSpectrogram'});}A.testExtractMelSpectrogram();return new Promise(function(resolve){var i=0;function tick(){var r=A.getLastResult();if(r&&r.op==='extractMelSpectrogram'&&r.status!=='pending'){resolve(r);return;}if(++i>=240){resolve({status:'timeout',last:r});return;}setTimeout(tick,500);}tick();});})()",
+        "async": true,
+        "timeout_ms": 130000,
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "success"
+        },
+        "intent": "Compute a mel spectrogram of the sample.",
+        "next": "prove-mel"
+      },
+      "prove-mel": {
+        "action": "assert_output",
+        "source": "mel",
+        "assert": {
+          "path": "$.result.timeSteps",
+          "operator": "gt",
+          "value": 0
+        },
+        "proves": [
+          "extraction"
+        ],
+        "intent": "The mel spectrogram has time steps.",
+        "next": "features"
+      },
+      "features": {
+        "action": "audiolab.query",
+        "expression": "(function(){var A=globalThis.__AGENTIC__;if(!A||!A.testAudioFeatures||!A.getLastResult){return Promise.resolve({status:'error',error:'agentic bridge missing testAudioFeatures'});}A.testAudioFeatures();return new Promise(function(resolve){var i=0;function tick(){var r=A.getLastResult();if(r&&r.op==='audioFeatures'&&r.status!=='pending'){resolve(r);return;}if(++i>=240){resolve({status:'timeout',last:r});return;}setTimeout(tick,500);}tick();});})()",
+        "async": true,
+        "timeout_ms": 130000,
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "success"
+        },
+        "intent": "Extract audio features from the sample.",
+        "next": "prove-features"
+      },
+      "prove-features": {
+        "action": "assert_output",
+        "source": "features",
+        "assert": {
+          "path": "$.result.dataPointCount",
+          "operator": "gt",
+          "value": 0
+        },
+        "proves": [
+          "extraction"
+        ],
+        "intent": "Feature extraction returned data points.",
+        "next": "trim"
+      },
+      "trim": {
+        "action": "audiolab.query",
+        "expression": "(function(){var A=globalThis.__AGENTIC__;if(!A||!A.testTrimAudio||!A.getLastResult){return Promise.resolve({status:'error',error:'agentic bridge missing testTrimAudio'});}A.testTrimAudio();return new Promise(function(resolve){var i=0;function tick(){var r=A.getLastResult();if(r&&r.op==='trimAudio'&&r.status!=='pending'){resolve(r);return;}if(++i>=240){resolve({status:'timeout',last:r});return;}setTimeout(tick,500);}tick();});})()",
+        "async": true,
+        "timeout_ms": 130000,
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "success"
+        },
+        "intent": "Trim the sample to its first five seconds and to two kept ranges.",
+        "next": "prove-trim"
+      },
+      "prove-trim": {
+        "action": "assert_output",
+        "source": "trim",
+        "assert": {
+          "path": "$.result.single.durationMs",
+          "operator": "gte",
+          "value": 4500
+        },
+        "proves": [
+          "extraction"
+        ],
+        "intent": "The trimmed file lasts about five seconds.",
+        "next": "done"
+      },
+      "done": {
+        "action": "end",
+        "status": "pass"
+      },
+      "restore": {
+        "action": "ui.navigate",
+        "path": "{{outputs.status.pathname}}",
+        "intent": "Return to the starting route.",
+        "next": "observe-restored"
+      },
+      "observe-restored": {
+        "action": "app.status",
+        "intent": "Read the route after restoring it.",
+        "next": "assert-restored"
+      },
+      "assert-restored": {
+        "action": "assert_output",
+        "source": "observe-restored",
+        "assert": {
+          "path": "$.pathname",
+          "operator": "eq",
+          "value": "{{outputs.status.pathname}}"
+        },
+        "proves": [
+          "restored"
+        ],
+        "intent": "The starting route is restored.",
+        "next": "cleanup-done"
+      },
+      "cleanup-done": {
+        "action": "end",
+        "status": "pass"
+      }
+    },
+    "teardown": "restore"
+  }
+}
diff --git a/scripts/agentic/recipe/recipes/playground/moonshine-web-live-transcription.recipe.json b/scripts/agentic/recipe/recipes/playground/moonshine-web-live-transcription.recipe.json
new file mode 100644
index 000000000..5def43943
--- /dev/null
+++ b/scripts/agentic/recipe/recipes/playground/moonshine-web-live-transcription.recipe.json
@@ -0,0 +1,372 @@
+{
+  "$schema": "https://farmslot.io/schemas/recipe-v1.schema.json",
+  "title": "Playground Moonshine web live transcription",
+  "description": "Opens the dev-only Moonshine live screen, loads the small-only Moonshine model, starts a live session and asserts the live transcript contains words from known speech on the microphone. On web, launch the browser with WEB_FAKE_AUDIO_FILE pointing at a JFK WAV so the microphone carries that speech. Sherpa speaker turns are native-only and not asserted.",
+  "proofTargets": [
+    {
+      "id": "model-load",
+      "claim": "The Moonshine model loads on the target platform.",
+      "proofMode": "state"
+    },
+    {
+      "id": "live-transcription",
+      "claim": "A live microphone session produces a transcript of the speech it hears, then stops with a kept recording.",
+      "proofMode": "mixed"
+    },
+    {
+      "id": "restored",
+      "claim": "The run ends on the route it started from."
+    }
+  ],
+  "workflow": {
+    "entry": "prepare-ready",
+    "nodes": {
+      "prepare-ready": {
+        "action": "audiolab.query",
+        "ref": "playground.agentic_ready",
+        "assert": {
+          "operator": "not_null",
+          "field": "pathname"
+        },
+        "intent": "The playground app is running with the agentic bridge installed.",
+        "next": "status"
+      },
+      "status": {
+        "action": "app.status",
+        "intent": "Read the starting route so teardown can restore it.",
+        "next": "screen-ready"
+      },
+      "screen-ready": {
+        "action": "call",
+        "ref": "playground.flows.moonshine-live-screen-ready",
+        "intent": "Open the Moonshine live screen with its prepare and start controls visible.",
+        "next": "read-start"
+      },
+      "read-start": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify(globalThis.__AGENTIC__?.getPageState?.() || null)",
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "platformAvailable",
+              "value": true
+            },
+            {
+              "operator": "eq",
+              "field": "isRecording",
+              "value": false
+            }
+          ]
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "Moonshine reports it is available on this platform and nothing is recording.",
+        "next": "choose-clear"
+      },
+      "choose-clear": {
+        "action": "audiolab.choose",
+        "intent": "Clear a transcript left by an earlier session.",
+        "rules": [
+          {
+            "operator": "not_null",
+            "field": "last.finalTranscript"
+          },
+          {
+            "operator": "gt",
+            "field": "last.liveCommittedLineCount",
+            "value": 0
+          }
+        ],
+        "cases": {
+          "case-0": "press-clear",
+          "case-1": "press-clear"
+        },
+        "default": "press-prepare"
+      },
+      "press-clear": {
+        "action": "ui.press",
+        "test_id": "moonshine-live-clear",
+        "intent": "Clear the earlier transcript.",
+        "next": "press-prepare"
+      },
+      "press-prepare": {
+        "action": "ui.press",
+        "test_id": "moonshine-live-prepare-models",
+        "intent": "Load the Moonshine model for a new session.",
+        "next": "wait-model-ready"
+      },
+      "wait-model-ready": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify(globalThis.__AGENTIC__?.getPageState?.() || null)",
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "liveModelDownloaded",
+              "value": true
+            },
+            {
+              "operator": "eq",
+              "field": "isPreparingModels",
+              "value": false
+            },
+            {
+              "operator": "eq",
+              "field": "isBusy",
+              "value": false
+            },
+            {
+              "operator": "eq",
+              "field": "statusMessage",
+              "value": "Moonshine small is ready."
+            }
+          ]
+        },
+        "fail_when": {
+          "operator": "not_null",
+          "field": "error"
+        },
+        "poll": true,
+        "poll_ms": 2000,
+        "timeout_ms": 600000,
+        "intent": "The Moonshine model is loaded and ready.",
+        "next": "prove-model"
+      },
+      "prove-model": {
+        "action": "assert_output",
+        "source": "wait-model-ready",
+        "assert": {
+          "path": "$.statusMessage",
+          "operator": "eq",
+          "value": "Moonshine small is ready."
+        },
+        "proves": [
+          "model-load"
+        ],
+        "intent": "The Moonshine model loaded in the browser.",
+        "next": "press-start"
+      },
+      "press-start": {
+        "action": "ui.press",
+        "test_id": "moonshine-live-start",
+        "intent": "Start recording with live transcription.",
+        "next": "wait-recording"
+      },
+      "wait-recording": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify(globalThis.__AGENTIC__?.getPageState?.() || null)",
+        "assert": {
+          "operator": "eq",
+          "field": "isRecording",
+          "value": true
+        },
+        "fail_when": {
+          "operator": "not_null",
+          "field": "error"
+        },
+        "poll": true,
+        "poll_ms": 1000,
+        "timeout_ms": 120000,
+        "intent": "The live session is recording from the microphone.",
+        "next": "wait-live-transcript"
+      },
+      "wait-live-transcript": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){var s=globalThis.__AGENTIC__?.getPageState?.()||{};var t=[s.liveCommittedText,s.liveInterimText,s.finalTranscript].filter(Boolean).join(' ');return {isRecording:!!s.isRecording,error:s.error||null,liveCommittedLineCount:s.liveCommittedLineCount||0,liveInterimLineCount:s.liveInterimLineCount||0,text:t,hasJfkWord:/\\bfellow\\b/i.test(t)&&/\\bamerica(ns?)?\\b/i.test(t),finalTranscript:s.finalTranscript||null,recordingDurationMs:s.recordingDurationMs||0};})())",
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "isRecording",
+              "value": true
+            },
+            {
+              "operator": "eq",
+              "field": "hasJfkWord",
+              "value": true
+            }
+          ]
+        },
+        "fail_when": {
+          "operator": "not_null",
+          "field": "error"
+        },
+        "poll": true,
+        "poll_ms": 1000,
+        "timeout_ms": 180000,
+        "intent": "The live transcript shows words from the JFK speech fed to the microphone.",
+        "next": "prove-live-transcript"
+      },
+      "prove-live-transcript": {
+        "action": "assert_output",
+        "source": "wait-live-transcript",
+        "assert": {
+          "path": "$.hasJfkWord",
+          "operator": "eq",
+          "value": true
+        },
+        "proves": [
+          "live-transcription"
+        ],
+        "intent": "Live transcription produced JFK speech words while recording.",
+        "next": "reveal-live-transcript"
+      },
+      "reveal-live-transcript": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {visible:false};var e=[].slice.call(document.querySelectorAll('div,span')).find(function(d){return d.childElementCount===0&&(d.textContent||'').trim()===\"Live Transcript\"&&d.offsetParent!==null;});if(!e)return {visible:false};e.scrollIntoView({block:'start'});return {visible:true};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "visible",
+          "value": true
+        },
+        "poll": true,
+        "timeout_ms": 10000,
+        "intent": "Scroll the live transcript into view.",
+        "next": "shot-live"
+      },
+      "shot-live": {
+        "action": "ui.screenshot",
+        "path": "screenshots/moonshine-web-live.png",
+        "covers": [
+          "live-transcription"
+        ],
+        "label": "Moonshine live transcript while recording",
+        "intent": "Show the live transcript section during recording.",
+        "next": "press-stop"
+      },
+      "press-stop": {
+        "action": "ui.press",
+        "test_id": "moonshine-live-stop",
+        "intent": "Stop the live session.",
+        "next": "wait-stopped"
+      },
+      "wait-stopped": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){var s=globalThis.__AGENTIC__?.getPageState?.()||{};var t=[s.liveCommittedText,s.liveInterimText,s.finalTranscript].filter(Boolean).join(' ');var f=s.finalTranscript||'';return {isRecording:!!s.isRecording,isStopping:!!s.isStopping,isBusy:!!s.isBusy,error:s.error||null,statusMessage:s.statusMessage||null,liveCommittedLineCount:s.liveCommittedLineCount||0,liveInterimLineCount:s.liveInterimLineCount||0,text:t,hasJfkWord:/\\bfellow\\b/i.test(t)&&/\\bamerica(ns?)?\\b/i.test(t),finalTranscript:s.finalTranscript||null,finalHasJfkWord:/\\bfellow\\b/i.test(f)&&/\\bamerica(ns?)?\\b/i.test(f),recordingDurationMs:s.recordingDurationMs||0};})())",
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "isRecording",
+              "value": false
+            },
+            {
+              "operator": "eq",
+              "field": "isStopping",
+              "value": false
+            },
+            {
+              "operator": "eq",
+              "field": "isBusy",
+              "value": false
+            },
+            {
+              "operator": "gt",
+              "field": "recordingDurationMs",
+              "value": 0
+            },
+            {
+              "operator": "not_null",
+              "field": "finalTranscript"
+            }
+          ]
+        },
+        "fail_when": {
+          "operator": "not_null",
+          "field": "error"
+        },
+        "poll": true,
+        "poll_ms": 1000,
+        "timeout_ms": 120000,
+        "intent": "The session finishes stopping, keeps its recording and sets a final transcript.",
+        "next": "prove-stopped"
+      },
+      "prove-stopped": {
+        "action": "assert_output",
+        "source": "wait-stopped",
+        "assert": {
+          "path": "$.recordingDurationMs",
+          "operator": "gt",
+          "value": 0
+        },
+        "proves": [
+          "live-transcription"
+        ],
+        "intent": "The stopped session kept a recording with a duration.",
+        "next": "prove-final-transcript"
+      },
+      "prove-final-transcript": {
+        "action": "assert_output",
+        "source": "wait-stopped",
+        "assert": {
+          "path": "$.finalHasJfkWord",
+          "operator": "eq",
+          "value": true
+        },
+        "proves": [
+          "live-transcription"
+        ],
+        "intent": "The final transcript kept the JFK speech words.",
+        "next": "reveal-final-transcript"
+      },
+      "reveal-final-transcript": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {visible:false};var e=[].slice.call(document.querySelectorAll('div,span')).find(function(d){return d.childElementCount===0&&(d.textContent||'').trim()===\"Final Transcript\"&&d.offsetParent!==null;});if(!e)return {visible:false};e.scrollIntoView({block:'center'});return {visible:true};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "visible",
+          "value": true
+        },
+        "poll": true,
+        "timeout_ms": 10000,
+        "intent": "Scroll the final transcript into view.",
+        "next": "shot-stopped"
+      },
+      "shot-stopped": {
+        "action": "ui.screenshot",
+        "path": "screenshots/moonshine-web-stopped.png",
+        "covers": [
+          "live-transcription"
+        ],
+        "label": "Moonshine live screen after stop",
+        "intent": "Show the final transcript after the session stopped.",
+        "next": "done"
+      },
+      "done": {
+        "action": "end",
+        "status": "pass"
+      },
+      "restore": {
+        "action": "ui.navigate",
+        "path": "{{outputs.status.pathname}}",
+        "intent": "Return to the starting route.",
+        "next": "observe-restored"
+      },
+      "observe-restored": {
+        "action": "app.status",
+        "intent": "Read the route after restoring it.",
+        "next": "assert-restored"
+      },
+      "assert-restored": {
+        "action": "assert_output",
+        "source": "observe-restored",
+        "assert": {
+          "path": "$.pathname",
+          "operator": "eq",
+          "value": "{{outputs.status.pathname}}"
+        },
+        "proves": [
+          "restored"
+        ],
+        "intent": "The starting route is restored.",
+        "next": "cleanup-done"
+      },
+      "cleanup-done": {
+        "action": "end",
+        "status": "pass"
+      }
+    },
+    "teardown": "restore"
+  }
+}
diff --git a/scripts/agentic/recipe/recipes/sherpa/web-asr-validation.recipe.json b/scripts/agentic/recipe/recipes/sherpa/web-asr-validation.recipe.json
new file mode 100644
index 000000000..5be5e639d
--- /dev/null
+++ b/scripts/agentic/recipe/recipes/sherpa/web-asr-validation.recipe.json
@@ -0,0 +1,560 @@
+{
+  "$schema": "https://farmslot.io/schemas/recipe-v1.schema.json",
+  "title": "Sherpa voice web ASR: file and live microphone",
+  "description": "Web only. Transcribes the bundled JFK sample on the ASR screen with the web-preloaded streaming model, then switches to Live Mic and asserts the live transcript of the JFK speech fed to the microphone. Launch the browser with WEB_FAKE_AUDIO_FILE pointing at a JFK WAV. Labelled buttons are clicked through the DOM because react-native-web exposes no fiber roots to the label walker in sherpa.upgrade-audio-flows.",
+  "paramsSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "asr_model": {
+        "type": "string",
+        "default": "streaming-zipformer-en-general"
+      }
+    }
+  },
+  "proofTargets": [
+    {
+      "id": "file-asr",
+      "claim": "The web ASR model loads and transcribes the bundled JFK sample.",
+      "proofMode": "mixed"
+    },
+    {
+      "id": "sample-info",
+      "claim": "Selecting a bundled sample on web shows its real size and duration.",
+      "proofMode": "mixed"
+    },
+    {
+      "id": "live-asr",
+      "claim": "Live Mic transcribes the speech on the microphone while recording, and stops cleanly.",
+      "proofMode": "mixed"
+    },
+    {
+      "id": "restored",
+      "claim": "The run ends on the route it started from."
+    }
+  ],
+  "workflow": {
+    "entry": "prepare-ready",
+    "teardown": "restore",
+    "nodes": {
+      "prepare-ready": {
+        "action": "audiolab.query",
+        "ref": "sherpa.agentic_ready",
+        "assert": {
+          "operator": "not_null",
+          "field": "pathname"
+        },
+        "poll": true,
+        "timeout_ms": 90000,
+        "intent": "The sherpa-voice app is running with the agentic bridge installed.",
+        "next": "status"
+      },
+      "status": {
+        "action": "app.status",
+        "intent": "Read the starting route so teardown can restore it.",
+        "next": "reset-stack"
+      },
+      "reset-stack": {
+        "action": "audiolab.query",
+        "expression": "(function(){var A=globalThis.__AGENTIC__;if(!A||!A.canGoBack||!A.goBack){return Promise.resolve({status:'error',error:'bridge missing canGoBack/goBack'});}var n=0;return new Promise(function(resolve){function step(){if(!A.canGoBack()||n>=30){resolve({status:'reset',popped:n,atRoot:!A.canGoBack()});return;}A.goBack();n++;setTimeout(step,300);}step();});})()",
+        "async": true,
+        "timeout_ms": 20000,
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "status",
+              "value": "reset"
+            },
+            {
+              "operator": "eq",
+              "field": "atRoot",
+              "value": true
+            }
+          ]
+        },
+        "intent": "Pop earlier screens so the run starts from the root of the stack.",
+        "next": "nav-asr"
+      },
+      "nav-asr": {
+        "action": "ui.navigate",
+        "path": "/features/asr",
+        "intent": "Open the speech recognition screen.",
+        "next": "assert-single-screen"
+      },
+      "read-asr": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify(globalThis.__AGENTIC__?.getPageState?.() || null)",
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "route",
+              "value": "/features/asr"
+            },
+            {
+              "operator": "eq",
+              "field": "isRecording",
+              "value": false
+            }
+          ]
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "The ASR screen is shown and not recording.",
+        "next": "choose-file-mode"
+      },
+      "assert-single-screen": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify({pickers: typeof document==='undefined'?-1:document.querySelectorAll('[data-testid=model-picker-list]').length})",
+        "assert": {
+          "operator": "eq",
+          "field": "pickers",
+          "value": 1
+        },
+        "poll": true,
+        "timeout_ms": 10000,
+        "intent": "Exactly one ASR screen is mounted.",
+        "next": "read-asr"
+      },
+      "choose-file-mode": {
+        "action": "audiolab.choose",
+        "intent": "Switch to file mode when the screen opened in live mode.",
+        "rules": [
+          {
+            "operator": "eq",
+            "field": "last.mode",
+            "value": "live"
+          }
+        ],
+        "cases": {
+          "case-0": "press-file-mode"
+        },
+        "default": "select-model"
+      },
+      "press-file-mode": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {status:'no-dom'};var els=[].slice.call(document.querySelectorAll('[role=button],button,[tabindex]')).filter(function(e){return e.offsetParent!==null&&(e.textContent||'').trim()===\"File\";});if(!els.length)return {status:'not-found',label:\"File\"};els[els.length-1].click();return {status:'clicked',label:\"File\"};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "clicked"
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "Switch the screen to file mode.",
+        "next": "select-model"
+      },
+      "select-model": {
+        "action": "ui.press",
+        "test_id": "model-option-{{params.asr_model}}",
+        "intent": "Pick the web streaming English model.",
+        "next": "read-init"
+      },
+      "read-init": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify(globalThis.__AGENTIC__?.getPageState?.() || null)",
+        "assert": {
+          "operator": "eq",
+          "field": "mode",
+          "value": "file"
+        },
+        "poll": true,
+        "timeout_ms": 10000,
+        "intent": "File mode is active with the model selected.",
+        "next": "choose-init"
+      },
+      "choose-init": {
+        "action": "audiolab.choose",
+        "intent": "Initialize the model unless it is already loaded.",
+        "rules": [
+          {
+            "operator": "eq",
+            "field": "last.initialized",
+            "value": true
+          }
+        ],
+        "cases": {
+          "case-0": "choose-file-after-init"
+        },
+        "default": "press-init"
+      },
+      "press-init": {
+        "action": "ui.press",
+        "test_id": "btn-init-asr",
+        "intent": "Initialize the selected model.",
+        "next": "wait-initialized"
+      },
+      "wait-initialized": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify(globalThis.__AGENTIC__?.getPageState?.() || null)",
+        "assert": {
+          "operator": "eq",
+          "field": "initialized",
+          "value": true
+        },
+        "fail_when": {
+          "operator": "not_null",
+          "field": "error"
+        },
+        "poll": true,
+        "poll_ms": 1000,
+        "timeout_ms": 300000,
+        "intent": "The model is loaded in the browser.",
+        "next": "choose-file-after-init"
+      },
+      "choose-file-after-init": {
+        "action": "audiolab.choose",
+        "intent": "Return to file mode if the screen restored live mode while loading.",
+        "rules": [
+          {
+            "operator": "eq",
+            "field": "last.mode",
+            "value": "live"
+          }
+        ],
+        "cases": {
+          "case-0": "press-file-after-init"
+        },
+        "default": "wait-audio-option"
+      },
+      "press-file-after-init": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {status:'no-dom'};var els=[].slice.call(document.querySelectorAll('[role=button],button,[tabindex]')).filter(function(e){return e.offsetParent!==null&&(e.textContent||'').trim()===\"File\";});if(!els.length)return {status:'not-found',label:\"File\"};els[els.length-1].click();return {status:'clicked',label:\"File\"};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "clicked"
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "Switch back to file mode.",
+        "next": "wait-audio-option"
+      },
+      "wait-audio-option": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify({visible: !!globalThis.__AGENTIC__?.findFiberByTestId?.('audio-option-1')})",
+        "assert": {
+          "operator": "eq",
+          "field": "visible",
+          "value": true
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "The bundled samples are listed.",
+        "next": "select-audio"
+      },
+      "select-audio": {
+        "action": "ui.press",
+        "test_id": "audio-option-1",
+        "intent": "Pick the bundled JFK speech sample.",
+        "next": "wait-sample-info"
+      },
+      "wait-sample-info": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {hasSize:false,hasDuration:false};var t=document.body.innerText||'';var size=(t.match(/Size: ([^\\n]+)/)||[])[1]||null;var dur=(t.match(/Duration: ([^\\n]+)/)||[])[1]||null;return {sizeText:size,durationText:dur,hasSize:!!size&&size.trim()!=='0 Bytes',hasDuration:!!dur&&dur.trim()!=='0:00'};})())",
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "hasSize",
+              "value": true
+            },
+            {
+              "operator": "eq",
+              "field": "hasDuration",
+              "value": true
+            }
+          ]
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "The sample card shows the real file size and duration.",
+        "next": "prove-sample-info"
+      },
+      "prove-sample-info": {
+        "action": "assert_output",
+        "source": "wait-sample-info",
+        "assert": {
+          "path": "$.hasSize",
+          "operator": "eq",
+          "value": true
+        },
+        "proves": [
+          "sample-info"
+        ],
+        "intent": "The web sample card reports a non-zero size.",
+        "next": "press-recognize"
+      },
+      "press-recognize": {
+        "action": "ui.press",
+        "test_id": "btn-recognize",
+        "intent": "Recognize the selected sample.",
+        "next": "wait-transcript"
+      },
+      "wait-transcript": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){var s=globalThis.__AGENTIC__?.getPageState?.()||{};var t=[s.recognitionResult].filter(Boolean).join(' ');return {mode:s.mode,initialized:!!s.initialized,isRecording:!!s.isRecording,error:s.error||null,text:t,hasJfkWords:/country/i.test(t)&&/americans/i.test(t)};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "hasJfkWords",
+          "value": true
+        },
+        "fail_when": {
+          "operator": "not_null",
+          "field": "error"
+        },
+        "poll": true,
+        "poll_ms": 1000,
+        "timeout_ms": 120000,
+        "intent": "The displayed transcript holds the JFK sentence.",
+        "next": "prove-transcript"
+      },
+      "prove-transcript": {
+        "action": "assert_output",
+        "source": "wait-transcript",
+        "assert": {
+          "path": "$.hasJfkWords",
+          "operator": "eq",
+          "value": true
+        },
+        "proves": [
+          "file-asr"
+        ],
+        "intent": "The file transcript contains \"americans\" and \"country\".",
+        "next": "reveal-transcript"
+      },
+      "reveal-transcript": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){var e=typeof document!=='undefined'&&document.querySelector('[data-testid=text-recognition-result]');if(!e)return {visible:false};e.scrollIntoView({block:'center'});return {visible:true};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "visible",
+          "value": true
+        },
+        "poll": true,
+        "timeout_ms": 10000,
+        "intent": "Scroll the transcript into view.",
+        "next": "shot-transcript"
+      },
+      "shot-transcript": {
+        "action": "ui.screenshot",
+        "path": "screenshots/sherpa-web-asr-file.png",
+        "covers": [
+          "file-asr"
+        ],
+        "label": "JFK sample transcript",
+        "intent": "Show the file transcript on screen.",
+        "next": "press-live-mode"
+      },
+      "press-live-mode": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {status:'no-dom'};var els=[].slice.call(document.querySelectorAll('[role=button],button,[tabindex]')).filter(function(e){return e.offsetParent!==null&&(e.textContent||'').trim()===\"Live Mic\";});if(!els.length)return {status:'not-found',label:\"Live Mic\"};els[els.length-1].click();return {status:'clicked',label:\"Live Mic\"};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "clicked"
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "Switch the screen to live microphone mode.",
+        "next": "read-live"
+      },
+      "read-live": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify(globalThis.__AGENTIC__?.getPageState?.() || null)",
+        "assert": {
+          "operator": "eq",
+          "field": "mode",
+          "value": "live"
+        },
+        "poll": true,
+        "timeout_ms": 10000,
+        "intent": "Live mode is active.",
+        "next": "choose-live-init"
+      },
+      "choose-live-init": {
+        "action": "audiolab.choose",
+        "intent": "Initialize again if switching modes released the model.",
+        "rules": [
+          {
+            "operator": "eq",
+            "field": "last.initialized",
+            "value": true
+          }
+        ],
+        "cases": {
+          "case-0": "press-start-listening"
+        },
+        "default": "press-init-live"
+      },
+      "press-init-live": {
+        "action": "ui.press",
+        "test_id": "btn-init-asr",
+        "intent": "Initialize the model for live mode.",
+        "next": "wait-live-initialized"
+      },
+      "wait-live-initialized": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify(globalThis.__AGENTIC__?.getPageState?.() || null)",
+        "assert": {
+          "operator": "eq",
+          "field": "initialized",
+          "value": true
+        },
+        "fail_when": {
+          "operator": "not_null",
+          "field": "error"
+        },
+        "poll": true,
+        "poll_ms": 1000,
+        "timeout_ms": 300000,
+        "intent": "The model is loaded for live mode.",
+        "next": "press-start-listening"
+      },
+      "press-start-listening": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {status:'no-dom'};var els=[].slice.call(document.querySelectorAll('[role=button],button,[tabindex]')).filter(function(e){return e.offsetParent!==null&&(e.textContent||'').trim()===\"Start Listening\";});if(!els.length)return {status:'not-found',label:\"Start Listening\"};els[els.length-1].click();return {status:'clicked',label:\"Start Listening\"};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "clicked"
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "Start listening on the microphone.",
+        "next": "wait-live-transcript"
+      },
+      "wait-live-transcript": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){var s=globalThis.__AGENTIC__?.getPageState?.()||{};var t=[s.committedText,s.interimText].filter(Boolean).join(' ');return {mode:s.mode,initialized:!!s.initialized,isRecording:!!s.isRecording,error:s.error||null,text:t,hasJfkWords:/country/i.test(t)&&/americans/i.test(t)};})())",
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "isRecording",
+              "value": true
+            },
+            {
+              "operator": "eq",
+              "field": "hasJfkWords",
+              "value": true
+            }
+          ]
+        },
+        "fail_when": {
+          "operator": "not_null",
+          "field": "error"
+        },
+        "poll": true,
+        "poll_ms": 1000,
+        "timeout_ms": 90000,
+        "intent": "The live transcript shows the JFK speech heard on the microphone.",
+        "next": "prove-live"
+      },
+      "prove-live": {
+        "action": "assert_output",
+        "source": "wait-live-transcript",
+        "assert": {
+          "path": "$.hasJfkWords",
+          "operator": "eq",
+          "value": true
+        },
+        "proves": [
+          "live-asr"
+        ],
+        "intent": "Live transcription produced \"americans\" and \"country\" while recording.",
+        "next": "shot-live"
+      },
+      "shot-live": {
+        "action": "ui.screenshot",
+        "path": "screenshots/sherpa-web-asr-live.png",
+        "covers": [
+          "live-asr"
+        ],
+        "label": "Live Mic transcript",
+        "intent": "Show the live transcript while listening.",
+        "next": "press-stop-listening"
+      },
+      "press-stop-listening": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {status:'no-dom'};var els=[].slice.call(document.querySelectorAll('[role=button],button,[tabindex]')).filter(function(e){return e.offsetParent!==null&&(e.textContent||'').trim()===\"Stop Listening\";});if(!els.length)return {status:'not-found',label:\"Stop Listening\"};els[els.length-1].click();return {status:'clicked',label:\"Stop Listening\"};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "clicked"
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "Stop listening.",
+        "next": "wait-stopped"
+      },
+      "wait-stopped": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify(globalThis.__AGENTIC__?.getPageState?.() || null)",
+        "assert": {
+          "operator": "eq",
+          "field": "isRecording",
+          "value": false
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "The microphone session stops.",
+        "next": "prove-stopped"
+      },
+      "prove-stopped": {
+        "action": "assert_output",
+        "source": "wait-stopped",
+        "assert": {
+          "path": "$.isRecording",
+          "operator": "eq",
+          "value": false
+        },
+        "proves": [
+          "live-asr"
+        ],
+        "intent": "Recording is off after stopping.",
+        "next": "press-release"
+      },
+      "press-release": {
+        "action": "ui.press",
+        "test_id": "btn-release-asr",
+        "intent": "Release the speech model.",
+        "next": "done"
+      },
+      "done": {
+        "action": "end",
+        "status": "pass"
+      },
+      "restore": {
+        "action": "ui.navigate",
+        "path": "{{outputs.status.pathname}}",
+        "intent": "Return to the starting route.",
+        "next": "observe-restored"
+      },
+      "observe-restored": {
+        "action": "app.status",
+        "intent": "Read the route after restoring it.",
+        "next": "assert-restored"
+      },
+      "assert-restored": {
+        "action": "assert_output",
+        "source": "observe-restored",
+        "assert": {
+          "path": "$.pathname",
+          "operator": "eq",
+          "value": "{{outputs.status.pathname}}"
+        },
+        "proves": [
+          "restored"
+        ],
+        "intent": "The starting route is restored.",
+        "next": "cleanup-done"
+      },
+      "cleanup-done": {
+        "action": "end",
+        "status": "pass"
+      }
+    }
+  }
+}
diff --git a/scripts/agentic/recipe/recipes/sherpa/web-tts-validation.recipe.json b/scripts/agentic/recipe/recipes/sherpa/web-tts-validation.recipe.json
new file mode 100644
index 000000000..642fe366c
--- /dev/null
+++ b/scripts/agentic/recipe/recipes/sherpa/web-tts-validation.recipe.json
@@ -0,0 +1,233 @@
+{
+  "$schema": "https://farmslot.io/schemas/recipe-v1.schema.json",
+  "title": "Sherpa voice web TTS: initialize and generate",
+  "description": "Web only. Initializes the web-preloaded vits-icefall-en-low voice on the TTS screen, generates speech from the default text and asserts generateSpeech reports success. Needs tts/lexicon-en-us.txt hosted next to the voice files; until then initialization fails with \"Failed to load TTS model files: <lexicon url>\".",
+  "proofTargets": [
+    {
+      "id": "tts",
+      "claim": "The web TTS voice initializes and generates speech.",
+      "proofMode": "mixed"
+    },
+    {
+      "id": "restored",
+      "claim": "The run ends on the route it started from."
+    }
+  ],
+  "workflow": {
+    "entry": "prepare-ready",
+    "teardown": "restore",
+    "nodes": {
+      "prepare-ready": {
+        "action": "audiolab.query",
+        "ref": "sherpa.agentic_ready",
+        "assert": {
+          "operator": "not_null",
+          "field": "pathname"
+        },
+        "poll": true,
+        "timeout_ms": 90000,
+        "intent": "The sherpa-voice app is running with the agentic bridge installed.",
+        "next": "status"
+      },
+      "status": {
+        "action": "app.status",
+        "intent": "Read the starting route so teardown can restore it.",
+        "next": "reset-stack"
+      },
+      "reset-stack": {
+        "action": "audiolab.query",
+        "expression": "(function(){var A=globalThis.__AGENTIC__;if(!A||!A.canGoBack||!A.goBack){return Promise.resolve({status:'error',error:'bridge missing canGoBack/goBack'});}var n=0;return new Promise(function(resolve){function step(){if(!A.canGoBack()||n>=30){resolve({status:'reset',popped:n,atRoot:!A.canGoBack()});return;}A.goBack();n++;setTimeout(step,300);}step();});})()",
+        "async": true,
+        "timeout_ms": 20000,
+        "assert": {
+          "all": [
+            {
+              "operator": "eq",
+              "field": "status",
+              "value": "reset"
+            },
+            {
+              "operator": "eq",
+              "field": "atRoot",
+              "value": true
+            }
+          ]
+        },
+        "intent": "Pop earlier screens so the run starts from the root of the stack.",
+        "next": "nav-tts"
+      },
+      "nav-tts": {
+        "action": "ui.navigate",
+        "path": "/features/tts",
+        "intent": "Open the text-to-speech screen.",
+        "next": "read-tts"
+      },
+      "read-tts": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify(globalThis.__AGENTIC__?.getPageState?.() || null)",
+        "assert": {
+          "operator": "eq",
+          "field": "selectedModelId",
+          "value": "vits-icefall-en-low"
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "The TTS screen shows the web voice.",
+        "next": "choose-init"
+      },
+      "choose-init": {
+        "action": "audiolab.choose",
+        "intent": "Initialize the voice unless it is already loaded.",
+        "rules": [
+          {
+            "operator": "eq",
+            "field": "last.ttsInitialized",
+            "value": true
+          }
+        ],
+        "cases": {
+          "case-0": "press-generate"
+        },
+        "default": "press-init"
+      },
+      "press-init": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {status:'no-dom'};var els=[].slice.call(document.querySelectorAll('[role=button],button,[tabindex]')).filter(function(e){return e.offsetParent!==null&&(e.textContent||'').trim()===\"Initialize TTS\";});if(!els.length)return {status:'not-found',label:\"Initialize TTS\"};els[els.length-1].click();return {status:'clicked',label:\"Initialize TTS\"};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "clicked"
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "Initialize text-to-speech.",
+        "next": "wait-initialized"
+      },
+      "wait-initialized": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify(globalThis.__AGENTIC__?.getPageState?.() || null)",
+        "assert": {
+          "operator": "eq",
+          "field": "ttsInitialized",
+          "value": true
+        },
+        "fail_when": {
+          "operator": "not_null",
+          "field": "errorMessage"
+        },
+        "poll": true,
+        "poll_ms": 1000,
+        "timeout_ms": 300000,
+        "intent": "The voice is loaded in the browser.",
+        "next": "shot-initialized"
+      },
+      "shot-initialized": {
+        "action": "ui.screenshot",
+        "path": "screenshots/sherpa-web-tts-initialized.png",
+        "covers": [
+          "tts"
+        ],
+        "label": "TTS initialized",
+        "intent": "Show the initialized voice.",
+        "next": "press-generate"
+      },
+      "press-generate": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify((function(){if(typeof document==='undefined')return {status:'no-dom'};var els=[].slice.call(document.querySelectorAll('[role=button],button,[tabindex]')).filter(function(e){return e.offsetParent!==null&&(e.textContent||'').trim()===\"Generate Speech\";});if(!els.length)return {status:'not-found',label:\"Generate Speech\"};els[els.length-1].click();return {status:'clicked',label:\"Generate Speech\"};})())",
+        "assert": {
+          "operator": "eq",
+          "field": "status",
+          "value": "clicked"
+        },
+        "poll": true,
+        "timeout_ms": 15000,
+        "intent": "Generate speech from the default text.",
+        "next": "wait-generated"
+      },
+      "wait-generated": {
+        "action": "audiolab.query",
+        "expression": "JSON.stringify(globalThis.__AGENTIC__?.getPageState?.() || null)",
+        "assert": {
+          "all": [
+            {
+              "operator": "matches",
+              "field": "statusMessage",
+              "value": "^Speech (played|generated) successfully!$"
+            },
+            {
+              "operator": "eq",
+              "field": "isLoading",
+              "value": false
+            }
+          ]
+        },
+        "fail_when": {
+          "operator": "not_null",
+          "field": "errorMessage"
+        },
+        "poll": true,
+        "poll_ms": 1000,
+        "timeout_ms": 120000,
+        "intent": "generateSpeech returned success and playback finished.",
+        "next": "prove-generated"
+      },
+      "prove-generated": {
+        "action": "assert_output",
+        "source": "wait-generated",
+        "assert": {
+          "path": "$.statusMessage",
+          "operator": "matches",
+          "value": "^Speech (played|generated) successfully!$"
+        },
+        "proves": [
+          "tts"
+        ],
+        "intent": "generateSpeech returned success and the app reported it.",
+        "next": "shot-generated"
+      },
+      "shot-generated": {
+        "action": "ui.screenshot",
+        "path": "screenshots/sherpa-web-tts-generated.png",
+        "covers": [
+          "tts"
+        ],
+        "label": "Generated speech",
+        "intent": "Show the generated speech result.",
+        "next": "done"
+      },
+      "done": {
+        "action": "end",
+        "status": "pass"
+      },
+      "restore": {
+        "action": "ui.navigate",
+        "path": "{{outputs.status.pathname}}",
+        "intent": "Return to the starting route.",
+        "next": "observe-restored"
+      },
+      "observe-restored": {
+        "action": "app.status",
+        "intent": "Read the route after restoring it.",
+        "next": "assert-restored"
+      },
+      "assert-restored": {
+        "action": "assert_output",
+        "source": "observe-restored",
+        "assert": {
+          "path": "$.pathname",
+          "operator": "eq",
+          "value": "{{outputs.status.pathname}}"
+        },
+        "proves": [
+          "restored"
+        ],
+        "intent": "The starting route is restored.",
+        "next": "cleanup-done"
+      },
+      "cleanup-done": {
+        "action": "end",
+        "status": "pass"
+      }
+    }
+  }
+}
diff --git a/scripts/agentic/web-browser.mjs b/scripts/agentic/web-browser.mjs
index c447da895..f73b6e91b 100755
--- a/scripts/agentic/web-browser.mjs
+++ b/scripts/agentic/web-browser.mjs
@@ -35,13 +35,14 @@
  *   WEB_STARTUP_TIMEOUT  Overall startup budget in ms (default: all stage budgets and retries)
  *   WEB_BROWSER_PID_FILE  Chrome PID path for the farm's ownership watch
  *   CDP_PORT        Chrome remote debugging port (default: 9222)
+ *   WEB_FAKE_AUDIO_FILE  PCM WAV fed to getUserMedia instead of the real mic (loops)
  *
  * Known limitation — live microphone on macOS:
  *   macOS TCC (privacy framework) attributes getUserMedia requests to the
  *   process that spawned Chrome (node), not to the Chrome bundle itself.
  *   The permission is silently denied and the audio stream produces silence.
- *   File-based audio testing works fine. For live mic validation use a
- *   regular browser session opened manually.
+ *   File-based audio testing works fine. For live mic validation set
+ *   WEB_FAKE_AUDIO_FILE, or use a regular browser session opened manually.
  */
 
 import path from 'node:path';
@@ -279,6 +280,18 @@ async function cmdLaunch() {
     '--use-fake-ui-for-media-stream',
     '--autoplay-policy=no-user-gesture-required',
   ];
+  if (process.env.WEB_FAKE_AUDIO_FILE) {
+    const fakeAudio = path.resolve(process.env.WEB_FAKE_AUDIO_FILE);
+    // Chrome silently captures silence for a missing file, so fail before launching.
+    if (!fs.existsSync(fakeAudio)) {
+      console.error(`WEB_FAKE_AUDIO_FILE not found: ${fakeAudio}`);
+      process.exit(1);
+    }
+    launchArgs.push(
+      '--use-fake-device-for-media-stream',
+      `--use-file-for-fake-audio-capture=${fakeAudio}`,
+    );
+  }
   const launchOptions = {
     headless: HEADLESS,
     args: launchArgs,