@belonguniverseai/react-sdk 0.1.8 → 0.3.0

package/dist/component/{mindmap-definition-RKZ34NQL-DnvW0LPZ.js → mindmap-definition-RKZ34NQL-CJO5YIaF.js}

@@ -1,6 +1,6 @@
-import { g as oe } from "./chunk-55IACEB6-CgTvaBsI.js";
-import { s as ae } from "./chunk-2J33WTMH-j6gfAyGs.js";
-import { _ as l, l as C, p as ce, r as le, G as he, K as G, c as B, i as F, b6 as de, af as ge, ag as ue, ah as pe } from "./mermaid-GHXKKRXX-BP0EPCnA.js";
+import { g as oe } from "./chunk-55IACEB6-CWb5s5u5.js";
+import { s as ae } from "./chunk-2J33WTMH-Bqhv40NQ.js";
+import { _ as l, l as C, p as ce, r as le, G as he, K as G, c as B, i as F, b6 as de, af as ge, ag as ue, ah as pe } from "./mermaid-GHXKKRXX-Bb3nq6cF.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 const b = [];
@@ -830,4 +830,4 @@ var _e = Y, ke = 12, N = {
 export {
   we as diagram
 };
-//# sourceMappingURL=mindmap-definition-RKZ34NQL-DnvW0LPZ.js.map
+//# sourceMappingURL=mindmap-definition-RKZ34NQL-CJO5YIaF.js.map

package/dist/component/{pieDiagram-4H26LBE5-DA_l8HVF.js → pieDiagram-4H26LBE5-fLrS62rY.js}

@@ -1,7 +1,7 @@
-import { a0 as S, S as R, b5 as J, g as Q, s as Y, a as tt, b as et, t as at, q as nt, _ as g, l as W, c as rt, I as it, N as st, a7 as lt, e as ot, B as ct, K as ut } from "./mermaid-GHXKKRXX-BP0EPCnA.js";
-import { p as gt } from "./chunk-4BX2VUAB-DiX7q4eX.js";
+import { a0 as S, S as R, b5 as J, g as Q, s as Y, a as tt, b as et, t as at, q as nt, _ as g, l as W, c as rt, I as it, N as st, a7 as lt, e as ot, B as ct, K as ut } from "./mermaid-GHXKKRXX-Bb3nq6cF.js";
+import { p as gt } from "./chunk-4BX2VUAB-DtucQWno.js";
 import { p as dt } from "./wardley-L42UT6IY-HA1eSIS_.js";
-import { d as P } from "./arc-BZj9pfle.js";
+import { d as P } from "./arc-CMhGaHbE.js";
 import { o as pt } from "./ordinal-D0x7izaa.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
@@ -163,4 +163,4 @@ var vt = ut.pie, z = {
 export {
   Lt as diagram
 };
-//# sourceMappingURL=pieDiagram-4H26LBE5-DA_l8HVF.js.map
+//# sourceMappingURL=pieDiagram-4H26LBE5-fLrS62rY.js.map

package/dist/component/{quadrantDiagram-W4KKPZXB-CJH3QV2I.js → quadrantDiagram-W4KKPZXB-BMjq2Lu4.js}

@@ -1,5 +1,5 @@
-import { s as Se, g as _e, t as ee, q as Ae, a as ke, b as Fe, _ as r, c as Et, l as qt, d as vt, e as Pe, B as ve, K as z, i as Ce, a4 as Le } from "./mermaid-GHXKKRXX-BP0EPCnA.js";
-import { l as te } from "./linear-DXA6Ni38.js";
+import { s as Se, g as _e, t as ee, q as Ae, a as ke, b as Fe, _ as r, c as Et, l as qt, d as vt, e as Pe, B as ve, K as z, i as Ce, a4 as Le } from "./mermaid-GHXKKRXX-Bb3nq6cF.js";
+import { l as te } from "./linear-Deqp7k-y.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var Ct = (function() {
@@ -1030,4 +1030,4 @@ var Ve = /* @__PURE__ */ r(function() {
 export {
   We as diagram
 };
-//# sourceMappingURL=quadrantDiagram-W4KKPZXB-CJH3QV2I.js.map
+//# sourceMappingURL=quadrantDiagram-W4KKPZXB-BMjq2Lu4.js.map

package/dist/component/{requirementDiagram-4Y6WPE33-RQu1NwhU.js → requirementDiagram-4Y6WPE33-BPUkO56k.js}

@@ -1,6 +1,6 @@
-import { g as Ge } from "./chunk-55IACEB6-CgTvaBsI.js";
-import { s as ze } from "./chunk-2J33WTMH-j6gfAyGs.js";
-import { _ as h, G as Ye, b as Xe, a as Je, s as Ze, g as et, q as tt, t as st, c as ke, l as Ne, B as it, F as rt, p as nt, r as at, u as lt } from "./mermaid-GHXKKRXX-BP0EPCnA.js";
+import { g as Ge } from "./chunk-55IACEB6-CWb5s5u5.js";
+import { s as ze } from "./chunk-2J33WTMH-Bqhv40NQ.js";
+import { _ as h, G as Ye, b as Xe, a as Je, s as Ze, g as et, q as tt, t as st, c as ke, l as Ne, B as it, F as rt, p as nt, r as at, u as lt } from "./mermaid-GHXKKRXX-Bb3nq6cF.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var qe = (function() {
@@ -885,4 +885,4 @@ var mt = /* @__PURE__ */ h(async function(e, u, o, n) {
 export {
   Rt as diagram
 };
-//# sourceMappingURL=requirementDiagram-4Y6WPE33-RQu1NwhU.js.map
+//# sourceMappingURL=requirementDiagram-4Y6WPE33-BPUkO56k.js.map

package/dist/component/{sankeyDiagram-5OEKKPKP-DaQ-xlau.js → sankeyDiagram-5OEKKPKP-ekNfY75x.js}

@@ -1,4 +1,4 @@
-import { q as kt, t as mt, s as xt, g as _t, b as vt, a as bt, _ as y, c as ot, C as St, d as G, ai as wt, B as Lt, k as Et } from "./mermaid-GHXKKRXX-BP0EPCnA.js";
+import { q as kt, t as mt, s as xt, g as _t, b as vt, a as bt, _ as y, c as ot, C as St, d as G, ai as wt, B as Lt, k as Et } from "./mermaid-GHXKKRXX-Bb3nq6cF.js";
 import { o as Tt } from "./ordinal-D0x7izaa.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
@@ -859,4 +859,4 @@ var ge = {
 export {
   ge as diagram
 };
-//# sourceMappingURL=sankeyDiagram-5OEKKPKP-DaQ-xlau.js.map
+//# sourceMappingURL=sankeyDiagram-5OEKKPKP-ekNfY75x.js.map

package/dist/component/{sequenceDiagram-3UESZ5HK-DVuPvNoe.js → sequenceDiagram-3UESZ5HK-CyVmC9Rm.js}

@@ -1,6 +1,6 @@
-import { _ as g, o as tr, c as $, d as Mt, l as at, j as Ce, e as er, f as rr, k as P, b as ke, s as ar, q as sr, a as ir, g as nr, t as or, v as cr, J as lr, B as hr, i as Bt, u as Z, a5 as Q, a6 as wt, a7 as Me, a8 as dr, G as Yt, a9 as Tr, aa as Be } from "./mermaid-GHXKKRXX-BP0EPCnA.js";
-import { a as pr, b as ee, g as dt, d as Er, e as re, f as ae } from "./chunk-ND2GUHAM-Cto8_209.js";
-import { I as ur } from "./chunk-QZHKN3VN-CM6Lx0p-.js";
+import { _ as g, o as tr, c as $, d as Mt, l as at, j as Ce, e as er, f as rr, k as P, b as ke, s as ar, q as sr, a as ir, g as nr, t as or, v as cr, J as lr, B as hr, i as Bt, u as Z, a5 as Q, a6 as wt, a7 as Me, a8 as dr, G as Yt, a9 as Tr, aa as Be } from "./mermaid-GHXKKRXX-Bb3nq6cF.js";
+import { a as pr, b as ee, g as dt, d as Er, e as re, f as ae } from "./chunk-ND2GUHAM-DUfRBvcM.js";
+import { I as ur } from "./chunk-QZHKN3VN-ZyFUERub.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var $t = (function() {
@@ -2894,4 +2894,4 @@ var ra = /* @__PURE__ */ g(async function(e, t, a) {
 export {
   Ta as diagram
 };
-//# sourceMappingURL=sequenceDiagram-3UESZ5HK-DVuPvNoe.js.map
+//# sourceMappingURL=sequenceDiagram-3UESZ5HK-CyVmC9Rm.js.map

package/dist/component/{stateDiagram-AJRCARHV-CUhrYhQ-.js → stateDiagram-AJRCARHV-DFkc559m.js}

@@ -1,5 +1,5 @@
-import { s as R, a as W, S as N } from "./chunk-AQP2D5EJ-ClrornzZ.js";
-import { _ as f, c as t, d as M, l as S, e as P, k as z, ac as _, ad as U, a9 as C, u as F } from "./mermaid-GHXKKRXX-BP0EPCnA.js";
+import { s as R, a as W, S as N } from "./chunk-AQP2D5EJ-D00bX5Fy.js";
+import { _ as f, c as t, d as M, l as S, e as P, k as z, ac as _, ad as U, a9 as C, u as F } from "./mermaid-GHXKKRXX-Bb3nq6cF.js";
 import { G as O } from "./graph-BZLHvygk.js";
 import { l as J } from "./layout-Bu6nRdWm.js";
 globalThis.process = globalThis.process || { env: {} };
@@ -263,4 +263,4 @@ var X = /* @__PURE__ */ f((e) => e.append("circle").attr("class", "start-state")
 export {
   ot as diagram
 };
-//# sourceMappingURL=stateDiagram-AJRCARHV-CUhrYhQ-.js.map
+//# sourceMappingURL=stateDiagram-AJRCARHV-DFkc559m.js.map

package/dist/component/{stateDiagram-v2-BHNVJYJU-DJwdiVQa.js → stateDiagram-v2-BHNVJYJU-DyEtRcsV.js}

@@ -1,5 +1,5 @@
-import { s as e, b as r, a as s, S as t } from "./chunk-AQP2D5EJ-ClrornzZ.js";
-import { _ as l } from "./mermaid-GHXKKRXX-BP0EPCnA.js";
+import { s as e, b as r, a as s, S as t } from "./chunk-AQP2D5EJ-D00bX5Fy.js";
+import { _ as l } from "./mermaid-GHXKKRXX-Bb3nq6cF.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var b = {
@@ -16,4 +16,4 @@ var b = {
 export {
   b as diagram
 };
-//# sourceMappingURL=stateDiagram-v2-BHNVJYJU-DJwdiVQa.js.map
+//# sourceMappingURL=stateDiagram-v2-BHNVJYJU-DyEtRcsV.js.map

package/dist/component/{timeline-definition-PNZ67QCA-vxoNetpl.js → timeline-definition-PNZ67QCA-BDLP-x66.js}

@@ -1,5 +1,5 @@
-import { _ as o, G as gt, af as Rt, ag as Ct, ah as Wt, c as pt, l as E, N as Pt, a7 as Bt, ai as ft, d as U, F as Vt, aj as Ft, B as zt } from "./mermaid-GHXKKRXX-BP0EPCnA.js";
-import { d as ot } from "./arc-BZj9pfle.js";
+import { _ as o, G as gt, af as Rt, ag as Ct, ah as Wt, c as pt, l as E, N as Pt, a7 as Bt, ai as ft, d as U, F as Vt, aj as Ft, B as zt } from "./mermaid-GHXKKRXX-Bb3nq6cF.js";
+import { d as ot } from "./arc-CMhGaHbE.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var tt = (function() {
@@ -1055,4 +1055,4 @@ var Qt = /* @__PURE__ */ o(function(e, t, n, i, r, h = !1) {
 export {
   me as diagram
 };
-//# sourceMappingURL=timeline-definition-PNZ67QCA-vxoNetpl.js.map
+//# sourceMappingURL=timeline-definition-PNZ67QCA-BDLP-x66.js.map

package/dist/component/{vennDiagram-CIIHVFJN-B23Eo4r8.js → vennDiagram-CIIHVFJN-Bvhzsn8q.js}

@@ -1,4 +1,4 @@
-import { aX as Gt, s as Wt, g as Kt, t as Ht, q as Xt, a as Yt, b as Zt, _ as w, G as wt, N as Jt, d as ot, ao as Qt, af as $t, ag as te, ah as ee, e as ne, B as se, I as ie, K as oe } from "./mermaid-GHXKKRXX-BP0EPCnA.js";
+import { aX as Gt, s as Wt, g as Kt, t as Ht, q as Xt, a as Yt, b as Zt, _ as w, G as wt, N as Jt, d as ot, ao as Qt, af as $t, ag as te, ah as ee, e as ne, B as se, I as ie, K as oe } from "./mermaid-GHXKKRXX-Bb3nq6cF.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 const kt = (t, n) => Gt(t, "a", -n), _t = 1e-10;
@@ -1557,4 +1557,4 @@ var qe = { draw: Ve }, Ge = {
 export {
   Ge as diagram
 };
-//# sourceMappingURL=vennDiagram-CIIHVFJN-B23Eo4r8.js.map
+//# sourceMappingURL=vennDiagram-CIIHVFJN-Bvhzsn8q.js.map

package/dist/component/{wardleyDiagram-YWT4CUSO-CHPIaRL_.js → wardleyDiagram-YWT4CUSO-SKdyvNF1.js}

@@ -1,5 +1,5 @@
-import { s as St, g as Mt, t as Nt, q as Tt, a as zt, b as Lt, _ as u, a4 as At, G as Xt, I as U, l as K, N as Et, e as Yt, B as It, c as j } from "./mermaid-GHXKKRXX-BP0EPCnA.js";
-import { p as Bt } from "./chunk-4BX2VUAB-DiX7q4eX.js";
+import { s as St, g as Mt, t as Nt, q as Tt, a as zt, b as Lt, _ as u, a4 as At, G as Xt, I as U, l as K, N as Et, e as Yt, B as It, c as j } from "./mermaid-GHXKKRXX-Bb3nq6cF.js";
+import { p as Bt } from "./chunk-4BX2VUAB-DtucQWno.js";
 import { p as Ft } from "./wardley-L42UT6IY-HA1eSIS_.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
@@ -678,4 +678,4 @@ var Dt = {
 export {
   Qt as diagram
 };
-//# sourceMappingURL=wardleyDiagram-YWT4CUSO-CHPIaRL_.js.map
+//# sourceMappingURL=wardleyDiagram-YWT4CUSO-SKdyvNF1.js.map

package/dist/component/{xychartDiagram-2RQKCTM6-gaiGaKCA.js → xychartDiagram-2RQKCTM6-DHchnrpW.js}

@@ -1,7 +1,7 @@
-import { s as ei, g as si, t as Lt, q as ni, a as ai, b as oi, _ as a, l as Et, N as ri, e as hi, B as li, G as dt, i as ci, I as It, K as ui, a4 as gi, ap as xi, ac as Rt } from "./mermaid-GHXKKRXX-BP0EPCnA.js";
+import { s as ei, g as si, t as Lt, q as ni, a as ai, b as oi, _ as a, l as Et, N as ri, e as hi, B as li, G as dt, i as ci, I as It, K as ui, a4 as gi, ap as xi, ac as Rt } from "./mermaid-GHXKKRXX-Bb3nq6cF.js";
 import { i as di } from "./init-BOu0eQYQ.js";
 import { o as fi } from "./ordinal-D0x7izaa.js";
-import { l as Dt } from "./linear-DXA6Ni38.js";
+import { l as Dt } from "./linear-Deqp7k-y.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 function pi(t, i, e) {
@@ -1372,4 +1372,4 @@ var Ti = /* @__PURE__ */ a(function() {
 export {
   Mi as diagram
 };
-//# sourceMappingURL=xychartDiagram-2RQKCTM6-gaiGaKCA.js.map
+//# sourceMappingURL=xychartDiagram-2RQKCTM6-DHchnrpW.js.map

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

@@ -0,0 +1,26 @@
+import { BelongThemePalette } from '../../types/public.ts';
+/**
+ * Live-call button — shared by the desktop rail (always visible, docked or
+ * collapsed) and the mobile bottom nav bar, so the user can call their agent
+ * from either chrome. Store-connected and self-contained: idle shows a plain
+ * phone; connecting spins; in-call shows a hang-up glyph over a pulsing ring
+ * (the "live" animation). Clicking toggles dial / hang-up; errors surface on
+ * the CallScreen when the chat surface is visible (audio + state machine run
+ * regardless).
+ */
+export declare const CallButton: ({ palette, testId, className, label, callSurfaceHidden, onShowCallSurface, }: {
+    palette: BelongThemePalette;
+    /** Distinguishes the rail instance from the mobile nav bar instance. */
+    testId?: string;
+    className?: string;
+    /** Visible text under the icon (mobile nav tabs carry names; the 52px rail
+     *  has no room and stays icon-only with the aria-label/tooltip). */
+    label?: string;
+    /** True when the CallScreen cannot be on screen (chat view hidden or dock
+     *  collapsed). A live call with the surface hidden means this button
+     *  RETURNS to the call — hanging up belongs to a screen the user can see. */
+    callSurfaceHidden?: boolean;
+    /** Navigate so the CallScreen is visible (switch to chat / expand). Called
+     *  when dialing or returning from a place where the surface is hidden. */
+    onShowCallSurface?: () => void;
+}) => import("react").JSX.Element;

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

@@ -7,12 +7,15 @@ import { BelongTheme, BelongThemePalette, PresetName } from '../../types/public.
  * colour + custom CSS), then Log out. Gradient is brand-driven (Ocean → Deep
  * Sea) via the active palette.
  */
-export declare function EmbedAvatar({ user, size, theme, palette, side, sessionId, voiceSupported, accent, cssVars, presets, activePreset, onToggleMode, onToggleSide, onAccentChange, onAccentReset, onCssVarsChange, onApplyPreset, onLogout, }: {
+export declare function EmbedAvatar({ user, size, theme, palette, side, menuSide: menuSideOverride, sessionId, voiceSupported, accent, cssVars, presets, activePreset, onToggleMode, onToggleSide, onAccentChange, onAccentReset, onCssVarsChange, onApplyPreset, onLogout, }: {
     user: string | null;
     size?: number;
     theme: BelongTheme;
     palette: BelongThemePalette;
     side: "left" | "right";
+    /** Where the menu opens. Defaults to "toward the panel" from the rail edge;
+     *  the mobile bottom nav bar overrides it to open upward. */
+    menuSide?: "left" | "right" | "top";
     /** Active chat session id (null when no conversation is open yet). Shown in
      *  the menu under the build stamp and copyable for telemetry correlation. */
     sessionId: string | null;

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

@@ -9,12 +9,19 @@ export interface SessionSummary {
  * an inline text edit, or delete one via an inline trash → confirm flow. Rename +
  * delete are per-row inline affordances that keep the menu open (BEL-120).
  */
-export declare function EmbedSessions({ sessions, activeId, theme, side, onNew, onSelect, onDelete, onRename, onOpen, }: {
+export declare function EmbedSessions({ sessions, activeId, theme, side, triggerClassName, triggerLabel, onNew, onSelect, onDelete, onRename, onOpen, }: {
     sessions: readonly SessionSummary[];
     activeId: string | null;
     theme: BelongTheme;
-    /** Which way the menu opens — toward the panel from the rail edge. */
-    side?: "left" | "right";
+    /** Which way the menu opens — toward the panel from the rail edge, or
+     *  upward when the trigger lives in the mobile bottom nav bar. */
+    side?: "left" | "right" | "top";
+    /** Extra trigger classes — the mobile nav bar bumps the 32px rail trigger
+     *  to a ≥44px touch target. */
+    triggerClassName?: string;
+    /** Visible text under the trigger icon (mobile nav names its cells; the
+     *  rail stays icon-only). */
+    triggerLabel?: string;
     onNew: () => void;
     onSelect: (id: string) => void;
     onDelete: (id: string) => void;

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

@@ -0,0 +1,39 @@
+import { SessionSummary } from './EmbedSessions';
+import { EmbedView } from './EmbedRail';
+import { BelongTheme, BelongThemePalette, PresetName } from '../../types/public.ts';
+/**
+ * Bottom nav bar for the MOBILE fullscreen sheet — the phone-width stand-in
+ * for the 52px desktop rail (which has no room on a phone). View tabs
+ * (chat / files / scheduled), the sessions switcher, the account avatar, and
+ * a close chevron. Every cell is a ≥44px touch target; menus open upward.
+ */
+export declare function MobileNavBar({ view, user, theme, palette, sessions, activeId, voiceSupported, accent, cssVars, presets, activePreset, onSelectView, onClose, onToggleMode, onToggleSide, onAccentChange, onAccentReset, onCssVarsChange, onApplyPreset, onLogout, onNewSession, onSelectSession, onDeleteSession, onRenameSession, onSessionsOpen, }: {
+    view: EmbedView;
+    user: string | null;
+    theme: BelongTheme;
+    palette: BelongThemePalette;
+    sessions: readonly SessionSummary[];
+    activeId: string | null;
+    voiceSupported: boolean;
+    accent: string | null;
+    cssVars: Record<string, string>;
+    presets: readonly {
+        name: PresetName;
+        label: string;
+    }[];
+    activePreset: PresetName;
+    onSelectView: (v: EmbedView) => void;
+    onClose: () => void;
+    onToggleMode: () => void;
+    onToggleSide: () => void;
+    onAccentChange: (c: string) => void;
+    onAccentReset: () => void;
+    onCssVarsChange: (v: Record<string, string>) => void;
+    onApplyPreset: (name: PresetName) => void;
+    onLogout: () => void;
+    onNewSession: () => void;
+    onSelectSession: (id: string) => void;
+    onDeleteSession: (id: string) => void;
+    onRenameSession: (id: string, title: string) => void;
+    onSessionsOpen?: () => void;
+}): import("react").JSX.Element;

package/dist/components/embed/mobile-nav-bar.fixtures.d.ts

@@ -0,0 +1,3 @@
+import { ComponentProps } from 'react';
+import { MobileNavBar } from './MobileNavBar.tsx';
+export declare const mobileNavBarProps: (overrides?: Partial<ComponentProps<typeof MobileNavBar>>) => ComponentProps<typeof MobileNavBar>;

package/dist/embed/approval-bus.d.ts

@@ -12,3 +12,6 @@ export type PendingApproval = {
 };
 export declare const registerPendingApproval: (entry: PendingApproval) => (() => void);
 export declare const peekPendingApproval: () => PendingApproval | null;
+/** Fires whenever an approval card registers or resolves — live call mode
+ * uses this to surface the ask into the call and offer voice approval. */
+export declare const subscribePendingApproval: (listener: () => void) => (() => void);

package/dist/embed/copy.d.ts

@@ -127,9 +127,13 @@ export type DockCopy = {
         readonly placeholderDefault: Readonly<Record<DockCopyVariant, string>>;
         readonly placeholderPlan: Readonly<Record<DockCopyVariant, string>>;
         readonly voiceHint: (keyLabel: string) => string;
+        /** Mobile variant — no physical keyboard, so no push-to-talk key. */
+        readonly voiceHintTouch: string;
         readonly micNotSupported: string;
         readonly micNotConfigured: string;
         readonly micTooltip: (keyLabel: string) => string;
+        /** Mobile variant of the mic tooltip — omits the keyboard fallback. */
+        readonly micTooltipTouch: string;
         readonly viewPlan: string;
         readonly hidePlan: string;
     };

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

@@ -5,6 +5,21 @@
  * uses the same resolver so the dock never overlaps host content.
  */
 export type DockResizeState = "collapsed" | "expanded" | "modal";
+/**
+ * Desktop = side-docked panel + rail with a host-body reserve. Mobile = the
+ * dock takes the whole viewport as an overlay sheet (a side dock plus reserve
+ * would squeeze the host to zero width on a phone).
+ */
+export type DockLayoutMode = "desktop" | "mobile";
+/** Viewports at or below this width get the mobile fullscreen-sheet layout. */
+export declare const MOBILE_LAYOUT_MAX_WIDTH_PX = 640;
+/** Short viewports get the mobile layout too: a rotated phone (e.g. 844×390)
+ *  is wider than the width breakpoint, but a 52px rail + side panel is
+ *  unusable at that height. */
+export declare const MOBILE_LAYOUT_MAX_HEIGHT_PX = 480;
+/** The single matchMedia source for the mode — both clauses, OR'd. */
+export declare const MOBILE_LAYOUT_MEDIA_QUERY: string;
+export declare const resolveLayoutMode: (viewportWidthPx: number, viewportHeightPx?: number) => DockLayoutMode;
 /** The always-visible rail strip. Reference spec: 52px. */
 export declare const RAIL_WIDTH_PX = 52;
 /** Fixed panel width in modal state. Reference spec: 760px panel. */
@@ -17,6 +32,14 @@ export declare const MAX_PANEL_WIDTH_PX = 720;
 export declare const clampPanelWidth: (px: number, viewportPx: number) => number;
 /** Total dock width (panel + rail) for a state, given the expanded panel width. */
 export declare const resolveDockWidthPx: (state: DockResizeState, panelWidth: number) => number;
+/**
+ * Desktop dock width clamped to the live viewport — mid-size screens (small
+ * tablets, half-snapped windows just above the mobile breakpoint) must never
+ * get a dock wider than the screen: the 760px modal alone overflows a 768px
+ * tablet, and a persisted wide panel can overflow a re-narrowed window.
+ * Cap: 90% of the viewport (same budget clampPanelWidth uses for drags).
+ */
+export declare const resolveClampedDockWidthPx: (state: DockResizeState, panelWidth: number, viewportWidthPx: number) => number;
 /**
  * The panel's OWN width for a state. While collapsed this is the width the
  * panel would reveal to (the dock container clips it), so the panel keeps a

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

@@ -0,0 +1,6 @@
+import { DockLayoutMode } from './dock-layout.ts';
+export declare const peekLayoutMode: () => DockLayoutMode;
+export declare const subscribeLayoutMode: (listener: () => void) => (() => void);
+export declare const useLayoutMode: () => DockLayoutMode;
+/** Test-only: drop the cached media query so a new stub takes effect. */
+export declare const __resetLayoutModeForTest: () => void;

package/dist/embed/voice/line-dispatch.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Background-line dispatch: create the line's session on first use (plain
+ * HTTP — the same endpoints the chat transport uses), post the message, and
+ * attach the line-run reader so results/failures/phases/approvals flow back
+ * into the call. Line 1 (the foreground chat) never comes through here.
+ *
+ * Workspace isolation (§28): a background line opened while the host is inside
+ * a workspace must land in THAT workspace, not the shared legacy root — so the
+ * create body carries the effective `workspaceExternalId` (absent when the host
+ * runs unscoped). The line's registry label seeds the session title, so the
+ * sessions list names the background conversation.
+ */
+/** Abort every live line reader and invalidate their callbacks (call teardown).
+ * Subscribed below to fire whenever a call leaves in_call/connecting. */
+export declare const abortAllLineReaders: () => void;
+export declare const dispatchToLine: (req: {
+    readonly line: number;
+    readonly request: string;
+    readonly isNewLine: boolean;
+}, fetchFn?: typeof fetch) => Promise<void>;

package/dist/embed/voice/line-run-reader.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Minimal SSE consumer for a BACKGROUND line's run stream — the Operator's
+ * ear on lines the chat surface isn't showing. Reads the AI-SDK data-stream
+ * protocol from `GET /v1/runs/:runId/stream` and surfaces only what the call
+ * needs: tool phases, approval-needed, the final text, errors. No `useChat`,
+ * no rendering, no reconnect/resume (that's `BelongChatTransport`'s job for
+ * the foreground chat surface — a background line reader just watches once).
+ * Fetch is injected for tests.
+ *
+ * Wire shapes mirror the real protocol pinned in `belong-chat-transport.ts` /
+ * `belong-data-parts.ts` — NOT the placeholder `text-delta` / `finish` shapes
+ * from the original task brief:
+ *   - text is a DELTA part: `{ type: "text", id, text }` — accumulate `.text`.
+ *   - `data-tool-call` carries a `state` ("started" | "completed" | "failed");
+ *     only "started" is a phase change worth reporting.
+ *   - `data-approval-request` carries a `state` ("pending" | "approved" |
+ *     "rejected" | "amend_requested" | "expired"); only "pending" means an
+ *     approval is newly needed.
+ *   - there is no `finish` / `error` part. The terminal signal is
+ *     `data-status` with `status` ∈ "continuing" | "completed" | "cancelled" |
+ *     "failed" | "throttled". "continuing" is the max-turns auto-continue —
+ *     NOT terminal, keep reading the same stream. "completed" finishes with
+ *     the accumulated text; "cancelled" | "failed" | "throttled" are errors.
+ *
+ * SSE parsing here is LINE-BY-LINE (split on "\n", not "\n\n") — the server
+ * sends exactly one `data:` line per event. `id:` lines carry the event
+ * cursor (ignored — v1 has no reconnect/resume) and `:`-prefixed lines are
+ * keepalive comments.
+ */
+export type WatchLineRunInput = {
+    readonly runId: string;
+    readonly onPhase: (toolName: string) => void;
+    readonly onApprovalNeeded: () => void;
+    readonly onArtifact: (artifact: {
+        artifactId: string;
+        title: string;
+        mimeType: string;
+    }) => void;
+    readonly onFinish: (finalText: string) => void;
+    readonly onError: (message: string) => void;
+};
+export declare const watchLineRun: (input: WatchLineRunInput, fetchFn?: typeof fetch) => (() => void);

package/dist/embed/voice/realtime-call.d.ts

@@ -0,0 +1,56 @@
+/**
+ * WebRTC transport for live call mode (OpenAI Realtime, speech-to-speech).
+ *
+ * Mirrors the Deepgram pattern one file over: the browser holds a short-lived
+ * secret minted by belong-cloud (`POST /v1/voice/call-token`) and negotiates a
+ * DIRECT WebRTC media session with the provider — call audio never relays
+ * through the backend. The one plain `fetch` in the handshake (the SDP
+ * offer/answer exchange) goes through belong-cloud (`POST /v1/voice/call-sdp`)
+ * because embedding hosts' CSP `connect-src` allowlists rarely include
+ * api.openai.com (Simetrik's doesn't) — the negotiated ICE/DTLS media leg is
+ * not governed by `connect-src`, so only the signaling needs the relay.
+ *
+ *   getUserMedia (mic track) ──▶ RTCPeerConnection ──▶ remote audio track
+ *                                     │                    (autoplay <audio>)
+ *                                     └─ data channel "oai-events"
+ *                                        JSON events both ways (transcripts,
+ *                                        function calls, response control)
+ *
+ * This module owns ONLY the transport: connection setup, the event pipe, mic
+ * mute, and teardown. Conversation logic (function-call dispatch, captions,
+ * state machine) lives in `voice-call.ts`. Hand-rolled like `deepgram-stt.ts`
+ * — no provider SDK for one SDP exchange.
+ */
+export type RealtimeCallHandle = {
+    /** Queue-or-send a client event on the data channel (JSON-encoded). */
+    readonly sendEvent: (event: Record<string, unknown>) => void;
+    /** Toggle the local mic track without renegotiating. */
+    readonly setMuted: (muted: boolean) => void;
+    /** Tear down mic, peer connection, and audio playback. Idempotent. */
+    readonly close: () => void;
+};
+export type ConnectRealtimeCallResult = {
+    readonly ok: true;
+    readonly call: RealtimeCallHandle;
+} | {
+    readonly ok: false;
+    readonly reason: "mic_denied" | "connect_failed";
+};
+export type ConnectRealtimeCallInput = {
+    readonly callToken: string;
+    /** Every server event, JSON-parsed to `unknown` — the store Zod-narrows. */
+    readonly onServerEvent: (event: unknown) => void;
+    /** Fired once when the transport drops (remote close / ICE failure). */
+    readonly onDisconnect: () => void;
+    /** Fired once when the event channel opens — the store decides THEN whether
+     * a greeting is still appropriate (a blind pre-queued greeting races the
+     * server-VAD response created while the channel was still connecting). */
+    readonly onOpen?: () => void;
+    /** Local mic + remote (agent voice) streams, for audio-level analysis —
+     * the orb visualization reacts to REAL speech, not a canned loop. */
+    readonly onStreams?: (streams: {
+        readonly local: MediaStream;
+        readonly remote: MediaStream;
+    }) => void;
+};
+export declare const connectRealtimeCall: (input: ConnectRealtimeCallInput) => Promise<ConnectRealtimeCallResult>;

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

@@ -43,10 +43,11 @@ export declare const __setVoiceEngineFactories: (overrides: Partial<VoiceEngineF
  * from the reactive state so it stays consistent with `peekVoiceState().interim`.
  */
 export declare const peekVoiceInterim: () => string;
+export declare const setCaptureSuppressed: (suppressed: boolean) => void;
 /**
  * Begin a push-to-talk capture: mint a voice token, open the streaming STT,
  * then start the mic. No-op unless idle/error (a re-entrant start while
- * requesting/listening is ignored).
+ * requesting/listening is ignored), and no-op while a live call owns the mic.
  */
 export declare const startCapture: () => void;
 /**

package/dist/embed/voice-call-lines.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Agent lines registry — the Operator's switchboard. Line 1 is the
+ * FOREGROUND chat (existing single-line behavior, unchanged); lines 2+ are
+ * background sessions dispatched over plain HTTP and monitored by the
+ * line-run reader. External-store singleton, same idiom as voice-bus.ts.
+ */
+export declare const MAX_AGENT_LINES = 3;
+export type AgentLineStatus = "working" | "ready" | "failed" | "needs_approval";
+export type AgentLine = {
+    readonly line: number;
+    readonly sessionId: string | null;
+    readonly label: string;
+    readonly status: AgentLineStatus;
+    readonly lastText: string;
+};
+export declare const peekAgentLines: () => readonly AgentLine[];
+export declare const subscribeAgentLines: (listener: () => void) => (() => void);
+export declare const resetAgentLines: () => void;
+export declare const getLine: (line: number) => AgentLine | undefined;
+/**
+ * The "foreground-routed alias": a background line (≥ 2) bound to the SAME
+ * session line 1 currently shows (the user opened it in the chat via
+ * `show_agent_line`). New work for that line is routed through the foreground
+ * pipeline so the visible chat renders the run — but the background line's
+ * strip status must still be kept truthful, and this finds the line to update.
+ * Returns `undefined` when line 1 is unbound or no background line aliases it.
+ */
+export declare const findAliasedLine: () => AgentLine | undefined;
+export declare const openAgentLine: (label: string) => AgentLine | null;
+export declare const bindLineSession: (line: number, sessionId: string) => void;
+export declare const setLineStatus: (line: number, status: AgentLineStatus, lastText?: string) => void;

package/dist/embed/voice-call-pacing.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The utterance pacer: sequencing for agent-initiated call utterances,
+ * extracted from the voice-call store so every ordering (audio response,
+ * no-audio response, stopped-before-done, lost `stopped`, barge-in mid-gap)
+ * is unit-testable without a WebRTC/mic harness. voice-call.ts is a thin
+ * driver: it feeds server events into the pacer's entry points and sends the
+ * actual `response.create` from the `dispatch` callback.
+ *
+ * Agent-initiated utterances (function acks, result relays, progress nudges,
+ * the greeting) are paced from AUDIO PLAYOUT END, not generation end: the next
+ * one may only dispatch once both generation (`responseActive`) and playback
+ * (`audioPlaying`) are idle, plus a breath (`UTTERANCE_GAP_MS`). User turns go
+ * through server VAD directly and never touch this logic.
+ */
+/**
+ * Breath between agent-initiated utterances, measured from AUDIO PLAYOUT END
+ * (the `output_audio_buffer.stopped` server event), NOT from `response.done`
+ * (generation complete). Anchoring to playout end is what makes the gap real:
+ * generation outpaces realtime playback, so a pause timed from `response.done`
+ * routinely elapses while the previous sentence is still audible.
+ */
+export declare const UTTERANCE_GAP_MS = 700;
+/**
+ * Safety net for a missing `output_audio_buffer.stopped`. If audio began but no
+ * stopped event arrives within this window after `response.done`, the pacer
+ * treats audio as idle and releases any queued follow-up so it cannot wedge.
+ * Conservative — real spoken relays are a few seconds; 30 s only trips on a
+ * genuinely dropped stopped event.
+ */
+export declare const AUDIO_IDLE_SAFETY_MS = 30000;
+/**
+ * Hold a follow-up `response.create` while a response is still generating OR
+ * its audio is still playing out. Both must be idle before the pause timer may
+ * run and the create may be sent.
+ */
+export declare const shouldHoldDispatch: (input: {
+    readonly responseActive: boolean;
+    readonly audioPlaying: boolean;
+}) => boolean;
+/**
+ * On `response.done`, decide whether to release a queued follow-up immediately.
+ * When audio is still playing, the release is deferred to
+ * `output_audio_buffer.stopped`. When the response produced no audio (nothing
+ * in playout — e.g. a function-call-only or empty response), release now so the
+ * pacer can't wedge waiting for a stopped event that will never arrive.
+ */
+export declare const shouldReleaseFollowUpOnDone: (audioPlaying: boolean) => boolean;
+/** What `response.done` found in playout — the driver clears its `speaking`
+ * UI state on `"no_audio"` (no `output_audio_buffer.stopped` will come). */
+export type ResponseAudioOutcome = "no_audio" | "audio_playing";
+export type UtterancePacer = {
+    /** Ask for an agent-initiated `response.create`. Held (deduped to one
+     * pending) while a response is generating or its audio is playing; otherwise
+     * dispatched after `UTTERANCE_GAP_MS`. */
+    readonly request: () => void;
+    /** A response started generating (`response.created`) — server VAD or ours. */
+    readonly onResponseCreated: () => void;
+    /** Generation finished (`response.done`). Releases a held follow-up when the
+     * response produced no audio; otherwise arms the missing-`stopped` safety. */
+    readonly onResponseDone: () => ResponseAudioOutcome;
+    /** Audio playout began (`output_audio_buffer.started`). */
+    readonly onAudioStarted: () => void;
+    /** Audio playout ended (`output_audio_buffer.stopped`) — the anchor the next
+     * agent-initiated breath is measured from. */
+    readonly onAudioStopped: () => void;
+    /** The user took the floor (`input_audio_buffer.speech_started`). Clears the
+     * playout gate and timers; a follow-up already counting down its breath is
+     * DEFERRED behind the user's turn (re-queued as pending), never dropped. */
+    readonly onBargeIn: () => void;
+    /** Call teardown: clear all flags and timers so nothing leaks forward. */
+    readonly reset: () => void;
+};
+export declare const createUtterancePacer: (opts: {
+    /** Send the actual `response.create`. Called at most once per released
+     * follow-up, only when generation + playout are idle and the gap elapsed. */
+    readonly dispatch: () => void;
+    /** The safety net declared audio idle after a lost `stopped` — the driver
+     * clears its `speaking` UI state here. */
+    readonly onSafetyIdle?: () => void;
+}) => UtterancePacer;