@wow-two-beta/ui-vue 0.0.5 → 0.0.6

package/dist/foundation/shortcuts/index.js

@@ -1,6 +1,7 @@
-import { M, f, a, i, m, p } from "../../chunks/Chord-D9Z-j3O0.js";
-import { u, a as a2 } from "../../chunks/UseHotkeys-CKIYK5Mq.js";
-import { K } from "../../chunks/KeyboardExtensions-CQlkK53D.js";
+import { M, f, a, i, m, p } from "../../chunks/Chord-C3OKRsgk.js";
+import { K } from "../../chunks/Key-CQlkK53D.js";
+import { u, a as a2 } from "../../chunks/UseHotkeys-dSOwoutT.js";
+import { u as u2 } from "../../chunks/UseEscape-CYPdpm_l.js";
 export {
   K as Key,
   M as Modifier,
@@ -9,6 +10,7 @@ export {
   i as isApplePlatform,
   m as matchesChord,
   p as parseChord,
+  u2 as useEscape,
   u as useHotkeyMap,
   a2 as useHotkeys
 };

package/dist/foundation/shortcuts/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/foundation/speech/CreateSpeechRecognizer.d.ts

@@ -1,25 +1,10 @@
+import { RecognizerStartResult } from './models/RecognizerStartResult';
 import { SpeechRecognitionFailure, SpeechTranscript } from './SpeechRecognitionResult';
-/**
- * The outcome of a {@link SpeechRecognizer.start} call.
- *
- * - `started` — the engine accepted the request. Listening begins later, at the `onStart` callback.
- * - `already-started` — a session is running or starting. The native call would have thrown here.
- * - `unsupported` — no recognition API (SSR, Firefox).
- * - `failed` — the engine refused, carrying the normalized `Error`.
- */
-export type RecognizerStartResult = {
-    readonly status: 'started';
-} | {
-    readonly status: 'already-started';
-} | {
-    readonly status: 'unsupported';
-} | {
-    readonly status: 'failed';
-    readonly error: Error;
-};
+export type { RecognizerStartFailure } from './models/RecognizerStartFailure';
+export type { RecognizerStartResult } from './models/RecognizerStartResult';
 /** Configuration and callbacks for a recognizer. Applied once, at creation — see {@link createSpeechRecognizer}. */
 export interface SpeechRecognizerOptions {
-    /** BCP-47 tag to transcribe (`en-US`, `uz`). Same vocabulary as `foundation/i18n`'s locale. Defaults to the engine's. */
+    /** BCP-47 tag to transcribe (`en-US`, `uz`). Same vocabulary as `foundation/i18n`. Defaults to the engine's. */
     readonly lang?: string;
     /** Keep listening past the first phrase. Defaults to `false`. Chrome still ends the session on long silence. */
     readonly continuous?: boolean;
@@ -46,7 +31,7 @@ export interface SpeechRecognizer {
     readonly supported: boolean;
     /** Whether the engine is listening right now — `false` during the gap between `start()` and the `start` event. */
     readonly listening: boolean;
-    /** Begins a session. Safe to call twice: the second call answers `already-started` instead of throwing. */
+    /** Begins a session. Repeated calls succeed without restarting a session that is starting or listening. */
     readonly start: () => RecognizerStartResult;
     /** Ends the session, keeping results the engine has already recognized. A no-op when idle. */
     readonly stop: () => void;

package/dist/foundation/speech/ListVoices.d.ts

@@ -16,7 +16,7 @@ export interface ListVoicesOptions {
  *
  * @returns The voices the engine has registered so far.
  */
-export declare function listVoicesSync(): readonly SpeechSynthesisVoice[];
+export declare function listVoicesSync(): ReadonlyArray<SpeechSynthesisVoice>;
 /**
  * Subscribes to `voiceschanged`.
  *
@@ -46,7 +46,7 @@ export declare function onVoicesChanged(listener: () => void): () => void;
  * @param options The wait bound. Defaults to {@link DefaultVoicesTimeoutMs}.
  * @returns The voices, or `[]`.
  */
-export declare function listVoices(options?: ListVoicesOptions): Promise<readonly SpeechSynthesisVoice[]>;
+export declare function listVoices(options?: ListVoicesOptions): Promise<ReadonlyArray<SpeechSynthesisVoice>>;
 /**
  * Filters voices to a language tag, exact matches first, then same-primary-subtag ones.
  *
@@ -60,7 +60,7 @@ export declare function listVoices(options?: ListVoicesOptions): Promise<readonl
  * @param lang A BCP-47 tag (`de`, `en-GB`). Same vocabulary as `foundation/i18n`'s locale.
  * @returns The matching voices, best match first. Empty when nothing matches.
  */
-export declare function voicesForLang(voices: readonly SpeechSynthesisVoice[], lang: string): readonly SpeechSynthesisVoice[];
+export declare function voicesForLang(voices: ReadonlyArray<SpeechSynthesisVoice>, lang: string): ReadonlyArray<SpeechSynthesisVoice>;
 /**
  * Picks the best voice for a language tag, waiting for the voice list the same way {@link listVoices} does.
  *

package/dist/foundation/speech/Speak.d.ts

@@ -1,9 +1,9 @@
-import { SpeakResult } from './SpeechResult';
+import { SpeechSpeakResult } from './SpeechResult';
 /** Tunes one utterance. Every field is optional; an omitted one leaves the engine's own default in place. */
 export interface SpeakOptions {
     /** The voice to speak with — an entry from `listVoices()`. Omitted means the engine's default for `lang`. */
     readonly voice?: SpeechSynthesisVoice;
-    /** BCP-47 language tag (`en-US`, `de`). Same vocabulary as `foundation/i18n`'s locale, which `useSpeechSynthesis` defaults it to. */
+    /** BCP-47 tag (`en-US`, `de`). Same vocabulary as `foundation/i18n`, which `useSpeechSynthesis` defaults it to. */
     readonly lang?: string;
     /** Speed, `0.1`–`10`, default `1`. Clamped to that range; a non-finite value is ignored. */
     readonly rate?: number;
@@ -18,9 +18,9 @@ export interface SpeakOptions {
  * All three controls are GLOBAL — the platform exposes no per-utterance cancel or pause, so they act on the
  * document's whole utterance queue.
  */
-export interface SpeechHandle extends PromiseLike<SpeakResult> {
+export interface SpeechHandle extends PromiseLike<SpeechSpeakResult> {
     /** The underlying promise, for a caller that wants to store or pass it. Never rejects. */
-    readonly spoken: Promise<SpeakResult>;
+    readonly spoken: Promise<SpeechSpeakResult>;
     /** Stops this utterance — and every other queued one. Settles the handle as `cancelled`. */
     readonly cancel: () => void;
     /** Pauses the engine. See `SpeechControls` for Chrome-on-Android's pause-is-cancel behaviour. */
@@ -33,7 +33,7 @@ export interface SpeechHandle extends PromiseLike<SpeakResult> {
  *
  * ```ts
  * const result = await speak('Order confirmed', { lang: 'en-GB', rate: 1.1 });
- * if (result.status === 'unsupported') showTextInstead();
+ * if (!result.ok && result.failure.status === 'unsupported') showTextInstead();
  *
  * const handle = speak(longArticle);
  * stopButton.onclick = () => handle.cancel(); // settles as `cancelled`
@@ -44,8 +44,7 @@ export interface SpeechHandle extends PromiseLike<SpeakResult> {
  *
  * Never throws, never rejects.
  *
- * @param text The text to speak. Empty text is handed to the engine unchanged — engines differ on whether they
- *   fire `end` for it, which is exactly the kind of thing a caller should not have to guess about mid-sentence.
+ * @param text The text to speak. Empty text completes immediately without waiting for a browser event.
  * @param options Voice, language, and prosody. Out-of-range prosody is clamped; see {@link SpeakOptions}.
  * @returns The awaitable handle — `spoken` / `cancelled` / `unsupported` / `failed`, plus the live controls.
  */

package/dist/foundation/speech/SpeechControls.d.ts

@@ -1,3 +1,5 @@
+/** Registers an internal settlement callback for queue-wide cancellation. */
+export declare function onSpeechCancelled(listener: () => void): () => void;
 /**
  * The current cancel generation.
  *

package/dist/foundation/speech/SpeechResult.d.ts

@@ -1,26 +1,10 @@
+import { SpeechSpeakResult } from './models/SpeechSpeakResult';
+import { SpeechFailure } from './models/SpeechFailure';
+export type { SpeechFailure } from './models/SpeechFailure';
+export type { SpeechSpeakResult } from './models/SpeechSpeakResult';
+export type SpeakStatus = 'spoken' | SpeechFailure['status'];
 /**
- * The outcome of a {@link speak} attempt. Four arms because an utterance has four meaningfully different endings.
- *
- * - `spoken` — the engine reached the end of the text. It does NOT mean anyone heard it: the device may be muted.
- * - `cancelled` — something called `cancelSpeech` (or the handle's `cancel`) before it finished. A decision, not
- *   an error, and never reported as one.
- * - `unsupported` — no `speechSynthesis` / `SpeechSynthesisUtterance` here: SSR, or a stripped webview.
- * - `failed` — anything else, carrying the normalized `Error`.
- */
-export type SpeakResult = {
-    readonly status: 'spoken';
-} | {
-    readonly status: 'cancelled';
-} | {
-    readonly status: 'unsupported';
-} | {
-    readonly status: 'failed';
-    readonly error: Error;
-};
-/** The `status` discriminant of a {@link SpeakResult} — for a consumer's own switch or status→copy map. */
-export type SpeakStatus = SpeakResult['status'];
-/**
- * Classifies a `SpeechSynthesisUtterance` `error` event into its {@link SpeakResult}.
+ * Classifies a `SpeechSynthesisUtterance` `error` event into its {@link SpeechSpeakResult}.
  *
  * Exported for the sibling `Speak` module and its tests; absent from the barrel, where `speak` is the surface a
  * consumer wants. Never throws — an unrecognized or unreadable code becomes `failed` with an `Error` naming what
@@ -29,4 +13,4 @@ export type SpeakStatus = SpeakResult['status'];
  * @param event The `error` event the platform delivered.
  * @returns `cancelled` for a cancellation code, `failed` for everything else.
  */
-export declare function toSpeakFailure(event: unknown): SpeakResult;
+export declare function toSpeakFailure(event: unknown): SpeechSpeakResult;

package/dist/foundation/speech/enums/RecognizerStartFailureCode.d.ts

@@ -0,0 +1,6 @@
+/** Closed failure vocabulary for RecognizerStartFailure. */
+export declare const RecognizerStartFailureCode: {
+    readonly Unsupported: "unsupported";
+    readonly Failed: "failed";
+};
+export type RecognizerStartFailureCode = (typeof RecognizerStartFailureCode)[keyof typeof RecognizerStartFailureCode];

package/dist/foundation/speech/enums/SpeechFailureCode.d.ts

@@ -0,0 +1,7 @@
+/** Closed failure vocabulary for SpeechFailure. */
+export declare const SpeechFailureCode: {
+    readonly Cancelled: "cancelled";
+    readonly Unsupported: "unsupported";
+    readonly Failed: "failed";
+};
+export type SpeechFailureCode = (typeof SpeechFailureCode)[keyof typeof SpeechFailureCode];

package/dist/foundation/speech/hooks/UseSpeechRecognition.d.ts

@@ -0,0 +1,45 @@
+import { MaybeRefOrGetter, ShallowRef } from 'vue';
+import { RecognizerStartResult, SpeechRecognizerOptions } from '../CreateSpeechRecognizer';
+import { SpeechRecognitionFailure } from '../SpeechRecognitionResult';
+/** Options for {@link useSpeechRecognition} — the recognizer's own, with the composable layering state on top. */
+export type UseSpeechRecognitionOptions = SpeechRecognizerOptions;
+/** What {@link useSpeechRecognition} returns. */
+export interface SpeechRecognitionControls {
+    /** Whether this browser can transcribe at all. `false` under SSR and in Firefox — gate the button on it. */
+    readonly supported: Readonly<ShallowRef<boolean>>;
+    /** Whether the engine is listening. `false` in the gap between `start()` and the microphone actually opening. */
+    readonly listening: Readonly<ShallowRef<boolean>>;
+    /** Every committed phrase of the session, space-joined. Survives an ended session; cleared by `reset`. */
+    readonly transcript: Readonly<ShallowRef<string>>;
+    /** The current uncommitted text. Requires `interimResults`; cleared when the phrase commits or the session ends. */
+    readonly interimTranscript: Readonly<ShallowRef<string>>;
+    /** The last classified failure, or `null`. Cleared when a new session starts. `no-speech` lands here too. */
+    readonly error: Readonly<ShallowRef<SpeechRecognitionFailure | null>>;
+    /** Begins a session. Repeated calls succeed without restarting a session that is starting or listening. */
+    readonly start: () => RecognizerStartResult;
+    /** Ends the session, keeping what the engine already recognized. */
+    readonly stop: () => void;
+    /** Ends the session immediately, discarding pending results. */
+    readonly abort: () => void;
+    /** Clears `transcript`, `interimTranscript`, and `error`. Does not touch the session. */
+    readonly reset: () => void;
+}
+/**
+ * Transcribes speech into accumulating reactive state, aborting the session when the scope is disposed.
+ *
+ * ```vue
+ * const dictation = useSpeechRecognition({ interimResults: true, continuous: true });
+ * <button :disabled="!dictation.supported.value" @click="dictation.start()">
+ *   {{ dictation.listening.value ? 'Listening…' : 'Dictate' }}
+ * </button>
+ * <p>{{ dictation.transcript.value }} <em>{{ dictation.interimTranscript.value }}</em></p>
+ * ```
+ *
+ * `lang` defaults to the active `LocaleProvider` locale, so a localized app transcribes the language its user is
+ * reading. Nothing throws.
+ *
+ * @param options Session shape and pass-through callbacks — each is called in addition to the state updates.
+ *   A ref or getter is read at call time, so a reactive options source is followed.
+ * @returns The transcript state plus the four controls.
+ */
+export declare function useSpeechRecognition(options?: MaybeRefOrGetter<UseSpeechRecognitionOptions | undefined>): SpeechRecognitionControls;

package/dist/foundation/speech/hooks/UseSpeechSynthesis.d.ts

@@ -0,0 +1,37 @@
+import { ShallowRef } from 'vue';
+import { SpeakOptions } from '../Speak';
+import { SpeechSpeakResult } from '../SpeechResult';
+/** What {@link useSpeechSynthesis} returns. */
+export interface SpeechSynthesisControls {
+    /** Whether this browser can speak. `false` under SSR — render the button only once this is `true`. */
+    readonly supported: Readonly<ShallowRef<boolean>>;
+    /** The installed voices. Starts empty and fills in asynchronously; see `ListVoices` for why that is normal. */
+    readonly voices: Readonly<ShallowRef<ReadonlyArray<SpeechSynthesisVoice>>>;
+    /** Whether this composable has an utterance in flight — not the engine's global flag, shared by all callers. */
+    readonly speaking: Readonly<ShallowRef<boolean>>;
+    /** Whether this composable paused the engine. */
+    readonly paused: Readonly<ShallowRef<boolean>>;
+    /** Speaks text, resolving to the outcome. Never throws. Defaults `lang` to the active locale. */
+    readonly speak: (text: string, options?: SpeakOptions) => Promise<SpeechSpeakResult>;
+    /** Stops all speech in the document — no narrower cancel exists. In-flight `speak` calls settle as `cancelled`. */
+    readonly cancel: () => void;
+    /** Pauses the engine. See `SpeechControls` for Chrome-on-Android's pause-is-cancel behaviour. */
+    readonly pause: () => void;
+    /** Resumes a paused engine. */
+    readonly resume: () => void;
+}
+/**
+ * Speaks text and owns the lifecycle — cancelling this composable's in-flight speech when the scope is disposed.
+ *
+ * ```vue
+ * const speech = useSpeechSynthesis();
+ * <button :disabled="!speech.supported.value" @click="speech.speak(article)">
+ *   {{ speech.speaking.value ? 'Stop' : 'Read aloud' }}
+ * </button>
+ * ```
+ *
+ * Inherits the slice's never-throws contract — a rejected promise is not one of the outcomes.
+ *
+ * @returns The state plus the four controls.
+ */
+export declare function useSpeechSynthesis(): SpeechSynthesisControls;

package/dist/foundation/speech/index.d.ts

@@ -1,10 +1,12 @@
 export { canSpeak, canRecognizeSpeech, getSpeechSupport, type SpeechSupport } from './SpeechSupport';
-export { type SpeakResult, type SpeakStatus } from './SpeechResult';
+export { type SpeechFailure, type SpeechSpeakResult, type SpeakStatus } from './SpeechResult';
 export { speak, type SpeakOptions, type SpeechHandle } from './Speak';
 export { cancelSpeech, pauseSpeech, resumeSpeech, isSpeaking, isSpeechPaused } from './SpeechControls';
 export { listVoices, listVoicesSync, findVoice, voicesForLang, DefaultVoicesTimeoutMs, type ListVoicesOptions, } from './ListVoices';
-export { useSpeechSynthesis, type SpeechSynthesisControls, } from './UseSpeechSynthesis';
+export { useSpeechSynthesis, type SpeechSynthesisControls } from './hooks/UseSpeechSynthesis';
 export { type SpeechRecognitionStatus, type SpeechRecognitionFailure, type SpeechTranscript, } from './SpeechRecognitionResult';
-export { createSpeechRecognizer, type SpeechRecognizer, type SpeechRecognizerOptions, type RecognizerStartResult, } from './CreateSpeechRecognizer';
-export { useSpeechRecognition, type SpeechRecognitionControls, type UseSpeechRecognitionOptions, } from './UseSpeechRecognition';
+export { createSpeechRecognizer, type SpeechRecognizer, type SpeechRecognizerOptions, type RecognizerStartResult, type RecognizerStartFailure, } from './CreateSpeechRecognizer';
+export { useSpeechRecognition, type SpeechRecognitionControls, type UseSpeechRecognitionOptions, } from './hooks/UseSpeechRecognition';
 export type { SpeechRecognitionLike, SpeechRecognitionEventLike, SpeechRecognitionErrorEventLike, SpeechRecognitionResultLike, SpeechRecognitionResultListLike, SpeechRecognitionAlternativeLike, SpeechRecognitionConstructor, } from './SpeechRecognitionTypes';
+export { SpeechFailureCode } from './enums/SpeechFailureCode';
+export { RecognizerStartFailureCode } from './enums/RecognizerStartFailureCode';

package/dist/foundation/speech/index.js

@@ -1,6 +1,7 @@
-import { t as toError } from "../../chunks/ToError-CyTBsmLO.js";
+import { t as toError } from "../../chunks/ToError-vXncXe19.js";
 import { shallowRef, onMounted, onScopeDispose, watch, toValue } from "vue";
-import { u as useLocale } from "../../chunks/LocaleContext-B3UXrI6p.js";
+import { u as useLocale } from "../../chunks/LocaleContext-B7vUZmX-.js";
+import { R as ResultExtensions } from "../../chunks/ResultExtensions-B7dWH0FZ.js";
 function speechSynthesisWith(member) {
   try {
     const candidate = globalThis.speechSynthesis;
@@ -50,11 +51,16 @@ function errorCodeOf(event) {
 }
 function toSpeakFailure(event) {
   const code = errorCodeOf(event);
-  if (code !== void 0 && CancellationCodes.has(code)) return { status: "cancelled" };
+  if (code !== void 0 && CancellationCodes.has(code)) return { ok: false, failure: { status: "cancelled" } };
   const error = new Error(`speech synthesis failed: ${code ?? "unknown"}`, { cause: event });
-  return { status: "failed", error };
+  return { ok: false, failure: { status: "failed", error } };
 }
 let cancels = 0;
+const cancellationListeners = /* @__PURE__ */ new Set();
+function onSpeechCancelled(listener) {
+  cancellationListeners.add(listener);
+  return () => cancellationListeners.delete(listener);
+}
 function cancelGeneration() {
   return cancels;
 }
@@ -62,6 +68,7 @@ function cancelSpeech() {
   const synth = speechSynthesisWith("cancel");
   if (synth === void 0) return false;
   cancels += 1;
+  for (const listener of [...cancellationListeners]) listener();
   try {
     synth.cancel();
     return true;
@@ -141,10 +148,11 @@ function inertControls() {
   return { cancel: noop, pause: noop, resume: noop };
 }
 function speak(text, options) {
+  if (text.length === 0) return toHandle(Promise.resolve({ ok: true, value: void 0 }), inertControls());
   const synth = speechSynthesisWith("speak");
   const Utterance = utteranceConstructor();
   if (synth === void 0 || Utterance === void 0) {
-    return toHandle(Promise.resolve({ status: "unsupported" }), inertControls());
+    return toHandle(Promise.resolve({ ok: false, failure: { status: "unsupported" } }), inertControls());
   }
   let settle;
   const spoken = new Promise((resolve) => {
@@ -155,28 +163,33 @@ function speak(text, options) {
   const finish = (result) => {
     if (settled) return;
     settled = true;
+    unsubscribeCancel?.();
     if (utterance !== void 0) inFlight.delete(utterance);
     settle(result);
   };
   try {
     utterance = new Utterance(text);
   } catch (cause) {
-    return toHandle(Promise.resolve({ status: "failed", error: toError(cause) }), inertControls());
+    return toHandle(
+      Promise.resolve({ ok: false, failure: { status: "failed", error: toError(cause) } }),
+      inertControls()
+    );
   }
   configure(utterance, options);
   const generation = cancelGeneration();
   const wasCancelled = () => cancelGeneration() !== generation;
+  const unsubscribeCancel = onSpeechCancelled(() => finish({ ok: false, failure: { status: "cancelled" } }));
   utterance.onend = () => {
-    finish(wasCancelled() ? { status: "cancelled" } : { status: "spoken" });
+    finish(wasCancelled() ? { ok: false, failure: { status: "cancelled" } } : { ok: true, value: void 0 });
   };
   utterance.onerror = (event) => {
-    finish(wasCancelled() ? { status: "cancelled" } : toSpeakFailure(event));
+    finish(wasCancelled() ? { ok: false, failure: { status: "cancelled" } } : toSpeakFailure(event));
   };
   inFlight.add(utterance);
   try {
     synth.speak(utterance);
   } catch (cause) {
-    finish({ status: "failed", error: toError(cause) });
+    finish({ ok: false, failure: { status: "failed", error: toError(cause) } });
   }
   return toHandle(spoken, {
     cancel: () => {
@@ -289,6 +302,7 @@ function useSpeechSynthesis() {
   let disposed = false;
   let inFlight2 = 0;
   const speak$1 = async (text, options) => {
+    if (disposed) return { ok: false, failure: { status: "cancelled" } };
     inFlight2 += 1;
     if (!disposed) {
       speaking.value = true;
@@ -370,13 +384,13 @@ function inertRecognizer(start) {
 }
 function createSpeechRecognizer(options) {
   const Recognition = speechRecognitionConstructor();
-  if (Recognition === void 0) return inertRecognizer(() => ({ status: "unsupported" }));
+  if (Recognition === void 0) return inertRecognizer(() => ResultExtensions.fail({ status: "unsupported" }));
   let instance;
   try {
     instance = new Recognition();
   } catch (cause) {
     const error = toError(cause);
-    return inertRecognizer(() => ({ status: "failed", error }));
+    return inertRecognizer(() => ResultExtensions.fail({ status: "failed", error }));
   }
   try {
     if (options?.lang !== void 0) instance.lang = options.lang;
@@ -429,14 +443,14 @@ function createSpeechRecognizer(options) {
       return state === "listening";
     },
     start: () => {
-      if (state !== "idle") return { status: "already-started" };
+      if (state !== "idle") return ResultExtensions.ok(void 0);
       try {
         instance.start();
         state = "starting";
-        return { status: "started" };
+        return ResultExtensions.ok(void 0);
       } catch (cause) {
         state = "idle";
-        return { status: "failed", error: toError(cause) };
+        return ResultExtensions.fail({ status: "failed", error: toError(cause) });
       }
     },
     stop: () => {
@@ -469,9 +483,12 @@ function useSpeechRecognition(options) {
   const error = shallowRef(null);
   const supported = shallowRef(false);
   let disposed = false;
+  let generation = 0;
   let recognizer = null;
   function getRecognizer() {
     if (recognizer !== null) return recognizer;
+    const operation = ++generation;
+    const current = () => !disposed && operation === generation;
     const created = createSpeechRecognizer({
       lang: toValue(options)?.lang ?? locale.value,
       continuous: toValue(options)?.continuous,
@@ -480,45 +497,45 @@ function useSpeechRecognition(options) {
       interimResults: toValue(options)?.interimResults ?? true,
       maxAlternatives: toValue(options)?.maxAlternatives,
       onStart: () => {
-        if (!disposed) {
-          listening.value = true;
-          error.value = null;
-        }
+        if (!current()) return;
+        listening.value = true;
+        error.value = null;
         toValue(options)?.onStart?.();
       },
       onEnd: () => {
-        if (!disposed) {
-          listening.value = false;
-          interimTranscript.value = "";
-        }
+        if (!current()) return;
+        listening.value = false;
+        interimTranscript.value = "";
         toValue(options)?.onEnd?.();
       },
       onError: (failure) => {
-        if (!disposed) error.value = failure;
+        if (!current()) return;
+        error.value = failure;
         toValue(options)?.onError?.(failure);
       },
       onResult: (result) => {
-        if (!disposed) {
-          if (result.isFinal) {
-            transcript.value = appendPhrase(transcript.value, result.transcript);
-            interimTranscript.value = "";
-          } else {
-            interimTranscript.value = result.transcript;
-          }
+        if (!current()) return;
+        if (result.isFinal) {
+          transcript.value = appendPhrase(transcript.value, result.transcript);
+          interimTranscript.value = "";
+        } else {
+          interimTranscript.value = result.transcript;
         }
         toValue(options)?.onResult?.(result);
       },
       onFinal: (text) => {
+        if (!current()) return;
         toValue(options)?.onFinal?.(text);
       },
       onInterim: (text) => {
+        if (!current()) return;
         toValue(options)?.onInterim?.(text);
       }
     });
     recognizer = created;
     return created;
   }
-  const start = () => getRecognizer().start();
+  const start = () => disposed ? { ok: false, failure: { status: "unsupported" } } : getRecognizer().start();
   const stop = () => {
     recognizer?.stop();
   };
@@ -540,6 +557,9 @@ function useSpeechRecognition(options) {
       () => toValue(options)?.interimResults ?? true
     ],
     () => {
+      generation++;
+      listening.value = false;
+      interimTranscript.value = "";
       recognizer?.abort();
       recognizer = null;
     }
@@ -551,8 +571,19 @@ function useSpeechRecognition(options) {
   });
   return { supported, listening, transcript, interimTranscript, error, start, stop, abort, reset };
 }
+const SpeechFailureCode = {
+  Cancelled: "cancelled",
+  Unsupported: "unsupported",
+  Failed: "failed"
+};
+const RecognizerStartFailureCode = {
+  Unsupported: "unsupported",
+  Failed: "failed"
+};
 export {
   DefaultVoicesTimeoutMs,
+  RecognizerStartFailureCode,
+  SpeechFailureCode,
   canRecognizeSpeech,
   canSpeak,
   cancelSpeech,