@belonguniverseai/react-sdk 0.6.27 → 0.6.29

package/dist/components/embed/ResponseModeDial.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The composer's response mode (embed/response-mode.ts), on the Codex app's
+ * dial: a pill showing the current mode opens a popover with the mode names
+ * over a chunky three-stop slider, and the chosen mode's upside spelled out
+ * underneath. The dock names modes only; which model a mode buys is the
+ * backend's call, so no model name ever appears here.
+ */
+export declare function ResponseModeDial({ className, }: Readonly<{
+    /** The composer's shared control sizing. */
+    className: string;
+}>): import("react").JSX.Element;

package/dist/components/embed/SessionStatsPanel.d.ts

@@ -4,6 +4,9 @@
  * session, not just the active one, so REST not folded stream parts). Shows
  * tokens, time running, turns, tool calls, runtime + a per-turn table, with two
  * CSV exports.
+ *
+ * Plan 018 — tokens are WEIGHTED tokens, the one unit users see; the raw
+ * input / output split is not shown (nor exported).
  */
 export type SessionStatsPanelProps = {
     readonly sessionId: string | null;

package/dist/components/embed/UsageSettings.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Settings → Usage (plan 018): the signed-in user's own consumption, in
+ * weighted tokens — month-to-date, today, and a 30-day daily strip.
+ *
+ * One unit only. The raw input / output / cache counts never reach the dock
+ * (`GET /v1/usage` does not send them). Days are UTC days, and the view says so.
+ * Quiet by design (§42): primary-coloured bars, muted text, no red. A load
+ * failure is one muted line with a retry, and a cloud that predates the route
+ * says "not available yet" instead of failing.
+ */
+export declare const UsageSettings: () => import("react").JSX.Element;

package/dist/components/embed/format-compact-number.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Locale-aware compact numbers for the Usage view (plan 018): "1.3M" in
+ * English, "1,3 M" in Spanish — `formatTokens` predates the dock's locales and
+ * always writes "." and "k". One formatter per locale, built once.
+ */
+export declare const formatCompactNumber: (value: number, locale: string) => string;
+/** A full, grouped number for tooltips and screen readers: "1,250,000". */
+export declare const formatWholeNumber: (value: number, locale: string) => string;

package/dist/components/embed/use-artifact-operation-notices.d.ts

@@ -15,5 +15,6 @@ export declare const useArtifactOperationNotices: (input: {
 }) => {
     readonly notice: ArtifactOperationNotice;
     readonly onOperation: (operation: ArtifactOperation, sighting: ArtifactOperationSighting) => void;
+    readonly onReconnectRequired: (reconnectId: string) => void;
     readonly stop: () => void;
 };

package/dist/components/scheduled/ConfirmRunPausedScheduleDialog.d.ts

@@ -0,0 +1,18 @@
+/**
+ * "Run now" confirmation for a PAUSED schedule (list card menu + detail menu).
+ *
+ * #837: run-now on a paused task runs the whole task once, emails included,
+ * and the task stays paused. Users reasonably read "paused" as "nothing will
+ * go out", so an email that arrives afterwards looks like a bug unless the
+ * surface says so first. An active task runs straight away, as before.
+ *
+ * Every schedule notifies by email (completion or custom), so the copy names
+ * emails unconditionally. Not red (§42): nothing is failing and the user is
+ * choosing it, so the confirm is the ordinary primary button.
+ */
+export declare const ConfirmRunPausedScheduleDialog: (props: {
+    readonly open: boolean;
+    readonly onOpenChange: (open: boolean) => void;
+    readonly busy: boolean;
+    readonly onConfirm: () => void;
+}) => import("react").JSX.Element;

package/dist/components/scheduled/EmailCopiesFields.d.ts

@@ -0,0 +1,19 @@
+import { EmailCopies } from '../../api/task-schedules.ts';
+export type EmailCopiesText = {
+    readonly cc: string;
+    readonly bcc: string;
+    readonly replyTo: string;
+};
+export declare const EMPTY_EMAIL_COPIES_TEXT: EmailCopiesText;
+export declare const emailCopiesText: (copies: EmailCopies | null | undefined) => EmailCopiesText;
+/** `null` when any list is invalid; empty lists are dropped from the result. */
+export declare const parseEmailCopies: (text: EmailCopiesText) => EmailCopies | null;
+export declare const EmailCopiesFields: (props: {
+    readonly value: EmailCopiesText;
+    readonly onChange: (value: EmailCopiesText) => void;
+    readonly disabled: boolean;
+    /** Section label when expanded; collapsed, the link reads "Add CC, BCC or Reply-To". */
+    readonly label: string;
+    readonly help: string;
+    readonly testIdPrefix: string;
+}) => import("react").JSX.Element;

package/dist/components/scheduled/ScheduledDetailSurface.d.ts

@@ -1,8 +1,9 @@
-import { TaskScheduleDetail, TaskScheduleRun } from '../../api/task-schedules.ts';
+import { EmailCopies, TaskScheduleDetail, TaskScheduleRun } from '../../api/task-schedules.ts';
 export declare const EmailNotificationIndicator: (props: {
     readonly notification: TaskScheduleDetail["notification"];
     readonly shared?: boolean;
     readonly sharedRecipients?: readonly string[] | undefined;
+    readonly sharedCopies?: EmailCopies | null | undefined;
 }) => import("react").JSX.Element;
 export declare const MicrosoftTeamsDeliveryIndicator: (props: {
     readonly delivery: NonNullable<TaskScheduleDetail["microsoftTeamsDelivery"]>;

package/dist/components/scheduled/use-run-now-with-confirmation.d.ts

@@ -0,0 +1,17 @@
+import { TaskScheduleDetail } from '../../api/task-schedules.ts';
+export declare const useRunNowWithConfirmation: (props: {
+    readonly taskScheduleId: string;
+    readonly onStarted: () => void;
+    readonly onFailed: () => void;
+}) => {
+    /** Start Run now from the status the surface currently shows. */
+    request: (shownStatus: TaskScheduleDetail["status"]) => void;
+    pending: boolean;
+    /** Spread onto `ConfirmRunPausedScheduleDialog`. */
+    dialog: {
+        open: boolean;
+        busy: boolean;
+        onOpenChange: (open: boolean) => void;
+        onConfirm: () => void;
+    };
+};

package/dist/embed/artifact-action-bridge.d.ts

@@ -11,9 +11,16 @@ export type ArtifactActionBridge = {
 /**
  * Why a bridge asks its owner for a fresh preview mint (new token, new document key, new frame):
  * `navigation` — a second document loaded in the frame (the report reloaded or navigated itself);
- * `stale` — the bridge was created for a frame that already loaded, or for a key already spent.
+ * `stale` — the bridge was created for a frame that already loaded, or for a key already spent;
+ * `unanswered` — the document never answered its challenge (#796).
  */
-export type ArtifactRemintReason = "navigation" | "stale";
+export type ArtifactRemintReason = "navigation" | "stale" | "unanswered";
+/**
+ * Visible time the parent waits for the report to answer its challenge. A document served without
+ * its single-use key (a refetch, a failed key claim, an early self-navigation) never answers and
+ * would otherwise stay without actions until its preview URL renews, about 12 minutes later (#796).
+ */
+export declare const ARTIFACT_CHALLENGE_TIMEOUT_MS = 10000;
 /**
  * How the parent learned a snapshot: `transition` = it just changed in front of this view (a
  * submission, an approval decision, an observed status read); `snapshot` = a current read the
@@ -47,7 +54,8 @@ export declare const nextArtifactPollDelayMs: (previous: {
  * challenge sent on the frame's FIRST load, and the minted document key; origin "null" is never an
  * authority. The first document is the one the parent navigated the frame to; any later load is a
  * document the report chose (reload or navigation), so the bridge retires and asks for a re-mint
- * rather than offering that document a channel.
+ * rather than offering that document a channel. A challenge still unanswered after 10 s of visible
+ * time also asks for a re-mint; the bridge keeps listening until its owner replaces it.
  */
 export declare const createArtifactActionBridge: (input: {
     readonly frame: HTMLIFrameElement;
@@ -59,6 +67,8 @@ export declare const createArtifactActionBridge: (input: {
     readonly onRemint: (reason: ArtifactRemintReason) => void;
     /** Every validated snapshot this bridge received, for trusted parent UI (never the report). */
     readonly onOperation?: (operation: ArtifactOperation, sighting: ArtifactOperationSighting) => void;
+    /** An authenticated API refusal needs connection repair; never a report-requested method. */
+    readonly onReconnectRequired?: (reconnectId: string) => void;
     /** The frame already finished a load before this bridge existed: its document is unknown. */
     readonly frameAlreadyLoaded?: boolean;
     readonly requestWindow?: ArtifactRequestWindow;

package/dist/embed/artifact-remint-budget.d.ts

@@ -7,6 +7,11 @@
 export declare const ARTIFACT_SELF_RELOAD_WINDOW_MS = 60000;
 /** Delay before each successive re-mint inside one window. Its length is the per-window cap. */
 export declare const ARTIFACT_REMINT_BACKOFF_MS: readonly number[];
+/**
+ * Re-mints one view spends on a report that never answered its challenge (it was served without
+ * its single-use key). Separate from the self-reload allowance: the report did nothing wrong (#796).
+ */
+export declare const ARTIFACT_UNANSWERED_REMINTS_PER_VIEW = 2;
 export type ArtifactRemintDecision = {
     readonly kind: "remint";
     readonly delayMs: number;

package/dist/embed/copy.d.ts

@@ -68,8 +68,8 @@ export type MenuCopy = {
     readonly history: string;
     readonly voice: string;
     readonly pushToTalk: string;
-    readonly pressAnyKey: string;
-    readonly change: string;
+    /** Push-to-talk key select: the option that binds no key. */
+    readonly pushToTalkOff: string;
     readonly reset: string;
     readonly voiceSend: string;
     readonly voiceSendConfirm: string;
@@ -96,9 +96,6 @@ export type SkillsPanelCopy = {
 export type DockCopy = {
     readonly welcomeCard: WelcomeCardContent;
     readonly tour: TourCopy;
-    /** Localized name for the Space key (every other code renders via
-     *  `formatKeyCode`, which is already language-neutral). */
-    readonly spaceKeyLabel: string;
     readonly replayMenu: string;
     readonly language: {
         readonly label: string;
@@ -159,25 +156,22 @@ export type DockCopy = {
         readonly micTooltip: (keyLabel: string) => string;
         /** Mobile variant of the mic tooltip — omits the keyboard fallback. */
         readonly micTooltipTouch: string;
+        /** Desktop mic tooltip while no push-to-talk key is bound — says where to pick one. */
+        readonly micTooltipNoKey: string;
         readonly viewPlan: string;
         readonly hidePlan: string;
     };
 };
 export declare const DOCK_COPY: Record<Locale, DockCopy>;
-/**
- * Human label for the push-to-talk key, localized where a translation exists:
- * "Space" reads "Espacio"/"Espaço" in ES/PT; every other code goes through
- * `formatKeyCode` ("ControlLeft" → "Left Ctrl", "KeyV" → "V", …).
- */
-export declare const voiceKeyLabel: (code: string, locale: Locale) => string;
 /**
  * Flatten the variant-keyed welcome-card content into the strings the
- * presentational card renders, injecting the LIVE voice key label, then
- * applying the active theme's per-locale `copy` override (BEL-135) when a
- * tenant supplies one — Simetrik's preset, or a published theme.json. A
- * neutral host with no override gets the variant copy as-is.
+ * presentational card renders, injecting the LIVE voice key label (`null`
+ * when no push-to-talk key is bound), then applying the active theme's
+ * per-locale `copy` override (BEL-135) when a tenant supplies one — Simetrik's
+ * preset, or a published theme.json. A neutral host with no override gets the
+ * variant copy as-is.
  */
-export declare const resolveWelcomeCardCopy: (locale: Locale, variant: DockCopyVariant, keyLabel: string, override?: DockCopyOverride, options?: {
+export declare const resolveWelcomeCardCopy: (locale: Locale, variant: DockCopyVariant, keyLabel: string | null, override?: DockCopyOverride, options?: {
     readonly mobile?: boolean;
     readonly voiceAvailable?: boolean;
 }) => WelcomeCardCopy;
@@ -192,8 +186,9 @@ export type ResolvedWelcomeCopy = {
 };
 export declare const resolveWelcomeCopy: (locale: Locale, variant: DockCopyVariant, override: DockCopyOverride | undefined) => ResolvedWelcomeCopy;
 /** Merge the locale-independent step defs with this locale's titles/bodies,
- *  injecting the LIVE voice key label and picking the variant's `/` step. */
-export declare const buildTourSteps: (locale: Locale, keyLabel: string, variant: DockCopyVariant, options?: {
+ *  injecting the LIVE voice key label (`null` when no push-to-talk key is
+ *  bound) and picking the variant's `/` step. */
+export declare const buildTourSteps: (locale: Locale, keyLabel: string | null, variant: DockCopyVariant, options?: {
     readonly mobile?: boolean;
 }) => readonly TourStep[];
 export {};

package/dist/embed/dock-state.d.ts

@@ -5,7 +5,7 @@
  * in the stream-state store; this module owns only view + size. Best-effort:
  * disabled/quota'd storage just means no cross-reload restore.
  */
-export type DockView = "chat" | "goal" | "files" | "scheduled" | "prompts" | "connectors" | "skills";
+export type DockView = "chat" | "goal" | "files" | "scheduled" | "prompts" | "connectors" | "skills" | "artifacts";
 export type DockSize = "collapsed" | "expanded" | "fullscreen";
 export type DockState = {
     readonly view: DockView;

package/dist/embed/global.d.ts

@@ -1,4 +1,6 @@
 import { BelongGlobal, BelongInitInput, RouteHandler, UiActionHandler } from '../types/public.ts';
+/** Release listeners and invalidate pending theme reads when an embed leaves. */
+export declare const stopTenantThemeRefresh: () => void;
 type AgentGrantConfig = {
     readonly provider: string;
     readonly scopeExternalId: string | null;

package/dist/embed/goal-edit-command.d.ts

@@ -1,3 +1,4 @@
+import { TFunction } from 'i18next';
 import { GoalActionOutcome, GoalEditInput } from '../api/goals.ts';
 import { BuiltinCommand } from './slash-commands.ts';
 /** The three `/goal` sub-commands that map onto `POST .../goal/edit`. */
@@ -13,13 +14,13 @@ type GoalEditCommand = Extract<BuiltinCommand, {
 type GoalEditOutcome = GoalActionOutcome | {
     readonly status: "no_change";
 };
-type GoalEditNoticeKey = "goal.revived" | "goal.edited" | "goal.notEditable" | "goal.editUsage" | "goal.none" | "goal.disabled" | "goal.error";
 /** Command → `POST .../goal/edit` request body. */
 export declare const goalEditRequestBody: (command: GoalEditCommand) => GoalEditInput;
 /**
- * `editSessionGoal` outcome → the i18n key for the local notice. A `revived`
- * edit (a raised cap that un-stalled a `budget_limited` goal) gets its own
- * copy distinct from a plain edit — see `GoalActionOutcome`'s `revived` flag.
+ * `editSessionGoal` outcome → the local notice. A `revived` edit (a raised
+ * cap that un-stalled a `budget_limited` goal) gets its own copy distinct
+ * from a plain edit — see `GoalActionOutcome`'s `revived` flag — and one
+ * that left the goal `budget_limited` says it is still stopped (#766).
  */
-export declare const goalEditNoticeKey: (outcome: GoalEditOutcome) => GoalEditNoticeKey;
+export declare const goalEditNoticeText: (t: TFunction, outcome: GoalEditOutcome) => string;
 export {};

package/dist/embed/plan-decision-text.d.ts

@@ -0,0 +1 @@
+export { PLAN_DECISION_TEXTS, recognizePlanDecisionText } from '@belong/codec/plan-decision-text';

package/dist/embed/presets.d.ts

@@ -6,6 +6,7 @@ export declare const PRESET_NAME_SCHEMA: z.ZodEnum<{
     custom: "custom";
     belong: "belong";
     simetrik: "simetrik";
+    tenant: "tenant";
 }>;
 export declare const BELONG_LIGHT_PALETTE: BelongThemePalette;
 export declare const BELONG_DARK_PALETTE: BelongThemePalette;

package/dist/embed/response-mode.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The composer's RESPONSE MODE — Fast / Balanced / Smart on a three-stop
+ * slider (the Codex app's dial). Every mode is named for its upside: a person
+ * picks what they want more of, never "less" of anything.
+ *
+ *   fast     → quick answers for simple requests
+ *   balanced → everyday work
+ *   smart    → the most capable, for complex multi-step work (the default)
+ *
+ * The dock only ever names a MODE. Which model a mode buys is the backend's
+ * call (`response-mode-model.ts`), so no model name ever reaches a customer.
+ *
+ * "Never picked" is NOT "picked Smart". Until a person picks a mode the dial
+ * shows Smart but the dock sends no mode at all, so the deployment decides:
+ * its own model today, or the intention model switch where that is enabled. A
+ * pick — Smart included — is the person's choice, sent with every message and
+ * outranking the switch.
+ *
+ * A personal preference, not a per-conversation one: the mode a person last
+ * picked carries into new chats, the way other assistants remember your last
+ * choice. Persisted best-effort to localStorage (zod-validated at the storage
+ * perimeter); private mode, disabled storage or a junk value read as "never
+ * picked". The transport stamps the pick on every send (beside the locale),
+ * and the backend keeps it durable on the message, so a continuation after a
+ * reload still runs in the mode the person chose.
+ */
+/** Fastest first — the slider's stops, left to right. */
+export declare const RESPONSE_MODES: readonly ["fast", "balanced", "smart"];
+export type ResponseMode = (typeof RESPONSE_MODES)[number];
+/** What the dial shows before a person picks: the deployment's own model. */
+export declare const DEFAULT_RESPONSE_MODE: ResponseMode;
+/** Narrow an untrusted value (storage, a slider position's lookup) to a mode. */
+export declare const parseResponseMode: (value: unknown) => ResponseMode | null;
+/** The mode the person picked, or null when they never did — sends carry a mode only then. */
+export declare const peekResponseModePick: () => ResponseMode | null;
+/** The mode the dial shows: the person's pick, else the default. */
+export declare const peekResponseMode: () => ResponseMode;
+export declare const subscribeResponseMode: (listener: () => void) => (() => void);
+/** Pick `mode` — Smart included — and remember it for this browser. */
+export declare const writeResponseMode: (mode: ResponseMode) => void;
+/** Test-only: back to a browser that never picked a mode. */
+export declare const __resetResponseModeForTest: () => void;
+/** The current mode, re-rendering on change. */
+export declare const useResponseMode: () => ResponseMode;
+/** Ask the API once whether it offers the dial (repeat calls are no-ops). */
+export declare const askResponseModesAvailability: (apiBaseUrl: string) => void;
+/** Whether the composer should show the dial for this API (the shell asked). */
+export declare const useResponseModesAvailable: (apiBaseUrl: string) => boolean;

package/dist/embed/theme.d.ts

@@ -4,6 +4,11 @@ export declare const DEFAULT_THEME: BelongTheme;
 export declare const peekTheme: () => BelongTheme;
 export declare const subscribeTheme: (listener: () => void) => (() => void);
 export declare const setTheme: (partial: PartialBelongTheme) => void;
+/** Start a branding scope. Old global prefs cannot override a tenant's default. */
+export declare const configureTenantTheme: (scope: string, inline?: PartialBelongTheme) => void;
+/** Refresh the baseline even while a user-selected style is active. No writes
+ * to local preferences: only explicit user/host overrides are persisted. */
+export declare const setPublishedTenantTheme: (partial: PartialBelongTheme | null) => void;
 /** Switch the active theme style. Built-in presets render their pure palette;
  *  the Custom style overlays the user's accent/cssVars stash. */
 export declare const applyPreset: (name: PresetName) => void;

package/dist/embed/voice-config.d.ts

@@ -1,35 +1,23 @@
+import { z } from 'zod';
 /**
- * Voice configuration — module-level knobs shared by the capture engine
- * (`voice-bus.ts`) and the TTS player (`voice-tts.ts`).
- *
- * The host sets these once at init (or via the public API):
- *
- *   • `apiBaseUrl`     — where `/v1/voice/*` lives (same origin as the rest
- *                        of the backend RPC client). Default "" → same-origin
- *                        relative fetch.
- *   • `pushToTalkKey`  — a `KeyboardEvent.code` (default "ControlLeft") the
- *                        dock binds for hold-to-talk. This is the HOST default;
- *                        the end user may override it per browser via
- *                        `voice-prefs.ts` (the dock binds the EFFECTIVE key
- *                        from `getEffectivePushToTalkKey()`).
- *   • `autoplayTts`    — whether assistant replies are spoken aloud by default.
- *   • `voiceId`        — TTS voice id; "" means "let the backend default apply".
- *   • `utteranceFlushMs` — how long (ms) to wait before flushing a buffered
- *                          partial utterance to the backend. Default 1000.
- *   • `callSilenceMs`  — silence window (ms) after which a live call turn ends.
- *                        Default 3000.
- *   • `ttsPlaybackRate` — client-side playback speed for spoken audio (filler +
- *                         reply). Gemini's batch TTS has no rate knob, so we slow
- *                         it on the element (pitch preserved). Default 0.9 (10%
- *                         slower); sane range 0.5–1.5.
- *   • `ttsChunkGapMs`  — minimum pause (ms) between sentence chunks in
- *                        conversational playback, so consecutive sentences
- *                        breathe like natural speech instead of running
- *                        back-to-back. Default 350; 0 disables the pause.
- *
- * Plain module state mirrors `theme.ts`: no class, no DI — these are global
- * UX preferences for the embedded dock, not domain state.
+ * The keys push-to-talk may bind. The dock swallows the key's keydown on the
+ * whole page while it is bound, so a key that types (letters, digits, Space,
+ * Enter, Tab) would silently eat that character in every text field. F-keys the
+ * browser owns (F1 help, F3 find, F5 reload, F6/F10 focus moves, F7 caret
+ * browsing, F11 fullscreen, F12 devtools) are left out too: an idle-only
+ * `preventDefault` cannot keep them from firing mid-recording.
  */
+export declare const PUSH_TO_TALK_KEYS: readonly ["ControlRight", "ControlLeft", "AltRight", "AltLeft", "F2", "F8", "F9"];
+export type PushToTalkKey = (typeof PUSH_TO_TALK_KEYS)[number];
+export declare const pushToTalkKeySchema: z.ZodEnum<{
+    ControlRight: "ControlRight";
+    ControlLeft: "ControlLeft";
+    AltRight: "AltRight";
+    AltLeft: "AltLeft";
+    F2: "F2";
+    F8: "F8";
+    F9: "F9";
+}>;
 export type VoiceConfigInput = {
     readonly apiBaseUrl?: string;
     readonly pushToTalkKey?: string;
@@ -43,7 +31,10 @@ export type VoiceConfigInput = {
 /** Merge host-provided config; `undefined` fields leave the current value intact. */
 export declare const configureVoice: (input: VoiceConfigInput) => void;
 export declare const getVoiceApiBaseUrl: () => string;
-export declare const getPushToTalkKey: () => string;
+/** The host's default key, or `null` when the host binds none. */
+export declare const getPushToTalkKey: () => PushToTalkKey | null;
+/** Test-only: drop a host default set via `configureVoice` (back to none). */
+export declare const __resetPushToTalkKeyForTest: () => void;
 export declare const getAutoplayTtsDefault: () => boolean;
 export declare const getVoiceId: () => string;
 export declare const getUtteranceFlushMs: () => number;

package/dist/embed/voice-prefs.d.ts

@@ -1,32 +1,20 @@
+import { PushToTalkKey } from './voice-config.ts';
+/** What the user picked in Settings: a key to hold, or push-to-talk off. */
+export type PushToTalkChoice = PushToTalkKey | "off";
+/** `useSyncExternalStore` subscribe — fires whenever the user's choice changes, in any tab. */
+export declare const subscribePushToTalkKey: (listener: () => void) => (() => void);
+/** The user's own choice, or `null` when they never chose (host default applies). */
+export declare const peekUserPushToTalkChoice: () => PushToTalkChoice | null;
+/** The key the dock actually binds — the user's choice over the host default — or `null` for none. */
+export declare const getEffectivePushToTalkKey: () => PushToTalkKey | null;
+/** `useSyncExternalStore` snapshot — the effective key (a primitive, so stable). */
+export declare const peekPushToTalkKey: () => PushToTalkKey | null;
 /**
- * User voice preferences — the per-browser push-to-talk key override and the
- * first-conversation voice hint flag.
- *
- *   Host default (voice-config `pushToTalkKey`)  ◀  user pref (localStorage)
- *
- * `voice-config.ts` carries the HOST's deployment-wide knobs (set once via
- * `configureVoice`); this module layers the END USER's own choice on top, the
- * same way `theme.ts` layers user prefs over the host theme. Components read
- * the EFFECTIVE key (user pref if set, else host default) through a tiny
- * external store (`subscribePushToTalkKey` / `peekPushToTalkKey`) so the
- * settings UI, the composer tooltip, and the dock's key handler all rebind
- * live when the user picks a new key.
- *
- * localStorage is a perimeter: the prefs bag is zod-validated on read and any
- * junk (corrupted JSON, wrong shape, storage disabled) degrades to "no pref".
+ * Persist the user's choice and notify subscribers. The value comes from a
+ * form control, so it is parsed here: anything outside the key list and "off"
+ * is ignored.
  */
-/** `useSyncExternalStore` subscribe — fires on set/clear of the user key. */
-export declare const subscribePushToTalkKey: (listener: () => void) => (() => void);
-/** The user's own override, or `null` when the host default applies. */
-export declare const peekUserPushToTalkKey: () => string | null;
-/** The key the dock actually binds: user pref if set, else the host default. */
-export declare const getEffectivePushToTalkKey: () => string;
-/** `useSyncExternalStore` snapshot — the effective key (string, so stable). */
-export declare const peekPushToTalkKey: () => string;
-/** Persist a user-chosen `KeyboardEvent.code` and notify subscribers. */
-export declare const setUserPushToTalkKey: (code: string) => void;
-/** Drop the user override (back to the host default) and notify subscribers. */
-export declare const clearUserPushToTalkKey: () => void;
+export declare const setUserPushToTalkChoice: (choice: string) => void;
 /** True once the push-to-talk hint chip was dismissed (X or first capture). */
 export declare const readVoiceHintDismissed: () => boolean;
 /** Persist the hint dismissal so it never shows again in this browser. */
@@ -46,14 +34,10 @@ export type VoiceClosedSendMode = "confirm" | "auto";
 export declare const subscribeVoiceClosedSendMode: (listener: () => void) => (() => void);
 export declare const peekVoiceClosedSendMode: () => VoiceClosedSendMode;
 export declare const setVoiceClosedSendMode: (mode: VoiceClosedSendMode) => void;
+/** Human label for a push-to-talk key: "ControlLeft" → "Left Ctrl". */
+export declare const formatKeyCode: (code: PushToTalkKey) => string;
 /**
- * Human label for a `KeyboardEvent.code`: "ControlLeft" → "Left Ctrl",
- * "KeyA" → "A", "Digit7" → "7". Codes with no friendlier reading ("Space",
- * "F1", unknown codes) pass through unchanged.
- */
-export declare const formatKeyCode: (code: string) => string;
-/**
- * Test-only: clear listeners and re-seed the user key from localStorage. The
+ * Test-only: clear listeners and re-seed the user's choice from localStorage. The
  * store is a module singleton, so unit tests reset it in `beforeEach`.
  */
 export declare const __resetVoicePrefsForTest: () => void;