@theoremjs/react 0.0.0-stage → 0.3.0

package/client/voice-recorder.js

@@ -0,0 +1,165 @@
+import { describeError } from '@theoremjs/agents';
+import { pickMediaRecorderMime } from '@theoremjs/agents/interface';
+import { timeDomainBytesToLevel } from "./audio-level.js";
+class VoiceRecorderFailure extends Error {
+    code;
+    /** `detail` is raw diagnostic text for the builder, never shown to the user. */
+    constructor(code, detail) {
+        super(detail ?? code);
+        this.name = 'VoiceRecorderFailure';
+        this.code = code;
+    }
+}
+function extensionForMime(mime) {
+    if (mime.includes('webm'))
+        return 'webm';
+    if (mime.includes('mp4'))
+        return 'm4a';
+    if (mime.includes('wav'))
+        return 'wav';
+    if (mime.includes('mpeg'))
+        return 'mp3';
+    return 'bin';
+}
+function isPermissionDenied(err) {
+    return err instanceof DOMException && err.name === 'NotAllowedError';
+}
+/** Headless MediaRecorder session for turn-composer voice notes. */
+export class ComposerVoiceRecorder {
+    accept;
+    onLevel;
+    stream = null;
+    recorder = null;
+    chunks = [];
+    audioContext = null;
+    analyser = null;
+    source = null;
+    rafId = 0;
+    mime = '';
+    recording = false;
+    constructor(accept, onLevel) {
+        this.accept = accept;
+        this.onLevel = onLevel;
+    }
+    // fallow-ignore-next-line unused-class-member -- called from useComposerVoice via recorder refs
+    async start() {
+        this.disposeTracks();
+        const mime = pickMediaRecorderMime(this.accept);
+        if (!mime) {
+            throw new VoiceRecorderFailure('unsupported');
+        }
+        try {
+            this.stream = await navigator.mediaDevices.getUserMedia({
+                audio: {
+                    channelCount: 1,
+                    echoCancellation: true,
+                    noiseSuppression: true,
+                    autoGainControl: true,
+                },
+            });
+        }
+        catch (err) {
+            throw new VoiceRecorderFailure(isPermissionDenied(err) ? 'permission' : 'unavailable', describeError(err));
+        }
+        this.mime = mime;
+        this.chunks = [];
+        this.recorder = new MediaRecorder(this.stream, { mimeType: mime });
+        this.recorder.ondataavailable = (event) => {
+            if (event.data.size > 0)
+                this.chunks.push(event.data);
+        };
+        this.recorder.start(250);
+        this.recording = true;
+        this.startMeter();
+    }
+    // fallow-ignore-next-line unused-class-member -- called from useComposerVoice via recorder refs
+    async stop() {
+        if (!this.recorder || !this.recording) {
+            // lexicon-exempt: internal diagnostic; the user reads voice.empty
+            throw new VoiceRecorderFailure('empty', 'stop without a recording');
+        }
+        const recorder = this.recorder;
+        const blob = await new Promise((resolve, reject) => {
+            recorder.onerror = () => {
+                reject(new VoiceRecorderFailure('failed'));
+            };
+            recorder.onstop = () => {
+                const parts = this.chunks;
+                if (parts.length === 0) {
+                    reject(new VoiceRecorderFailure('empty'));
+                    return;
+                }
+                resolve(new Blob(parts, { type: this.mime }));
+            };
+            recorder.stop();
+        });
+        this.recording = false;
+        this.stopMeter();
+        this.disposeTracks();
+        if (blob.size === 0) {
+            throw new VoiceRecorderFailure('empty');
+        }
+        const ext = extensionForMime(this.mime);
+        return new File([blob], `voice-note.${ext}`, { type: this.mime });
+    }
+    cancel() {
+        this.recording = false;
+        this.stopMeter();
+        if (this.recorder && this.recorder.state !== 'inactive') {
+            try {
+                this.recorder.stop();
+            }
+            catch {
+                // ignore
+            }
+        }
+        this.disposeTracks();
+        this.chunks = [];
+        this.recorder = null;
+    }
+    // fallow-ignore-next-line unused-class-member -- called from useComposerVoice cleanup
+    dispose() {
+        this.cancel();
+    }
+    startMeter() {
+        if (!this.stream)
+            return;
+        const AudioContextClass = globalThis.AudioContext;
+        this.audioContext = new AudioContextClass();
+        this.analyser = this.audioContext.createAnalyser();
+        this.analyser.fftSize = 2048;
+        this.source = this.audioContext.createMediaStreamSource(this.stream);
+        this.source.connect(this.analyser);
+        const tick = () => {
+            if (!this.analyser || !this.recording)
+                return;
+            const data = new Uint8Array(this.analyser.fftSize);
+            this.analyser.getByteTimeDomainData(data);
+            this.onLevel?.(timeDomainBytesToLevel(data));
+            this.rafId = requestAnimationFrame(tick);
+        };
+        this.rafId = requestAnimationFrame(tick);
+    }
+    stopMeter() {
+        cancelAnimationFrame(this.rafId);
+        this.rafId = 0;
+        this.onLevel?.(0);
+        this.source?.disconnect();
+        this.analyser?.disconnect();
+        this.source = null;
+        this.analyser = null;
+        if (this.audioContext && this.audioContext.state !== 'closed') {
+            void this.audioContext.close();
+        }
+        this.audioContext = null;
+    }
+    disposeTracks() {
+        for (const track of this.stream?.getTracks() ?? []) {
+            track.stop();
+        }
+        this.stream = null;
+    }
+}
+export function isVoiceRecorderFailure(value) {
+    return value instanceof VoiceRecorderFailure;
+}

package/client/walk-away.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A message sent while its reply waits on gates walks away from them in the
+ * same request: `abandon` names the waiting calls, and the history carries the
+ * paused reply with those calls open. The host settles each one cancelled and
+ * streams those events ahead of the message's reply; once the last one
+ * settles, the paused reply commits whole, and the message's reply begins.
+ *
+ * @module
+ */
+import { type TurnHistoryMessage } from '@theoremjs/agents';
+import { type ComposerProfileInterface, type InterfaceTurnSession, type TranscriptBlock } from '@theoremjs/agents/interface';
+import type { TurnEventSink } from './transport.ts';
+import { type WalkAway } from './turn-client.ts';
+/** The paused reply, committed with its settled calls, and its blocks as the transcript keeps them. */
+export type WalkedAway = {
+    session: InterfaceTurnSession;
+    blocks: TranscriptBlock[];
+};
+export type WalkingAway = {
+    /** For `buildTurnRequest`: the paused session and the calls it waits on. */
+    request: WalkAway;
+    /** The paused reply as the model reads it, its waiting calls open. */
+    history: TurnHistoryMessage[];
+    /**
+     * The sink for the request's stream: each waiting call's events settle the
+     * paused reply, and `onSettled` fires once the last one has; every event
+     * after that is the message's reply, and goes on to `onEvent`.
+     */
+    sink(onEvent: TurnEventSink, onSettled: (walked: WalkedAway) => void): TurnEventSink;
+    /** Whether every waiting call has settled. */
+    settled(): boolean;
+};
+/** Walk away from every call `paused` waits on; `workedMs` is the paused reply's work so far. */
+export declare function walkAwayFrom(iface: ComposerProfileInterface, paused: InterfaceTurnSession, workedMs: number): WalkingAway;

package/client/walk-away.js

@@ -0,0 +1,48 @@
+/**
+ * A message sent while its reply waits on gates walks away from them in the
+ * same request: `abandon` names the waiting calls, and the history carries the
+ * paused reply with those calls open. The host settles each one cancelled and
+ * streams those events ahead of the message's reply; once the last one
+ * settles, the paused reply commits whole, and the message's reply begins.
+ *
+ * @module
+ */
+import { TheoremError } from '@theoremjs/agents';
+import { appendPausedTurnToHistory, gatedToolsFromEvents, settlesToolCall, } from '@theoremjs/agents/interface';
+import { commitCompletedTurn, stampWorked } from "./run-commit.js";
+import { foldAssistantTurn } from "./turn-client.js";
+/** Walk away from every call `paused` waits on; `workedMs` is the paused reply's work so far. */
+export function walkAwayFrom(iface, paused, workedMs) {
+    const calls = gatedToolsFromEvents(paused.assistantEvents);
+    const waiting = new Set(calls.map((call) => call.callId));
+    const events = [...paused.assistantEvents];
+    const settle = (event) => {
+        events.push(event);
+        if (event.type === 'tool' && settlesToolCall(event, event.tool.callId))
+            waiting.delete(event.tool.callId);
+        if (waiting.size)
+            return undefined;
+        return {
+            session: commitCompletedTurn(paused, events),
+            blocks: stampWorked(foldAssistantTurn(iface, events), { workedMs, endedAt: Date.now() }),
+        };
+    };
+    return {
+        request: { paused, calls },
+        history: appendPausedTurnToHistory(paused.history, paused.assistantEvents),
+        sink: (onEvent, onSettled) => (event) => {
+            if (!waiting.size || event.type === 'unsupported' || event.type === 'malformed') {
+                onEvent(event);
+                return;
+            }
+            if (event.type !== 'tool' || !waiting.has(event.tool.callId)) {
+                // lexicon-exempt: internal diagnostic; the user reads the error kind's wording
+                throw new TheoremError('bad_response', 'the reply began before the calls it walked away from settled');
+            }
+            const walked = settle(event);
+            if (walked)
+                onSettled(walked);
+        },
+        settled: () => waiting.size === 0,
+    };
+}

package/client/wire-line.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Every value that reaches the browser over a wire (NDJSON lines, live
+ * envelopes) is checked against its schema here. A line or event of a kind the
+ * client does not know is reported as `unsupported`, and one that fails its
+ * check (not JSON, no kind, or a known kind that fails its schema) as
+ * `malformed`; either way the reply goes on. A whole reply that fails its check
+ * (the profile description) is `bad_response`.
+ *
+ * @module
+ */
+import { TheoremError, z } from '@theoremjs/agents';
+/**
+ * A line or envelope of a kind the client does not know. The server never
+ * sends it; the client's parser makes it so the host sees what arrived. Theorem
+ * shows nothing for it.
+ */
+export type UnsupportedEvent = {
+    type: 'unsupported';
+    received: string;
+    raw: unknown;
+};
+/**
+ * A line or event that failed its wire check. The server never sends it; the
+ * client's reader makes it, leaves the line out, and the reply goes on. `error`
+ * is `bad_response`: its message names what broke, never the value, and the
+ * user reads `session.part_skipped`.
+ */
+export type MalformedEvent = {
+    type: 'malformed';
+    error: TheoremError;
+};
+/** Every kind a wire carries, and the schema a value of that kind must pass. */
+export type WireLines<Line extends {
+    type: string;
+}> = {
+    readonly [K in Line['type']]: z.ZodType<Extract<Line, {
+        type: K;
+    }>>;
+};
+/**
+ * Issue paths and codes only: a failure names what broke, never the value. A
+ * union that matched no branch lists each branch's issues.
+ */
+export declare function issueSummary(error: z.ZodError): string;
+/** `raw` as `schema` reads it; one that fails is `bad_response`, naming `what`. */
+export declare function checkWire<T>(schema: z.ZodType<T>, raw: unknown, what: string): T;
+/** One wire value: a known kind that passed its schema, `unsupported`, or `malformed`. */
+export declare function readWireValue<Line extends {
+    type: string;
+}>(lines: WireLines<Line>, raw: unknown): Line | UnsupportedEvent | MalformedEvent;
+/** One wire line's text: {@link readWireValue} of its JSON, or `malformed` when it is not JSON. */
+export declare function readWireLine<Line extends {
+    type: string;
+}>(lines: WireLines<Line>, text: string): Line | UnsupportedEvent | MalformedEvent;
+/** A whole reply's JSON text as a value; text that is not JSON is `bad_response`. */
+export declare function parseWireJson(text: string): unknown;

package/client/wire-line.js

@@ -0,0 +1,90 @@
+/**
+ * Every value that reaches the browser over a wire (NDJSON lines, live
+ * envelopes) is checked against its schema here. A line or event of a kind the
+ * client does not know is reported as `unsupported`, and one that fails its
+ * check (not JSON, no kind, or a known kind that fails its schema) as
+ * `malformed`; either way the reply goes on. A whole reply that fails its check
+ * (the profile description) is `bad_response`.
+ *
+ * @module
+ */
+import { TheoremError, z } from '@theoremjs/agents';
+const wireKind = z.object({ type: z.string() });
+function isKnown(lines, type) {
+    return Object.hasOwn(lines, type);
+}
+function issuesSummary(issues, at) {
+    return issues
+        .map((issue) => {
+        const path = [...at, ...issue.path];
+        const head = `${path.map(String).join('.') || '(root)'} ${issue.code}`;
+        if (issue.code !== 'invalid_union' || issue.errors.length === 0)
+            return head;
+        return `${head} [${issue.errors.map((branch) => issuesSummary(branch, path)).join(' | ')}]`;
+    })
+        .join('; ');
+}
+/**
+ * Issue paths and codes only: a failure names what broke, never the value. A
+ * union that matched no branch lists each branch's issues.
+ */
+export function issueSummary(error) {
+    return issuesSummary(error.issues, []);
+}
+function badResponse(what, error) {
+    // lexicon-exempt: internal diagnostic; the user reads error.bad_response
+    return new TheoremError('bad_response', `${what} failed its wire check: ${issueSummary(error)}`);
+}
+/** `raw` as `schema` reads it; one that fails is `bad_response`, naming `what`. */
+export function checkWire(schema, raw, what) {
+    const parsed = schema.safeParse(raw);
+    if (!parsed.success)
+        throw badResponse(what, parsed.error);
+    return parsed.data;
+}
+function malformed(message) {
+    return {
+        type: 'malformed',
+        error: new TheoremError('bad_response', message, { copy: { key: 'session.part_skipped' } }),
+    };
+}
+/** One wire value: a known kind that passed its schema, `unsupported`, or `malformed`. */
+export function readWireValue(lines, raw) {
+    const kind = wireKind.safeParse(raw);
+    // lexicon-exempt: internal diagnostic; the user reads session.part_skipped
+    if (!kind.success)
+        return malformed(`a line without a kind failed its wire check: ${issueSummary(kind.error)}`);
+    const { type } = kind.data;
+    if (!isKnown(lines, type))
+        return { type: 'unsupported', received: type, raw };
+    const line = lines[type].safeParse(raw);
+    if (line.success)
+        return line.data;
+    // lexicon-exempt: internal diagnostic; the user reads session.part_skipped
+    return malformed(`a '${type}' line failed its wire check: ${issueSummary(line.error)}`);
+}
+/** JSON text as a value, or undefined when it is not JSON. The parser's own error quotes the text, so it is not kept. */
+function jsonValue(text) {
+    try {
+        return { value: JSON.parse(text) };
+    }
+    catch (err) {
+        if (err instanceof SyntaxError)
+            return undefined;
+        throw err;
+    }
+}
+/** One wire line's text: {@link readWireValue} of its JSON, or `malformed` when it is not JSON. */
+export function readWireLine(lines, text) {
+    const json = jsonValue(text);
+    // lexicon-exempt: internal diagnostic; the user reads session.part_skipped
+    return json ? readWireValue(lines, json.value) : malformed('a line is not JSON');
+}
+/** A whole reply's JSON text as a value; text that is not JSON is `bad_response`. */
+export function parseWireJson(text) {
+    const json = jsonValue(text);
+    // lexicon-exempt: internal diagnostic; the user reads error.bad_response
+    if (!json)
+        throw new TheoremError('bad_response', 'a line is not JSON');
+    return json.value;
+}

package/client/worklets/mic-capture.js

@@ -0,0 +1,16 @@
+/**
+ * AudioWorklet processor that forwards mono mic frames to the main thread.
+ * Plain JS: it runs in the AudioWorkletGlobalScope as its own module, loaded
+ * by URL (see `../mic-capture.ts`), so it imports nothing and ships as is.
+ */
+registerProcessor(
+	'mic-capture-processor',
+	class MicCaptureProcessor extends AudioWorkletProcessor {
+		process(inputs) {
+			const channel = inputs[0][0];
+			const copy = new Float32Array(channel);
+			this.port.postMessage(copy, [copy.buffer]);
+			return true;
+		}
+	},
+);

package/components/InkWaveform.d.ts

@@ -0,0 +1,10 @@
+import { type InkWaveStatus } from '../client/ink-waveform.ts';
+export type InkWaveformProps = {
+    status?: InkWaveStatus;
+    inputLevel?: number;
+    outputLevel?: number;
+    toolActive?: boolean;
+    frozen?: boolean;
+    variant?: 'default' | 'hero' | 'pill' | 'strip';
+};
+export declare function InkWaveform({ status, inputLevel, outputLevel, toolActive, frozen, variant, }: InkWaveformProps): import("react").JSX.Element;

package/components/InkWaveform.js

@@ -0,0 +1,108 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { computeInkBarTargets, INK_WAVE_BAR_COUNT, INK_WAVE_HERO_BAR_COUNT, inkWaveDriver, inkWavePhases, stepInkBarHeights, } from "../client/ink-waveform.js";
+const WAVE_CONFIG = {
+    hero: {
+        viewWidth: 960,
+        viewHeight: 720,
+        preserveAspect: 'xMidYMax slice',
+        strokeWidth: 2,
+        barCount: INK_WAVE_HERO_BAR_COUNT,
+    },
+    pill: {
+        viewWidth: 480,
+        viewHeight: 120,
+        preserveAspect: 'none',
+        strokeWidth: 3,
+        barCount: INK_WAVE_BAR_COUNT,
+    },
+    // A long, low band (a call bar along the foot of a page): many fine bars.
+    strip: {
+        viewWidth: 1600,
+        viewHeight: 48,
+        preserveAspect: 'none',
+        strokeWidth: 2,
+        barCount: 120,
+    },
+    default: {
+        viewWidth: 480,
+        viewHeight: 320,
+        preserveAspect: 'xMidYMax meet',
+        strokeWidth: 2,
+        barCount: INK_WAVE_BAR_COUNT,
+    },
+};
+function resolveWaveDimensions(variant) {
+    const cfg = WAVE_CONFIG[variant] ?? WAVE_CONFIG.default;
+    const gap = (cfg.viewWidth - cfg.strokeWidth * cfg.barCount) / (cfg.barCount + 1);
+    return { ...cfg, gap };
+}
+function useAnimatedWaveHeights(args) {
+    const { barCount, phases, status, inputLevel, outputLevel, toolActive, frozen } = args;
+    const [heights, setHeights] = useState(() => Array.from({ length: barCount }, () => 0.06));
+    const snapRef = useRef({
+        status,
+        inputLevel,
+        outputLevel,
+        toolActive,
+        frozen,
+    });
+    useEffect(() => {
+        snapRef.current = { status, inputLevel, outputLevel, toolActive, frozen };
+    }, [status, inputLevel, outputLevel, toolActive, frozen]);
+    useEffect(() => {
+        let frame = 0;
+        setHeights(Array.from({ length: barCount }, () => 0.06));
+        const tick = (time) => {
+            const snap = snapRef.current;
+            setHeights((prev) => {
+                const current = prev.length === barCount ? prev : Array.from({ length: barCount }, () => 0.06);
+                const targets = computeInkBarTargets({
+                    phases,
+                    timeMs: time,
+                    driver: inkWaveDriver(snap.status, snap.toolActive, snap.inputLevel, snap.outputLevel, snap.frozen),
+                    inputLevel: snap.frozen ? 0 : snap.inputLevel,
+                    outputLevel: snap.frozen ? 0 : snap.outputLevel,
+                    frozen: snap.frozen,
+                });
+                return stepInkBarHeights(current, targets, snap.frozen ? 0.2 : 0.14);
+            });
+            frame = requestAnimationFrame(tick);
+        };
+        frame = requestAnimationFrame(tick);
+        return () => {
+            cancelAnimationFrame(frame);
+        };
+    }, [barCount, phases]);
+    return heights;
+}
+export function InkWaveform({ status = 'disconnected', inputLevel = 0, outputLevel = 0, toolActive = false, frozen = false, variant = 'default', }) {
+    const { viewWidth, viewHeight, preserveAspect, strokeWidth, barCount, gap } = resolveWaveDimensions(variant);
+    const phases = useMemo(() => inkWavePhases(barCount), [barCount]);
+    const heights = useAnimatedWaveHeights({
+        barCount,
+        phases,
+        status,
+        inputLevel,
+        outputLevel,
+        toolActive,
+        frozen,
+    });
+    const bars = heights.map((height, index) => {
+        const x = gap + index * (strokeWidth + gap) + strokeWidth / 2;
+        const barHeight = height * (viewHeight - 4);
+        return { x, y2: viewHeight - barHeight };
+    });
+    const className = [
+        'ink-wave',
+        variant === 'hero' ? 'ink-wave--hero' : '',
+        variant === 'pill' ? 'ink-wave--pill' : '',
+        variant === 'strip' ? 'ink-wave--strip' : '',
+    ]
+        .filter(Boolean)
+        .join(' ');
+    return (_jsx("svg", { className: className, "aria-hidden": "true", viewBox: `0 0 ${String(viewWidth)} ${String(viewHeight)}`, preserveAspectRatio: preserveAspect, 
+        // Attribute defaults for hosts without ink-controls.css (the Astryx UI);
+        // the live stylesheet overrides them where it loads.
+        width: "100%", height: "100%", children: bars.map((bar) => (_jsx("line", { className: "ink-wave__bar", x1: bar.x, x2: bar.x, y1: viewHeight, y2: bar.y2, strokeWidth: strokeWidth, stroke: "currentColor", strokeLinecap: "square" }, `${String(bar.x)}:${String(bar.y2)}`))) }));
+}

package/components/live/use-live-runner-controls.d.ts

@@ -0,0 +1,48 @@
+import { type MutableRefObject, type Dispatch, type SetStateAction } from 'react';
+import { type LiveCaptionState } from '../../client/live/live-captions.ts';
+import { type LiveFacingMode, type LiveVideoCapture } from '../../client/live/live-video.ts';
+import type { LiveConnectPhase, LiveSessionStatus } from '../../client/live/live-state.ts';
+import type { LiveConnection, LiveSessionClient } from '../../client/live-client.ts';
+/** Media + session lifecycle handlers for LiveRunner. */
+export declare function useLiveRunnerControls(args: {
+    clientRef: MutableRefObject<LiveSessionClient | null>;
+    videoCaptureRef: MutableRefObject<LiveVideoCapture | null>;
+    captionsRef: MutableRefObject<LiveCaptionState>;
+    connectionRef: MutableRefObject<() => LiveConnection | Promise<LiveConnection>>;
+    statusRef: MutableRefObject<LiveSessionStatus>;
+    isMutedRef: MutableRefObject<boolean>;
+    sessionPermissionsRef: MutableRefObject<string[]>;
+    ensureClient: (connection: LiveConnection) => LiveSessionClient;
+    clearClient: () => void;
+    cancelGateDecision: (reason?: string) => void;
+    stopVideo: () => void;
+    resetCaptions: () => void;
+    sessionActive: boolean;
+    textAvailable: boolean;
+    videoAvailable: boolean;
+    voiceAvailable: boolean;
+    isVideoOn: boolean;
+    textDraft: string;
+    setTextDraft: Dispatch<SetStateAction<string>>;
+    setCaptions: Dispatch<SetStateAction<LiveCaptionState>>;
+    reportFailure: (err: unknown) => void;
+    clearFailure: () => void;
+    setIsMuted: Dispatch<SetStateAction<boolean>>;
+    setSessionActive: Dispatch<SetStateAction<boolean>>;
+    setSessionPermissions: Dispatch<SetStateAction<string[]>>;
+    setStatus: Dispatch<SetStateAction<LiveSessionStatus>>;
+    setConnectPhase: Dispatch<SetStateAction<LiveConnectPhase | null>>;
+    setInputLevel: Dispatch<SetStateAction<number>>;
+    setOutputLevel: Dispatch<SetStateAction<number>>;
+    setVideoPreview: Dispatch<SetStateAction<HTMLVideoElement | null>>;
+    setVideoFacingMode: Dispatch<SetStateAction<LiveFacingMode>>;
+    setIsVideoOn: Dispatch<SetStateAction<boolean>>;
+}): {
+    teardownSession: () => void;
+    startSession: () => Promise<void>;
+    handleSendText: () => void;
+    handleToggleVideo: () => Promise<void>;
+    handleFlipCamera: () => Promise<void>;
+    handleToggleMic: () => void;
+    handleRestart: () => Promise<void>;
+};

package/components/live/use-live-runner-controls.js

@@ -0,0 +1,100 @@
+import { useCallback } from 'react';
+import { applyLiveTranscript, } from "../../client/live/live-captions.js";
+import { startLiveVideoCapture, } from "../../client/live/live-video.js";
+/** Media + session lifecycle handlers for LiveRunner. */
+export function useLiveRunnerControls(args) {
+    const teardownSession = useCallback(() => {
+        args.cancelGateDecision();
+        args.clearClient();
+        args.stopVideo();
+        args.setIsMuted(false);
+        args.isMutedRef.current = false;
+        args.setSessionActive(false);
+        args.setSessionPermissions([]);
+        args.sessionPermissionsRef.current = [];
+        args.statusRef.current = 'disconnected';
+        args.setStatus('disconnected');
+        args.setConnectPhase(null);
+        args.setInputLevel(0);
+        args.setOutputLevel(0);
+    }, [args]);
+    const startSession = useCallback(async () => {
+        args.clearFailure();
+        args.resetCaptions();
+        try {
+            const liveClient = args.ensureClient(await args.connectionRef.current());
+            if (args.statusRef.current === 'disconnected' || args.statusRef.current === 'error') {
+                await liveClient.connect();
+            }
+        }
+        catch (err) {
+            args.reportFailure(err);
+        }
+    }, [args]);
+    const handleSendText = useCallback(() => {
+        const text = args.textDraft.trim();
+        if (!text || !args.clientRef.current || !args.sessionActive || !args.textAvailable)
+            return;
+        args.clientRef.current.sendText(text);
+        args.setTextDraft('');
+        const next = applyLiveTranscript(args.captionsRef.current, text, true, false, {
+            forceNew: true,
+        });
+        args.captionsRef.current = next;
+        args.setCaptions(next);
+    }, [args]);
+    const handleToggleVideo = useCallback(async () => {
+        if (!args.clientRef.current || !args.sessionActive || !args.videoAvailable)
+            return;
+        if (args.isVideoOn) {
+            args.stopVideo();
+            return;
+        }
+        try {
+            const capture = await startLiveVideoCapture((base64) => {
+                args.clientRef.current?.sendVideo(base64);
+            });
+            args.videoCaptureRef.current = capture;
+            args.setVideoPreview(capture.video);
+            args.setVideoFacingMode(capture.facingMode());
+            args.setIsVideoOn(true);
+        }
+        catch (err) {
+            args.reportFailure(err);
+            args.stopVideo();
+        }
+    }, [args]);
+    const handleFlipCamera = useCallback(async () => {
+        const capture = args.videoCaptureRef.current;
+        if (!capture || !args.sessionActive || !args.isVideoOn)
+            return;
+        try {
+            const facing = await capture.flip();
+            args.setVideoFacingMode(facing);
+            args.setVideoPreview(capture.video);
+        }
+        catch (err) {
+            args.reportFailure(err);
+        }
+    }, [args]);
+    const handleToggleMic = useCallback(() => {
+        if (!args.clientRef.current || !args.sessionActive || !args.voiceAvailable)
+            return;
+        const muted = args.clientRef.current.toggleMute();
+        args.isMutedRef.current = muted;
+        args.setIsMuted(muted);
+    }, [args]);
+    const handleRestart = useCallback(async () => {
+        teardownSession();
+        await startSession();
+    }, [startSession, teardownSession]);
+    return {
+        teardownSession,
+        startSession,
+        handleSendText,
+        handleToggleVideo,
+        handleFlipCamera,
+        handleToggleMic,
+        handleRestart,
+    };
+}