@theoremjs/react 0.0.0-stage → 0.3.1

package/ui/labels.d.ts

@@ -0,0 +1,1442 @@
+/**
+ * The default UI's words, as an Astryx i18n catalog under `@theorem.*` keys:
+ * the same mechanism that words Astryx's own components (`@astryx.*`), so one
+ * override table replaces any line on screen, per locale. Messages are ICU
+ * (`{handle}`, `{n, plural, …}`); `params` names the values each one is given.
+ * Failures are worded by the profile labels, not here.
+ *
+ * @module
+ */
+import type { ComposerDrawerSummary } from '../client/composer-drawer.ts';
+import type { LiveState } from '../client/live/live-state.ts';
+import type { TurnUsage, WorkStatus } from '../client/transcript-groups.ts';
+export declare const THEOREM_UI_CATALOG: {
+    readonly '@theorem.agent.handle': {
+        readonly defaultMessage: "@{handle}";
+        readonly description: "The agent's name above its messages, on the landing and in captions.";
+        readonly params: readonly ["handle"];
+    };
+    readonly '@theorem.chat.greeting': {
+        readonly defaultMessage: "What are we working on?";
+        readonly description: "Chat landing heading, before the first message.";
+    };
+    readonly '@theorem.chat.loading': {
+        readonly defaultMessage: "Loading…";
+        readonly description: "Spinner label while the profile loads.";
+    };
+    readonly '@theorem.chat.live_unsupported.title': {
+        readonly defaultMessage: "Live profiles aren't supported here";
+        readonly description: "Shown when TheoremChat is pointed at a live profile.";
+    };
+    readonly '@theorem.chat.live_unsupported.description': {
+        readonly defaultMessage: "Use LiveRunner from @theoremjs/react/live.";
+        readonly description: "Where to go instead, under the live-profile warning.";
+    };
+    readonly '@theorem.composer.placeholder': {
+        readonly defaultMessage: "Message @{handle}";
+        readonly description: "Empty composer placeholder.";
+        readonly params: readonly ["handle"];
+    };
+    readonly '@theorem.composer.listening': {
+        readonly defaultMessage: "Listening…";
+        readonly description: "Composer placeholder while a voice note records.";
+    };
+    readonly '@theorem.composer.attach': {
+        readonly defaultMessage: "Attach files";
+        readonly description: "Paperclip button.";
+    };
+    readonly '@theorem.composer.record': {
+        readonly defaultMessage: "Record voice";
+        readonly description: "Microphone button, idle.";
+    };
+    readonly '@theorem.composer.stop_recording': {
+        readonly defaultMessage: "Stop recording";
+        readonly description: "Microphone button, recording.";
+    };
+    readonly '@theorem.composer.send_options': {
+        readonly defaultMessage: "More send options";
+        readonly description: "Menu button beside send.";
+    };
+    readonly '@theorem.composer.menu.queue': {
+        readonly defaultMessage: "Queue";
+        readonly description: "Send menu item.";
+    };
+    readonly '@theorem.composer.menu.queue.description': {
+        readonly defaultMessage: "Send it once this reply finishes.";
+        readonly description: "Send menu item detail: the message waits its turn.";
+    };
+    readonly '@theorem.composer.menu.steer': {
+        readonly defaultMessage: "Steer this reply";
+        readonly description: "Send menu item.";
+    };
+    readonly '@theorem.composer.menu.steer.description': {
+        readonly defaultMessage: "Add it to the reply in progress. The agent reads it at its next step.";
+        readonly description: "Send menu item detail: the message joins the running reply instead of waiting.";
+    };
+    readonly '@theorem.composer.menu.send_now': {
+        readonly defaultMessage: "Send now";
+        readonly description: "Send menu item.";
+    };
+    readonly '@theorem.composer.menu.send_now.description': {
+        readonly defaultMessage: "Stop this reply and send it instead.";
+        readonly description: "Send menu item detail: ends the running reply (or its wait for approval), then sends.";
+    };
+    readonly '@theorem.composer.menu.stash': {
+        readonly defaultMessage: "Stash";
+        readonly description: "Send menu item.";
+    };
+    readonly '@theorem.composer.menu.stash.description': {
+        readonly defaultMessage: "Set it aside to send later.";
+        readonly description: "Send menu item detail: the message waits in the composer until sent.";
+    };
+    readonly '@theorem.composer.hint.stash-selected-draft.message': {
+        readonly defaultMessage: "Replacing this?";
+        readonly description: "Hint when the whole draft is selected and could be stashed.";
+    };
+    readonly '@theorem.composer.hint.stash-selected-draft.action': {
+        readonly defaultMessage: "Stash it";
+        readonly description: "The hint's button.";
+    };
+    readonly '@theorem.composer.drawer.steer': {
+        readonly defaultMessage: "steering";
+        readonly description: "Drawer header when only steering messages wait.";
+    };
+    readonly '@theorem.composer.drawer.queue': {
+        readonly defaultMessage: "queued";
+        readonly description: "Drawer header when only queued messages wait.";
+    };
+    readonly '@theorem.composer.drawer.stash': {
+        readonly defaultMessage: "stashed";
+        readonly description: "Drawer header when only stashed messages wait.";
+    };
+    readonly '@theorem.composer.drawer.attached': {
+        readonly defaultMessage: "attached";
+        readonly description: "Drawer header when only files wait.";
+    };
+    readonly '@theorem.composer.drawer.steer.count': {
+        readonly defaultMessage: "{n} steering";
+        readonly description: "One part of a mixed drawer header.";
+        readonly params: readonly ["n"];
+    };
+    readonly '@theorem.composer.drawer.queue.count': {
+        readonly defaultMessage: "{n} queued";
+        readonly description: "One part of a mixed drawer header.";
+        readonly params: readonly ["n"];
+    };
+    readonly '@theorem.composer.drawer.stash.count': {
+        readonly defaultMessage: "{n} stashed";
+        readonly description: "One part of a mixed drawer header.";
+        readonly params: readonly ["n"];
+    };
+    readonly '@theorem.composer.drawer.attached.count': {
+        readonly defaultMessage: "{n} attached";
+        readonly description: "One part of a mixed drawer header.";
+        readonly params: readonly ["n"];
+    };
+    readonly '@theorem.composer.drawer.separator': {
+        readonly defaultMessage: " · ";
+        readonly description: "Between the parts of a mixed drawer header.";
+    };
+    readonly '@theorem.composer.pending.steer': {
+        readonly defaultMessage: "Steering";
+        readonly description: "Badge on a waiting steering message.";
+    };
+    readonly '@theorem.composer.pending.queue': {
+        readonly defaultMessage: "Queued";
+        readonly description: "Badge on a waiting queued message.";
+    };
+    readonly '@theorem.composer.pending.stash': {
+        readonly defaultMessage: "Stashed";
+        readonly description: "Badge on a waiting stashed message.";
+    };
+    readonly '@theorem.composer.pending.edit': {
+        readonly defaultMessage: "Edit";
+        readonly description: "Waiting message: back into the composer.";
+    };
+    readonly '@theorem.composer.pending.queue_action': {
+        readonly defaultMessage: "Queue";
+        readonly description: "Stashed message: queue it.";
+    };
+    readonly '@theorem.composer.pending.send_now': {
+        readonly defaultMessage: "Send now";
+        readonly description: "Waiting message: send it now.";
+    };
+    readonly '@theorem.composer.pending.move_up': {
+        readonly defaultMessage: "Move up";
+        readonly description: "Waiting message: earlier.";
+    };
+    readonly '@theorem.composer.pending.move_down': {
+        readonly defaultMessage: "Move down";
+        readonly description: "Waiting message: later.";
+    };
+    readonly '@theorem.composer.pending.remove': {
+        readonly defaultMessage: "Remove";
+        readonly description: "Waiting message: discard.";
+    };
+    readonly '@theorem.transcript.copy': {
+        readonly defaultMessage: "Copy";
+        readonly description: "Copy a message.";
+    };
+    readonly '@theorem.transcript.copied': {
+        readonly defaultMessage: "Copied";
+        readonly description: "Right after copying a message.";
+    };
+    readonly '@theorem.transcript.now': {
+        readonly defaultMessage: "now";
+        readonly description: "Message time during its first minute.";
+    };
+    readonly '@theorem.transcript.failed': {
+        readonly defaultMessage: "failed";
+        readonly description: "Message status: the turn failed. The reason shows on hover.";
+    };
+    readonly '@theorem.transcript.generated_image': {
+        readonly defaultMessage: "Generated image";
+        readonly description: "Alt text for a generated image.";
+    };
+    readonly '@theorem.transcript.generated_video': {
+        readonly defaultMessage: "Generated video";
+        readonly description: "Alt text for a generated video.";
+    };
+    readonly '@theorem.transcript.open_generated_image': {
+        readonly defaultMessage: "Open generated image";
+        readonly description: "Opens the image full size.";
+    };
+    readonly '@theorem.transcript.generating_image': {
+        readonly defaultMessage: "Generating image";
+        readonly description: "Placeholder while an image generates.";
+    };
+    readonly '@theorem.transcript.sources': {
+        readonly defaultMessage: "Sources";
+        readonly description: "The row of source chips (screen readers).";
+    };
+    readonly '@theorem.transcript.tool_input': {
+        readonly defaultMessage: "Input";
+        readonly description: "A tool call's arguments, in its detail.";
+    };
+    readonly '@theorem.transcript.tool_input_edited': {
+        readonly defaultMessage: "Input (edited)";
+        readonly description: "A tool call's arguments after the user edited them on approval.";
+    };
+    readonly '@theorem.transcript.tool_output': {
+        readonly defaultMessage: "Output";
+        readonly description: "A tool call's result, in its detail.";
+    };
+    readonly '@theorem.transcript.tool_error': {
+        readonly defaultMessage: "Error";
+        readonly description: "A failed tool call's failure, in its detail.";
+    };
+    readonly '@theorem.transcript.tokens': {
+        readonly defaultMessage: "{count, plural, one {# token} other {# tokens}}";
+        readonly description: "Tokens a reply used, under it, or an agent tool's called agent used, on its call row.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.data.view': {
+        readonly defaultMessage: "View as";
+        readonly description: "Switch between tool data drawn by its shape and its JSON.";
+    };
+    readonly '@theorem.data.shaped': {
+        readonly defaultMessage: "Data";
+        readonly description: "Tool data drawn as fields, sections, and tables.";
+    };
+    readonly '@theorem.data.json': {
+        readonly defaultMessage: "JSON";
+        readonly description: "Tool data as its raw JSON.";
+    };
+    readonly '@theorem.data.item': {
+        readonly defaultMessage: "Item {index}";
+        readonly description: "A list row with no name of its own.";
+        readonly params: readonly ["index"];
+    };
+    readonly '@theorem.data.none': {
+        readonly defaultMessage: "Empty";
+        readonly description: "An empty list or object in tool data.";
+    };
+    readonly '@theorem.data.yes': {
+        readonly defaultMessage: "Yes";
+        readonly description: "A true value in tool data.";
+    };
+    readonly '@theorem.data.no': {
+        readonly defaultMessage: "No";
+        readonly description: "A false value in tool data.";
+    };
+    readonly '@theorem.data.more': {
+        readonly defaultMessage: "{count} more — switch to JSON to see them";
+        readonly description: "Rows past the shown ones, left to the JSON view.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.data.large': {
+        readonly defaultMessage: "Too large to lay out — showing the first {size} of its JSON";
+        readonly description: "A payload too big to draw by its shape, shown as the start of its JSON.";
+        readonly params: readonly ["size"];
+    };
+    readonly '@theorem.transcript.copy_text.tool': {
+        readonly defaultMessage: "Tool: {name}";
+        readonly description: "A tool call in copied message text.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.transcript.copy_text.media': {
+        readonly defaultMessage: "[{mimeType} media]";
+        readonly description: "Media without a link, in copied message text.";
+        readonly params: readonly ["mimeType"];
+    };
+    readonly '@theorem.transcript.working': {
+        readonly defaultMessage: "Working…";
+        readonly description: "Turn status while running, start unknown.";
+    };
+    readonly '@theorem.transcript.working_for': {
+        readonly defaultMessage: "Working for {duration}";
+        readonly description: "Turn status while running.";
+        readonly params: readonly ["duration"];
+    };
+    readonly '@theorem.transcript.worked': {
+        readonly defaultMessage: "Worked";
+        readonly description: "Turn status once done, duration unknown.";
+    };
+    readonly '@theorem.transcript.worked_for': {
+        readonly defaultMessage: "Worked for {duration}";
+        readonly description: "Turn status once done.";
+        readonly params: readonly ["duration"];
+    };
+    readonly '@theorem.duration.milliseconds': {
+        readonly defaultMessage: "{ms}ms";
+        readonly description: "Under a second.";
+        readonly params: readonly ["ms"];
+    };
+    readonly '@theorem.duration.belowTenth': {
+        readonly defaultMessage: "<0.1ms";
+        readonly description: "Above zero but under a tenth of a millisecond, such as a quick guardrail check.";
+    };
+    readonly '@theorem.duration.seconds': {
+        readonly defaultMessage: "{seconds}s";
+        readonly description: "Under a minute.";
+        readonly params: readonly ["seconds"];
+    };
+    readonly '@theorem.duration.minutes': {
+        readonly defaultMessage: "{minutes}m";
+        readonly description: "Whole minutes.";
+        readonly params: readonly ["minutes"];
+    };
+    readonly '@theorem.duration.minutes_seconds': {
+        readonly defaultMessage: "{minutes}m {seconds}s";
+        readonly description: "Minutes and seconds.";
+        readonly params: readonly ["minutes", "seconds"];
+    };
+    readonly '@theorem.gate.approval.title': {
+        readonly defaultMessage: "{agent} wants to {request}";
+        readonly description: "Approval card heading. {agent} is the agent's handle; {request} is what the call would do, e.g. 'check the weather'.";
+        readonly params: readonly ["agent", "request"];
+    };
+    readonly '@theorem.gate.approval.title_no_agent': {
+        readonly defaultMessage: "The agent wants to {request}";
+        readonly description: "Approval card heading when the host names no agent.";
+        readonly params: readonly ["request"];
+    };
+    readonly '@theorem.gate.approval.use_tool': {
+        readonly defaultMessage: "use {tool}";
+        readonly description: "The {request} in the heading when the tool sets no labels.request. {tool} is the tool's name in words.";
+        readonly params: readonly ["tool"];
+    };
+    readonly '@theorem.gate.approval.input': {
+        readonly defaultMessage: "Details";
+        readonly description: "Expands the arguments the tool would run with.";
+    };
+    readonly '@theorem.gate.approval.deny': {
+        readonly defaultMessage: "Reject";
+        readonly description: "Approval card button.";
+    };
+    readonly '@theorem.gate.approval.approve': {
+        readonly defaultMessage: "Approve";
+        readonly description: "Approval card button.";
+    };
+    readonly '@theorem.gate.tag.bearer': {
+        readonly defaultMessage: "bearer";
+        readonly description: "Credential type tag.";
+    };
+    readonly '@theorem.gate.tag.api_key': {
+        readonly defaultMessage: "api_key";
+        readonly description: "Credential type tag.";
+    };
+    readonly '@theorem.gate.tag.oauth2': {
+        readonly defaultMessage: "oauth2";
+        readonly description: "Credential type tag.";
+    };
+    readonly '@theorem.gate.auth.title': {
+        readonly defaultMessage: "Sign in to use {tool}";
+        readonly description: "Credential card heading. {tool} is the tool's name in words.";
+        readonly params: readonly ["tool"];
+    };
+    readonly '@theorem.gate.auth.resource': {
+        readonly defaultMessage: "Resource: {resource}";
+        readonly description: "What the credential is for.";
+        readonly params: readonly ["resource"];
+    };
+    readonly '@theorem.gate.auth.no_oauth': {
+        readonly defaultMessage: "No OAuth authorization endpoint is configured.";
+        readonly description: "OAuth tool without an authorization URL.";
+    };
+    readonly '@theorem.gate.auth.authorize': {
+        readonly defaultMessage: "Authorize with provider";
+        readonly description: "Opens the OAuth sign-in.";
+    };
+    readonly '@theorem.gate.auth.provided': {
+        readonly defaultMessage: "Credential provided for {slot}";
+        readonly description: "After submitting a credential or finishing an OAuth sign-in.";
+        readonly params: readonly ["slot"];
+    };
+    readonly '@theorem.gate.auth.api_key': {
+        readonly defaultMessage: "API key";
+        readonly description: "Secret field label, API-key tools.";
+    };
+    readonly '@theorem.gate.auth.bearer': {
+        readonly defaultMessage: "Bearer token";
+        readonly description: "Secret field label, bearer tools.";
+    };
+    readonly '@theorem.gate.auth.secret_placeholder': {
+        readonly defaultMessage: "Secret for slot ''{slot}''";
+        readonly description: "Secret field placeholder.";
+        readonly params: readonly ["slot"];
+    };
+    readonly '@theorem.gate.auth.secret_note': {
+        readonly defaultMessage: " ";
+        readonly description: "Under the secret field: how the host handles the credential. Blank by default, since only the host knows; the studio says it is used for one call.";
+    };
+    readonly '@theorem.gate.auth.submit': {
+        readonly defaultMessage: "Submit & continue";
+        readonly description: "Sends the credential.";
+    };
+    readonly '@theorem.voice_note.name': {
+        readonly defaultMessage: "voice.{format}";
+        readonly description: "A voice note's name, by audio format (webm, wav, mp3, m4a, ogg).";
+        readonly params: readonly ["format"];
+    };
+    readonly '@theorem.voice_note.unnamed': {
+        readonly defaultMessage: "voice note";
+        readonly description: "A voice note's name when its format is unknown.";
+    };
+    readonly '@theorem.voice_note.play': {
+        readonly defaultMessage: "Play {name}";
+        readonly description: "Voice note, paused.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.voice_note.pause': {
+        readonly defaultMessage: "Pause {name}";
+        readonly description: "Voice note, playing.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.voice_note.remove': {
+        readonly defaultMessage: "Remove {name}";
+        readonly description: "Unstages a voice note.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.decision.state': {
+        readonly defaultMessage: "State";
+        readonly description: "The JSON a decision is asked about (field label).";
+    };
+    readonly '@theorem.decision.state_size': {
+        readonly defaultMessage: "{size} of {limit}";
+        readonly description: "The state's size against the profile's limit, under the field.";
+        readonly params: readonly ["size", "limit"];
+    };
+    readonly '@theorem.decision.view': {
+        readonly defaultMessage: "Edit as";
+        readonly description: "Switch between the state as fields and as JSON.";
+    };
+    readonly '@theorem.decision.fields': {
+        readonly defaultMessage: "Fields";
+        readonly description: "The state edited field by field.";
+    };
+    readonly '@theorem.decision.add_item': {
+        readonly defaultMessage: "Add to {field}";
+        readonly description: "Adds a row to a list in the state.";
+        readonly params: readonly ["field"];
+    };
+    readonly '@theorem.decision.remove_item': {
+        readonly defaultMessage: "Remove {item}";
+        readonly description: "Removes a row from a list in the state.";
+        readonly params: readonly ["item"];
+    };
+    readonly '@theorem.decision.add_value': {
+        readonly defaultMessage: "Add a value";
+        readonly description: "A list of words in the state, while it is empty.";
+    };
+    readonly '@theorem.decision.invalid_json': {
+        readonly defaultMessage: "Not valid JSON yet";
+        readonly description: "The state doesn't parse.";
+    };
+    readonly '@theorem.decision.null_state': {
+        readonly defaultMessage: "State can’t be null";
+        readonly description: "The state is the JSON null.";
+    };
+    readonly '@theorem.decision.too_large': {
+        readonly defaultMessage: "Over the {limit} limit";
+        readonly description: "The state is larger than the profile's limit.";
+        readonly params: readonly ["limit"];
+    };
+    readonly '@theorem.decision.answers': {
+        readonly defaultMessage: "Answers";
+        readonly description: "The decision response column.";
+    };
+    readonly '@theorem.decision.decide': {
+        readonly defaultMessage: "Decide";
+        readonly description: "Asks the questions about the state.";
+    };
+    readonly '@theorem.decision.deciding': {
+        readonly defaultMessage: "Deciding…";
+        readonly description: "The decide button while it runs.";
+    };
+    readonly '@theorem.decision.stop': {
+        readonly defaultMessage: "Stop";
+        readonly description: "Cancels the running decision.";
+    };
+    readonly '@theorem.decision.confidence': {
+        readonly defaultMessage: "{percent} sure";
+        readonly description: "How sure the model is of a choice or score; percent is formatted, e.g. '92%'.";
+        readonly params: readonly ["percent"];
+    };
+    readonly '@theorem.decision.option': {
+        readonly defaultMessage: "{label}, {percent}";
+        readonly description: "One option and its probability (screen readers); percent is formatted.";
+        readonly params: readonly ["label", "percent"];
+    };
+    readonly '@theorem.decision.score_of': {
+        readonly defaultMessage: "{score} of {max}";
+        readonly description: "A score on its scale from 0, e.g. 1.4 of 3.";
+        readonly params: readonly ["score", "max"];
+    };
+    readonly '@theorem.decision.type.choice': {
+        readonly defaultMessage: "Choice";
+        readonly description: "A question that picks one label.";
+    };
+    readonly '@theorem.decision.type.score': {
+        readonly defaultMessage: "Score";
+        readonly description: "A question that places the state on a scale.";
+    };
+    readonly '@theorem.decision.type.noul': {
+        readonly defaultMessage: "Noul";
+        readonly description: "A question answered with one number.";
+    };
+    readonly '@theorem.decision.type.box': {
+        readonly defaultMessage: "Box";
+        readonly description: "A question answered with one box in an image.";
+    };
+    readonly '@theorem.decision.box_edges': {
+        readonly defaultMessage: "Left {left}, top {top}, right {right}, bottom {bottom}";
+        readonly description: "Where a box sits in its image, each edge as a share of the image from its top-left corner.";
+        readonly params: readonly ["left", "top", "right", "bottom"];
+    };
+    readonly '@theorem.decision.add_image': {
+        readonly defaultMessage: "Add an image";
+        readonly description: "The drop area under the state: each image dropped or chosen becomes a state field.";
+    };
+    readonly '@theorem.decision.add_image_hint': {
+        readonly defaultMessage: "Drop a PNG or JPEG, or choose one. It becomes a field the questions can name.";
+        readonly description: "What the drop area under the state says it does.";
+    };
+    readonly '@theorem.decision.replace_image': {
+        readonly defaultMessage: "Replace";
+        readonly description: "An image field's file input, which swaps in another PNG or JPEG.";
+    };
+    readonly '@theorem.decision.image_bad': {
+        readonly defaultMessage: "{file} is not a PNG or JPEG.";
+        readonly description: "A file attached as an image that is neither.";
+        readonly params: readonly ["file"];
+    };
+    readonly '@theorem.decision.edit_question': {
+        readonly defaultMessage: "Edit {question}";
+        readonly description: "The button on an answer that opens its question where it is set up. The page shows it only when it can.";
+        readonly params: readonly ["question"];
+    };
+    readonly '@theorem.decision.box_in': {
+        readonly defaultMessage: "The box, cut from the image";
+        readonly description: "The alt text of the part of the image a box answer covers.";
+    };
+    readonly '@theorem.decision.open_box': {
+        readonly defaultMessage: "See the box in the whole image";
+        readonly description: "The cut-out box on an answer, which opens the whole image with the box outlined.";
+    };
+    readonly '@theorem.decision.box_marked': {
+        readonly defaultMessage: "The whole image, the box outlined and the rest shaded";
+        readonly description: "The alt text of the whole image a box answer opens.";
+    };
+    readonly '@theorem.decision.tokens': {
+        readonly defaultMessage: "{count, plural, one {# token} other {# tokens}}";
+        readonly description: "Input tokens the decision used, in the line under the answers.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.embedding.documents': {
+        readonly defaultMessage: "Documents";
+        readonly description: "What a search looks through: the texts and files to embed (card title).";
+    };
+    readonly '@theorem.embedding.document': {
+        readonly defaultMessage: "Document {number}";
+        readonly description: "One document, by its place in the list.";
+        readonly params: readonly ["number"];
+    };
+    readonly '@theorem.embedding.text': {
+        readonly defaultMessage: "Text";
+        readonly description: "Text to split into documents (field label).";
+    };
+    readonly '@theorem.embedding.text_placeholder': {
+        readonly defaultMessage: "Paste text to search through";
+        readonly description: "The empty text field on the documents card.";
+    };
+    readonly '@theorem.embedding.split': {
+        readonly defaultMessage: "Split by";
+        readonly description: "Where the text is cut into documents (field label).";
+    };
+    readonly '@theorem.embedding.split_whole': {
+        readonly defaultMessage: "Nothing: one document";
+        readonly description: "The text is one document.";
+    };
+    readonly '@theorem.embedding.split_lines': {
+        readonly defaultMessage: "Lines";
+        readonly description: "Each line of the text is a document.";
+    };
+    readonly '@theorem.embedding.split_paragraphs': {
+        readonly defaultMessage: "Paragraphs";
+        readonly description: "Each run of text between blank lines is a document.";
+    };
+    readonly '@theorem.embedding.split_commas': {
+        readonly defaultMessage: "Commas";
+        readonly description: "Each piece of the text between commas is a document.";
+    };
+    readonly '@theorem.embedding.split_custom': {
+        readonly defaultMessage: "A separator you type";
+        readonly description: "The text is cut wherever a separator of the user’s own appears.";
+    };
+    readonly '@theorem.embedding.separator': {
+        readonly defaultMessage: "Separator";
+        readonly description: "The text the documents are cut at (field label).";
+    };
+    readonly '@theorem.embedding.files': {
+        readonly defaultMessage: "Files";
+        readonly description: "Adds files as documents (field label).";
+    };
+    readonly '@theorem.embedding.drop_files': {
+        readonly defaultMessage: "Drop files here, or click to upload";
+        readonly description: "The file field's prompt.";
+    };
+    readonly '@theorem.embedding.unreadable': {
+        readonly defaultMessage: "{name} couldn't be read.";
+        readonly description: "A chosen file the browser could not read.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.embedding.remove': {
+        readonly defaultMessage: "Remove {name}";
+        readonly description: "Takes a document off the list.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.embedding.from_file': {
+        readonly defaultMessage: "From {name}";
+        readonly description: "A document that is a piece of a text file, under its text.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.embedding.from_json': {
+        readonly defaultMessage: "From the JSON";
+        readonly description: "The documents of a pasted list, as a group.";
+    };
+    readonly '@theorem.embedding.group': {
+        readonly defaultMessage: "{source} · {count, plural, one {# document} other {# documents}}";
+        readonly description: "A group of documents from one source, above its first few.";
+        readonly params: readonly ["source", "count"];
+    };
+    readonly '@theorem.embedding.held_file': {
+        readonly defaultMessage: "Held by the provider";
+        readonly description: "A file the provider already holds, referred to by address, beside its type.";
+    };
+    readonly '@theorem.embedding.more': {
+        readonly defaultMessage: "{count, plural, one {# more document} other {# more documents}}";
+        readonly description: "Documents past the ones the list shows.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.embedding.invalid_json': {
+        readonly defaultMessage: "Not a list of documents: each is text, or an object with parts.";
+        readonly description: "The documents' JSON doesn't read as the inputs an embedding takes.";
+    };
+    readonly '@theorem.embedding.no_documents': {
+        readonly defaultMessage: "Add text or files to search through.";
+        readonly description: "There are no documents yet.";
+    };
+    readonly '@theorem.embedding.empty': {
+        readonly defaultMessage: "{name} is empty.";
+        readonly description: "A document or the query has no text and no file.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.embedding.text_off': {
+        readonly defaultMessage: "{name} has text, and this profile embeds files only.";
+        readonly description: "A document or the query has text the profile does not take.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.embedding.too_many': {
+        readonly defaultMessage: "One request takes at most {max} documents.";
+        readonly description: "A request holds more inputs than the profile's model takes in one call.";
+        readonly params: readonly ["max"];
+    };
+    readonly '@theorem.embedding.ready': {
+        readonly defaultMessage: "{count, plural, one {# document} other {# documents}} in {requests, plural, one {# request} other {# requests}}";
+        readonly description: "The documents are ready: how many, and how many requests the profile’s limits make them.";
+        readonly params: readonly ["count", "requests"];
+    };
+    readonly '@theorem.embedding.index': {
+        readonly defaultMessage: "Index";
+        readonly description: "Embeds the documents so they can be searched.";
+    };
+    readonly '@theorem.embedding.indexing': {
+        readonly defaultMessage: "Indexing…";
+        readonly description: "The index button while the documents are embedded.";
+    };
+    readonly '@theorem.embedding.indexing_progress': {
+        readonly defaultMessage: "Indexing {done}/{total}…";
+        readonly description: "The pane while the documents are embedded: the request in flight, of all of them.";
+        readonly params: readonly ["done", "total"];
+    };
+    readonly '@theorem.embedding.stop': {
+        readonly defaultMessage: "Stop";
+        readonly description: "Cancels the running index or search.";
+    };
+    readonly '@theorem.embedding.query': {
+        readonly defaultMessage: "Query";
+        readonly description: "What to search the documents for (card title).";
+    };
+    readonly '@theorem.embedding.query_placeholder': {
+        readonly defaultMessage: "What to search for";
+        readonly description: "The empty query field.";
+    };
+    readonly '@theorem.embedding.query_file': {
+        readonly defaultMessage: "Search with a file";
+        readonly description: "Adds a file to the query, such as an image to find documents like it.";
+    };
+    readonly '@theorem.embedding.query_invalid_json': {
+        readonly defaultMessage: "Not a query: text, or an object with parts.";
+        readonly description: "The query's JSON doesn't read as one embedding input.";
+    };
+    readonly '@theorem.embedding.stale': {
+        readonly defaultMessage: "The documents changed. Index them again.";
+        readonly description: "The documents differ from the ones last embedded.";
+    };
+    readonly '@theorem.embedding.remodelled': {
+        readonly defaultMessage: "The model changed. Index the documents again.";
+        readonly description: "The last query came from another model than the one the documents were embedded with.";
+    };
+    readonly '@theorem.embedding.search': {
+        readonly defaultMessage: "Search";
+        readonly description: "Embeds the query and ranks the documents by it.";
+    };
+    readonly '@theorem.embedding.searching': {
+        readonly defaultMessage: "Searching…";
+        readonly description: "The search button while the query is embedded.";
+    };
+    readonly '@theorem.embedding.results': {
+        readonly defaultMessage: "Results";
+        readonly description: "The index and the matches (heading).";
+    };
+    readonly '@theorem.embedding.indexed': {
+        readonly defaultMessage: "{count, plural, one {# document} other {# documents}}";
+        readonly description: "How many documents the index holds, its card’s figure.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.embedding.view': {
+        readonly defaultMessage: "View";
+        readonly description: "Switches the index card between the space and the list of vectors.";
+    };
+    readonly '@theorem.embedding.space': {
+        readonly defaultMessage: "Space";
+        readonly description: "The index drawn in three dimensions, alike documents together.";
+    };
+    readonly '@theorem.embedding.list': {
+        readonly defaultMessage: "List";
+        readonly description: "The index as a list of documents and their vectors.";
+    };
+    readonly '@theorem.embedding.space_label': {
+        readonly defaultMessage: "{count, plural, one {# document} other {# documents}} drawn in three dimensions by where their vectors differ most: each document is joined to the one most like it when that pair is far more alike than the typical pair in this index, heavier the more alike, documents the lines connect share a colour, and three circles mark the planes of the axes.";
+        readonly description: "What the space shows, for screen readers.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.embedding.space_query': {
+        readonly defaultMessage: "The query lands among its matches, with a line to each match far more alike than its typical document.";
+        readonly description: "What the space shows after a search, for screen readers.";
+    };
+    readonly '@theorem.embedding.space_off': {
+        readonly defaultMessage: "This browser can’t draw the space, so the vectors are listed.";
+        readonly description: "WebGL2 is unavailable, so the index card shows the list.";
+    };
+    readonly '@theorem.embedding.copy_vector': {
+        readonly defaultMessage: "Copy vector";
+        readonly description: "Copies one document's vector as JSON.";
+    };
+    readonly '@theorem.embedding.copy_vectors': {
+        readonly defaultMessage: "Copy all";
+        readonly description: "Copies every vector in the index as JSON, in document order.";
+    };
+    readonly '@theorem.embedding.copied': {
+        readonly defaultMessage: "Copied";
+        readonly description: "Right after copying a vector.";
+    };
+    readonly '@theorem.embedding.width': {
+        readonly defaultMessage: "{dimensions, plural, one {# dimension} other {# dimensions}}";
+        readonly description: "How wide a vector is, after its first values in the list.";
+        readonly params: readonly ["dimensions"];
+    };
+    readonly '@theorem.embedding.matches': {
+        readonly defaultMessage: "Matches";
+        readonly description: "The documents most like the query, best first (card title).";
+    };
+    readonly '@theorem.embedding.matches_shown': {
+        readonly defaultMessage: "Top {shown} of {count}";
+        readonly description: "The matches card lists the best documents only.";
+        readonly params: readonly ["shown", "count"];
+    };
+    readonly '@theorem.embedding.best': {
+        readonly defaultMessage: "Best: {name}";
+        readonly description: "The document most like the query, under the matches figure.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.embedding.no_matches': {
+        readonly defaultMessage: "No document has a vector as wide as the query’s.";
+        readonly description: "The query and the documents were embedded by models of different widths.";
+    };
+    readonly '@theorem.embedding.tokens': {
+        readonly defaultMessage: "{count, plural, one {# token} other {# tokens}}";
+        readonly description: "Input tokens a call used, in the line under the results.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.host.tool': {
+        readonly defaultMessage: "Tool";
+        readonly description: "Picks which of the host’s tools to call (field label).";
+    };
+    readonly '@theorem.host.request': {
+        readonly defaultMessage: "Request";
+        readonly description: "The input a tool call sends (card heading).";
+    };
+    readonly '@theorem.host.response': {
+        readonly defaultMessage: "Response";
+        readonly description: "What a tool call returned (section heading).";
+    };
+    readonly '@theorem.host.run': {
+        readonly defaultMessage: "Run";
+        readonly description: "Calls the tool with the request.";
+    };
+    readonly '@theorem.host.image': {
+        readonly defaultMessage: "Image the tool returned";
+        readonly description: "Alt text for an image a tool returned beside its output.";
+    };
+    readonly '@theorem.host.running': {
+        readonly defaultMessage: "Running…";
+        readonly description: "The run button while the call runs.";
+    };
+    readonly '@theorem.host.stop': {
+        readonly defaultMessage: "Stop";
+        readonly description: "Cancels the running call.";
+    };
+    readonly '@theorem.host.missing': {
+        readonly defaultMessage: "Needs {fields}";
+        readonly description: "Required fields the request is still missing, under the form.";
+        readonly params: readonly ["fields"];
+    };
+    readonly '@theorem.host.shortcut': {
+        readonly defaultMessage: "⌘↵ to run";
+        readonly description: "The keyboard shortcut that runs the call, under the form.";
+    };
+    readonly '@theorem.host.no_tools': {
+        readonly defaultMessage: "This host has no tools yet";
+        readonly description: "A host profile that allows no tools.";
+    };
+    readonly '@theorem.host.earlier': {
+        readonly defaultMessage: "Earlier calls";
+        readonly description: "Heading over this page’s previous tool calls.";
+    };
+    readonly '@theorem.host.kind.function': {
+        readonly defaultMessage: "Function";
+        readonly description: "A tool that runs a function on the host.";
+    };
+    readonly '@theorem.host.kind.http': {
+        readonly defaultMessage: "HTTP";
+        readonly description: "A tool that calls an HTTP endpoint.";
+    };
+    readonly '@theorem.host.kind.mcp': {
+        readonly defaultMessage: "MCP";
+        readonly description: "A tool served by an MCP server.";
+    };
+    readonly '@theorem.tool.access.read-only': {
+        readonly defaultMessage: "Read only";
+        readonly description: "A tool that only reads.";
+    };
+    readonly '@theorem.tool.access.read-write': {
+        readonly defaultMessage: "Read and write";
+        readonly description: "A tool that can change things.";
+    };
+    readonly '@theorem.tool.access.destructive': {
+        readonly defaultMessage: "Destructive";
+        readonly description: "A tool that can delete or overwrite.";
+    };
+    readonly '@theorem.host.status.running': {
+        readonly defaultMessage: "running";
+        readonly description: "A tool call in progress.";
+    };
+    readonly '@theorem.host.status.gate': {
+        readonly defaultMessage: "waiting";
+        readonly description: "A tool call paused on approval or sign-in.";
+    };
+    readonly '@theorem.host.status.complete': {
+        readonly defaultMessage: "done";
+        readonly description: "A tool call that returned.";
+    };
+    readonly '@theorem.host.status.error': {
+        readonly defaultMessage: "failed";
+        readonly description: "A tool call that failed.";
+    };
+    readonly '@theorem.host.status.cancel': {
+        readonly defaultMessage: "stopped";
+        readonly description: "A tool call that was cancelled.";
+    };
+    readonly '@theorem.host.finished': {
+        readonly defaultMessage: "{activity} in {duration}";
+        readonly description: "A finished tool call: what it did, and how long it took.";
+        readonly params: readonly ["activity", "duration"];
+    };
+    readonly '@theorem.panel.trace.name': {
+        readonly defaultMessage: "Trace";
+        readonly description: "Trace side panel (screen readers).";
+    };
+    readonly '@theorem.panel.trace.show': {
+        readonly defaultMessage: "Show trace";
+        readonly description: "Trace panel toggle, closed.";
+    };
+    readonly '@theorem.panel.trace.hide': {
+        readonly defaultMessage: "Hide trace";
+        readonly description: "Trace panel toggle, open.";
+    };
+    readonly '@theorem.panel.trace.resize': {
+        readonly defaultMessage: "Resize trace";
+        readonly description: "Trace panel drag handle.";
+    };
+    readonly '@theorem.panel.resize': {
+        readonly defaultMessage: "Resize {name}";
+        readonly description: "Drag handle for a named console panel.";
+        readonly params: readonly ["name"];
+    };
+    readonly '@theorem.panel.trace.empty.title': {
+        readonly defaultMessage: "No trace yet";
+        readonly description: "Empty trace panel.";
+    };
+    readonly '@theorem.panel.trace.empty.description': {
+        readonly defaultMessage: "Spans for each run will show here.";
+        readonly description: "Empty trace panel.";
+    };
+    readonly '@theorem.panel.trace.summary': {
+        readonly defaultMessage: "{traces, plural, one {# trace} other {# traces}} · {spans, plural, one {# span} other {# spans}}";
+        readonly description: "Trace panel line under the search: how many traces and spans it holds.";
+        readonly params: readonly ["traces", "spans"];
+    };
+    readonly '@theorem.panel.trace.separator': {
+        readonly defaultMessage: " · ";
+        readonly description: "Between facts on one trace panel line.";
+    };
+    readonly '@theorem.panel.trace.search': {
+        readonly defaultMessage: "Search spans";
+        readonly description: "Trace panel search (screen readers).";
+    };
+    readonly '@theorem.panel.trace.search.placeholder': {
+        readonly defaultMessage: "Filter by type, status, model, text…";
+        readonly description: "Trace panel search, empty.";
+    };
+    readonly '@theorem.panel.trace.search.text': {
+        readonly defaultMessage: "Any text";
+        readonly description: "Search field matching any text a span holds.";
+    };
+    readonly '@theorem.panel.trace.search.text.description': {
+        readonly defaultMessage: "Names, values, and stored text.";
+        readonly description: "What the any-text search field matches.";
+    };
+    readonly '@theorem.panel.trace.no_match': {
+        readonly defaultMessage: "No spans match";
+        readonly description: "Trace panel, when the search matches nothing.";
+    };
+    readonly '@theorem.panel.trace.back': {
+        readonly defaultMessage: "Back";
+        readonly description: "Leaves an open span for its turn.";
+    };
+    readonly '@theorem.panel.trace.show_text': {
+        readonly defaultMessage: "Show text";
+        readonly description: "Reveals stored text, JSON, or messages.";
+    };
+    readonly '@theorem.panel.trace.hide_text': {
+        readonly defaultMessage: "Hide text";
+        readonly description: "Hides revealed stored text.";
+    };
+    readonly '@theorem.panel.trace.other': {
+        readonly defaultMessage: "Other";
+        readonly description: "Group for attributes the trace catalog does not name.";
+    };
+    readonly '@theorem.panel.trace.yes': {
+        readonly defaultMessage: "Yes";
+        readonly description: "A true trace value.";
+    };
+    readonly '@theorem.panel.trace.no': {
+        readonly defaultMessage: "No";
+        readonly description: "A false trace value.";
+    };
+    readonly '@theorem.panel.trace.tokens': {
+        readonly defaultMessage: "Tokens";
+        readonly description: "Card of token counts.";
+    };
+    readonly '@theorem.panel.trace.errors': {
+        readonly defaultMessage: "Errors";
+        readonly description: "Card counting failed spans.";
+    };
+    readonly '@theorem.panel.trace.at_least': {
+        readonly defaultMessage: "At least {value}";
+        readonly description: "A total some calls did not report.";
+        readonly params: readonly ["value"];
+    };
+    readonly '@theorem.panel.trace.about': {
+        readonly defaultMessage: "About {value}";
+        readonly description: "A total with estimated counts.";
+        readonly params: readonly ["value"];
+    };
+    readonly '@theorem.panel.trace.offset': {
+        readonly defaultMessage: "+{duration}";
+        readonly description: "When an event happened, after its span started.";
+        readonly params: readonly ["duration"];
+    };
+    readonly '@theorem.panel.trace.unit.milliseconds': {
+        readonly defaultMessage: "ms";
+        readonly description: "Unit of a search field in milliseconds.";
+    };
+    readonly '@theorem.panel.trace.unit.seconds': {
+        readonly defaultMessage: "s";
+        readonly description: "Unit of a search field in seconds.";
+    };
+    readonly '@theorem.panel.trace.unit.usd': {
+        readonly defaultMessage: "USD";
+        readonly description: "Unit of a search field in US dollars.";
+    };
+    readonly '@theorem.panel.trace.turn': {
+        readonly defaultMessage: "{label} {index} of {count}";
+        readonly description: "Which root of the trace is shown: \"Turn 2 of 3\".";
+        readonly params: readonly ["label", "index", "count"];
+    };
+    readonly '@theorem.panel.trace.turns': {
+        readonly defaultMessage: "Turns";
+        readonly description: "List of every turn of the conversation; a row opens its turn.";
+    };
+    readonly '@theorem.panel.trace.conversation': {
+        readonly defaultMessage: "{count, plural, one {# turn} other {# turns}}";
+        readonly description: "Heading of the whole-conversation view: how many turns it holds.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.panel.trace.conversation.back': {
+        readonly defaultMessage: "All turns";
+        readonly description: "Leaves a turn for the whole-conversation view.";
+    };
+    readonly '@theorem.panel.trace.previous': {
+        readonly defaultMessage: "Previous turn";
+        readonly description: "Opens the turn before this one.";
+    };
+    readonly '@theorem.panel.trace.next': {
+        readonly defaultMessage: "Next turn";
+        readonly description: "Opens the turn after this one.";
+    };
+    readonly '@theorem.panel.trace.calls': {
+        readonly defaultMessage: "Tool calls";
+        readonly description: "List of every call of a host's trace; a row opens its call.";
+    };
+    readonly '@theorem.panel.trace.calls.count': {
+        readonly defaultMessage: "{count, plural, one {# tool call} other {# tool calls}}";
+        readonly description: "Heading of a host's whole-trace view: how many tool calls it holds.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.panel.trace.calls.back': {
+        readonly defaultMessage: "All tool calls";
+        readonly description: "Leaves a call for the host's whole-trace view.";
+    };
+    readonly '@theorem.panel.trace.calls.previous': {
+        readonly defaultMessage: "Previous call";
+        readonly description: "Opens the tool call before this one.";
+    };
+    readonly '@theorem.panel.trace.calls.next': {
+        readonly defaultMessage: "Next call";
+        readonly description: "Opens the tool call after this one.";
+    };
+    readonly '@theorem.panel.trace.steps': {
+        readonly defaultMessage: "Steps";
+        readonly description: "Card counting the model and tool calls of a turn.";
+    };
+    readonly '@theorem.panel.trace.steps.detail': {
+        readonly defaultMessage: "{calls, plural, one {# model call} other {# model calls}} · {tools, plural, one {# tool} other {# tools}}";
+        readonly description: "Under the steps count: how many were model calls and tool calls.";
+        readonly params: readonly ["calls", "tools"];
+    };
+    readonly '@theorem.panel.trace.failed': {
+        readonly defaultMessage: "{count} failed";
+        readonly description: "Under the steps count, when some failed.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.panel.trace.firstText': {
+        readonly defaultMessage: "First text";
+        readonly description: "Card: how long the person waited before any of the answer appeared.";
+    };
+    readonly '@theorem.panel.trace.rate': {
+        readonly defaultMessage: "{rate} tokens/s";
+        readonly description: "Under the first-text time: how fast the model wrote once it started.";
+        readonly params: readonly ["rate"];
+    };
+    readonly '@theorem.panel.trace.held': {
+        readonly defaultMessage: "{duration} held back";
+        readonly description: "Under the first-text time: how long guardrails held written text back before showing it.";
+        readonly params: readonly ["duration"];
+    };
+    readonly '@theorem.panel.trace.guardrails': {
+        readonly defaultMessage: "Guardrails";
+        readonly description: "Card: the time guardrail checks took in a turn.";
+    };
+    readonly '@theorem.panel.trace.guardrails.passed': {
+        readonly defaultMessage: "Passed: {checks}";
+        readonly description: "Under the guardrail checks that acted: the checks that let the text through, each with what it checked and its time.";
+        readonly params: readonly ["checks"];
+    };
+    readonly '@theorem.panel.trace.guardrails.from': {
+        readonly defaultMessage: "from {tool}";
+        readonly description: "A guardrail check: the tool the checked text came from.";
+        readonly params: readonly ["tool"];
+    };
+    readonly '@theorem.panel.trace.guardrails.tainted': {
+        readonly defaultMessage: "Tainted";
+        readonly description: "A guardrail check: a tool that writes or deletes was called after the turn read remote content.";
+    };
+    readonly '@theorem.panel.trace.guardrails.steered': {
+        readonly defaultMessage: "Steered";
+        readonly description: "A guardrail check: a tool that writes or deletes was called after the turn read remote content that looked like instructions.";
+    };
+    readonly '@theorem.panel.trace.guardrails.detail': {
+        readonly defaultMessage: "{checks, plural, one {# check} other {# checks}} · {flagged, plural, =0 {all passed} other {# acted}}";
+        readonly description: "Under the guardrail time: how many checks ran, and how many redacted, flagged, or blocked.";
+        readonly params: readonly ["checks", "flagged"];
+    };
+    readonly '@theorem.panel.trace.tokens.detail': {
+        readonly defaultMessage: "{input} in · {output} out";
+        readonly description: "Under the token total: tokens read and written.";
+        readonly params: readonly ["input", "output"];
+    };
+    readonly '@theorem.panel.trace.time': {
+        readonly defaultMessage: "Where the time went";
+        readonly description: "Bar splitting a turn into model, tool, and other time.";
+    };
+    readonly '@theorem.panel.trace.time.model': {
+        readonly defaultMessage: "Model";
+        readonly description: "Time spent waiting on the model.";
+    };
+    readonly '@theorem.panel.trace.time.tools': {
+        readonly defaultMessage: "Tools";
+        readonly description: "Time spent running tools.";
+    };
+    readonly '@theorem.panel.trace.time.guardrails': {
+        readonly defaultMessage: "Guardrails";
+        readonly description: "Time guardrail checks took: on the input, the stream, and the answer.";
+    };
+    readonly '@theorem.panel.trace.time.hooks': {
+        readonly defaultMessage: "Hooks";
+        readonly description: "Time the host's turn hooks took.";
+    };
+    readonly '@theorem.panel.trace.time.other': {
+        readonly defaultMessage: "Other";
+        readonly description: "Time spent on none of these: waiting between steps, the host, the network.";
+    };
+    readonly '@theorem.panel.trace.charts.calls': {
+        readonly defaultMessage: "Tokens per model call";
+        readonly description: "Chart of each model call: its tokens stacked as a bar.";
+    };
+    readonly '@theorem.panel.trace.charts.cached': {
+        readonly defaultMessage: "Cached";
+        readonly description: "Legend: input tokens read from cache.";
+    };
+    readonly '@theorem.panel.trace.charts.input': {
+        readonly defaultMessage: "Input";
+        readonly description: "Legend: input tokens read fresh.";
+    };
+    readonly '@theorem.panel.trace.charts.output': {
+        readonly defaultMessage: "Output";
+        readonly description: "Legend: tokens the model wrote.";
+    };
+    readonly '@theorem.panel.trace.charts.slowest': {
+        readonly defaultMessage: "Slowest steps";
+        readonly description: "Chart ranking the steps that took longest.";
+    };
+    readonly '@theorem.panel.trace.charts.modelShare': {
+        readonly defaultMessage: "{share} on the model";
+        readonly description: "Beside a chart's total time: the model's share.";
+        readonly params: readonly ["share"];
+    };
+    readonly '@theorem.panel.trace.charts.cachedShare': {
+        readonly defaultMessage: "{share} of input cached";
+        readonly description: "Beside a chart's total tokens: the input read from cache.";
+        readonly params: readonly ["share"];
+    };
+    readonly '@theorem.panel.trace.charts.turnTime': {
+        readonly defaultMessage: "Time per turn";
+        readonly description: "Chart of each turn: its model, tool, and other time stacked.";
+    };
+    readonly '@theorem.panel.trace.charts.callTime': {
+        readonly defaultMessage: "Time per call";
+        readonly description: "Chart of each tool call of a host's trace: its tool, check, and hook time stacked.";
+    };
+    readonly '@theorem.panel.trace.charts.turnTokens': {
+        readonly defaultMessage: "Tokens per turn";
+        readonly description: "Chart of each turn: its tokens stacked as a bar.";
+    };
+    readonly '@theorem.panel.trace.charts.turn': {
+        readonly defaultMessage: "Turn {index}";
+        readonly description: "A turn, by its order in the conversation.";
+        readonly params: readonly ["index"];
+    };
+    readonly '@theorem.panel.trace.charts.hostCall': {
+        readonly defaultMessage: "Call {index}";
+        readonly description: "A tool call, by its order in a host's trace.";
+        readonly params: readonly ["index"];
+    };
+    readonly '@theorem.panel.trace.charts.call': {
+        readonly defaultMessage: "Model call {index}";
+        readonly description: "A model call, by its order in the turn.";
+        readonly params: readonly ["index"];
+    };
+    readonly '@theorem.panel.trace.charts.tokens': {
+        readonly defaultMessage: "{cached} cached · {fresh} new in · {output} out";
+        readonly description: "A model call's tokens: read from cache, read fresh, and written.";
+        readonly params: readonly ["cached", "fresh", "output"];
+    };
+    readonly '@theorem.panel.trace.story': {
+        readonly defaultMessage: "What happened";
+        readonly description: "The turn told step by step.";
+    };
+    readonly '@theorem.panel.trace.story.asked': {
+        readonly defaultMessage: "User asked";
+        readonly description: "The first step: what the user sent.";
+    };
+    readonly '@theorem.panel.trace.story.requested': {
+        readonly defaultMessage: "Asked for {count, plural, one {# tool} other {# tools}}";
+        readonly description: "A model call that answered with tool calls.";
+        readonly params: readonly ["count"];
+    };
+    readonly '@theorem.panel.trace.story.wrote': {
+        readonly defaultMessage: "Wrote a reply";
+        readonly description: "A model call that answered with text.";
+    };
+    readonly '@theorem.panel.trace.story.answered': {
+        readonly defaultMessage: "Answered";
+        readonly description: "The last step: the turn ended with this answer.";
+    };
+    readonly '@theorem.panel.trace.story.failed': {
+        readonly defaultMessage: "Ended with an error";
+        readonly description: "The last step, when the turn failed.";
+    };
+    readonly '@theorem.panel.trace.timeline': {
+        readonly defaultMessage: "Timeline";
+        readonly description: "Every span of the turn on one time axis.";
+    };
+    readonly '@theorem.panel.trace.timeline.zoom': {
+        readonly defaultMessage: "Drag across the strip to zoom";
+        readonly description: "Hint beside the activity strip that zooms the timeline.";
+    };
+    readonly '@theorem.panel.trace.timeline.reset': {
+        readonly defaultMessage: "Show the whole turn";
+        readonly description: "Zooms the timeline back out to the full turn.";
+    };
+    readonly '@theorem.panel.trace.input': {
+        readonly defaultMessage: "Input";
+        readonly description: "What a span was given.";
+    };
+    readonly '@theorem.panel.trace.output': {
+        readonly defaultMessage: "Output";
+        readonly description: "What a span gave back.";
+    };
+    readonly '@theorem.panel.trace.details': {
+        readonly defaultMessage: "All details";
+        readonly description: "A span's every attribute, event, and link.";
+    };
+    readonly '@theorem.panel.trace.close': {
+        readonly defaultMessage: "Close";
+        readonly description: "Closes the open span.";
+    };
+    readonly '@theorem.panel.captions.name': {
+        readonly defaultMessage: "Captions";
+        readonly description: "Captions side panel (screen readers).";
+    };
+    readonly '@theorem.panel.captions.show': {
+        readonly defaultMessage: "Show captions";
+        readonly description: "Captions panel toggle, closed.";
+    };
+    readonly '@theorem.panel.captions.hide': {
+        readonly defaultMessage: "Hide captions";
+        readonly description: "Captions panel toggle, open.";
+    };
+    readonly '@theorem.panel.captions.resize': {
+        readonly defaultMessage: "Resize captions";
+        readonly description: "Captions panel drag handle.";
+    };
+    readonly '@theorem.panel.captions.empty.title': {
+        readonly defaultMessage: "No captions yet";
+        readonly description: "Empty captions panel.";
+    };
+    readonly '@theorem.panel.captions.empty.description': {
+        readonly defaultMessage: "What you and the agent say will show here.";
+        readonly description: "Empty captions panel.";
+    };
+    readonly '@theorem.live.greeting': {
+        readonly defaultMessage: "Ready when you are.";
+        readonly description: "Live landing heading, before a call.";
+    };
+    readonly '@theorem.live.start_voice_call': {
+        readonly defaultMessage: "Start voice call";
+        readonly description: "Live landing, voice profiles.";
+    };
+    readonly '@theorem.live.start_call': {
+        readonly defaultMessage: "Start call";
+        readonly description: "Starts or restarts a call.";
+    };
+    readonly '@theorem.live.start_video_call': {
+        readonly defaultMessage: "Start video call";
+        readonly description: "Live landing, video profiles.";
+    };
+    readonly '@theorem.live.microphone': {
+        readonly defaultMessage: "Microphone";
+        readonly description: "Mic toggle.";
+    };
+    readonly '@theorem.live.mute': {
+        readonly defaultMessage: "Mute";
+        readonly description: "Mic toggle tooltip, unmuted.";
+    };
+    readonly '@theorem.live.unmute': {
+        readonly defaultMessage: "Unmute";
+        readonly description: "Mic toggle tooltip, muted.";
+    };
+    readonly '@theorem.live.camera': {
+        readonly defaultMessage: "Camera";
+        readonly description: "Camera toggle.";
+    };
+    readonly '@theorem.live.camera_on': {
+        readonly defaultMessage: "Turn camera on";
+        readonly description: "Camera toggle tooltip, off.";
+    };
+    readonly '@theorem.live.camera_off': {
+        readonly defaultMessage: "Turn camera off";
+        readonly description: "Camera toggle tooltip, on.";
+    };
+    readonly '@theorem.live.flip_camera': {
+        readonly defaultMessage: "Flip camera";
+        readonly description: "Switches front and back camera.";
+    };
+    readonly '@theorem.live.end_call': {
+        readonly defaultMessage: "End call";
+        readonly description: "Hangs up.";
+    };
+    readonly '@theorem.live.new_session': {
+        readonly defaultMessage: "New session";
+        readonly description: "Captions divider between calls.";
+    };
+    readonly '@theorem.live.controls': {
+        readonly defaultMessage: "Call controls";
+        readonly description: "The control toolbar (screen readers).";
+    };
+    readonly '@theorem.live.camera_preview': {
+        readonly defaultMessage: "Camera preview";
+        readonly description: "Self-view (screen readers).";
+    };
+    readonly '@theorem.live.state.calling_tool': {
+        readonly defaultMessage: "calling {tool}";
+        readonly description: "Call status: a tool runs.";
+        readonly params: readonly ["tool"];
+    };
+    readonly '@theorem.live.state.connecting': {
+        readonly defaultMessage: "connecting";
+        readonly description: "Call status.";
+    };
+    readonly '@theorem.live.state.reconnecting': {
+        readonly defaultMessage: "reconnecting";
+        readonly description: "Call status: the call dropped and is being taken up again.";
+    };
+    readonly '@theorem.live.state.requesting_mic': {
+        readonly defaultMessage: "requesting mic";
+        readonly description: "Call status.";
+    };
+    readonly '@theorem.live.state.speaking': {
+        readonly defaultMessage: "speaking";
+        readonly description: "Call status: the agent speaks.";
+    };
+    readonly '@theorem.live.state.connected': {
+        readonly defaultMessage: "connected";
+        readonly description: "Call status.";
+    };
+    readonly '@theorem.live.state.muted': {
+        readonly defaultMessage: "muted";
+        readonly description: "Call status.";
+    };
+    readonly '@theorem.live.state.listening': {
+        readonly defaultMessage: "listening";
+        readonly description: "Call status.";
+    };
+    readonly '@theorem.live.state.error': {
+        readonly defaultMessage: "error";
+        readonly description: "Call status.";
+    };
+    readonly '@theorem.live.state.ended': {
+        readonly defaultMessage: "ended";
+        readonly description: "Call status.";
+    };
+};
+/** The default UI's catalog: each line's default message, description, and values. */
+export type TheoremUiCatalog = typeof THEOREM_UI_CATALOG;
+/** Every line the default UI writes. */
+export type TheoremLabelKey = keyof TheoremUiCatalog;
+/** The values a label's message is formatted with; none for a plain line. */
+export type TheoremLabelValues<K extends TheoremLabelKey> = TheoremUiCatalog[K] extends {
+    params: readonly (infer P extends string)[];
+} ? Record<P, string | number> : undefined;
+/** Words a label; the default UI gets one from Astryx's `useTranslator`. */
+export type LabelText = <K extends TheoremLabelKey>(key: K, values?: TheoremLabelValues<K>) => string;
+/**
+ * One locale's replacements: any `@theorem.*` line, and any of Astryx's own
+ * (`@astryx.*`, see `@astryxdesign/core/locales/en.json`).
+ */
+export type TheoremLabelOverrides = {
+    readonly [K in TheoremLabelKey]?: string;
+} & {
+    readonly [key: `@astryx.${string}`]: string;
+};
+/** Replacements by locale (`en`, `en-GB`, `de`, …), as Astryx's `overrides`. */
+export type TheoremLabels = {
+    readonly [locale: string]: TheoremLabelOverrides | undefined;
+};
+/** A single kind is just its word ("queued"); a mix spells out each count ("2 queued · 1 attached"). */
+export declare function composerDrawerLabel(t: LabelText, summary: ComposerDrawerSummary): string;
+/** What a reply or a called agent used: its tokens, then its cost when the provider gave one. */
+export declare function usageLine(t: LabelText, locale: string, tokens: TurnUsage): string;
+/** Wall-clock duration, matching Seance's builder-trace formatter: "<0.1ms", "0.4ms", "850ms", "3.2s", "12s", "1m 5s". */
+export declare function workDuration(t: LabelText, durationMs: number): string;
+/** A console result's quiet line: model, time, tokens, and cost, leaving out what it lacks. */
+export declare function resultMeta(t: LabelText, usd: Intl.NumberFormat, result: {
+    model: string;
+    usage?: {
+        inputTokens?: number;
+        costUsd?: number;
+    };
+    elapsedMs?: number | null;
+    tokens: (count: number) => string;
+}): string;
+/** Whole-second ticker while a turn runs: "0s", "12s", "1m 5s". */
+export declare function liveDuration(t: LabelText, durationMs: number): string;
+/** "Working for 12s" while streaming (when the start is known), "Worked for 3.2s" after. */
+export declare function workStatusLabel(t: LabelText, status: WorkStatus | null): string;
+/** A live call's status line; `calling_tool` names the tool. */
+export declare function liveStateLabel(t: LabelText, state: LiveState, toolName: string | null): string;
+/** A voice note's name from its audio format; the unnamed line when the format is unknown. */
+export declare function voiceNoteName(t: LabelText, format: string | undefined): string;
+/**
+ * Checks a label table before it renders: every `@theorem.*` key must exist
+ * and its message must format with that key's values only; with `strict`
+ * (the `labels` prop), every other key must be an `@astryx.*` line whose
+ * message parses. A host's own Astryx overrides are checked for `@theorem.*`
+ * keys only, since the rest may be the host app's own strings. Throws, naming
+ * the locale and key, so a typo fails at mount instead of showing a raw key or
+ * crashing mid-render.
+ */
+export declare function assertLabelOverrides(labels: TheoremLabels, strict: boolean): void;