@signalcore/ui 0.1.0 → 1.0.0-beta.0

package/dist/useConversation.js

@@ -0,0 +1,523 @@
+import { createScreen } from "./browser.js";
+import { sayOf, toolResultOf } from "./frames.js";
+import { note } from "./dev.js";
+import { useLive } from "./useLive.js";
+import { useEffect, useReducer, useRef, useState } from "react";
+//#region src/useConversation.ts
+const EMPTY = {
+	messages: [],
+	pending: false,
+	draft: "",
+	awaiting: null,
+	loaded: false,
+	error: null,
+	browser: null,
+	holder: null,
+	handovers: [],
+	tools: [],
+	answered: null
+};
+/**
+* Errors told only to the socket that sent something (the agent still replying, a frame it did
+* not understand, a turn waiting on a surface, files it can't carry, what only the channel or the
+* business answers, a tool's answer no call waits on: nothing was stored): the turn, if there is
+* one, goes on. Any other error ends it.
+*/
+const ASIDE = /* @__PURE__ */ new Set([
+	"busy",
+	"unknown",
+	"pending",
+	"files",
+	"channel",
+	"business",
+	"tool"
+]);
+/**
+* Told when the page answered a host's tool no call waits on any more (answered already, from
+* another tab or before a reload; or late): nothing for the person to hear.
+*/
+const STALE = "tool";
+/** Whether a step's state is its last: done, or failed. */
+const settled = (step) => step?.state === "done" || step?.state === "failed";
+/**
+* The turn, one step at a time, from what the socket says alone, so a page opened mid-turn (a
+* reload, another tab) reads it as the one that sent. The person's message opens it (their words,
+* or their answer on a surface); on a channel, where the reply comes on its own time, its first
+* words or step do. `done`, `stopped` or an error closes it, and either way the
+* draft goes: the reply now lives in the messages, and after an error there is none (on a
+* refusal the partial text was never one). A reply that calls actions is stored before they run,
+* so what `step`, `ui` and `request` frames say lands on its steps: the message is the one place
+* a step is drawn from, live or read back. The socket opening afresh empties the draft too, since
+* the turn so far is then told again. Who answers the conversation is the read's, then each
+* `holder` frame's: its change kept once beside those read, in order, and who answers taken from
+* it only when it is the newest; a `decision` lands on its message (null clears it). A host's
+* tool the page runs (`tool`) is its step working, and a turn under way until its step is done
+* or failed, whatever `done` said meanwhile. A yes the business gives (`decides: "business"`)
+* waits on its step without stopping the turn or holding the person; one the person gave and the
+* API refused as the business's (`business`) waits for the business again.
+*/
+function reduce(state, action) {
+	switch (action.type) {
+		case "reset": return {
+			...state,
+			pending: false,
+			draft: "",
+			awaiting: null,
+			browser: null,
+			tools: [],
+			answered: null
+		};
+		case "history": {
+			const read = action.handovers ?? [];
+			const handovers = withHandovers(read, state.handovers);
+			const heard = handovers.length > read.length ? handovers.at(-1)?.holder : void 0;
+			return {
+				...state,
+				messages: withMessages(action.messages, state.messages),
+				awaiting: action.pending ? awaited(action.messages) : null,
+				loaded: true,
+				error: null,
+				holder: heard ?? action.holder ?? state.holder,
+				handovers
+			};
+		}
+		case "failed": return {
+			...state,
+			error: action.error
+		};
+		case "working": return {
+			...state,
+			pending: true
+		};
+		case "text": return {
+			...state,
+			pending: true,
+			draft: state.draft + action.delta
+		};
+		case "message": {
+			const { message } = action;
+			const messages = withStored(state.messages, message);
+			if (message.author === "contact" || message.author === "operator") return {
+				...state,
+				messages
+			};
+			if (message.role === "assistant") return {
+				...state,
+				messages,
+				draft: ""
+			};
+			return {
+				...state,
+				messages: message.action ? answered(messages, message.action) : messages,
+				pending: true,
+				draft: ""
+			};
+		}
+		case "ui": return {
+			...state,
+			messages: withStep(state.messages, action.id, (step) => ({
+				...step,
+				surface: action.surface,
+				awaits: action.awaits
+			})),
+			awaiting: action.awaits ? action.id : state.awaiting
+		};
+		case "step": {
+			const waits = action.state === "waiting";
+			const ended = action.state === "done" || action.state === "failed";
+			return {
+				...state,
+				pending: state.pending || action.state === "running",
+				messages: withStep(state.messages, action.id, (step) => ({
+					...step,
+					state: action.state,
+					output: action.output ?? step.output,
+					awaits: waits || step.awaits
+				})),
+				awaiting: waits ? action.id : ended && state.awaiting === action.id ? null : state.awaiting,
+				tools: ended ? state.tools.filter((id) => id !== action.id) : state.tools,
+				answered: state.answered?.id === action.id ? null : state.answered
+			};
+		}
+		case "tool":
+			if (settled(stepOf(state.messages, action.id))) return state;
+			return {
+				...state,
+				pending: true,
+				awaiting: state.awaiting === action.id ? null : state.awaiting,
+				messages: withStep(state.messages, action.id, (step) => ({
+					...step,
+					state: "running",
+					awaits: false
+				})),
+				tools: state.tools.includes(action.id) ? state.tools : [...state.tools, action.id]
+			};
+		case "request": {
+			const { id, action: name, input, decides = "person" } = action;
+			const theirs = decides === "person";
+			return {
+				...state,
+				awaiting: theirs ? id : state.awaiting,
+				messages: withStep(state.messages, id, (step) => ({
+					...step,
+					state: "waiting",
+					awaits: theirs,
+					request: {
+						action: name,
+						input,
+						decides
+					}
+				}))
+			};
+		}
+		case "acted": {
+			const { surface } = action.action;
+			const request = stepOf(state.messages, surface)?.request ?? null;
+			return {
+				...state,
+				awaiting: surface === state.awaiting ? null : state.awaiting,
+				messages: withStep(state.messages, surface, (step) => ({
+					...step,
+					request: null
+				})),
+				answered: request === null ? state.answered : {
+					id: surface,
+					request
+				}
+			};
+		}
+		case "handoff": return state;
+		case "holder": {
+			const handovers = withHandovers(state.handovers, [action.handover]);
+			const newest = handovers.at(-1) === action.handover;
+			return {
+				...state,
+				holder: newest ? action.handled_by : state.holder,
+				handovers
+			};
+		}
+		case "decision": return {
+			...state,
+			messages: withMessage(state.messages, action.message_id, (message) => ({
+				...message,
+				decision: action.decision
+			}))
+		};
+		case "done": return {
+			...state,
+			pending: state.tools.length > 0,
+			draft: ""
+		};
+		case "stopped": return {
+			...state,
+			pending: false,
+			draft: "",
+			tools: []
+		};
+		case "error":
+			if (action.code === "business" && state.answered !== null) {
+				const { id, request } = state.answered;
+				return {
+					...state,
+					answered: null,
+					messages: withStep(state.messages, id, (step) => ({
+						...step,
+						awaits: false,
+						request: {
+							...request,
+							decides: "business"
+						}
+					}))
+				};
+			}
+			return ASIDE.has(action.code) ? state : {
+				...state,
+				pending: false,
+				draft: "",
+				awaiting: null,
+				tools: [],
+				answered: null
+			};
+		case "browser":
+			if (!action.open) return {
+				...state,
+				browser: null
+			};
+			return {
+				...state,
+				browser: {
+					url: action.url,
+					title: action.title,
+					where: action.where,
+					control: action.control,
+					reason: action.reason,
+					wait: action.wait,
+					width: action.width,
+					height: action.height
+				}
+			};
+		case "browser.frame": return state;
+	}
+}
+/**
+* `known` with whatever of `more` it lacks, at the end, by id: a message is kept once however
+* many times it is heard (stored live, then read in the history, or told again on a reconnect).
+*/
+function withMessages(known, more) {
+	const ids = new Set(known.map((message) => message.id));
+	const missing = more.filter((message) => !ids.has(message.id));
+	return missing.length === 0 ? known : [...known, ...missing];
+}
+/** What going out on a channel changes of a message once it is stored, as it goes. */
+const OUTGOING = [
+	"delivery",
+	"delivery_error",
+	"pieces",
+	"sent_parts",
+	"voice"
+];
+/**
+* `known` with a message stored: one it lacks joins at the end; one it holds takes what going out
+* on its channel changed since (where it got to, its parts, its voice note) and keeps the rest as
+* this page has it (its steps, moved by their own frames); untouched when nothing changed.
+*/
+function withStored(known, stored) {
+	const held = known.find((message) => message.id === stored.id);
+	if (held === void 0) return [...known, stored];
+	if (OUTGOING.every((field) => isEqual(held[field], stored[field]))) return known;
+	const outgoing = Object.fromEntries(OUTGOING.map((field) => [field, stored[field]]));
+	return known.map((message) => message === held ? {
+		...held,
+		...outgoing
+	} : message);
+}
+/** The same value, told again: equal by what it holds. */
+const isEqual = (one, other) => JSON.stringify(one ?? null) === JSON.stringify(other ?? null);
+/** A change of who answers, as one however it was told: its moment, and to whom. */
+const handoverKey = ({ at, holder }) => `${Date.parse(at)} ${holder}`;
+/**
+* `known` with whatever of `more` it lacks, in the order they were made: a change is kept once
+* however often, and by whatever, it is told (the read, a frame, the host's own request).
+*/
+function withHandovers(known, more) {
+	const keys = new Set(known.map(handoverKey));
+	const missing = more.filter((handover) => !keys.has(handoverKey(handover)));
+	if (missing.length === 0) return known;
+	return [...known, ...missing].sort((one, other) => Date.parse(one.at) - Date.parse(other.at));
+}
+/** The messages with message `id` changed; untouched when none is it. */
+function withMessage(messages, id, change) {
+	const at = messages.findIndex((message) => message.id === id);
+	const message = messages[at];
+	return message ? messages.with(at, change(message)) : messages;
+}
+/** Step `id`, wherever it is; none when no message holds it. */
+function stepOf(messages, id) {
+	return messages.flatMap((message) => message.steps).findLast((step) => step.id === id);
+}
+/** The messages with step `id` changed, wherever it is; untouched when no message holds it. */
+function withStep(messages, id, change) {
+	const at = messages.findLastIndex((message) => message.steps.some((step) => step.id === id));
+	const message = messages[at];
+	if (!message) return messages;
+	const steps = message.steps.map((step) => step.id === id ? change(step) : step);
+	return messages.with(at, {
+		...message,
+		steps
+	});
+}
+/** The surface a stopped turn waits on, as the history tells it. */
+function awaited(messages) {
+	return messages.flatMap((message) => message.steps).find((step) => step.awaits)?.id ?? null;
+}
+/**
+* The person's answer, landed on the step that waited for it: a question is done with their
+* words as its output (what the history reads back); an action they allowed or declined was
+* already told its own state.
+*/
+function answered(messages, action) {
+	return withStep(messages, action.surface, (step) => step.state === "waiting" ? {
+		...step,
+		state: "done",
+		output: action.label,
+		awaits: false,
+		request: null
+	} : {
+		...step,
+		awaits: false,
+		request: null
+	});
+}
+/** How often the history is read again while something goes out on a channel. */
+const DELIVERY_EVERY = 3e3;
+/** How long a message sent is watched for its receipt before the next read brings it. */
+const RECEIPT_WITHIN = 6e4;
+/**
+* Whether a message is still on its way to the person on a channel: waiting to go, or gone a
+* moment ago and not yet received. What it gets to moves without a frame, so it is read again.
+*/
+function onItsWay(message, now) {
+	if (message.delivery === "queued") return true;
+	return message.delivery === "sent" && now - Date.parse(message.created_at) < RECEIPT_WITHIN;
+}
+/** What the page answers a tool of the host's when it runs none (no `onTool`), for the agent. */
+const NO_TOOL = "This page can't do that";
+const refuse = () => Promise.reject(/* @__PURE__ */ new Error(NO_TOOL));
+/**
+* Conversation `conversationId` as the person sees it: the history, kept live by the socket.
+* Each time the socket opens the history is read, with the socket already listening, so nothing
+* stored can fall between the two; what came live meanwhile is kept. `onError` hears each
+* error's code (the socket's, or `load` for a history that could not be read): the host words
+* it, this hook shows no text; but `tool`, the page's answer to a call no longer waiting (one it
+* answered already, told again), which is let pass (noted in development). `onHolder` hears each
+* change of who answers it, live, for the host's own views of it; `handover` is the last change
+* the host knows of (one it made itself, as its request answered), taken at once, so it shows
+* whether or not the socket tells it.
+* `onStep` hears each step the agent starts, live, by its action's name, for the host's own
+* views of it (the builder's column, opened as the agent asks it).
+* `onTool` runs the host's own tools the agent calls in the page (a `tool` frame), and its answer
+* goes up (`tool_result`); each call runs once, and one told again while it waits (the socket
+* opened anew) is answered again with what it gave. Without `onTool`, each is refused with
+* `NO_TOOL`, so the turn never waits on a page that can't run it. One conversation per mount: key
+* the component on the id.
+*/
+function useConversation(client, conversationId, { onError, onHolder, onStep, handover, onTool } = {}) {
+	const [state, dispatch] = useReducer(reduce, EMPTY);
+	const told = handover ?? null;
+	const toldKey = told === null ? null : handoverKey(told);
+	useEffect(() => {
+		if (told !== null) dispatch({
+			type: "holder",
+			handled_by: told.holder,
+			handover: told
+		});
+	}, [toldKey]);
+	const [screen] = useState(createScreen);
+	const reads = useRef(0);
+	useEffect(() => () => {
+		reads.current += 1;
+	}, [client, conversationId]);
+	const read = () => {
+		const run = ++reads.current;
+		client.conversations.get(conversationId).then(({ messages, pending, handled_by, handovers = [] }) => {
+			if (run !== reads.current) return;
+			dispatch({
+				type: "history",
+				messages,
+				pending,
+				holder: handled_by,
+				handovers
+			});
+		}, (error) => {
+			if (run !== reads.current) return;
+			dispatch({
+				type: "failed",
+				error
+			});
+			onError?.("load");
+		});
+	};
+	const tools = useRef(/* @__PURE__ */ new Map());
+	const runTool = ({ id, name, input }) => {
+		const known = tools.current.get(id);
+		if (known !== void 0) {
+			if (known !== null) live.send(known);
+			return;
+		}
+		tools.current.set(id, null);
+		Promise.resolve({
+			id,
+			name,
+			input
+		}).then(onTool ?? refuse).then((value) => ({
+			status: "fulfilled",
+			value
+		}), (reason) => ({
+			status: "rejected",
+			reason
+		})).then((settled) => {
+			const answer = toolResultOf(id, settled);
+			tools.current.set(id, answer);
+			live.send(answer);
+		});
+	};
+	const live = useLive(client, conversationId, {
+		onFrame: (frame) => {
+			if (frame.type === "browser.frame") {
+				screen.show({
+					jpeg: frame.jpeg,
+					width: frame.width,
+					height: frame.height
+				});
+				return;
+			}
+			if (frame.type === "error" && frame.code === STALE) {
+				note("A host's tool answer was let pass:", frame.detail);
+				return;
+			}
+			if (frame.type === "browser" && !frame.open) screen.clear();
+			dispatch(frame);
+			if (frame.type === "error") onError?.(frame.code);
+			if (frame.type === "holder") onHolder?.(frame.handled_by, frame.handover);
+			if (frame.type === "step" && frame.state === "running" && frame.action !== void 0) onStep?.(frame.action);
+			if (frame.type === "tool") runTool(frame);
+		},
+		onOpen: () => {
+			dispatch({ type: "reset" });
+			read();
+		}
+	});
+	const travelling = state.messages.some((message) => onItsWay(message, Date.now()));
+	useEffect(() => {
+		if (!travelling || !live.open) return void 0;
+		const again = setInterval(read, DELIVERY_EVERY);
+		return () => {
+			clearInterval(again);
+		};
+	}, [travelling, live.open]);
+	const say = (text, files = []) => {
+		const frame = sayOf(text, files);
+		if (frame === null || state.pending || state.awaiting !== null) return false;
+		return live.send(frame);
+	};
+	const act = (action) => {
+		if (!live.send({
+			type: "action",
+			...action
+		})) return false;
+		dispatch({
+			type: "acted",
+			action
+		});
+		return true;
+	};
+	return {
+		messages: state.messages,
+		draft: state.draft,
+		pending: state.pending,
+		awaiting: state.awaiting,
+		open: live.open,
+		loading: !state.loaded,
+		error: state.error,
+		say,
+		act,
+		stop: () => live.send({ type: "stop" }),
+		browser: state.browser,
+		watchScreen: screen.watch,
+		control: (to) => live.send({
+			type: "browser.control",
+			to
+		}),
+		closeBrowser: () => live.send({ type: "browser.close" }),
+		input: (event) => live.send({
+			type: "browser.input",
+			event
+		}),
+		holder: state.holder,
+		handovers: state.handovers
+	};
+}
+//#endregion
+export { EMPTY, NO_TOOL, onItsWay, reduce, useConversation };
+
+//# sourceMappingURL=useConversation.js.map

package/dist/useConversation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConversation.js","names":[],"sources":["../src/useConversation.ts"],"sourcesContent":["import { useEffect, useReducer, useRef, useState } from \"react\";\n\nimport { createScreen, type Screen } from \"./browser\";\nimport type { Client } from \"./client\";\nimport { note } from \"./dev\";\nimport { sayOf, toolResultOf, type Frame, type ToolResult } from \"./frames\";\nimport type {\n  Action,\n  BrowserControl,\n  BrowserFrame,\n  BrowserInput,\n  BrowserState,\n  Handover,\n  Holder,\n  Message,\n  Request,\n  Step,\n  ToolCall,\n} from \"./types\";\nimport { useLive } from \"./useLive\";\n\n/**\n * Where a conversation stands: its stored messages, the turn (whether a reply is on its way, what\n * of it has come so far, and what it waits on), and what its history read has said.\n */\nexport interface ConversationState {\n  messages: Message[];\n  pending: boolean;\n  draft: string;\n  /** The step the turn stopped on (a surface to answer, or an action to allow), until the person acts. */\n  awaiting: string | null;\n  /** Whether the history has landed once; until then an empty list means nothing. */\n  loaded: boolean;\n  /** What the last read threw; null once one lands. */\n  error: unknown;\n  /** The conversation's browser while it is open. */\n  browser: BrowserState | null;\n  /** Who answers it now; null until the history lands. */\n  holder: Holder | null;\n  /** Every change of who answers it, in order: read with the history, then heard live. */\n  handovers: Handover[];\n  /**\n   * The host's tools the page runs now, by the call's id: the turn is under way while one runs\n   * (its `done` said only that it stopped to wait for them), until its step is done or failed.\n   */\n  tools: string[];\n  /**\n   * The yes or no the person just gave, until the step's own frames say what came of it: what\n   * the API refuses as the business's (`business`) is drawn as waiting for the business again.\n   */\n  answered: { id: string; request: Request } | null;\n}\n\nexport const EMPTY: ConversationState = {\n  messages: [],\n  pending: false,\n  draft: \"\",\n  awaiting: null,\n  loaded: false,\n  error: null,\n  browser: null,\n  holder: null,\n  handovers: [],\n  tools: [],\n  answered: null,\n};\n\n/**\n * What moves the state: the socket opening afresh, a read landing (with who answers it, and its\n * changes, when the API tells them) or failing, the person acting on a surface, or a frame.\n */\nexport type ConversationAction =\n  | { type: \"reset\" }\n  | {\n      type: \"history\";\n      messages: Message[];\n      pending: boolean;\n      holder?: Holder;\n      handovers?: Handover[];\n    }\n  | { type: \"failed\"; error: unknown }\n  | { type: \"acted\"; action: Action }\n  | Frame;\n\n/**\n * Errors told only to the socket that sent something (the agent still replying, a frame it did\n * not understand, a turn waiting on a surface, files it can't carry, what only the channel or the\n * business answers, a tool's answer no call waits on: nothing was stored): the turn, if there is\n * one, goes on. Any other error ends it.\n */\nconst ASIDE: ReadonlySet<string> = new Set([\n  \"busy\",\n  \"unknown\",\n  \"pending\",\n  \"files\",\n  \"channel\",\n  \"business\",\n  \"tool\",\n]);\n\n/**\n * Told when the page answered a host's tool no call waits on any more (answered already, from\n * another tab or before a reload; or late): nothing for the person to hear.\n */\nconst STALE = \"tool\";\n\n/** Whether a step's state is its last: done, or failed. */\nconst settled = (step: Step | undefined): boolean =>\n  step?.state === \"done\" || step?.state === \"failed\";\n\n/**\n * The turn, one step at a time, from what the socket says alone, so a page opened mid-turn (a\n * reload, another tab) reads it as the one that sent. The person's message opens it (their words,\n * or their answer on a surface); on a channel, where the reply comes on its own time, its first\n * words or step do. `done`, `stopped` or an error closes it, and either way the\n * draft goes: the reply now lives in the messages, and after an error there is none (on a\n * refusal the partial text was never one). A reply that calls actions is stored before they run,\n * so what `step`, `ui` and `request` frames say lands on its steps: the message is the one place\n * a step is drawn from, live or read back. The socket opening afresh empties the draft too, since\n * the turn so far is then told again. Who answers the conversation is the read's, then each\n * `holder` frame's: its change kept once beside those read, in order, and who answers taken from\n * it only when it is the newest; a `decision` lands on its message (null clears it). A host's\n * tool the page runs (`tool`) is its step working, and a turn under way until its step is done\n * or failed, whatever `done` said meanwhile. A yes the business gives (`decides: \"business\"`)\n * waits on its step without stopping the turn or holding the person; one the person gave and the\n * API refused as the business's (`business`) waits for the business again.\n */\nexport function reduce(state: ConversationState, action: ConversationAction): ConversationState {\n  switch (action.type) {\n    case \"reset\":\n      // The socket that opens is told the browser again, if there is one, and the tools awaited.\n      return {\n        ...state,\n        pending: false,\n        draft: \"\",\n        awaiting: null,\n        browser: null,\n        tools: [],\n        answered: null,\n      };\n    case \"history\": {\n      // A change heard while the read was on its way is newer than what it says.\n      const read = action.handovers ?? [];\n      const handovers = withHandovers(read, state.handovers);\n      const heard = handovers.length > read.length ? handovers.at(-1)?.holder : undefined;\n      return {\n        ...state,\n        messages: withMessages(action.messages, state.messages),\n        awaiting: action.pending ? awaited(action.messages) : null,\n        loaded: true,\n        error: null,\n        holder: heard ?? action.holder ?? state.holder,\n        handovers,\n      };\n    }\n    case \"failed\":\n      return { ...state, error: action.error };\n    case \"working\":\n      // The agent began its reply: told first to a socket that opens while it thinks.\n      return { ...state, pending: true };\n    case \"text\":\n      return { ...state, pending: true, draft: state.draft + action.delta };\n    case \"message\": {\n      const { message } = action;\n      const messages = withStored(state.messages, message);\n      // On a channel the turn is no one's message's: the person's words wait for the agent's\n      // reply on its own time, and the business's own go out beside the turn, never in it.\n      if (message.author === \"contact\" || message.author === \"operator\") {\n        return { ...state, messages };\n      }\n      if (message.role === \"assistant\") return { ...state, messages, draft: \"\" };\n      return {\n        ...state,\n        messages: message.action ? answered(messages, message.action) : messages,\n        pending: true,\n        draft: \"\",\n      };\n    }\n    case \"ui\":\n      return {\n        ...state,\n        messages: withStep(state.messages, action.id, (step) => ({\n          ...step,\n          surface: action.surface,\n          awaits: action.awaits,\n        })),\n        awaiting: action.awaits ? action.id : state.awaiting,\n      };\n    case \"step\": {\n      // A step that waits holds the turn until the person answers, as the history reads it; one\n      // that runs says a turn is under way (on a channel, nobody's message told so before).\n      const waits = action.state === \"waiting\";\n      const ended = action.state === \"done\" || action.state === \"failed\";\n      return {\n        ...state,\n        pending: state.pending || action.state === \"running\",\n        messages: withStep(state.messages, action.id, (step) => ({\n          ...step,\n          state: action.state,\n          output: action.output ?? step.output,\n          awaits: waits || step.awaits,\n        })),\n        // One answered elsewhere (another screen, the owner's own Chrome) ends here too.\n        awaiting: waits ? action.id : ended && state.awaiting === action.id ? null : state.awaiting,\n        tools: ended ? state.tools.filter((id) => id !== action.id) : state.tools,\n        answered: state.answered?.id === action.id ? null : state.answered,\n      };\n    }\n    case \"tool\":\n      // Told again once its answer is in (a socket opening as it went): nothing runs anew.\n      if (settled(stepOf(state.messages, action.id))) return state;\n      // The page runs it now: its step works like any step, until the step's own frames move it,\n      // and it is never the person's to answer.\n      return {\n        ...state,\n        pending: true,\n        awaiting: state.awaiting === action.id ? null : state.awaiting,\n        messages: withStep(state.messages, action.id, (step) => ({\n          ...step,\n          state: \"running\",\n          awaits: false,\n        })),\n        tools: state.tools.includes(action.id) ? state.tools : [...state.tools, action.id],\n      };\n    case \"request\": {\n      const { id, action: name, input, decides = \"person\" } = action;\n      // The business's yes: the turn went on, and nothing waits on the person.\n      const theirs = decides === \"person\";\n      return {\n        ...state,\n        awaiting: theirs ? id : state.awaiting,\n        messages: withStep(state.messages, id, (step) => ({\n          ...step,\n          state: \"waiting\",\n          awaits: theirs,\n          request: { action: name, input, decides },\n        })),\n      };\n    }\n    case \"acted\": {\n      const { surface } = action.action;\n      const request = stepOf(state.messages, surface)?.request ?? null;\n      return {\n        ...state,\n        awaiting: surface === state.awaiting ? null : state.awaiting,\n        // Leave given or refused: the card goes at once; the step's own frames say what came of it.\n        messages: withStep(state.messages, surface, (step) => ({ ...step, request: null })),\n        answered: request === null ? state.answered : { id: surface, request },\n      };\n    }\n    case \"handoff\":\n      // Nothing to keep: the reply's `escalate` step says it, live (its `done` follows this\n      // frame) and read back alike; who answers now comes in its `holder` frame.\n      return state;\n    case \"holder\": {\n      const handovers = withHandovers(state.handovers, [action.handover]);\n      // One older than a change known says nothing of who answers now.\n      const newest = handovers.at(-1) === action.handover;\n      return { ...state, holder: newest ? action.handled_by : state.holder, handovers };\n    }\n    case \"decision\":\n      return {\n        ...state,\n        messages: withMessage(state.messages, action.message_id, (message) => ({\n          ...message,\n          decision: action.decision,\n        })),\n      };\n    case \"done\":\n      // The turn ended, or stopped to wait: on the host's tools the page still runs, it goes on.\n      return { ...state, pending: state.tools.length > 0, draft: \"\" };\n    case \"stopped\":\n      return { ...state, pending: false, draft: \"\", tools: [] };\n    case \"error\":\n      if (action.code === \"business\" && state.answered !== null) {\n        // The person's yes or no on what the business decides: it waits for the business again.\n        const { id, request } = state.answered;\n        return {\n          ...state,\n          answered: null,\n          messages: withStep(state.messages, id, (step) => ({\n            ...step,\n            awaits: false,\n            request: { ...request, decides: \"business\" },\n          })),\n        };\n      }\n      return ASIDE.has(action.code)\n        ? state\n        : { ...state, pending: false, draft: \"\", awaiting: null, tools: [], answered: null };\n    case \"browser\":\n      if (!action.open) return { ...state, browser: null };\n      return {\n        ...state,\n        browser: {\n          url: action.url,\n          title: action.title,\n          where: action.where,\n          control: action.control,\n          reason: action.reason,\n          wait: action.wait,\n          width: action.width,\n          height: action.height,\n        },\n      };\n    case \"browser.frame\":\n      // Pictures repaint the screen, never the conversation (`Screen`).\n      return state;\n  }\n}\n\n/**\n * `known` with whatever of `more` it lacks, at the end, by id: a message is kept once however\n * many times it is heard (stored live, then read in the history, or told again on a reconnect).\n */\nfunction withMessages(known: Message[], more: Message[]): Message[] {\n  const ids = new Set(known.map((message) => message.id));\n  const missing = more.filter((message) => !ids.has(message.id));\n  return missing.length === 0 ? known : [...known, ...missing];\n}\n\n/** What going out on a channel changes of a message once it is stored, as it goes. */\nconst OUTGOING = [\"delivery\", \"delivery_error\", \"pieces\", \"sent_parts\", \"voice\"] as const;\n\n/**\n * `known` with a message stored: one it lacks joins at the end; one it holds takes what going out\n * on its channel changed since (where it got to, its parts, its voice note) and keeps the rest as\n * this page has it (its steps, moved by their own frames); untouched when nothing changed.\n */\nfunction withStored(known: Message[], stored: Message): Message[] {\n  const held = known.find((message) => message.id === stored.id);\n  if (held === undefined) return [...known, stored];\n  if (OUTGOING.every((field) => isEqual(held[field], stored[field]))) return known;\n  const outgoing = Object.fromEntries(OUTGOING.map((field) => [field, stored[field]]));\n  return known.map((message) => (message === held ? { ...held, ...outgoing } : message));\n}\n\n/** The same value, told again: equal by what it holds. */\nconst isEqual = (one: unknown, other: unknown): boolean =>\n  JSON.stringify(one ?? null) === JSON.stringify(other ?? null);\n\n/** A change of who answers, as one however it was told: its moment, and to whom. */\nconst handoverKey = ({ at, holder }: Handover): string => `${Date.parse(at)} ${holder}`;\n\n/**\n * `known` with whatever of `more` it lacks, in the order they were made: a change is kept once\n * however often, and by whatever, it is told (the read, a frame, the host's own request).\n */\nfunction withHandovers(known: Handover[], more: Handover[]): Handover[] {\n  const keys = new Set(known.map(handoverKey));\n  const missing = more.filter((handover) => !keys.has(handoverKey(handover)));\n  if (missing.length === 0) return known;\n  return [...known, ...missing].sort((one, other) => Date.parse(one.at) - Date.parse(other.at));\n}\n\n/** The messages with message `id` changed; untouched when none is it. */\nfunction withMessage(\n  messages: Message[],\n  id: string,\n  change: (message: Message) => Message,\n): Message[] {\n  const at = messages.findIndex((message) => message.id === id);\n  const message = messages[at];\n  return message ? messages.with(at, change(message)) : messages;\n}\n\n/** Step `id`, wherever it is; none when no message holds it. */\nfunction stepOf(messages: Message[], id: string): Step | undefined {\n  return messages.flatMap((message) => message.steps).findLast((step) => step.id === id);\n}\n\n/** The messages with step `id` changed, wherever it is; untouched when no message holds it. */\nfunction withStep(messages: Message[], id: string, change: (step: Step) => Step): Message[] {\n  const at = messages.findLastIndex((message) => message.steps.some((step) => step.id === id));\n  const message = messages[at];\n  if (!message) return messages;\n  const steps = message.steps.map((step) => (step.id === id ? change(step) : step));\n  return messages.with(at, { ...message, steps });\n}\n\n/** The surface a stopped turn waits on, as the history tells it. */\nfunction awaited(messages: Message[]): string | null {\n  return messages.flatMap((message) => message.steps).find((step) => step.awaits)?.id ?? null;\n}\n\n/**\n * The person's answer, landed on the step that waited for it: a question is done with their\n * words as its output (what the history reads back); an action they allowed or declined was\n * already told its own state.\n */\nfunction answered(messages: Message[], action: Action): Message[] {\n  return withStep(messages, action.surface, (step) =>\n    step.state === \"waiting\"\n      ? { ...step, state: \"done\", output: action.label, awaits: false, request: null }\n      : { ...step, awaits: false, request: null },\n  );\n}\n\n/** How often the history is read again while something goes out on a channel. */\nconst DELIVERY_EVERY = 3_000;\n/** How long a message sent is watched for its receipt before the next read brings it. */\nconst RECEIPT_WITHIN = 60_000;\n\n/**\n * Whether a message is still on its way to the person on a channel: waiting to go, or gone a\n * moment ago and not yet received. What it gets to moves without a frame, so it is read again.\n */\nexport function onItsWay(message: Message, now: number): boolean {\n  if (message.delivery === \"queued\") return true;\n  return message.delivery === \"sent\" && now - Date.parse(message.created_at) < RECEIPT_WITHIN;\n}\n\n/**\n * Runs one of the host's own tools in the page, for the agent: what it resolves to goes back as\n * the tool's output, what it rejects with as why it failed (an error's message).\n */\nexport type ToolHandler = (call: ToolCall) => Promise<unknown>;\n\n/** What the page answers a tool of the host's when it runs none (no `onTool`), for the agent. */\nexport const NO_TOOL = \"This page can't do that\";\n\nconst refuse = (): Promise<never> => Promise.reject(new Error(NO_TOOL));\n\n/** A conversation, live: its messages, where its turn stands, and the ways to speak. */\nexport interface LiveConversation {\n  messages: Message[];\n  draft: string;\n  pending: boolean;\n  /**\n   * The step the turn waits on: a surface to answer, or an action the person allows (its\n   * `request`, `decides: \"person\"`; `act` on its id with `approve` or `decline`). Nothing else\n   * goes until the person acts. A yes the business gives holds nothing.\n   */\n  awaiting: string | null;\n  open: boolean;\n  /** Until the history has landed once. */\n  loading: boolean;\n  /** What the last history read threw, if it failed. */\n  error: unknown;\n  /**\n   * Says something: words, the ids of files uploaded to the conversation for it, or both; false\n   * when it cannot go now: nothing to say, a turn running or waiting, the socket closed.\n   */\n  say: (text: string, files?: readonly string[]) => boolean;\n  /** What the person did on a surface; false when the socket is closed. */\n  act: (action: Action) => boolean;\n  /** Stops the reply on its way; false when the socket is closed. */\n  stop: () => boolean;\n  /** The conversation's browser while it is open: where it is, who holds it. */\n  browser: BrowserState | null;\n  /** Hears each picture of the browser's screen, the latest at once; returns how to stop. */\n  watchScreen: (listener: (frame: BrowserFrame) => void) => () => void;\n  /** Takes the browser from the agent, or gives it back; false when the socket is closed. */\n  control: (to: BrowserControl) => boolean;\n  /** Closes the browser now (it stops being billed); false when the socket is closed. */\n  closeBrowser: () => boolean;\n  /** What the person does on the browser's screen while they hold it. */\n  input: (event: BrowserInput) => boolean;\n  /** Who answers it now: its agent, a person of the business, or nobody; null until the history lands. */\n  holder: Holder | null;\n  /** Every change of who answers it, in order, kept live. */\n  handovers: Handover[];\n}\n\n/**\n * Conversation `conversationId` as the person sees it: the history, kept live by the socket.\n * Each time the socket opens the history is read, with the socket already listening, so nothing\n * stored can fall between the two; what came live meanwhile is kept. `onError` hears each\n * error's code (the socket's, or `load` for a history that could not be read): the host words\n * it, this hook shows no text; but `tool`, the page's answer to a call no longer waiting (one it\n * answered already, told again), which is let pass (noted in development). `onHolder` hears each\n * change of who answers it, live, for the host's own views of it; `handover` is the last change\n * the host knows of (one it made itself, as its request answered), taken at once, so it shows\n * whether or not the socket tells it.\n * `onStep` hears each step the agent starts, live, by its action's name, for the host's own\n * views of it (the builder's column, opened as the agent asks it).\n * `onTool` runs the host's own tools the agent calls in the page (a `tool` frame), and its answer\n * goes up (`tool_result`); each call runs once, and one told again while it waits (the socket\n * opened anew) is answered again with what it gave. Without `onTool`, each is refused with\n * `NO_TOOL`, so the turn never waits on a page that can't run it. One conversation per mount: key\n * the component on the id.\n */\nexport function useConversation(\n  client: Client,\n  conversationId: string,\n  {\n    onError,\n    onHolder,\n    onStep,\n    handover,\n    onTool,\n  }: {\n    onError?: ((code: string) => void) | undefined;\n    onHolder?: ((holder: Holder, handover: Handover) => void) | undefined;\n    onStep?: ((action: string) => void) | undefined;\n    handover?: Handover | null | undefined;\n    onTool?: ToolHandler | undefined;\n  } = {},\n): LiveConversation {\n  const [state, dispatch] = useReducer(reduce, EMPTY);\n  // The host's change, taken once by what it is: the same one told again changes nothing.\n  const told = handover ?? null;\n  const toldKey = told === null ? null : handoverKey(told);\n  useEffect(() => {\n    if (told !== null) dispatch({ type: \"holder\", handled_by: told.holder, handover: told });\n  }, [toldKey]);\n  // The browser's pictures, out of the state: each repaints its screen alone.\n  const [screen] = useState<Screen>(createScreen);\n  // Reads are numbered: one that lands after a newer one began, or after the conversation went,\n  // is dropped on the floor.\n  const reads = useRef(0);\n  useEffect(\n    () => () => {\n      reads.current += 1;\n    },\n    [client, conversationId],\n  );\n\n  const read = () => {\n    const run = ++reads.current;\n    client.conversations.get(conversationId).then(\n      ({ messages, pending, handled_by, handovers = [] }) => {\n        if (run !== reads.current) return;\n        dispatch({ type: \"history\", messages, pending, holder: handled_by, handovers });\n      },\n      (error: unknown) => {\n        if (run !== reads.current) return;\n        dispatch({ type: \"failed\", error });\n        onError?.(\"load\");\n      },\n    );\n  };\n\n  // The host's tools the agent called, by the call's id: running (null), or what each answered.\n  const tools = useRef(new Map<string, ToolResult | null>());\n  const runTool = ({ id, name, input }: ToolCall) => {\n    const known = tools.current.get(id);\n    if (known !== undefined) {\n      if (known !== null) live.send(known);\n      return;\n    }\n    tools.current.set(id, null);\n    void Promise.resolve({ id, name, input })\n      .then(onTool ?? refuse)\n      .then(\n        (value): PromiseSettledResult<unknown> => ({ status: \"fulfilled\", value }),\n        (reason: unknown): PromiseSettledResult<unknown> => ({ status: \"rejected\", reason }),\n      )\n      .then((settled) => {\n        const answer = toolResultOf(id, settled);\n        tools.current.set(id, answer);\n        // A socket closed now hears it when it opens: the call is told again while it waits.\n        live.send(answer);\n      });\n  };\n\n  const live = useLive(client, conversationId, {\n    onFrame: (frame: Frame) => {\n      if (frame.type === \"browser.frame\") {\n        screen.show({ jpeg: frame.jpeg, width: frame.width, height: frame.height });\n        return;\n      }\n      if (frame.type === \"error\" && frame.code === STALE) {\n        // An answer of the page's that no call waits on any more: nothing for the person.\n        note(\"A host's tool answer was let pass:\", frame.detail);\n        return;\n      }\n      if (frame.type === \"browser\" && !frame.open) screen.clear();\n      dispatch(frame);\n      if (frame.type === \"error\") onError?.(frame.code);\n      if (frame.type === \"holder\") onHolder?.(frame.handled_by, frame.handover);\n      if (frame.type === \"step\" && frame.state === \"running\" && frame.action !== undefined) {\n        onStep?.(frame.action);\n      }\n      if (frame.type === \"tool\") runTool(frame);\n    },\n    onOpen: () => {\n      dispatch({ type: \"reset\" });\n      read();\n    },\n  });\n\n  // On a channel, while something of the business's is on its way to the person, the history is\n  // read again every few seconds: where it got to (sent, delivered, read, failed) comes no other\n  // way. Each read is a new state, so the question is asked again after it.\n  const travelling = state.messages.some((message) => onItsWay(message, Date.now()));\n  useEffect(() => {\n    if (!travelling || !live.open) return undefined;\n    const again = setInterval(read, DELIVERY_EVERY);\n    return () => {\n      clearInterval(again);\n    };\n    // `read` does the same work from any render: what it reads is in refs and the dispatch.\n  }, [travelling, live.open]);\n\n  const say = (text: string, files: readonly string[] = []): boolean => {\n    const frame = sayOf(text, files);\n    if (frame === null || state.pending || state.awaiting !== null) return false;\n    return live.send(frame);\n  };\n\n  const act = (action: Action): boolean => {\n    if (!live.send({ type: \"action\", ...action })) return false;\n    dispatch({ type: \"acted\", action });\n    return true;\n  };\n\n  return {\n    messages: state.messages,\n    draft: state.draft,\n    pending: state.pending,\n    awaiting: state.awaiting,\n    open: live.open,\n    loading: !state.loaded,\n    error: state.error,\n    say,\n    act,\n    stop: () => live.send({ type: \"stop\" }),\n    browser: state.browser,\n    watchScreen: screen.watch,\n    control: (to) => live.send({ type: \"browser.control\", to }),\n    closeBrowser: () => live.send({ type: \"browser.close\" }),\n    input: (event) => live.send({ type: \"browser.input\", event }),\n    holder: state.holder,\n    handovers: state.handovers,\n  };\n}\n"],"mappings":";;;;;;AAqDA,MAAa,QAA2B;CACtC,UAAU,CAAC;CACX,SAAS;CACT,OAAO;CACP,UAAU;CACV,QAAQ;CACR,OAAO;CACP,SAAS;CACT,QAAQ;CACR,WAAW,CAAC;CACZ,OAAO,CAAC;CACR,UAAU;AACZ;;;;;;;AAyBA,MAAM,wBAA6B,IAAI,IAAI;CACzC;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;AAMD,MAAM,QAAQ;;AAGd,MAAM,WAAW,SACf,MAAM,UAAU,UAAU,MAAM,UAAU;;;;;;;;;;;;;;;;;;AAmB5C,SAAgB,OAAO,OAA0B,QAA+C;CAC9F,QAAQ,OAAO,MAAf;EACE,KAAK,SAEH,OAAO;GACL,GAAG;GACH,SAAS;GACT,OAAO;GACP,UAAU;GACV,SAAS;GACT,OAAO,CAAC;GACR,UAAU;EACZ;EACF,KAAK,WAAW;GAEd,MAAM,OAAO,OAAO,aAAa,CAAC;GAClC,MAAM,YAAY,cAAc,MAAM,MAAM,SAAS;GACrD,MAAM,QAAQ,UAAU,SAAS,KAAK,SAAS,UAAU,GAAG,EAAE,CAAC,EAAE,SAAS,KAAA;GAC1E,OAAO;IACL,GAAG;IACH,UAAU,aAAa,OAAO,UAAU,MAAM,QAAQ;IACtD,UAAU,OAAO,UAAU,QAAQ,OAAO,QAAQ,IAAI;IACtD,QAAQ;IACR,OAAO;IACP,QAAQ,SAAS,OAAO,UAAU,MAAM;IACxC;GACF;EACF;EACA,KAAK,UACH,OAAO;GAAE,GAAG;GAAO,OAAO,OAAO;EAAM;EACzC,KAAK,WAEH,OAAO;GAAE,GAAG;GAAO,SAAS;EAAK;EACnC,KAAK,QACH,OAAO;GAAE,GAAG;GAAO,SAAS;GAAM,OAAO,MAAM,QAAQ,OAAO;EAAM;EACtE,KAAK,WAAW;GACd,MAAM,EAAE,YAAY;GACpB,MAAM,WAAW,WAAW,MAAM,UAAU,OAAO;GAGnD,IAAI,QAAQ,WAAW,aAAa,QAAQ,WAAW,YACrD,OAAO;IAAE,GAAG;IAAO;GAAS;GAE9B,IAAI,QAAQ,SAAS,aAAa,OAAO;IAAE,GAAG;IAAO;IAAU,OAAO;GAAG;GACzE,OAAO;IACL,GAAG;IACH,UAAU,QAAQ,SAAS,SAAS,UAAU,QAAQ,MAAM,IAAI;IAChE,SAAS;IACT,OAAO;GACT;EACF;EACA,KAAK,MACH,OAAO;GACL,GAAG;GACH,UAAU,SAAS,MAAM,UAAU,OAAO,KAAK,UAAU;IACvD,GAAG;IACH,SAAS,OAAO;IAChB,QAAQ,OAAO;GACjB,EAAE;GACF,UAAU,OAAO,SAAS,OAAO,KAAK,MAAM;EAC9C;EACF,KAAK,QAAQ;GAGX,MAAM,QAAQ,OAAO,UAAU;GAC/B,MAAM,QAAQ,OAAO,UAAU,UAAU,OAAO,UAAU;GAC1D,OAAO;IACL,GAAG;IACH,SAAS,MAAM,WAAW,OAAO,UAAU;IAC3C,UAAU,SAAS,MAAM,UAAU,OAAO,KAAK,UAAU;KACvD,GAAG;KACH,OAAO,OAAO;KACd,QAAQ,OAAO,UAAU,KAAK;KAC9B,QAAQ,SAAS,KAAK;IACxB,EAAE;IAEF,UAAU,QAAQ,OAAO,KAAK,SAAS,MAAM,aAAa,OAAO,KAAK,OAAO,MAAM;IACnF,OAAO,QAAQ,MAAM,MAAM,QAAQ,OAAO,OAAO,OAAO,EAAE,IAAI,MAAM;IACpE,UAAU,MAAM,UAAU,OAAO,OAAO,KAAK,OAAO,MAAM;GAC5D;EACF;EACA,KAAK;GAEH,IAAI,QAAQ,OAAO,MAAM,UAAU,OAAO,EAAE,CAAC,GAAG,OAAO;GAGvD,OAAO;IACL,GAAG;IACH,SAAS;IACT,UAAU,MAAM,aAAa,OAAO,KAAK,OAAO,MAAM;IACtD,UAAU,SAAS,MAAM,UAAU,OAAO,KAAK,UAAU;KACvD,GAAG;KACH,OAAO;KACP,QAAQ;IACV,EAAE;IACF,OAAO,MAAM,MAAM,SAAS,OAAO,EAAE,IAAI,MAAM,QAAQ,CAAC,GAAG,MAAM,OAAO,OAAO,EAAE;GACnF;EACF,KAAK,WAAW;GACd,MAAM,EAAE,IAAI,QAAQ,MAAM,OAAO,UAAU,aAAa;GAExD,MAAM,SAAS,YAAY;GAC3B,OAAO;IACL,GAAG;IACH,UAAU,SAAS,KAAK,MAAM;IAC9B,UAAU,SAAS,MAAM,UAAU,KAAK,UAAU;KAChD,GAAG;KACH,OAAO;KACP,QAAQ;KACR,SAAS;MAAE,QAAQ;MAAM;MAAO;KAAQ;IAC1C,EAAE;GACJ;EACF;EACA,KAAK,SAAS;GACZ,MAAM,EAAE,YAAY,OAAO;GAC3B,MAAM,UAAU,OAAO,MAAM,UAAU,OAAO,CAAC,EAAE,WAAW;GAC5D,OAAO;IACL,GAAG;IACH,UAAU,YAAY,MAAM,WAAW,OAAO,MAAM;IAEpD,UAAU,SAAS,MAAM,UAAU,UAAU,UAAU;KAAE,GAAG;KAAM,SAAS;IAAK,EAAE;IAClF,UAAU,YAAY,OAAO,MAAM,WAAW;KAAE,IAAI;KAAS;IAAQ;GACvE;EACF;EACA,KAAK,WAGH,OAAO;EACT,KAAK,UAAU;GACb,MAAM,YAAY,cAAc,MAAM,WAAW,CAAC,OAAO,QAAQ,CAAC;GAElE,MAAM,SAAS,UAAU,GAAG,EAAE,MAAM,OAAO;GAC3C,OAAO;IAAE,GAAG;IAAO,QAAQ,SAAS,OAAO,aAAa,MAAM;IAAQ;GAAU;EAClF;EACA,KAAK,YACH,OAAO;GACL,GAAG;GACH,UAAU,YAAY,MAAM,UAAU,OAAO,aAAa,aAAa;IACrE,GAAG;IACH,UAAU,OAAO;GACnB,EAAE;EACJ;EACF,KAAK,QAEH,OAAO;GAAE,GAAG;GAAO,SAAS,MAAM,MAAM,SAAS;GAAG,OAAO;EAAG;EAChE,KAAK,WACH,OAAO;GAAE,GAAG;GAAO,SAAS;GAAO,OAAO;GAAI,OAAO,CAAC;EAAE;EAC1D,KAAK;GACH,IAAI,OAAO,SAAS,cAAc,MAAM,aAAa,MAAM;IAEzD,MAAM,EAAE,IAAI,YAAY,MAAM;IAC9B,OAAO;KACL,GAAG;KACH,UAAU;KACV,UAAU,SAAS,MAAM,UAAU,KAAK,UAAU;MAChD,GAAG;MACH,QAAQ;MACR,SAAS;OAAE,GAAG;OAAS,SAAS;MAAW;KAC7C,EAAE;IACJ;GACF;GACA,OAAO,MAAM,IAAI,OAAO,IAAI,IACxB,QACA;IAAE,GAAG;IAAO,SAAS;IAAO,OAAO;IAAI,UAAU;IAAM,OAAO,CAAC;IAAG,UAAU;GAAK;EACvF,KAAK;GACH,IAAI,CAAC,OAAO,MAAM,OAAO;IAAE,GAAG;IAAO,SAAS;GAAK;GACnD,OAAO;IACL,GAAG;IACH,SAAS;KACP,KAAK,OAAO;KACZ,OAAO,OAAO;KACd,OAAO,OAAO;KACd,SAAS,OAAO;KAChB,QAAQ,OAAO;KACf,MAAM,OAAO;KACb,OAAO,OAAO;KACd,QAAQ,OAAO;IACjB;GACF;EACF,KAAK,iBAEH,OAAO;CACX;AACF;;;;;AAMA,SAAS,aAAa,OAAkB,MAA4B;CAClE,MAAM,MAAM,IAAI,IAAI,MAAM,KAAK,YAAY,QAAQ,EAAE,CAAC;CACtD,MAAM,UAAU,KAAK,QAAQ,YAAY,CAAC,IAAI,IAAI,QAAQ,EAAE,CAAC;CAC7D,OAAO,QAAQ,WAAW,IAAI,QAAQ,CAAC,GAAG,OAAO,GAAG,OAAO;AAC7D;;AAGA,MAAM,WAAW;CAAC;CAAY;CAAkB;CAAU;CAAc;AAAO;;;;;;AAO/E,SAAS,WAAW,OAAkB,QAA4B;CAChE,MAAM,OAAO,MAAM,MAAM,YAAY,QAAQ,OAAO,OAAO,EAAE;CAC7D,IAAI,SAAS,KAAA,GAAW,OAAO,CAAC,GAAG,OAAO,MAAM;CAChD,IAAI,SAAS,OAAO,UAAU,QAAQ,KAAK,QAAQ,OAAO,MAAM,CAAC,GAAG,OAAO;CAC3E,MAAM,WAAW,OAAO,YAAY,SAAS,KAAK,UAAU,CAAC,OAAO,OAAO,MAAM,CAAC,CAAC;CACnF,OAAO,MAAM,KAAK,YAAa,YAAY,OAAO;EAAE,GAAG;EAAM,GAAG;CAAS,IAAI,OAAQ;AACvF;;AAGA,MAAM,WAAW,KAAc,UAC7B,KAAK,UAAU,OAAO,IAAI,MAAM,KAAK,UAAU,SAAS,IAAI;;AAG9D,MAAM,eAAe,EAAE,IAAI,aAA+B,GAAG,KAAK,MAAM,EAAE,EAAE,GAAG;;;;;AAM/E,SAAS,cAAc,OAAmB,MAA8B;CACtE,MAAM,OAAO,IAAI,IAAI,MAAM,IAAI,WAAW,CAAC;CAC3C,MAAM,UAAU,KAAK,QAAQ,aAAa,CAAC,KAAK,IAAI,YAAY,QAAQ,CAAC,CAAC;CAC1E,IAAI,QAAQ,WAAW,GAAG,OAAO;CACjC,OAAO,CAAC,GAAG,OAAO,GAAG,OAAO,CAAC,CAAC,MAAM,KAAK,UAAU,KAAK,MAAM,IAAI,EAAE,IAAI,KAAK,MAAM,MAAM,EAAE,CAAC;AAC9F;;AAGA,SAAS,YACP,UACA,IACA,QACW;CACX,MAAM,KAAK,SAAS,WAAW,YAAY,QAAQ,OAAO,EAAE;CAC5D,MAAM,UAAU,SAAS;CACzB,OAAO,UAAU,SAAS,KAAK,IAAI,OAAO,OAAO,CAAC,IAAI;AACxD;;AAGA,SAAS,OAAO,UAAqB,IAA8B;CACjE,OAAO,SAAS,SAAS,YAAY,QAAQ,KAAK,CAAC,CAAC,UAAU,SAAS,KAAK,OAAO,EAAE;AACvF;;AAGA,SAAS,SAAS,UAAqB,IAAY,QAAyC;CAC1F,MAAM,KAAK,SAAS,eAAe,YAAY,QAAQ,MAAM,MAAM,SAAS,KAAK,OAAO,EAAE,CAAC;CAC3F,MAAM,UAAU,SAAS;CACzB,IAAI,CAAC,SAAS,OAAO;CACrB,MAAM,QAAQ,QAAQ,MAAM,KAAK,SAAU,KAAK,OAAO,KAAK,OAAO,IAAI,IAAI,IAAK;CAChF,OAAO,SAAS,KAAK,IAAI;EAAE,GAAG;EAAS;CAAM,CAAC;AAChD;;AAGA,SAAS,QAAQ,UAAoC;CACnD,OAAO,SAAS,SAAS,YAAY,QAAQ,KAAK,CAAC,CAAC,MAAM,SAAS,KAAK,MAAM,CAAC,EAAE,MAAM;AACzF;;;;;;AAOA,SAAS,SAAS,UAAqB,QAA2B;CAChE,OAAO,SAAS,UAAU,OAAO,UAAU,SACzC,KAAK,UAAU,YACX;EAAE,GAAG;EAAM,OAAO;EAAQ,QAAQ,OAAO;EAAO,QAAQ;EAAO,SAAS;CAAK,IAC7E;EAAE,GAAG;EAAM,QAAQ;EAAO,SAAS;CAAK,CAC9C;AACF;;AAGA,MAAM,iBAAiB;;AAEvB,MAAM,iBAAiB;;;;;AAMvB,SAAgB,SAAS,SAAkB,KAAsB;CAC/D,IAAI,QAAQ,aAAa,UAAU,OAAO;CAC1C,OAAO,QAAQ,aAAa,UAAU,MAAM,KAAK,MAAM,QAAQ,UAAU,IAAI;AAC/E;;AASA,MAAa,UAAU;AAEvB,MAAM,eAA+B,QAAQ,uBAAO,IAAI,MAAM,OAAO,CAAC;;;;;;;;;;;;;;;;;;;AA6DtE,SAAgB,gBACd,QACA,gBACA,EACE,SACA,UACA,QACA,UACA,WAOE,CAAC,GACa;CAClB,MAAM,CAAC,OAAO,YAAY,WAAW,QAAQ,KAAK;CAElD,MAAM,OAAO,YAAY;CACzB,MAAM,UAAU,SAAS,OAAO,OAAO,YAAY,IAAI;CACvD,gBAAgB;EACd,IAAI,SAAS,MAAM,SAAS;GAAE,MAAM;GAAU,YAAY,KAAK;GAAQ,UAAU;EAAK,CAAC;CACzF,GAAG,CAAC,OAAO,CAAC;CAEZ,MAAM,CAAC,UAAU,SAAiB,YAAY;CAG9C,MAAM,QAAQ,OAAO,CAAC;CACtB,sBACc;EACV,MAAM,WAAW;CACnB,GACA,CAAC,QAAQ,cAAc,CACzB;CAEA,MAAM,aAAa;EACjB,MAAM,MAAM,EAAE,MAAM;EACpB,OAAO,cAAc,IAAI,cAAc,CAAC,CAAC,MACtC,EAAE,UAAU,SAAS,YAAY,YAAY,CAAC,QAAQ;GACrD,IAAI,QAAQ,MAAM,SAAS;GAC3B,SAAS;IAAE,MAAM;IAAW;IAAU;IAAS,QAAQ;IAAY;GAAU,CAAC;EAChF,IACC,UAAmB;GAClB,IAAI,QAAQ,MAAM,SAAS;GAC3B,SAAS;IAAE,MAAM;IAAU;GAAM,CAAC;GAClC,UAAU,MAAM;EAClB,CACF;CACF;CAGA,MAAM,QAAQ,uBAAO,IAAI,IAA+B,CAAC;CACzD,MAAM,WAAW,EAAE,IAAI,MAAM,YAAsB;EACjD,MAAM,QAAQ,MAAM,QAAQ,IAAI,EAAE;EAClC,IAAI,UAAU,KAAA,GAAW;GACvB,IAAI,UAAU,MAAM,KAAK,KAAK,KAAK;GACnC;EACF;EACA,MAAM,QAAQ,IAAI,IAAI,IAAI;EAC1B,QAAa,QAAQ;GAAE;GAAI;GAAM;EAAM,CAAC,CAAC,CACtC,KAAK,UAAU,MAAM,CAAC,CACtB,MACE,WAA0C;GAAE,QAAQ;GAAa;EAAM,KACvE,YAAoD;GAAE,QAAQ;GAAY;EAAO,EACpF,CAAC,CACA,MAAM,YAAY;GACjB,MAAM,SAAS,aAAa,IAAI,OAAO;GACvC,MAAM,QAAQ,IAAI,IAAI,MAAM;GAE5B,KAAK,KAAK,MAAM;EAClB,CAAC;CACL;CAEA,MAAM,OAAO,QAAQ,QAAQ,gBAAgB;EAC3C,UAAU,UAAiB;GACzB,IAAI,MAAM,SAAS,iBAAiB;IAClC,OAAO,KAAK;KAAE,MAAM,MAAM;KAAM,OAAO,MAAM;KAAO,QAAQ,MAAM;IAAO,CAAC;IAC1E;GACF;GACA,IAAI,MAAM,SAAS,WAAW,MAAM,SAAS,OAAO;IAElD,KAAK,sCAAsC,MAAM,MAAM;IACvD;GACF;GACA,IAAI,MAAM,SAAS,aAAa,CAAC,MAAM,MAAM,OAAO,MAAM;GAC1D,SAAS,KAAK;GACd,IAAI,MAAM,SAAS,SAAS,UAAU,MAAM,IAAI;GAChD,IAAI,MAAM,SAAS,UAAU,WAAW,MAAM,YAAY,MAAM,QAAQ;GACxE,IAAI,MAAM,SAAS,UAAU,MAAM,UAAU,aAAa,MAAM,WAAW,KAAA,GACzE,SAAS,MAAM,MAAM;GAEvB,IAAI,MAAM,SAAS,QAAQ,QAAQ,KAAK;EAC1C;EACA,cAAc;GACZ,SAAS,EAAE,MAAM,QAAQ,CAAC;GAC1B,KAAK;EACP;CACF,CAAC;CAKD,MAAM,aAAa,MAAM,SAAS,MAAM,YAAY,SAAS,SAAS,KAAK,IAAI,CAAC,CAAC;CACjF,gBAAgB;EACd,IAAI,CAAC,cAAc,CAAC,KAAK,MAAM,OAAO,KAAA;EACtC,MAAM,QAAQ,YAAY,MAAM,cAAc;EAC9C,aAAa;GACX,cAAc,KAAK;EACrB;CAEF,GAAG,CAAC,YAAY,KAAK,IAAI,CAAC;CAE1B,MAAM,OAAO,MAAc,QAA2B,CAAC,MAAe;EACpE,MAAM,QAAQ,MAAM,MAAM,KAAK;EAC/B,IAAI,UAAU,QAAQ,MAAM,WAAW,MAAM,aAAa,MAAM,OAAO;EACvE,OAAO,KAAK,KAAK,KAAK;CACxB;CAEA,MAAM,OAAO,WAA4B;EACvC,IAAI,CAAC,KAAK,KAAK;GAAE,MAAM;GAAU,GAAG;EAAO,CAAC,GAAG,OAAO;EACtD,SAAS;GAAE,MAAM;GAAS;EAAO,CAAC;EAClC,OAAO;CACT;CAEA,OAAO;EACL,UAAU,MAAM;EAChB,OAAO,MAAM;EACb,SAAS,MAAM;EACf,UAAU,MAAM;EAChB,MAAM,KAAK;EACX,SAAS,CAAC,MAAM;EAChB,OAAO,MAAM;EACb;EACA;EACA,YAAY,KAAK,KAAK,EAAE,MAAM,OAAO,CAAC;EACtC,SAAS,MAAM;EACf,aAAa,OAAO;EACpB,UAAU,OAAO,KAAK,KAAK;GAAE,MAAM;GAAmB;EAAG,CAAC;EAC1D,oBAAoB,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAC;EACvD,QAAQ,UAAU,KAAK,KAAK;GAAE,MAAM;GAAiB;EAAM,CAAC;EAC5D,QAAQ,MAAM;EACd,WAAW,MAAM;CACnB;AACF"}

package/dist/useDictation.d.ts

@@ -0,0 +1,17 @@
+//#region src/useDictation.d.ts
+/** Turns a recording into words: the host's (its server's speech to text). */
+export type Dictate = (audio: Blob) => Promise<string>;
+/** Where a dictation is: nothing, the microphone open, the words on their way, or refused. */
+export type Dictation = "idle" | "listening" | "writing" | "failed";
+/**
+ * Dictation in the composer: a press opens the microphone, the next one closes it and hands the
+ * recording to the host's `dictate`, whose words go to `onWords`. Without `dictate`, or in a
+ * browser that cannot record, it is not `available`. Leaving mid-recording stops the microphone.
+ */
+export declare function useDictation(dictate: Dictate | undefined, onWords: (words: string) => void): {
+  available: boolean;
+  state: Dictation;
+  toggle: () => void;
+};
+//#endregion
+//# sourceMappingURL=useDictation.d.ts.map