@burdenoff/fe-libs 2026.827.1 → 2026.903.2

package/dist/shared/assistant/index.d.ts

@@ -12,4 +12,8 @@ export { isQuotaExhaustedError } from './gatewayClient';
 export { buildProgress, getAssistantMedia, sanitize, isRecoverable, mergeMessagesById, mapSessionToHistory, } from './progress';
 export { buildPromptRequestBody, findExistingSandbox, createAssistantSandbox, waitForSandboxRunning, waitForAssistantServiceReady, createAssistantSession, getAssistantSession, sendAssistantPromptAsync, getAssistantMessages, getAssistantStreamAccess, extendAssistantSandboxTTL, sendHeartbeat, getAssistantArtifacts, downloadAssistantArtifact, checkAssistantAiCredits, reportAssistantAiTokenUsage, } from './api';
 export type { AssistantMode, AssistantPromptPart, PageContext, SandboxAssistantConfig, SandboxAssistantTransport, AssistantSendArgs, PrewarmLevel, AssistantRawMessage, AssistantRawMessagePart, AssistantWidgetMessage, AssistantArtifact, AssistantSandboxAuthContext, AssistantSessionInfo, DownloadedAssistantArtifact, StreamAccess, } from './types';
+export { isVoiceTurn, voiceSessionIdOf, voiceMarker, chatTurns, voiceTurnsOnly, groupBySession, groupConsecutiveBySession, } from './voice/turnVisibility';
+export type { VoiceSessionGroup, VoiceTranscriptTurn } from './voice/turnVisibility';
+export { useVoiceInput } from './voice/useVoiceInput';
+export type { UseVoiceInputOptions, UseVoiceInputResult, VoiceInputError } from './voice/useVoiceInput';
 //# sourceMappingURL=index.d.ts.map

package/dist/shared/assistant/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,QAAQ,EACR,aAAa,EACb,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAKpB,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,qBAAqB,EACrB,4BAA4B,EAC5B,sBAAsB,EACtB,mBAAmB,EACnB,wBAAwB,EACxB,oBAAoB,EACpB,wBAAwB,EACxB,yBAAyB,EACzB,aAAa,EACb,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,OAAO,CAAC;AAEf,YAAY,EACV,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,sBAAsB,EACtB,yBAAyB,EACzB,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,2BAA2B,EAC3B,YAAY,GACb,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,QAAQ,EACR,aAAa,EACb,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAKpB,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,qBAAqB,EACrB,4BAA4B,EAC5B,sBAAsB,EACtB,mBAAmB,EACnB,wBAAwB,EACxB,oBAAoB,EACpB,wBAAwB,EACxB,yBAAyB,EACzB,aAAa,EACb,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,OAAO,CAAC;AAEf,YAAY,EACV,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,sBAAsB,EACtB,yBAAyB,EACzB,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,2BAA2B,EAC3B,YAAY,GACb,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,WAAW,EACX,SAAS,EACT,cAAc,EACd,cAAc,EACd,yBAAyB,GAC1B,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,YAAY,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/shared/assistant/voice/turnVisibility.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Which surface does an assistant turn belong to — typed chat, or live voice?
+ *
+ * Shared by every product, for the same reason the transport is: voice was built
+ * as an overlay over the chat thread in the first product that needed it, so
+ * both surfaces write into ONE conversation. Without a marker there is no way to
+ * tell a spoken turn from a typed one once it is stored, and every voice
+ * exchange shows up in the typed thread.
+ *
+ * One marker fixes both directions:
+ *  - the chat panel hides turns that happened in voice
+ *  - the voice panel shows ONLY turns that happened in voice
+ *
+ * ★ Deliberately a DISPLAY split, not separate persistence. It survives a reload
+ * because the chat transcript is never rehydrated from the backend — the store is
+ * the only source of truth for what either panel shows. The backend session stays
+ * shared, so the model keeps full context across both surfaces, which is what
+ * makes "carry on where we left off" work. Genuinely separate backend sessions
+ * are a larger change and would cost that.
+ *
+ * ★ Product-agnostic by construction: it knows about turns and surfaces, never
+ * about crops, workflows or nodes. Nothing here needs to change for a product
+ * whose modes are `fluidgrids-node` rather than `api-calls`.
+ */
+interface TurnLike {
+    metadata?: ({
+        voice?: boolean;
+        voiceSessionId?: string;
+    } & Record<string, unknown>) | undefined;
+}
+/** True when this turn happened inside a live voice session. */
+export declare function isVoiceTurn(message: TurnLike): boolean;
+/**
+ * WHICH voice session produced this turn, if we know.
+ *
+ * ★ `undefined` is a real answer, not a failure: every spoken turn recorded
+ * before session ids existed carries `voice: true` and nothing else, and those
+ * conversations are in users' localStorage today. It means "some earlier
+ * session" and must never be read as "not spoken" — `isVoiceTurn` remains the
+ * only thing that decides which surface a turn belongs to.
+ */
+export declare function voiceSessionIdOf(message: TurnLike): string | undefined;
+/**
+ * The marker as a fragment to spread into a message's `metadata`.
+ *
+ * ★ `patchMessage` REPLACES `metadata` instead of merging it, so every write
+ * that rebuilds the object has to re-assert this or the turn silently demotes
+ * itself to a chat turn. That is exactly what shipped: the marker was stamped
+ * at creation and destroyed the instant the reply completed, so a spoken answer
+ * appeared in the typed thread AND disappeared from the voice transcript at the
+ * same moment — the transcript could only ever show the user's questions.
+ *
+ * Spreading one helper at all four sites is what keeps them from drifting;
+ * `voiceMarkerCallSitesAreComplete` in the test file fails the build if a new
+ * metadata write forgets it.
+ *
+ * ★ Takes the SESSION ID rather than a boolean, and stamps both fields from it.
+ * There used to be a separate `dictated` flag that call sites passed straight
+ * through, which made it possible to mark a turn as spoken while recording no
+ * session — a state with no meaning that only the transcript would ever notice.
+ * One argument means the two can never disagree.
+ *
+ * An absent id yields an EMPTY object, so a typed turn gets no marker at all:
+ * `chatTurns` is allow-by-default, and a stray `voice: false` would be a second
+ * way of saying the same thing.
+ */
+export declare function voiceMarker(sessionId: string | undefined): {
+    voice?: true;
+    voiceSessionId?: string;
+};
+/**
+ * The turns the CHAT panel should show: everything that was not spoken.
+ *
+ * Untagged turns are treated as chat, so every conversation recorded before the
+ * marker existed keeps rendering exactly as it did.
+ */
+export declare function chatTurns<T extends TurnLike>(messages: readonly T[]): T[];
+/**
+ * The turns the VOICE panel should show: only what was spoken.
+ *
+ * This is also what scopes the voice transcript to the session. Previously it
+ * took the last six messages of the whole conversation, so opening voice on an
+ * existing thread immediately painted typed replies — the wall of raw markdown
+ * in the operator's screenshot.
+ */
+export declare function voiceTurnsOnly<T extends TurnLike>(messages: readonly T[]): T[];
+/** One microphone-on-to-End, and the turns it produced, oldest first. */
+export interface VoiceSessionGroup<T> {
+    /**
+     * `undefined` for turns recorded before session ids existed. Rendered as one
+     * leading group rather than dropped — it is real history the user spoke.
+     */
+    sessionId: string | undefined;
+    turns: T[];
+}
+/**
+ * Split spoken turns into the sessions that produced them.
+ *
+ * The transcript shows a conversation's whole spoken history, which is the more
+ * useful of the two options — you can go back to what you asked last time — but
+ * run together it reads as one long exchange, and a question from a session
+ * three days ago looks like it was just asked. Grouping is what makes showing
+ * everything honest.
+ *
+ * ★ Groups by RUNS, not by collecting every turn with the same id. Turns are
+ * stored in the order they happened, so a run IS a session; gathering by id
+ * instead would silently reorder history if two sessions ever interleaved, and
+ * would hide it rather than show it if they did.
+ *
+ * ★ Consecutive un-stamped turns collapse into a single leading group. Treating
+ * each as its own session would print a divider between every pre-existing turn
+ * — one long exchange shattered into fragments, which is worse than the
+ * undivided version this is meant to fix.
+ */
+export declare function groupBySession<T extends TurnLike>(turns: readonly T[]): VoiceSessionGroup<T>[];
+/**
+ * The same grouping for turns that have already been flattened for display.
+ *
+ * The transcript renders `{id, role, text}`, not `Message`, so it cannot reach
+ * `metadata`. Passing the extractor keeps ONE implementation of the run logic
+ * instead of a second copy that drifts — the subtle part is the `undefined`
+ * merge, and having it in two places is how one of them stops doing it.
+ */
+export declare function groupConsecutiveBySession<T>(turns: readonly T[], sessionIdOf: (turn: T) => string | undefined): VoiceSessionGroup<T>[];
+/**
+ * A spoken turn flattened for display.
+ *
+ * ★ Shared by every component between the chat area and the transcript, so the
+ * session id is carried in the TYPE and not merely at runtime. The intermediate
+ * props used to declare `{id, role, text}` while the objects flowing through
+ * happened to have more: it compiled, and the dividers worked, purely because
+ * JavaScript keeps the extra property. Any future refactor that rebuilt one of
+ * those objects would have dropped the id and silently run every session back
+ * together — the exact defect this field was added to fix, reintroduced with no
+ * type error.
+ */
+export interface VoiceTranscriptTurn {
+    id: string;
+    role: 'user' | 'assistant';
+    text: string;
+    /**
+     * When the turn happened, ISO.
+     *
+     * Carried for the SAVED transcript rather than for the on-screen one: a file
+     * that outlives the session is read later, when "when did I ask that?" is the
+     * actual question, and a record without times answers it badly.
+     */
+    timestamp: string;
+    /**
+     * `undefined` on turns recorded before session ids existed.
+     *
+     * ★ REQUIRED-but-nullable rather than optional, and the difference is the
+     * whole point. With `sessionId?: string`, an object rebuilt without the key is
+     * still structurally assignable — so a refactor that mapped turns through and
+     * dropped it would compile, and every session would silently run back
+     * together. Written this way, omitting the key is a type error and passing
+     * `undefined` is a decision someone made on purpose.
+     */
+    sessionId: string | undefined;
+}
+export {};
+//# sourceMappingURL=turnVisibility.d.ts.map

package/dist/shared/assistant/voice/turnVisibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turnVisibility.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/voice/turnVisibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,UAAU,QAAQ;IAChB,QAAQ,CAAC,EAAE,CAAC;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;CACjG;AAED,gEAAgE;AAChE,wBAAgB,WAAW,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAEtD;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAGtE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG;IAAE,KAAK,CAAC,EAAE,IAAI,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,CAEpG;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAEzE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAE9E;AAED,yEAAyE;AACzE,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAClC;;;OAGG;IACH,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,KAAK,EAAE,CAAC,EAAE,CAAC;CACZ;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAE9F;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EACzC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,SAAS,GAC3C,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAWxB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;;OASG;IACH,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B"}

package/dist/shared/assistant/voice/turnVisibility.js

@@ -0,0 +1,36 @@
+//#region src/shared/assistant/voice/turnVisibility.ts
+function e(e) {
+	return e.metadata?.voice === !0;
+}
+function t(e) {
+	let t = e.metadata?.voiceSessionId;
+	return typeof t == "string" && t.length > 0 ? t : void 0;
+}
+function n(e) {
+	return e ? {
+		voice: !0,
+		voiceSessionId: e
+	} : {};
+}
+function r(t) {
+	return t.filter((t) => !e(t));
+}
+function i(t) {
+	return t.filter(e);
+}
+function a(e) {
+	return o(e, t);
+}
+function o(e, t) {
+	let n = [];
+	for (let r of e) {
+		let e = t(r), i = n[n.length - 1];
+		i && i.sessionId === e ? i.turns.push(r) : n.push({
+			sessionId: e,
+			turns: [r]
+		});
+	}
+	return n;
+}
+//#endregion
+export { r as chatTurns, a as groupBySession, o as groupConsecutiveBySession, e as isVoiceTurn, n as voiceMarker, t as voiceSessionIdOf, i as voiceTurnsOnly };

package/dist/shared/assistant/voice/useVoiceInput.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Speech-to-text for the assistant composer (Workstream 2 of the AI Assistant
+ * V2 multimodal effort).
+ *
+ * Input-only, browser-native (Web Speech API). It degrades gracefully:
+ * `isSupported` is false on engines without SpeechRecognition (notably Firefox),
+ * and the composer hides the mic entirely in that case rather than showing a
+ * dead control.
+ *
+ * ⚠️ This does NOT mean the audio stays on the device. Chrome's
+ * `webkitSpeechRecognition` is a NETWORK service — the audio is streamed to the
+ * browser vendor for recognition, and the supported language list is theirs, not
+ * ours. We neither receive nor store it, which is all an earlier version of this
+ * comment ("no audio ever leaves the device through us") actually claimed; read
+ * literally it implied something stronger and untrue. Whether recording farmers'
+ * speech this way needs disclosure or consent is a product/legal call, not a
+ * code one.
+ *
+ * Output (reading replies aloud) is a separate concern and lives in
+ * `AssistantSpeechProvider`; an earlier version of this note said the assistant
+ * does not speak, which stopped being true when BOFF-6290 shipped.
+ *
+ * Differences from the fe-libs `assistantWidget/useVoiceInput` this is modelled
+ * on, all of which the composer needs:
+ *  - **interim results are exposed**, so the user sees words appear while
+ *    speaking instead of staring at a silent button until a phrase finalises;
+ *  - **errors are surfaced** (`error`) so a denied mic permission can be
+ *    explained rather than looking like a no-op;
+ *  - **the recogniser language follows the app locale** (a Tamil or Hindi
+ *    farmer dictating into an `en-US` recogniser gets garbage);
+ *  - **`stop()` resolves the final transcript** through `onFinalize`, so the
+ *    composer can commit exactly once when the user stops.
+ */
+export type VoiceInputError = 'not-allowed' | 'no-speech' | 'audio-capture' | 'network' | 'language-not-supported' | 'unknown';
+export interface UseVoiceInputOptions {
+    /**
+     * Called with each newly finalised phrase. The composer appends it to the
+     * draft; keeping the committed text in the caller (rather than accumulating
+     * here) means the user can freely edit while dictation continues.
+     */
+    onFinalize: (text: string) => void;
+    /**
+     * BCP-47 tag to listen for. Omit to follow the app locale, which is what this
+     * hook did unconditionally before (BOFF-7108).
+     *
+     * The two are genuinely independent: a farmer whose interface is English may
+     * well speak Tamil, and deriving the recogniser language from the UI meant the
+     * only way to dictate Tamil was to translate the entire app.
+     */
+    language?: string;
+}
+export interface UseVoiceInputResult {
+    isSupported: boolean;
+    isListening: boolean;
+    /** Requested, not yet capturing. Distinguishes starting up from listening. */
+    isStarting: boolean;
+    /**
+     * Starting OR listening — "the microphone is busy".
+     *
+     * ★ Most callers mean THIS and were testing `isListening`, which was the same
+     * thing only while capture was assumed the instant start() returned. Exposing
+     * it once stops four call sites disagreeing about what counts as active.
+     */
+    isActive: boolean;
+    /** Words recognised but not yet finalised — render as a live hint. */
+    interim: string;
+    error: VoiceInputError | null;
+    /**
+     * BCP-47 tag the recogniser was asked for. Exposed so error copy can name the
+     * language that failed ("Tamil dictation is not supported…") rather than
+     * leaving the user to guess which language the browser rejected.
+     */
+    language: string;
+    start: () => void;
+    stop: () => void;
+    /** Start if idle, stop if listening — what the mic button binds to. */
+    toggle: () => void;
+    clearError: () => void;
+}
+export declare function useVoiceInput({ onFinalize, language: requested }: UseVoiceInputOptions): UseVoiceInputResult;
+//# sourceMappingURL=useVoiceInput.d.ts.map

package/dist/shared/assistant/voice/useVoiceInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVoiceInput.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/voice/useVoiceInput.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AA+DH,MAAM,MAAM,eAAe,GACzB,aAAa,GAAG,WAAW,GAAG,eAAe,GAAG,SAAS,GAAG,wBAAwB,GAAG,SAAS,CAAC;AA+BnG,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,8EAA8E;IAC9E,UAAU,EAAE,OAAO,CAAC;IACpB;;;;;;OAMG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,sEAAsE;IACtE,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,uEAAuE;IACvE,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED,wBAAgB,aAAa,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,oBAAoB,GAAG,mBAAmB,CA+K5G"}

package/dist/shared/assistant/voice/useVoiceInput.js

@@ -0,0 +1,100 @@
+import { useI18n as e } from "../../providers/shell/I18nProvider.js";
+import { useCallback as t, useEffect as n, useRef as r, useState as i } from "react";
+//#region src/shared/assistant/voice/useVoiceInput.ts
+var a = {
+	en: "en-US",
+	es: "es-ES",
+	fr: "fr-FR",
+	de: "de-DE",
+	ja: "ja-JP",
+	zh: "zh-CN",
+	ta: "ta-IN",
+	hi: "hi-IN",
+	ar: "ar-SA"
+};
+function o() {
+	if (typeof window > "u") return null;
+	let e = window;
+	return e.SpeechRecognition ?? e.webkitSpeechRecognition ?? null;
+}
+function s(e) {
+	switch (e) {
+		case "not-allowed":
+		case "service-not-allowed": return "not-allowed";
+		case "no-speech": return "no-speech";
+		case "audio-capture": return "audio-capture";
+		case "network": return "network";
+		case "language-not-supported": return "language-not-supported";
+		default: return "unknown";
+	}
+}
+function c({ onFinalize: c, language: l }) {
+	let { locale: u } = e(), [d, f] = i(!1), [p, m] = i(!1), [h, g] = i(""), [_, v] = i(null), y = r(null), b = r(0), x = r(c);
+	n(() => {
+		x.current = c;
+	}, [c]);
+	let S = o() !== null, C = l ?? a[u] ?? "en-US";
+	n(() => () => {
+		y.current?.abort(), y.current = null;
+	}, []);
+	let w = t(() => {
+		let e = o();
+		if (!e || y.current) return;
+		let t = new e();
+		t.continuous = !0, t.interimResults = !0, t.lang = C;
+		let n = b.current;
+		t.onresult = (e) => {
+			if (n !== b.current) return;
+			let t = "", r = "";
+			for (let n = e.resultIndex; n < e.results.length; n += 1) {
+				let i = e.results[n], a = i[0]?.transcript ?? "";
+				i.isFinal ? t += a : r += a;
+			}
+			t.trim() && x.current(t.trim()), g(r.trim());
+		}, t.onerror = (e) => {
+			if (n !== b.current) return;
+			let t = s(e.error);
+			t !== "no-speech" && v(t);
+		}, t.onend = () => {
+			n === b.current && (y.current = null, m(!1), f(!1), g(""));
+		}, t.onstart = () => {
+			n === b.current && (m(!1), f(!0));
+		}, m(!0);
+		try {
+			t.start();
+		} catch {
+			y.current = null, m(!1), f(!1);
+			return;
+		}
+		y.current = t, v(null), g("");
+	}, [C]), T = t(() => {
+		let e = y.current;
+		y.current = null, b.current += 1, e?.stop(), m(!1), f(!1), g("");
+	}, []), E = r(C);
+	n(() => {
+		E.current !== C && (E.current = C, T(), v(null));
+	}, [C, T]);
+	let D = t(() => {
+		d || p ? T() : w();
+	}, [
+		d,
+		p,
+		w,
+		T
+	]), O = t(() => v(null), []);
+	return {
+		isSupported: S,
+		isListening: d,
+		isStarting: p,
+		isActive: d || p,
+		interim: h,
+		error: _,
+		language: C,
+		start: w,
+		stop: T,
+		toggle: D,
+		clearError: O
+	};
+}
+//#endregion
+export { c as useVoiceInput };

package/dist/shared/components/assistantWidget/useVoiceInput.d.ts

@@ -1,15 +1,33 @@
 /**
- * Speech-to-text hook for the AssistantWidget (browser Web Speech API).
+ * The widget's dictation hook — now a thin wrapper over the shared engine.
  *
- * Input-only: it transcribes microphone speech into text. There is no
- * text-to-speech here by design (the widget does not read replies aloud).
- * Gracefully degrades — `isSupported` is false on browsers without
- * SpeechRecognition, and the mic button is hidden in that case.
+ * ★ WHY A WRAPPER AND NOT A REPLACEMENT. This file's API (`transcript`, `reset`)
+ * is what every shell mounting `AssistantWidget` already calls. The shared engine
+ * has a different, better contract — it reports finalised phrases through a
+ * callback instead of accumulating a string — so swapping it in directly would
+ * have broken every one of those consumers at once, for a change that is meant to
+ * FIX them.
+ *
+ * ★ WHAT CONSUMERS SILENTLY GAIN. This file was 122 lines and the engine it now
+ * delegates to is 350, because that engine carries fixes this copy never got:
+ *
+ *  - `onstart` as the real capture signal. `isListening` set after `start()`
+ *    returns only means the request was accepted, so the button reported
+ *    "listening" while the microphone was still closed.
+ *  - `isStarting`, cleared on every terminal path — the permission window used to
+ *    leave the control dead with no way to recover but a reload.
+ *  - `no-speech` and the other transient recogniser errors treated as recoverable
+ *    rather than fatal.
+ *
+ * Those were fixed in one product weeks ago. Every other product kept the broken
+ * button until this wrapper landed.
+ *
+ * Deprecated in favour of importing the engine directly: the callback contract
+ * loses nothing and avoids accumulating a string the caller may not want.
  */
 export interface UseVoiceInputReturn {
     isSupported: boolean;
     isListening: boolean;
-    /** Final transcript accumulated since the last `reset()`. */
     transcript: string;
     start: () => void;
     stop: () => void;

package/dist/shared/components/assistantWidget/useVoiceInput.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useVoiceInput.d.ts","sourceRoot":"","sources":["../../../../src/shared/components/assistantWidget/useVoiceInput.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAsCH,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,wBAAgB,aAAa,CAAC,IAAI,SAAU,GAAG,mBAAmB,CAkEjE"}
+{"version":3,"file":"useVoiceInput.d.ts","sourceRoot":"","sources":["../../../../src/shared/components/assistantWidget/useVoiceInput.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,wBAAgB,aAAa,CAAC,IAAI,SAAU,GAAG,mBAAmB,CA4BjE"}

package/dist/shared/components/assistantWidget/useVoiceInput.js

@@ -1,41 +1,21 @@
-import { useCallback as e, useEffect as t, useRef as n, useState as r } from "react";
+import { useVoiceInput as e } from "../../assistant/voice/useVoiceInput.js";
+import { useCallback as t, useRef as n, useState as r } from "react";
 //#region src/shared/components/assistantWidget/useVoiceInput.ts
-function i() {
-	if (typeof window > "u") return null;
-	let e = window;
-	return e.SpeechRecognition ?? e.webkitSpeechRecognition ?? null;
-}
-function a(a = "en-US") {
-	let [o, s] = r(!1), [c, l] = r(""), u = n(null), d = i(), f = d !== null;
-	return t(() => () => {
-		u.current &&= (u.current.abort(), null);
-	}, []), {
-		isSupported: f,
-		isListening: o,
-		transcript: c,
-		start: e(() => {
-			if (!d || u.current) return;
-			let e = new d();
-			e.continuous = !0, e.interimResults = !0, e.lang = a, e.onresult = (e) => {
-				let t = "";
-				for (let n = e.resultIndex; n < e.results.length; n++) {
-					let r = e.results[n];
-					r.isFinal && (t += r[0].transcript);
-				}
-				t && l((e) => e ? `${e} ${t}` : t);
-			}, e.onerror = () => {
-				s(!1), u.current = null;
-			}, e.onend = () => {
-				s(!1), u.current = null;
-			}, u.current = e, e.start(), s(!0);
-		}, [d, a]),
-		stop: e(() => {
-			u.current &&= (u.current.stop(), null), s(!1);
-		}, []),
-		reset: e(() => {
-			l("");
-		}, [])
+function i(i = "en-US") {
+	let [a, o] = r(""), s = n((e) => {
+		o((t) => t ? `${t} ${e}` : e);
+	}), c = e({
+		onFinalize: (e) => s.current(e),
+		language: i
+	}), l = t(() => o(""), []);
+	return {
+		isSupported: c.isSupported,
+		isListening: c.isActive,
+		transcript: a,
+		start: c.start,
+		stop: c.stop,
+		reset: l
 	};
 }
 //#endregion
-export { a as useVoiceInput };
+export { i as useVoiceInput };

package/dist/shared-assistant.js

@@ -1,7 +1,9 @@
-import { isQuotaExhaustedError as e } from "./shared/assistant/gatewayClient.js";
-import { buildPromptRequestBody as t, checkAssistantAiCredits as n, createAssistantSandbox as r, createAssistantSession as i, downloadAssistantArtifact as a, extendAssistantSandboxTTL as o, findExistingSandbox as s, getAssistantArtifacts as c, getAssistantMessages as l, getAssistantSession as u, getAssistantStreamAccess as d, reportAssistantAiTokenUsage as f, sendAssistantPromptAsync as p, sendHeartbeat as m, waitForAssistantServiceReady as h, waitForSandboxRunning as g } from "./shared/assistant/api.js";
-import { AssistantRuntimeManager as _ } from "./shared/assistant/runtime.js";
-import { buildProgress as v, getAssistantMedia as y, isRecoverable as b, mapSessionToHistory as x, mergeMessagesById as S, sanitize as C } from "./shared/assistant/progress.js";
-import { createSandboxAssistantTransport as w } from "./shared/assistant/createSandboxAssistantTransport.js";
-import { useSandboxAssistantTransport as T } from "./shared/assistant/useSandboxAssistantTransport.js";
-export { _ as AssistantRuntimeManager, v as buildProgress, t as buildPromptRequestBody, n as checkAssistantAiCredits, r as createAssistantSandbox, i as createAssistantSession, w as createSandboxAssistantTransport, a as downloadAssistantArtifact, o as extendAssistantSandboxTTL, s as findExistingSandbox, c as getAssistantArtifacts, y as getAssistantMedia, l as getAssistantMessages, u as getAssistantSession, d as getAssistantStreamAccess, e as isQuotaExhaustedError, b as isRecoverable, x as mapSessionToHistory, S as mergeMessagesById, f as reportAssistantAiTokenUsage, C as sanitize, p as sendAssistantPromptAsync, m as sendHeartbeat, T as useSandboxAssistantTransport, h as waitForAssistantServiceReady, g as waitForSandboxRunning };
+import { useVoiceInput as e } from "./shared/assistant/voice/useVoiceInput.js";
+import { isQuotaExhaustedError as t } from "./shared/assistant/gatewayClient.js";
+import { buildPromptRequestBody as n, checkAssistantAiCredits as r, createAssistantSandbox as i, createAssistantSession as a, downloadAssistantArtifact as o, extendAssistantSandboxTTL as s, findExistingSandbox as c, getAssistantArtifacts as l, getAssistantMessages as u, getAssistantSession as d, getAssistantStreamAccess as f, reportAssistantAiTokenUsage as p, sendAssistantPromptAsync as m, sendHeartbeat as h, waitForAssistantServiceReady as g, waitForSandboxRunning as _ } from "./shared/assistant/api.js";
+import { AssistantRuntimeManager as v } from "./shared/assistant/runtime.js";
+import { buildProgress as y, getAssistantMedia as b, isRecoverable as x, mapSessionToHistory as S, mergeMessagesById as C, sanitize as w } from "./shared/assistant/progress.js";
+import { createSandboxAssistantTransport as T } from "./shared/assistant/createSandboxAssistantTransport.js";
+import { useSandboxAssistantTransport as E } from "./shared/assistant/useSandboxAssistantTransport.js";
+import { chatTurns as D, groupBySession as O, groupConsecutiveBySession as k, isVoiceTurn as A, voiceMarker as j, voiceSessionIdOf as M, voiceTurnsOnly as N } from "./shared/assistant/voice/turnVisibility.js";
+export { v as AssistantRuntimeManager, y as buildProgress, n as buildPromptRequestBody, D as chatTurns, r as checkAssistantAiCredits, i as createAssistantSandbox, a as createAssistantSession, T as createSandboxAssistantTransport, o as downloadAssistantArtifact, s as extendAssistantSandboxTTL, c as findExistingSandbox, l as getAssistantArtifacts, b as getAssistantMedia, u as getAssistantMessages, d as getAssistantSession, f as getAssistantStreamAccess, O as groupBySession, k as groupConsecutiveBySession, t as isQuotaExhaustedError, x as isRecoverable, A as isVoiceTurn, S as mapSessionToHistory, C as mergeMessagesById, p as reportAssistantAiTokenUsage, w as sanitize, m as sendAssistantPromptAsync, h as sendHeartbeat, E as useSandboxAssistantTransport, e as useVoiceInput, j as voiceMarker, M as voiceSessionIdOf, N as voiceTurnsOnly, g as waitForAssistantServiceReady, _ as waitForSandboxRunning };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burdenoff/fe-libs",
-  "version": "2026.827.1",
+  "version": "2026.903.2",
   "description": "Burdenoff frontend primitives and domain libraries",
   "type": "module",
   "bin": {