@wcstack/speech 1.20.0 → 1.21.0

package/README.ja.md

@@ -91,6 +91,7 @@ export default {
 | `charIndex` | number \| null | 読み上げ中の単語の位置 |
 | `spokenWord` | string \| null | 読み上げ中の単語 |
 | `error` | `WcsSpeakErrorDetail` \| null | 直近の失敗 |
+| `errorInfo` | `WcsIoErrorInfo` \| null | `error` から派生するシリアライズ可能な失敗分類（`code` / `phase` / `recoverable`）。SpeechSynthesis のコード（[注意・制限](#注意制限)参照）。付加的で `error` の形状は不変 |
 | `unsupported` | boolean | SpeechSynthesis 非対応 |
 
 ### コマンド
@@ -148,6 +149,7 @@ export default {
 | `listening` | boolean | セッション中 |
 | `permission` | `"prompt"\|"granted"\|"denied"\|"unsupported"` | マイク permission |
 | `error` | `WcsListenErrorDetail` \| null | 直近の失敗 |
+| `errorInfo` | `WcsIoErrorInfo` \| null | `error` から派生するシリアライズ可能な失敗分類（`code` / `phase` / `recoverable`）。SpeechRecognition のコード（[注意・制限](#注意制限)参照）。付加的で `error` の形状は不変 |
 | `unsupported` | boolean | SpeechRecognition 非対応 |
 
 ### コマンド
@@ -243,6 +245,11 @@ SpeechRecognition 自体が Chrome 系のみの対応だからです（後述の
 - **ブラウザ対応。** SpeechSynthesis は広く対応。SpeechRecognition は Chrome 系のみ（`webkitSpeechRecognition`）で、それ以外では `<wcs-listen>` は `unsupported` を報告します。
 - **SpeechSynthesis はグローバルシングルトン。** `<wcs-speak>` は切断時に `cancel()` しません（他インスタンスまで止まるため）。音声を止めるには明示的に `cancel()` を。切断された要素は追跡を止めますが、発話中の utterance は自然に完了します。
 - **echo ループ。** `<wcs-listen>` → state → `<wcs-speak>` を繋ぐときは、認識中は発話をミュート（例: `manual` を束縛）して合成音声が再認識されないように。echo の例を参照。
+- **`errorInfo`——付加的な失敗分類。** `error` と並んで、各要素は付加的なバインド可能出力 `errorInfo`（`WcsIoErrorInfo` = 安定した `code` / `phase` / `recoverable` / `message`）を公開します。同じ失敗から派生し（`error` の形状は不変）、成功時に `null` へクリアされます。2 つの要素は **異なる** code セット（SpeechRecognition と SpeechSynthesis の error enum）を持ち、どちらも `core/speechCapabilities.ts` に定義されています:
+  - **`<wcs-listen>`**（`WCS_LISTEN_ERROR_CODE`・イベント `wcs-listen:error-info-changed`）: `capability-missing`（phase `probe`——SpeechRecognition 非対応）・`not-allowed`（`start`——`not-allowed` / `service-not-allowed`、マイク権限拒否）・`not-readable`（`start`——`audio-capture`、マイク読取不可）・`no-speech`（`execute`・recoverable——無音で検出なし）・`network-error`（`execute`・recoverable——`network`）・`aborted`（`execute`・recoverable——セッション中断）・`invalid-argument`（`start`——`language-not-supported` / `bad-grammar`）・`speech-error`（`execute`——その他コードへの防御的 fallback）。
+  - **`<wcs-speak>`**（`WCS_SPEAK_ERROR_CODE`・イベント `wcs-speak:error-info-changed`）: `capability-missing`（phase `probe`——SpeechSynthesis 非対応）・`not-allowed`（`start`——合成不許可）・`aborted`（`execute`・recoverable——`canceled` / `interrupted`）・`not-readable`（`execute`——`audio-busy` は recoverable、`audio-hardware` は不可）・`network-error`（`execute`・recoverable——`network`）・`invalid-argument`（`start`——`language-unavailable` / `voice-unavailable` / `text-too-long` / `invalid-argument`）・`synthesis-failed`（`execute`——`synthesis-unavailable` / `synthesis-failed`）・`speech-error`（`execute`——防御的 fallback）。
+
+  `WcsIoErrorInfo` 型と `WCS_LISTEN_ERROR_CODE` / `WCS_SPEAK_ERROR_CODE` 定数は export されます。
 
 ## ヘッドレス利用（`SpeakCore` / `ListenCore`）
 

package/README.md

@@ -92,6 +92,7 @@ export default {
 | `charIndex` | number \| null | offset of the word being spoken |
 | `spokenWord` | string \| null | the word being spoken |
 | `error` | `WcsSpeakErrorDetail` \| null | last failure |
+| `errorInfo` | `WcsIoErrorInfo` \| null | serializable failure taxonomy (`code` / `phase` / `recoverable`) derived from `error` — SpeechSynthesis codes, see [Notes & limitations](#notes--limitations); additive, `error` shape unchanged |
 | `unsupported` | boolean | SpeechSynthesis is unavailable |
 
 ### Commands
@@ -149,6 +150,7 @@ Like `<wcs-geo>`, it has two phases: a **one-shot** recognition (default) and a
 | `listening` | boolean | a session is active |
 | `permission` | `"prompt"\|"granted"\|"denied"\|"unsupported"` | microphone permission |
 | `error` | `WcsListenErrorDetail` \| null | last failure |
+| `errorInfo` | `WcsIoErrorInfo` \| null | serializable failure taxonomy (`code` / `phase` / `recoverable`) derived from `error` — SpeechRecognition codes, see [Notes & limitations](#notes--limitations); additive, `error` shape unchanged |
 | `unsupported` | boolean | SpeechRecognition is unavailable |
 
 ### Commands
@@ -244,6 +246,11 @@ DevTools open; they are not a supported styling hook.
 - **Browser support.** SpeechSynthesis is broad; SpeechRecognition is Chrome-only (vendor-prefixed `webkitSpeechRecognition`) — `<wcs-listen>` reports `unsupported` elsewhere.
 - **SpeechSynthesis is a global singleton.** `<wcs-speak>` does **not** `cancel()` on disconnect (that would stop other instances); call `cancel()` explicitly to stop audio. A disconnected element stops tracking but any in-flight utterance finishes.
 - **Echo loop.** When wiring `<wcs-listen>` → state → `<wcs-speak>`, mute speaking while listening (e.g. bind `manual`) so the synthesized audio is not re-recognized. See the echo example.
+- **`errorInfo` — additive failure taxonomy.** Alongside `error`, each element exposes an **additive** bindable output `errorInfo` (`WcsIoErrorInfo` = a stable `code` / `phase` / `recoverable` / `message`), derived from the same failure — the `error` shape is unchanged — and cleared to `null` on success. The two elements have **different** code sets (SpeechRecognition vs SpeechSynthesis error enums), both defined in `core/speechCapabilities.ts`:
+  - **`<wcs-listen>`** (`WCS_LISTEN_ERROR_CODE`, event `wcs-listen:error-info-changed`): `capability-missing` (phase `probe` — SpeechRecognition absent), `not-allowed` (`start` — `not-allowed` / `service-not-allowed`, mic permission denied), `not-readable` (`start` — `audio-capture`, mic unreadable), `no-speech` (`execute`, recoverable — silence, nothing detected), `network-error` (`execute`, recoverable — `network`), `aborted` (`execute`, recoverable — session interrupted), `invalid-argument` (`start` — `language-not-supported` / `bad-grammar`), `speech-error` (`execute` — defensive fallback for any other code).
+  - **`<wcs-speak>`** (`WCS_SPEAK_ERROR_CODE`, event `wcs-speak:error-info-changed`): `capability-missing` (phase `probe` — SpeechSynthesis absent), `not-allowed` (`start` — synthesis disallowed), `aborted` (`execute`, recoverable — `canceled` / `interrupted`), `not-readable` (`execute` — `audio-busy` recoverable, `audio-hardware` not), `network-error` (`execute`, recoverable — `network`), `invalid-argument` (`start` — `language-unavailable` / `voice-unavailable` / `text-too-long` / `invalid-argument`), `synthesis-failed` (`execute` — `synthesis-unavailable` / `synthesis-failed`), `speech-error` (`execute` — defensive fallback).
+
+  The `WcsIoErrorInfo` type and the `WCS_LISTEN_ERROR_CODE` / `WCS_SPEAK_ERROR_CODE` constants are exported.
 
 ## Headless usage (`SpeakCore` / `ListenCore`)
 

package/dist/index.d.ts

@@ -1,3 +1,14 @@
+/** operation error の phase(taxonomy)。 */
+type WcsIoErrorPhase = "probe" | "start" | "execute" | "decode" | "commit" | "dispose";
+/** serializable な error info(non-cloneable な cause とは分離。DevTools / remote へは info のみ)。 */
+interface WcsIoErrorInfo {
+    readonly code: string;
+    readonly phase: WcsIoErrorPhase;
+    readonly recoverable: boolean;
+    readonly capabilityId?: string;
+    readonly message: string;
+}
+
 interface IWcBindableProperty {
     readonly name: string;
     readonly event: string;
@@ -13,7 +24,8 @@ interface IWcBindableCommand {
 }
 interface IWcBindable {
     readonly protocol: "wc-bindable";
-    readonly version: 1;
+    /** Integer protocol version. All versions >= 1 are core-compatible. */
+    readonly version: number;
     readonly properties: readonly IWcBindableProperty[];
     readonly inputs?: readonly IWcBindableInput[];
     readonly commands?: readonly IWcBindableCommand[];
@@ -88,6 +100,8 @@ interface WcsSpeakCoreValues {
     charIndex: number | null;
     spokenWord: string | null;
     error: WcsSpeakErrorDetail | null;
+    /** Phase 6 serializable failure taxonomy derived from `error`, or null. */
+    errorInfo: WcsIoErrorInfo | null;
     unsupported: boolean;
 }
 /**
@@ -189,6 +203,8 @@ interface WcsListenCoreValues {
     listening: boolean;
     permission: ListenPermissionState;
     error: WcsListenErrorDetail | null;
+    /** Phase 6 serializable failure taxonomy derived from `error`, or null. */
+    errorInfo: WcsIoErrorInfo | null;
     unsupported: boolean;
 }
 /**
@@ -257,6 +273,7 @@ declare class SpeakCore extends EventTarget {
     private _charIndex;
     private _spokenWord;
     private _error;
+    private _errorInfo;
     private _unsupported;
     private _queued;
     private _started;
@@ -271,6 +288,13 @@ declare class SpeakCore extends EventTarget {
     get charIndex(): number | null;
     get spokenWord(): string | null;
     get error(): WcsSpeakErrorDetail | null;
+    /**
+     * The last failure's serializable `WcsIoErrorInfo` (stable `code` / `phase` /
+     * `recoverable`), or null. Additive wc-bindable property (event
+     * `wcs-speak:error-info-changed`), derived from `error`; the existing `error`
+     * property/event are unchanged.
+     */
+    get errorInfo(): WcsIoErrorInfo | null;
     get unsupported(): boolean;
     /** Resolves once the first probe settles (immediate — see `_ready`). */
     get ready(): Promise<void>;
@@ -281,6 +305,7 @@ declare class SpeakCore extends EventTarget {
     private _setPending;
     private _setBoundary;
     private _setError;
+    private _commitErrorInfo;
     private _setUnsupported;
     /**
      * Queue an utterance for `text` with optional per-utterance parameters. Never
@@ -373,6 +398,7 @@ declare class WcsSpeak extends HTMLElement {
     get charIndex(): number | null;
     get spokenWord(): string | null;
     get error(): WcsSpeakErrorDetail | null;
+    get errorInfo(): WcsIoErrorInfo | null;
     get unsupported(): boolean;
     speak(text: string): void;
     cancel(): void;
@@ -417,6 +443,7 @@ declare class ListenCore extends EventTarget {
     private _listening;
     private _permission;
     private _error;
+    private _errorInfo;
     private _unsupported;
     private _active;
     private _continuous;
@@ -433,6 +460,13 @@ declare class ListenCore extends EventTarget {
     get listening(): boolean;
     get permission(): ListenPermissionState;
     get error(): WcsListenErrorDetail | null;
+    /**
+     * The last failure's serializable `WcsIoErrorInfo` (stable `code` / `phase` /
+     * `recoverable`), or null. Additive wc-bindable property (event
+     * `wcs-listen:error-info-changed`), derived from `error`; the existing `error`
+     * property/event are unchanged.
+     */
+    get errorInfo(): WcsIoErrorInfo | null;
     get unsupported(): boolean;
     /** Resolves once the first probe settles (immediate — see `_ready`). */
     get ready(): Promise<void>;
@@ -442,6 +476,7 @@ declare class ListenCore extends EventTarget {
     private _setListening;
     private _setPermission;
     private _setError;
+    private _commitErrorInfo;
     private _setUnsupported;
     /**
      * Begin a recognition session. Resets the transcripts (a fresh, user-initiated
@@ -518,6 +553,7 @@ declare class WcsListen extends HTMLElement {
     get listening(): boolean;
     get permission(): ListenPermissionState;
     get error(): WcsListenErrorDetail | null;
+    get errorInfo(): WcsIoErrorInfo | null;
     get unsupported(): boolean;
     get trigger(): boolean;
     set trigger(value: boolean);
@@ -529,5 +565,66 @@ declare class WcsListen extends HTMLElement {
     disconnectedCallback(): void;
 }
 
-export { ListenCore, SpeakCore, WcsListen, WcsSpeak, bootstrapSpeech, getConfig };
-export type { IWritableConfig, IWritableTagNames, ListenOptions, ListenPermissionState, SpeakOptions, SpeechVoiceInfo, WcsListenAlternative, WcsListenCommands, WcsListenCoreCommands, WcsListenCoreValues, WcsListenErrorDetail, WcsListenInputs, WcsListenResultDetail, WcsListenValues, WcsSpeakCommands, WcsSpeakCoreCommands, WcsSpeakCoreValues, WcsSpeakErrorDetail, WcsSpeakInputs, WcsSpeakValues };
+/**
+ * speechCapabilities.ts
+ *
+ * speech node 固有の error code(taxonomy)と derivation。汎用の error info 型は
+ * `./platformCapability.js`(/io-core/ から copy-distribution される生成ファイル)から
+ * import する。speech パッケージは 2 つの Core を持つ:
+ *
+ * - ListenCore(`<wcs-listen>`, SpeechRecognition / STT) — 認識セッションの
+ *   start/stop/abort。監視ではなく command 駆動だが、競合する非同期 operation の lane は
+ *   持たない(直近の start が単一セッションを置換する)ため、lane は採用せず error
+ *   taxonomy(errorInfo)のみを追加する。
+ * - SpeakCore(`<wcs-speak>`, SpeechSynthesis / TTS) — 発話キュー。同上。
+ *
+ * SpeechRecognitionErrorEvent と SpeechSynthesisErrorEvent は `error` enum の値集合が
+ * 異なるため、taxonomy も Core ごとに別 derive を持つ。いずれの Core も error detail の
+ * `.error` は既に安定コード(SpeechRecognition/SpeechSynthesis の error enum、または
+ * `"unsupported"` fallback)であり Error.name ではないので、derivation は notification と
+ * 同型の「`.error` コードを taxonomy に写す純粋 map」である。想定外のコードは防御的に
+ * `speech-error` へ畳む。
+ */
+
+/** 安定した listen(SpeechRecognition)error code(taxonomy)。値は公開キーとして固定。 */
+declare const WCS_LISTEN_ERROR_CODE: {
+    /** SpeechRecognition API 非対応(`SpeechRecognition` / `webkitSpeechRecognition` 不在)。 */
+    readonly CapabilityMissing: "capability-missing";
+    /** `not-allowed` / `service-not-allowed` — マイク権限拒否 / サービス不許可。 */
+    readonly NotAllowed: "not-allowed";
+    /** `audio-capture` — マイクが読めない(不在 / ハードウェア)。 */
+    readonly NotReadable: "not-readable";
+    /** `no-speech` — 無音のまま検出できず(transient — retry で成功しうる)。 */
+    readonly NoSpeech: "no-speech";
+    /** `network` — 認識バックエンドへの通信失敗(transient)。 */
+    readonly NetworkError: "network-error";
+    /** `aborted` — セッションが中断された(transient)。 */
+    readonly Aborted: "aborted";
+    /** `language-not-supported` / `bad-grammar` — 言語 / 文法が不正(前提条件違反)。 */
+    readonly InvalidArgument: "invalid-argument";
+    /** その他 / 想定外の error code に対する防御的 fallback。 */
+    readonly SpeechError: "speech-error";
+};
+/** 安定した speak(SpeechSynthesis)error code(taxonomy)。値は公開キーとして固定。 */
+declare const WCS_SPEAK_ERROR_CODE: {
+    /** SpeechSynthesis API 非対応(`speechSynthesis` / `SpeechSynthesisUtterance` 不在)。 */
+    readonly CapabilityMissing: "capability-missing";
+    /** `not-allowed` — 合成が許可されていない。 */
+    readonly NotAllowed: "not-allowed";
+    /** `canceled` / `interrupted` — 発話がキャンセル / 中断された(transient)。 */
+    readonly Aborted: "aborted";
+    /** `audio-busy` / `audio-hardware` — オーディオ出力の占有 / ハードウェア障害。 */
+    readonly NotReadable: "not-readable";
+    /** `network` — 合成バックエンドへの通信失敗(transient)。 */
+    readonly NetworkError: "network-error";
+    /** `language-unavailable` / `voice-unavailable` / `text-too-long` / `invalid-argument` —
+     *  発話パラメータが不正 / 未対応(前提条件違反)。 */
+    readonly InvalidArgument: "invalid-argument";
+    /** `synthesis-unavailable` / `synthesis-failed` — 合成そのものが失敗した。 */
+    readonly SynthesisFailed: "synthesis-failed";
+    /** その他 / 想定外の error code に対する防御的 fallback。 */
+    readonly SpeechError: "speech-error";
+};
+
+export { ListenCore, SpeakCore, WCS_LISTEN_ERROR_CODE, WCS_SPEAK_ERROR_CODE, WcsListen, WcsSpeak, bootstrapSpeech, getConfig };
+export type { IWritableConfig, IWritableTagNames, ListenOptions, ListenPermissionState, SpeakOptions, SpeechVoiceInfo, WcsIoErrorInfo, WcsIoErrorPhase, WcsListenAlternative, WcsListenCommands, WcsListenCoreCommands, WcsListenCoreValues, WcsListenErrorDetail, WcsListenInputs, WcsListenResultDetail, WcsListenValues, WcsSpeakCommands, WcsSpeakCoreCommands, WcsSpeakCoreValues, WcsSpeakErrorDetail, WcsSpeakInputs, WcsSpeakValues };

package/dist/index.esm.js

@@ -56,6 +56,162 @@ function setConfig(partialConfig) {
     frozenConfig = null;
 }
 
+/**
+ * speechCapabilities.ts
+ *
+ * speech node 固有の error code(taxonomy)と derivation。汎用の error info 型は
+ * `./platformCapability.js`(/io-core/ から copy-distribution される生成ファイル)から
+ * import する。speech パッケージは 2 つの Core を持つ:
+ *
+ * - ListenCore(`<wcs-listen>`, SpeechRecognition / STT) — 認識セッションの
+ *   start/stop/abort。監視ではなく command 駆動だが、競合する非同期 operation の lane は
+ *   持たない(直近の start が単一セッションを置換する)ため、lane は採用せず error
+ *   taxonomy(errorInfo)のみを追加する。
+ * - SpeakCore(`<wcs-speak>`, SpeechSynthesis / TTS) — 発話キュー。同上。
+ *
+ * SpeechRecognitionErrorEvent と SpeechSynthesisErrorEvent は `error` enum の値集合が
+ * 異なるため、taxonomy も Core ごとに別 derive を持つ。いずれの Core も error detail の
+ * `.error` は既に安定コード(SpeechRecognition/SpeechSynthesis の error enum、または
+ * `"unsupported"` fallback)であり Error.name ではないので、derivation は notification と
+ * 同型の「`.error` コードを taxonomy に写す純粋 map」である。想定外のコードは防御的に
+ * `speech-error` へ畳む。
+ */
+// ---------------------------------------------------------------------------
+// SpeechRecognition (STT) — <wcs-listen>
+// ---------------------------------------------------------------------------
+/** 安定した listen(SpeechRecognition)error code(taxonomy)。値は公開キーとして固定。 */
+const WCS_LISTEN_ERROR_CODE = {
+    /** SpeechRecognition API 非対応(`SpeechRecognition` / `webkitSpeechRecognition` 不在)。 */
+    CapabilityMissing: "capability-missing",
+    /** `not-allowed` / `service-not-allowed` — マイク権限拒否 / サービス不許可。 */
+    NotAllowed: "not-allowed",
+    /** `audio-capture` — マイクが読めない(不在 / ハードウェア)。 */
+    NotReadable: "not-readable",
+    /** `no-speech` — 無音のまま検出できず(transient — retry で成功しうる)。 */
+    NoSpeech: "no-speech",
+    /** `network` — 認識バックエンドへの通信失敗(transient)。 */
+    NetworkError: "network-error",
+    /** `aborted` — セッションが中断された(transient)。 */
+    Aborted: "aborted",
+    /** `language-not-supported` / `bad-grammar` — 言語 / 文法が不正(前提条件違反)。 */
+    InvalidArgument: "invalid-argument",
+    /** その他 / 想定外の error code に対する防御的 fallback。 */
+    SpeechError: "speech-error",
+};
+/**
+ * listen(SpeechRecognition)の失敗を serializable な error taxonomy に写す。引数は
+ * `wcs-listen:error` の detail(`{ error, message }`)そのもの。`.error` は
+ * `SpeechRecognitionErrorEvent.error` enum(または `"unsupported"` / `"aborted"`
+ * fallback)で、Error.name ではない。
+ *
+ * - `"unsupported"` は開始前の能力欠如 → phase="probe" / capability-missing。
+ * - `"not-allowed"` / `"service-not-allowed"` はマイク権限拒否 → phase="start" /
+ *   not-allowed。回復しない(recoverable=false)。ListenCore はこの 2 つを終端扱いにし
+ *   自動再開を止める。
+ * - `"audio-capture"` はマイクの読取失敗 → phase="start" / not-readable / false。
+ * - `"no-speech"` / `"network"` / `"aborted"` は transient で、continuous セッションは
+ *   `maxRestarts` の範囲で自動再開しうる → phase="execute" / recoverable=true。
+ * - `"language-not-supported"` / `"bad-grammar"` は言語 / 文法の前提違反 →
+ *   phase="start" / invalid-argument / false。
+ * - それ以外(未知コード)は防御的に phase="execute" / speech-error / false。
+ */
+function deriveListenErrorInfo(error) {
+    const { error: code, message } = error;
+    switch (code) {
+        case "unsupported":
+            return { code: WCS_LISTEN_ERROR_CODE.CapabilityMissing, phase: "probe", recoverable: false, message };
+        case "not-allowed":
+        case "service-not-allowed":
+            return { code: WCS_LISTEN_ERROR_CODE.NotAllowed, phase: "start", recoverable: false, message };
+        case "audio-capture":
+            return { code: WCS_LISTEN_ERROR_CODE.NotReadable, phase: "start", recoverable: false, message };
+        case "no-speech":
+            return { code: WCS_LISTEN_ERROR_CODE.NoSpeech, phase: "execute", recoverable: true, message };
+        case "network":
+            return { code: WCS_LISTEN_ERROR_CODE.NetworkError, phase: "execute", recoverable: true, message };
+        case "aborted":
+            return { code: WCS_LISTEN_ERROR_CODE.Aborted, phase: "execute", recoverable: true, message };
+        case "language-not-supported":
+        case "bad-grammar":
+            return { code: WCS_LISTEN_ERROR_CODE.InvalidArgument, phase: "start", recoverable: false, message };
+        default:
+            return { code: WCS_LISTEN_ERROR_CODE.SpeechError, phase: "execute", recoverable: false, message };
+    }
+}
+// ---------------------------------------------------------------------------
+// SpeechSynthesis (TTS) — <wcs-speak>
+// ---------------------------------------------------------------------------
+/** 安定した speak(SpeechSynthesis)error code(taxonomy)。値は公開キーとして固定。 */
+const WCS_SPEAK_ERROR_CODE = {
+    /** SpeechSynthesis API 非対応(`speechSynthesis` / `SpeechSynthesisUtterance` 不在)。 */
+    CapabilityMissing: "capability-missing",
+    /** `not-allowed` — 合成が許可されていない。 */
+    NotAllowed: "not-allowed",
+    /** `canceled` / `interrupted` — 発話がキャンセル / 中断された(transient)。 */
+    Aborted: "aborted",
+    /** `audio-busy` / `audio-hardware` — オーディオ出力の占有 / ハードウェア障害。 */
+    NotReadable: "not-readable",
+    /** `network` — 合成バックエンドへの通信失敗(transient)。 */
+    NetworkError: "network-error",
+    /** `language-unavailable` / `voice-unavailable` / `text-too-long` / `invalid-argument` —
+     *  発話パラメータが不正 / 未対応(前提条件違反)。 */
+    InvalidArgument: "invalid-argument",
+    /** `synthesis-unavailable` / `synthesis-failed` — 合成そのものが失敗した。 */
+    SynthesisFailed: "synthesis-failed",
+    /** その他 / 想定外の error code に対する防御的 fallback。 */
+    SpeechError: "speech-error",
+};
+/**
+ * speak(SpeechSynthesis)の失敗を serializable な error taxonomy に写す。引数は
+ * `wcs-speak:error` の detail(`{ error, message }`)そのもの。`.error` は
+ * `SpeechSynthesisErrorEvent.error` enum(または `"unsupported"` /
+ * `"synthesis-failed"` fallback)で、Error.name ではない。
+ *
+ * - `"unsupported"` は開始前の能力欠如 → phase="probe" / capability-missing。
+ * - `"not-allowed"` は合成不許可 → phase="start" / not-allowed / false。
+ * - `"canceled"` / `"interrupted"` は cancel()/後続発話による中断 → phase="execute" /
+ *   aborted / recoverable=true(通常は SpeakCore の世代ガードが握りつぶすため error として
+ *   表面化しないが、防御的に写す)。
+ * - `"audio-busy"` はオーディオ占有で transient(retry で回復しうる)→ phase="execute" /
+ *   not-readable / recoverable=true。`"audio-hardware"` はハードウェア障害で回復しない →
+ *   同 not-readable だが recoverable=false。
+ * - `"network"` は transient → phase="execute" / network-error / recoverable=true。
+ * - `"language-unavailable"` / `"voice-unavailable"` / `"text-too-long"` /
+ *   `"invalid-argument"` は発話パラメータの前提違反 → phase="start" / invalid-argument /
+ *   false。
+ * - `"synthesis-unavailable"` / `"synthesis-failed"` は合成実行の失敗 → phase="execute" /
+ *   synthesis-failed / false。
+ * - それ以外(未知コード)は防御的に phase="execute" / speech-error / false。
+ */
+function deriveSpeakErrorInfo(error) {
+    const { error: code, message } = error;
+    switch (code) {
+        case "unsupported":
+            return { code: WCS_SPEAK_ERROR_CODE.CapabilityMissing, phase: "probe", recoverable: false, message };
+        case "not-allowed":
+            return { code: WCS_SPEAK_ERROR_CODE.NotAllowed, phase: "start", recoverable: false, message };
+        case "canceled":
+        case "interrupted":
+            return { code: WCS_SPEAK_ERROR_CODE.Aborted, phase: "execute", recoverable: true, message };
+        case "audio-busy":
+            return { code: WCS_SPEAK_ERROR_CODE.NotReadable, phase: "execute", recoverable: true, message };
+        case "audio-hardware":
+            return { code: WCS_SPEAK_ERROR_CODE.NotReadable, phase: "execute", recoverable: false, message };
+        case "network":
+            return { code: WCS_SPEAK_ERROR_CODE.NetworkError, phase: "execute", recoverable: true, message };
+        case "language-unavailable":
+        case "voice-unavailable":
+        case "text-too-long":
+        case "invalid-argument":
+            return { code: WCS_SPEAK_ERROR_CODE.InvalidArgument, phase: "start", recoverable: false, message };
+        case "synthesis-unavailable":
+        case "synthesis-failed":
+            return { code: WCS_SPEAK_ERROR_CODE.SynthesisFailed, phase: "execute", recoverable: false, message };
+        default:
+            return { code: WCS_SPEAK_ERROR_CODE.SpeechError, phase: "execute", recoverable: false, message };
+    }
+}
+
 /**
  * Headless text-to-speech primitive. A thin, framework-agnostic wrapper around
  * the SpeechSynthesis API exposed through the wc-bindable protocol.
@@ -89,6 +245,13 @@ class SpeakCore extends EventTarget {
             { name: "charIndex", event: "wcs-speak:boundary", getter: (e) => e.detail?.charIndex ?? null },
             { name: "spokenWord", event: "wcs-speak:boundary", getter: (e) => e.detail?.word ?? null },
             { name: "error", event: "wcs-speak:error" },
+            // Serializable failure taxonomy (stable code / phase / recoverable), or null.
+            // Additive bindable output derived from `error.error` (the
+            // SpeechSynthesisErrorEvent.error code / "unsupported"); the existing `error`
+            // property/event are unchanged. Fires wcs-speak:error-info-changed. No lane —
+            // speak() is a momentary queue submission with no competing async operation to
+            // serialize.
+            { name: "errorInfo", event: "wcs-speak:error-info-changed" },
             { name: "unsupported", event: "wcs-speak:unsupported-changed" },
         ],
         commands: [
@@ -107,6 +270,7 @@ class SpeakCore extends EventTarget {
     _charIndex = null;
     _spokenWord = null;
     _error = null;
+    _errorInfo = null;
     _unsupported = false;
     // Count of utterances submitted via speak() but not yet started, and of
     // utterances started but not yet ended/errored. `pending`/`speaking` are
@@ -162,6 +326,15 @@ class SpeakCore extends EventTarget {
     get error() {
         return this._error;
     }
+    /**
+     * The last failure's serializable `WcsIoErrorInfo` (stable `code` / `phase` /
+     * `recoverable`), or null. Additive wc-bindable property (event
+     * `wcs-speak:error-info-changed`), derived from `error`; the existing `error`
+     * property/event are unchanged.
+     */
+    get errorInfo() {
+        return this._errorInfo;
+    }
     // Resolved once in the constructor (`_setUnsupported(!_hasApi())`) and never
     // re-evaluated: the speechSynthesis API's presence is immutable for the
     // lifetime of a document, so there's nothing to re-check.
@@ -244,11 +417,24 @@ class SpeakCore extends EventTarget {
         if (this._error === error)
             return;
         this._error = error;
+        // Keep the additive `errorInfo` taxonomy in sync with `error`: derive from the
+        // error code (or null on clear). Fires before the `error` event so an observer
+        // binding both sees the classification first, mirroring the io-node family.
+        this._commitErrorInfo(error === null ? null : deriveSpeakErrorInfo(error));
         this._target.dispatchEvent(new CustomEvent("wcs-speak:error", {
             detail: error,
             bubbles: true,
         }));
     }
+    // Called only from _setError (which already guards on error identity), so
+    // errorInfo transitions exactly when error does — no separate guard needed here.
+    _commitErrorInfo(info) {
+        this._errorInfo = info;
+        this._target.dispatchEvent(new CustomEvent("wcs-speak:error-info-changed", {
+            detail: info,
+            bubbles: true,
+        }));
+    }
     _setUnsupported(unsupported) {
         if (this._unsupported === unsupported)
             return;
@@ -741,6 +927,11 @@ class WcsSpeak extends HTMLElement {
     get error() {
         return this._core.error;
     }
+    // Additive Phase 6 taxonomy output (event wcs-speak:error-info-changed),
+    // delegated from the Core; declared via the inherited SpeakCore.wcBindable.
+    get errorInfo() {
+        return this._core.errorInfo;
+    }
     get unsupported() {
         return this._core.unsupported;
     }
@@ -831,6 +1022,12 @@ class ListenCore extends EventTarget {
             { name: "listening", event: "wcs-listen:listening-changed" },
             { name: "permission", event: "wcs-listen:permission-changed" },
             { name: "error", event: "wcs-listen:error" },
+            // Serializable failure taxonomy (stable code / phase / recoverable), or null.
+            // Additive bindable output derived from `error.error` (the
+            // SpeechRecognitionErrorEvent.error code / "unsupported"); the existing `error`
+            // property/event are unchanged. Fires wcs-listen:error-info-changed. No lane —
+            // recognition has no competing async operation to serialize.
+            { name: "errorInfo", event: "wcs-listen:error-info-changed" },
             { name: "unsupported", event: "wcs-listen:unsupported-changed" },
         ],
         commands: [
@@ -847,6 +1044,7 @@ class ListenCore extends EventTarget {
     _listening = false;
     _permission = "prompt";
     _error = null;
+    _errorInfo = null;
     _unsupported = false;
     // Intent flag: true between start() and stop()/abort()/terminal-error. Gates
     // the auto-restart loop so a session that ended because the user stopped it
@@ -893,6 +1091,15 @@ class ListenCore extends EventTarget {
     get error() {
         return this._error;
     }
+    /**
+     * The last failure's serializable `WcsIoErrorInfo` (stable `code` / `phase` /
+     * `recoverable`), or null. Additive wc-bindable property (event
+     * `wcs-listen:error-info-changed`), derived from `error`; the existing `error`
+     * property/event are unchanged.
+     */
+    get errorInfo() {
+        return this._errorInfo;
+    }
     // Resolved once in the constructor (`_setUnsupported(!Ctor)`) and never
     // re-evaluated: the SpeechRecognition API's presence is immutable for the
     // lifetime of a document, so there's nothing to re-check.
@@ -936,8 +1143,18 @@ class ListenCore extends EventTarget {
         if (this._error === value)
             return;
         this._error = value;
+        // Keep the additive `errorInfo` taxonomy in sync with `error`: derive from the
+        // error code (or null on clear). Fires before the `error` event so an observer
+        // binding both sees the classification first, mirroring the io-node family.
+        this._commitErrorInfo(value === null ? null : deriveListenErrorInfo(value));
         this._target.dispatchEvent(new CustomEvent("wcs-listen:error", { detail: value, bubbles: true }));
     }
+    // Called only from _setError (which already guards on error identity), so
+    // errorInfo transitions exactly when error does — no separate guard needed here.
+    _commitErrorInfo(info) {
+        this._errorInfo = info;
+        this._target.dispatchEvent(new CustomEvent("wcs-listen:error-info-changed", { detail: info, bubbles: true }));
+    }
     _setUnsupported(value) {
         if (this._unsupported === value)
             return;
@@ -1410,6 +1627,11 @@ class WcsListen extends HTMLElement {
     get error() {
         return this._core.error;
     }
+    // Additive Phase 6 taxonomy output (event wcs-listen:error-info-changed),
+    // delegated from the Core; declared via the inherited ListenCore.wcBindable.
+    get errorInfo() {
+        return this._core.errorInfo;
+    }
     get unsupported() {
         return this._core.unsupported;
     }
@@ -1489,5 +1711,5 @@ function bootstrapSpeech(userConfig) {
     registerComponents();
 }
 
-export { ListenCore, SpeakCore, WcsListen, WcsSpeak, bootstrapSpeech, getConfig };
+export { ListenCore, SpeakCore, WCS_LISTEN_ERROR_CODE, WCS_SPEAK_ERROR_CODE, WcsListen, WcsSpeak, bootstrapSpeech, getConfig };
 //# sourceMappingURL=index.esm.js.map