arcane-os 0.46.0 → 0.47.0

package/docs/reference/inventory/package-api.json

@@ -3134,6 +3134,20 @@
       "protocol": "arcane-ai-provider/2 tts/synthesize",
       "normalization": "Construction and activation make no adapter network requests. SDK initial POSTs bypass the provider-local js-queue; follow-up status/result/audio GETs use followUpQueue capacity and cadence through complete body consumption. Retry-After affects only its job. Whole-job maxConcurrentRequests remains independent. Local Kokoro and Whisper paths are unchanged. Applications own model, voice, credentials, activation, and queue settings."
     },
+    {
+      "id": "browser-speech:createBrowserSpeechRecognitionProvider",
+      "name": "createBrowserSpeechRecognitionProvider",
+      "displayName": "createBrowserSpeechRecognitionProvider()",
+      "kind": "function",
+      "signature": "createBrowserSpeechRecognitionProvider({id,model,language}={})",
+      "entrypoints": ["arcane-os/ai/browser-speech"],
+      "primaryImport": "arcane-os/ai/browser-speech",
+      "group": "Browser speech providers",
+      "summary": "Creates an explicitly selected native browser speech recognition provider with gesture-started live capture.",
+      "availability": "Browser or WebView exposing SpeechRecognition or webkitSpeechRecognition; construction remains available on unsupported hosts",
+      "protocol": "arcane-ai-provider/2 stt with optional createCapture",
+      "normalization": "Non-local service declaration, independent STT lifecycle, exact final segments, transient interim results, graceful stop/drain and native abort. No model download, storage, microphone on activation, file-transcription emulation, or automatic fallback."
+    },
     {
       "id": "browser-speech:createBrowserKokoroProvider",
       "name": "createBrowserKokoroProvider",

package/docs/reference/runtime-components.md

@@ -1629,6 +1629,16 @@ Events: `source-explanation-ready`, `source-explanation-save`, `source-explanati
 
 ## speech.html
 
+An explicitly selected native Web Speech provider uses gesture-started live
+capture instead of MediaRecorder. The shared control retains every final
+result and emits its existing completion event once with the exact combined
+text when native capture ends. The live display retains final words alongside
+interim hypotheses while speaking; interim hypotheses stay transient. Release/Stop
+finishes native recognition; cancellation, replacement and destruction abort
+it and suppress late submission. A persisted page hide stops live native capture
+without restarting it when the page returns. Existing Whisper and TTS paths
+remain unchanged.
+
 ### Overview
 
 Coordinates explicit speech-to-text activation, speech controls, transcription
@@ -2083,6 +2093,19 @@ Native methods remain subject to the bound app's capabilities. [Deep protocol de
 
 ### Continuous capture and controls
 
+An explicitly selected native Web Speech provider uses the same ordered
+transcript/save queue in either capture mode. Each complete final text segment
+skips file transcription and enters the existing append/save stages; interim
+text stays in the transient `interim` part and never reaches a save or success
+event. Final segments waiting behind a save stay visible there until appended
+to the main transcript. Native `stopRecording()` returns the drain promise, including final
+results emitted during native stop. Browser `end` stops capture without an
+automatic restart. Provider replacement stops native capture while already
+accepted final segments retain their ordered saves. Explicit Cancel, transcript
+replacement and destruction retain the existing supersession behavior.
+This path does not require AudioWorklet or MediaRecorder. A supplied custom
+`transcribe(file,context)` callback keeps the existing audio-clip route.
+
 `configure({capture:{mode:'continuous'}})` opts into the SDK's
 [`ContinuousVoiceCapture`](runtime-modules.md#continuousvoicecapturejs) owner.
 The default capture settings are `preRollMs:1500`, `quietMs:2000`,

package/docs/reference/runtime-modules.md

@@ -275,8 +275,9 @@ tool declarations, emitted tool calls, or callback ordering.
 `configureSpeechProviders({stt,tts})` commits only the two speech routes and
 leaves the current LLM route and sticky lifecycle record unchanged. Both speech
 roles must be unloaded and own no request, load, unload, or dispose operation.
-STT remains local-only (`AI_STT_DEVICE_ONLY` for a remote selection); an
-explicit TTS provider may declare `localOnly:false`.
+File-based STT remains local-only (`AI_STT_DEVICE_ONLY` for an unsupported
+remote file selection). An explicitly selected native live-capture STT provider
+or TTS provider may declare `localOnly:false`.
 `transitionSpeechProviders({stt,tts})` stops queued audio, explicitly unloads
 only STT and TTS, then commits that same closed speech route record. Neither
 method loads a model, selects a fallback, or changes caller-owned model or voice
@@ -302,6 +303,13 @@ cancels that pending unmute. The application keeps model, voice, and credential
 selection. See [DigitalOcean FAL speech](ai/browser-speech.md#digitalocean-fal-text-to-speech)
 for the public remote adapter and completed-job audio transport.
 
+`supportsTranscriptionCapture()` reports whether the selected STT provider
+offers native live capture. `createTranscriptionCapture(options={})` delegates
+to the provider runtime's owned capture boundary below and returns `null` for
+file-only providers. Shared speech controls select it automatically; apps keep
+using their existing controls and completion/save callbacks. See
+[native browser recognition](ai/browser-speech.md#native-browser-speech-recognition).
+
 `startProviders({startLanguageModel=true,startMuted=true,startTranscription=false,signal=null}={})`
 starts provider-owned text chat without requesting an STT load by default.
 Callers selecting a browser-WASM LLM pass `startLanguageModel:false` so it
@@ -961,6 +969,8 @@ The singleton exposes read-only `protocol`, `configured`, and `speechMuted`;
 `request(role,options={},preparation={})`;
 `chat(payload,options={})`; `stream(payload,options={})`;
 `transcribe(payload,options={})`;
+`supportsTranscriptionCapture(providerId=null)`;
+`createTranscriptionCapture(options={})`;
 `synthesize(payload,options={},preparation={})`; and
 `setSpeechMuted(muted)`. Provider payloads must be data-only; callbacks,
 accessors, symbols, and cycles are rejected at the provider boundary.
@@ -1099,6 +1109,24 @@ cleanup are normalized, while the
 selected provider retains its own capability, permission, download, and model
 requirements. [Deep protocol details](protocols.md#portable-ai-provider-runtime).
 
+STT providers may additionally implement `createCapture(options)`. Registration
+retains that optional method without changing the required provider/2 methods.
+`supportsTranscriptionCapture(providerId=null)` checks the current selection by
+default or a specified registered STT provider without starting it.
+`createTranscriptionCapture({language,continuous,onSegment,onInterim,onState,onError})`
+returns `null` for a provider without that method; otherwise it returns
+`{start,stop,cancel,destroy,done}`. Creation has no microphone side effect.
+`start({signal})` requires the same selected ready provider with an idle STT
+lane and invokes its capture start synchronously in the caller's gesture.
+Capture occupies one active STT request until its `done` promise settles;
+ordinary file requests remain queued, and unload/dispose/cancel use the same
+owned request cancellation lifecycle. Stop drains native final recognition;
+cancel suppresses late callbacks. Provider callbacks carry exact final
+`{text,sequence}` segments, transient `{text}` interim results, capture state,
+or complete errors. The browser provider's `done` resolves a success boolean;
+runtime cleanup errors remain observable as rejection. No callback is inserted
+into a data-only transcription request payload.
+
 ### Example
 
 ```javascript

package/docs/reference/sdk-api.md

@@ -169,6 +169,7 @@ browser map are cataloged separately in [Runtime modules](runtime-modules.md).
 | `createBrowserSpeechAuthority()` | function | `arcane-os/ai/browser-speech` | Browser speech providers | Browser descriptor construction; use requires the selected storage and provider Web APIs |
 | `createBrowserWasmLlmProvider()` | function | `arcane-os/ai/browser-wasm` | Browser-WASM local AI | Browser context with WebAssembly and OPFS/DBOPFS; WebGPU by default or explicit CPU with gpuLayers:0 |
 | `createBrowserWhisperProvider()` | function | `arcane-os/ai/browser-speech` | Browser speech providers | Browser with Workers, object URLs, caller-selected Whisper runtime/model artifacts, and an SDK DBOPFS speech store |
+| `createBrowserSpeechRecognitionProvider()` | function | `arcane-os/ai/browser-speech` | Browser speech providers | Browser or WebView with native SpeechRecognition; construction and catalog remain available on unsupported hosts |
 | `createCanonicalUstarHeader()` | function | `arcane-os` | Packaging and release bundles | Node |
 | `createDbopfsModelStore()` | function | `arcane-os/ai/browser-wasm` | Browser-WASM local AI | Browser with a ready DBOPFS instance and OPFS |
 | `getBrowserDeviceClass()` | function | `arcane-os/browser-device` | Browser device settings | Node and Browser; synchronous identity hint with no model, storage, or GPU operation |
@@ -7185,6 +7186,62 @@ async function transcribeAfterUserChoice(audioBlob) {
 }
 ```
 
+## createBrowserSpeechRecognitionProvider()
+
+### Overview
+
+Creates an explicitly selected provider/2 STT adapter for the browser's native
+`SpeechRecognition` or `webkitSpeechRecognition` service. It declares
+`localOnly:false` because recognition may use a remote browser service. It does
+not change Whisper, TTS, typing, stored preferences, or any default selection.
+
+### Signature and result
+
+```text
+createBrowserSpeechRecognitionProvider({id,model,language}={})
+```
+
+The application supplies its provider `id` and `model:{id}`; optional `language`
+is passed to native recognition without changing transcript text. The provider
+implements the required `catalog`, `inspect`, `status`, `load`, `request`,
+`unload`, and `dispose` methods plus `createCapture(options)`. There is no SDK
+model download or storage. Construction/catalog do not require native support;
+inspect/load report actual browser availability without opening a microphone.
+File transcription requests are unsupported for this provider.
+
+`createCapture({language,continuous,onSegment,onInterim,onState,onError})`
+returns a single-use `{start,stop,cancel,destroy,done}` handle. Start must be
+called directly from a user gesture and returns a promise for startup success.
+Final callbacks carry exact `{text,sequence}` values once per final result;
+interim `{text}` stays transient. Stop preserves pending native final results
+through `end`; cancellation aborts recognition and suppresses late text.
+`done` resolves `true` for normal native end and `false` for cancellation or
+failure. Unload/dispose cancel owned capture.
+The shared runtime's `createTranscriptionCapture()` additionally owns STT busy
+state and lifecycle replacement. See the
+[complete native capture contract](ai/browser-speech.md#native-browser-speech-recognition).
+
+### Availability and normalization
+
+Conditional browser/native-WebView support on Windows, Linux, macOS and
+Android, determined by the actual browser API and permission/service outcome,
+not by operating-system name. Missing API, denied microphone permission and
+service errors remain honest STT failures without disabling TTS or typing.
+No Core, Whisper, or cloud-provider fallback is inferred.
+
+### Example
+
+```javascript
+import {createBrowserSpeechRecognitionProvider} from 'arcane-os/ai/browser-speech';
+
+async function selectNativeRecognition(ai, signal) {
+    const provider = createBrowserSpeechRecognitionProvider(
+        {id: 'WEB_SPEECH', model: {id: 'WEB_SPEECH'}}
+    );
+    return ai.configureSpeechProvider('stt', provider, {modelId: 'WEB_SPEECH', signal});
+}
+```
+
 ## createTwinCloudTTSProvider()
 
 ### Overview

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.46.0",
+  "version": "0.47.0",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",

package/runtime/arcane/components/speech.html

@@ -191,6 +191,7 @@
         }
     );
     const aiModuleImport = import('../modules/AI.js');
+    const providerRuntimeImport = import('../modules/AIProviderRuntime.js');
     const {
         requestAIRuntimeIntent,
         subscribeAIRuntimeState
@@ -200,6 +201,8 @@
         formatAIRuntimeProgress
     } = await import('../modules/ComponentContracts.js');
     const {getBrowserDeviceClass} = await browserDeviceImport;
+    const {getAIProviderRuntime} = await providerRuntimeImport;
+    const providerRuntime = getAIProviderRuntime();
 
     const host = this;
     const deviceClass = getBrowserDeviceClass();
@@ -237,6 +240,7 @@
     let microphonePermissionStatus = null;
     let microphonePermissionListener = null;
     let captureSession = null;
+    let nativeCaptureSession = null;
     let recordingRequested = false;
     let recordingGeneration = 0;
     let transcriptionGeneration = 0;
@@ -362,8 +366,8 @@
     host.setMuted = setMuted;
     host.availability = {
         microphone: transcriptionEnabled && Boolean(
-            navigator.mediaDevices?.getUserMedia
-            && globalThis.MediaRecorder
+            (navigator.mediaDevices?.getUserMedia && globalThis.MediaRecorder)
+            || globalThis.SpeechRecognition || globalThis.webkitSpeechRecognition
         ),
         stt: false,
         tts: false
@@ -626,24 +630,25 @@
         }
         const transcriptionReady = sttRole.state === 'ready';
         const microphoneReady = host.availability.microphone
-            && is.function(globalThis.MediaRecorder)
-            && is.function(navigator.mediaDevices?.getUserMedia);
+            && (providerRuntime.supportsTranscriptionCapture()
+                || (is.function(globalThis.MediaRecorder)
+                    && is.function(navigator.mediaDevices?.getUserMedia)));
         const activationVisible = sttActivationController.visible;
         recordButton.hidden = activationVisible;
         recordButton.disabled = !transcriptionReady
             || !microphoneReady
-            || sttRole.busy
+            || (sttRole.busy && !nativeCaptureSession)
             || transcriptionActive
             || destroyed;
         stopButton.disabled = destroyed
             || !transcriptionReady
-            || sttRole.busy
-            || captureSession?.recorder.state !== 'recording';
+            || (sttRole.busy && !nativeCaptureSession)
+            || (!nativeCaptureSession && captureSession?.recorder.state !== 'recording');
         recordButton.title = transcriptionButtonTitle();
         recordButton.setAttribute('aria-label', recordButton.title);
         recordButton.setAttribute(
             'aria-pressed',
-            String(recordingRequested || Boolean(captureSession))
+            String(recordingRequested || Boolean(captureSession) || Boolean(nativeCaptureSession))
         );
         sttActivationButton.hidden = !activationVisible;
         sttActivationButton.disabled = destroyed
@@ -1288,21 +1293,23 @@
                 }
             }
         );
-        transcriptionOperationId = null;
+        if (transcriptionOperationId === operationId) transcriptionOperationId = null;
         return accepted;
     }
 
     async function record() {
+        const liveCapture = providerRuntime.supportsTranscriptionCapture();
         if (
             !transcriptionEnabled
             || destroyed
             || sttRole.state !== 'ready'
             || sttRole.busy
             || !host.availability.microphone
-            || !is.function(globalThis.MediaRecorder)
-            || !is.function(navigator.mediaDevices?.getUserMedia)
+            || (!liveCapture && (!is.function(globalThis.MediaRecorder)
+                || !is.function(navigator.mediaDevices?.getUserMedia)))
             || recordingRequested
             || captureSession
+            || nativeCaptureSession
             || transcriptionActive
         ) {
             resetRecordPress();
@@ -1322,6 +1329,8 @@
         renderControls();
         renderStatus();
 
+        if (liveCapture) return startNativeRecognition(generation, operationId);
+
         let stream;
         try {
             stream = await navigator.mediaDevices.getUserMedia({ audio: true });
@@ -1461,6 +1470,111 @@
         }
     }
 
+    function startNativeRecognition(generation, operationId) {
+        const session = {
+            generation,
+            operationId,
+            controller: new AbortController(),
+            capture: null,
+            text: [],
+            interim: '',
+            cancelled: false,
+            error: null
+        };
+        nativeCaptureSession = session;
+        function currentNativeCapture() {
+            return !destroyed && !session.cancelled
+                && nativeCaptureSession === session
+                && generation === recordingGeneration;
+        }
+        function displayNativeRecognitionText() {
+            if (!currentNativeCapture()) return;
+            localStatus = {
+                message: session.text.join('') + session.interim || 'Listening. Release to finish.',
+                tone: '',
+                owner: 'recording',
+                generation
+            };
+            renderStatus();
+        }
+        async function finishNativeRecognition(error = null) {
+            if (!currentNativeCapture()) return;
+            nativeCaptureSession = null;
+            recordingRequested = false;
+            resetRecordPress();
+            clearRecordingStatus(generation);
+            if (error && error !== session.error) {
+                session.error = error;
+                reportTranscriptionError(error);
+            }
+            // Keep confirmed final words after a service/cleanup failure. Only
+            // explicit cancellation or supersession abandons this submission.
+            if (session.text.length && !destroyed && !session.cancelled
+                && generation === recordingGeneration) {
+                transcriptionOperationId = operationId;
+                await transcribe(session.text.join(''));
+            } else if (transcriptionOperationId === operationId) {
+                transcriptionOperationId = null;
+            }
+            renderControls();
+            renderStatus();
+        }
+        try {
+            session.capture = providerRuntime.createTranscriptionCapture(
+                {
+                    continuous: true,
+                    onSegment: function retainFinalRecognition(segment) {
+                        if (!currentNativeCapture()) return;
+                        session.text.push(segment.text);
+                        displayNativeRecognitionText();
+                    },
+                    onInterim: function displayInterimRecognition(result) {
+                        if (!currentNativeCapture()) return;
+                        session.interim = result.text;
+                        displayNativeRecognitionText();
+                    },
+                    onError: function reportNativeRecognitionFailure(error) {
+                        if (!currentNativeCapture()) return;
+                        session.error = error;
+                        reportTranscriptionError(error);
+                    }
+                }
+            );
+            if (!session.capture) throw new Error('The selected live transcription service is unavailable.');
+            session.capture.done.then(
+                function nativeRecognitionCompleted() {
+                    return finishNativeRecognition();
+                },
+                finishNativeRecognition
+            ).catch(
+                function reportNativeRecognitionSettlementFailure(error) {
+                    if (destroyed || generation !== recordingGeneration) return;
+                    reportTranscriptionError(error);
+                }
+            );
+            // No awaited preparation precedes the browser's gesture-bound start.
+            const starting = session.capture.start({signal: session.controller.signal});
+            return Promise.resolve(starting).catch(
+                function reportNativeRecognitionStartupFailure(error) {
+                    if (!currentNativeCapture()) return false;
+                    session.capture.cancel();
+                    nativeCaptureSession = null;
+                    recordingRequested = false;
+                    resetRecordPress();
+                    if (error !== session.error) reportTranscriptionError(error);
+                    return false;
+                }
+            );
+        } catch (error) {
+            session.capture?.cancel();
+            nativeCaptureSession = null;
+            recordingRequested = false;
+            resetRecordPress();
+            if (error !== session.error) reportTranscriptionError(error);
+            return false;
+        }
+    }
+
     function stopAfterSilence() {
         clearSilenceTimer();
         stop();
@@ -1483,6 +1597,12 @@
     }
 
     function stop() {
+        if (nativeCaptureSession) {
+            recordingRequested = false;
+            nativeCaptureSession.capture.stop();
+            renderControls();
+            return true;
+        }
         const pendingCaptureStart = recordingRequested && !captureSession;
         const generation = recordingGeneration;
         const operationId = transcriptionOperationId;
@@ -1703,6 +1823,7 @@
     function cancelSTTOperation(reason) {
         const hadActiveOperation = recordingRequested
             || Boolean(captureSession)
+            || Boolean(nativeCaptureSession)
             || transcriptionActive;
         recordingGeneration += 1;
         transcriptionGeneration += 1;
@@ -1713,6 +1834,14 @@
         clearSilenceTimer();
         resetRecordPress();
 
+        if (nativeCaptureSession) {
+            const session = nativeCaptureSession;
+            nativeCaptureSession = null;
+            session.cancelled = true;
+            session.controller.abort();
+            session.capture?.cancel();
+        }
+
         if (captureSession) {
             captureSession.cancelled = true;
             if (captureSession.recorder.state !== 'inactive') {
@@ -1769,6 +1898,7 @@
 
     function handlePageHide(event) {
         if (event.persisted === true) {
+            if (nativeCaptureSession) stop();
             return;
         }
         destroy();

package/runtime/arcane/components/voice-transcription.html

@@ -82,6 +82,7 @@
     <p id="description" class="description" part="description"></p>
     <section id="transcript" class="transcript" part="transcript"></section>
     <div class="transcription-feedback">
+        <p id="interim" class="status" part="interim" aria-live="polite" hidden></p>
         <p id="status" class="status" part="status" role="status" aria-live="polite"></p>
         <progress
             id="sttActivationProgress"
@@ -136,16 +137,20 @@
         {default:MD},
         {appendTranscription,createSTTActivationController,normalizeVoiceOptions},
         {requestAIRuntimeIntent,subscribeAIRuntimeState},
-        {default:ContinuousVoiceCapture}
+        {default:ContinuousVoiceCapture},
+        {getAIProviderRuntime}
     ]=await Promise.all([
         import('../modules/MD.js'),
         import('../modules/ComponentContracts.js'),
         import('../modules/AIRuntimeState.js'),
-        import('../modules/ContinuousVoiceCapture.js')
+        import('../modules/ContinuousVoiceCapture.js'),
+        import('../modules/AIProviderRuntime.js')
     ]);
+    const providerRuntime=getAIProviderRuntime();
     const description=host.shadowRoot.querySelector('#description');
     const transcriptElement=host.shadowRoot.querySelector('#transcript');
     const status=host.shadowRoot.querySelector('#status');
+    const interimElement=host.shadowRoot.querySelector('#interim');
     const startButton=host.shadowRoot.querySelector('#start');
     const sttActivationButton=host.shadowRoot.querySelector('#sttActivation');
     const sttActivationProgress = host.shadowRoot.querySelector('#sttActivationProgress');
@@ -385,6 +390,7 @@
             flushing:false,
             processing:'idle',
             queue:[],
+            interim:'',
             failure:null,
             captureError:null,
             worker:null,
@@ -396,15 +402,25 @@
             if(!isCurrentContinuousSession(session)||!session.listening){
                 return false;
             }
-            session.capture=new ContinuousVoiceCapture({
+            const captureOptions={
                 ...options.capture,
                 onSegment:function capturedSegment(clip){
                     if(!isCurrentContinuousSession(session)){
                         return;
                     }
-                    session.queue.push({...clip,stage:'transcribe',segment:null});
+                    session.queue.push({
+                        ...clip,
+                        stage:is.string(clip.text)?'append':'transcribe',
+                        segment:is.string(clip.text)?clip.text:null
+                    });
+                    renderInterimRecognition(session);
                     processContinuousQueue(session);
                 },
+                onInterim:function displayInterimRecognition(result){
+                    if(!isCurrentContinuousSession(session)) return;
+                    session.interim=result.text;
+                    renderInterimRecognition(session);
+                },
                 onState:function captureStateChanged(nextState){
                     if(!isCurrentContinuousSession(session)){
                         return;
@@ -412,8 +428,11 @@
                     session.captureState=nextState;
                     if(nextState==='stopped'||nextState==='interrupted'){
                         session.listening=false;
+                        session.interim='';
+                        renderInterimRecognition(session);
                     }
                     renderContinuousState(session);
+                    settleContinuousDrain(session);
                 },
                 onError:function captureFailed(error){
                     if(!isCurrentContinuousSession(session)){
@@ -425,7 +444,29 @@
                     reportContinuousError(session,'capture',error);
                     settleContinuousDrain(session);
                 }
-            });
+            };
+            session.capture=!options.transcribe
+                ?providerRuntime.createTranscriptionCapture(captureOptions):null;
+            session.native=Boolean(session.capture);
+            if(!session.capture){
+                session.capture=new ContinuousVoiceCapture(captureOptions);
+            }else{
+                session.capture.done.then(function nativeRecognitionEnded(){
+                    if(!isCurrentContinuousSession(session)) return;
+                    session.listening=false;
+                    session.interim='';
+                    renderInterimRecognition(session);
+                    if(!session.captureError) session.captureState='stopped';
+                    renderContinuousState(session);
+                    settleContinuousDrain(session);
+                }).catch(function nativeRecognitionCleanupFailed(error){
+                    if(!isCurrentContinuousSession(session)) return;
+                    session.captureError=error;
+                    session.listening=false;
+                    reportContinuousError(session,'capture',error);
+                    settleContinuousDrain(session);
+                });
+            }
             const started=await session.capture.start({
                 mediaConstraints:options.mediaConstraints,
                 signal:session.controller.signal
@@ -467,6 +508,17 @@
         };
     }
 
+    function renderInterimRecognition(session){
+        if(!isCurrentContinuousSession(session)) return;
+        const pending=[];
+        for(const clip of session.queue){
+            if(clip.stage==='append') pending.push(clip.segment);
+        }
+        const text=pending.join(options.separator)+session.interim;
+        interimElement.textContent=text;
+        interimElement.hidden=text.length===0;
+    }
+
     function renderContinuousState(session){
         if(!isCurrentContinuousSession(session)){
             return;
@@ -598,7 +650,10 @@
                         throw new TypeError('Transcription must return the complete text as a string.');
                     }
                     clip.segment=result;
-                    if(result.length===0){
+                    clip.stage='append';
+                }
+                if(clip.stage==='append'){
+                    if(clip.segment.length===0){
                         session.queue.shift();
                         const detail={sequence:clip.sequence,transcript};
                         dispatchVoiceEvent('voice-transcription-empty',detail,{
@@ -606,10 +661,11 @@
                         });
                         continue;
                     }
-                    clip.transcript=appendTranscription(transcript,result,options.separator);
+                    clip.transcript=appendTranscription(transcript,clip.segment,options.separator);
                     clip.stage='save';
                     transcript=clip.transcript;
                     renderTranscript();
+                    renderInterimRecognition(session);
                 }
                 if(options.persist){
                     const save=options.onSave||(is.function(host.save)?host.save.bind(host):null);
@@ -740,6 +796,8 @@
             return false;
         }
         continuousSession=null;
+        interimElement.textContent='';
+        interimElement.hidden=true;
         session.controller.abort();
         session.requestController?.abort();
         session.capture?.cancel();
@@ -766,7 +824,8 @@
     }
 
     async function startRecording(){
-        if(options.capture.mode==='continuous'){
+        if(options.capture.mode==='continuous'
+            ||(!options.transcribe&&providerRuntime.supportsTranscriptionCapture())){
             return startContinuousRecording();
         }
         if(!canStartVoiceRecording(sttRole,state,destroyed)){
@@ -1366,6 +1425,16 @@
         sttActivationController.synchronize(sttRole);
         if(continuousSession){
             const session=continuousSession;
+            if(session.native&&session.listening
+                &&(sttRole.state!=='ready'
+                    ||previousRole.providerId!==sttRole.providerId
+                    ||previousRole.modelId!==sttRole.modelId)){
+                session.capture?.cancel();
+                session.listening=false;
+                session.captureState='interrupted';
+                session.interim='';
+                renderInterimRecognition(session);
+            }
             if(['completing','complete'].includes(state)){
                 renderState();
                 return;