@alexkroman1/aai-ui 13.3.0 → 15.0.0

package/dist/{tool-call-block-Bunc6rCw.js → tool-call-block-C2t_5fpp.js}

@@ -1,8 +1,8 @@
 import { useTheme } from "./context.js";
-import { r as inkTint } from "./_colors-CZ6OlPbL.js";
+import { a as inkTint } from "./_colors-CpZO-88A.js";
 import { t as Eyebrow } from "./eyebrow-UfmSz9yy.js";
-import { i as tryParseJSON, r as truncate } from "./_utils-CyzjK0gW.js";
-import { n as useToolConfig } from "./tool-config-context-Bh8p3DtG.js";
+import { i as tryParseJSON, r as truncate } from "./_utils-DnQDM9Uy.js";
+import { n as useToolConfig } from "./tool-config-context-Es4YUzV2.js";
 import clsx from "clsx";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { memo, useMemo, useState } from "react";
@@ -123,6 +123,29 @@ function formatResult(result) {
 	return parsed === result ? result : JSON.stringify(parsed, null, 2);
 }
 /**
+* The expanded result pane.
+*
+* Its own component so the parse-and-pretty-print happens only when the row is
+* actually OPEN. `ToolCallRow` renders `children` under `isOpen && canExpand`,
+* and a row starts closed — so computing this in the parent meant every row
+* paid `JSON.parse` + `JSON.stringify(_, null, 2)` over its whole result, and
+* then RETAINED the pretty string, for a panel nobody clicked. The burst case
+* is `history.restored`, which mounts up to `DEFAULT_MAX_HISTORY` rows in one
+* commit.
+*
+* Creating this element is free; React only runs the body once it is mounted.
+*/
+function ToolCallResult({ result }) {
+	const theme = useTheme();
+	const formatted = useMemo(() => formatResult(result), [result]);
+	if (!formatted) return null;
+	return /* @__PURE__ */ jsx("pre", {
+		className: "font-aai-mono text-xs px-3.5 py-3 m-0 whitespace-pre-wrap wrap-break-word",
+		style: { color: inkTint(theme.text, theme.surface, 75) },
+		children: formatted
+	});
+}
+/**
 * Renders a tool invocation as the design system's console row (see
 * `ToolCallRow`): a small outlined "TOOL" chip (or the tool's configured
 * icon), the tool name in mono, a truncated args preview, and a rotating
@@ -151,7 +174,6 @@ const ToolCallBlock = memo(function ToolCallBlock({ toolCall, className }) {
 	const title = config?.label || toolCall.name;
 	const icon = config?.icon;
 	const canExpand = !isPending && Boolean(toolCall.result);
-	const formatted = useMemo(() => toolCall.result ? formatResult(toolCall.result) : "", [toolCall.result]);
 	const subtitle = useMemo(() => {
 		const args = toolCall.args;
 		if (toolCall.name === "run_code" && args.code) return truncate(String(args.code).split("\n")[0] ?? "");
@@ -175,11 +197,7 @@ const ToolCallBlock = memo(function ToolCallBlock({ toolCall, className }) {
 				borderColor: theme.border
 			},
 			children: String(toolCall.args.code)
-		}), formatted && /* @__PURE__ */ jsx("pre", {
-			className: "font-aai-mono text-xs px-3.5 py-3 m-0 whitespace-pre-wrap wrap-break-word",
-			style: { color: inkTint(theme.text, theme.surface, 75) },
-			children: formatted
-		})] }) : void 0
+		}), toolCall.result && /* @__PURE__ */ jsx(ToolCallResult, { result: toolCall.result })] }) : void 0
 	});
 });
 //#endregion

package/dist/{tool-config-context-Bh8p3DtG.js → tool-config-context-Es4YUzV2.js}

@@ -1,7 +1,7 @@
 import { createContext, useContext } from "react";
 //#region src/components/tool-config-context.ts
 /**
-* Context for tool display configuration. Installed by `client()` from
+* Context for tool display configuration. Installed by `mountClient()` from
 * `ClientConfig.tools`; the built-in components read it via `useToolConfig`.
 *
 * @internal

package/dist/types.d.ts

@@ -23,8 +23,8 @@ export { CAPTURE_STOP_ACK_TIMEOUT_MS, CLIENT_AUDIO_LEAD_MS, HEARD_AUDIO_LAG_MS,
  *
  * On `@alexkroman1/aai-ui/internal` rather than the root barrel, for the same
  * reason as the audio budgets above: it is a framework decision with no
- * `client()` field to set, and the root is the authoring surface. A custom
- * chrome that bypasses `client()` and opens its own microphone reaches it there
+ * `mountClient()` field to set, and the root is the authoring surface. A custom
+ * chrome that bypasses `mountClient()` and opens its own microphone reaches it there
  * alongside the providers it also needs.
  */
 export declare const VOICE_CAPTURE_CONSTRAINTS: MediaTrackConstraints;
@@ -135,11 +135,26 @@ export type SessionError = {
     readonly code: SessionErrorCode;
     /** A human-readable description of the error. */
     readonly message: string;
+    /**
+     * Whether the session is OVER.
+     *
+     * `false` means surface the message and keep the session interactive — a
+     * turn-level failure over a server that kept running. `true` means the call
+     * is dead and the microphone has been released.
+     *
+     * Required rather than optional, because the wire always carries it
+     * (`error.reported` declares `fatal: z.boolean()`) and a client that cannot
+     * tell the two apart has to guess which banner to render. It was dropped one
+     * line before reaching here for long enough that this type's own doc, and
+     * the reference page generated from it, described a field that did not
+     * exist.
+     */
+    readonly fatal: boolean;
 };
 /**
  * Options for creating a voice session — the shared field set accepted by
- * both `client()` and `createSessionCore`. The one difference: `client()`
- * defaults `platformUrl` from `location.href`, while `createSessionCore`
+ * both `mountClient()` and `createBrowserSession`. The one difference: `mountClient()`
+ * defaults `platformUrl` from `location.href`, while `createBrowserSession`
  * requires it.
  *
  * @public

package/dist/types.js

@@ -22,8 +22,8 @@ import { CAPTURE_STOP_ACK_TIMEOUT_MS, CLIENT_AUDIO_LEAD_MS, HEARD_AUDIO_LAG_MS,
 *
 * On `@alexkroman1/aai-ui/internal` rather than the root barrel, for the same
 * reason as the audio budgets above: it is a framework decision with no
-* `client()` field to set, and the root is the authoring surface. A custom
-* chrome that bypasses `client()` and opens its own microphone reaches it there
+* `mountClient()` field to set, and the root is the authoring surface. A custom
+* chrome that bypasses `mountClient()` and opens its own microphone reaches it there
 * alongside the providers it also needs.
 */
 const VOICE_CAPTURE_CONSTRAINTS = {

package/dist/url-chips-D62RTz7v.js

@@ -0,0 +1,239 @@
+import { useSessionSelector, useTheme } from "./context.js";
+import { a as inkTint, i as focusRingStyle, n as FOCUS_RING } from "./_colors-CpZO-88A.js";
+import { t as pageBaseUrl } from "./_utils-DnQDM9Uy.js";
+import clsx from "clsx";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+//#region src/use-flash.ts
+/**
+* A value that shows itself for a moment and then goes away.
+*
+* The "Copied" on a copy button, the "Saved" under an editor, the "Sent" on a
+* submit. There were three hand-rolled copies of this — two in the studio
+* front-end and one inside this package's own URL chips — each with the same
+* 1500ms and the same comment explaining the same two things the naive version
+* gets wrong. It is one primitive now, and it is PUBLIC because a custom chrome
+* is exactly the caller that needs it: the moment a client renders its own copy
+* button or its own save note, it is writing the timer again.
+*/
+/** How long a flashed value stays up. The one duration every caller used. */
+const FLASH_MS = 1500;
+/**
+* A transient value: set it, and it clears itself after `ms`.
+*
+* @remarks
+* The two things this holds that a `useState` plus a `setTimeout` at the call
+* site reliably gets wrong:
+*
+* - **At most ONE live timer.** A second flash while the first is still up
+*   re-arms rather than stacking, so the new value gets its full window
+*   instead of being cleared early by the previous click's timeout.
+* - **Nothing fires after unmount.** The timer is cleared on teardown, so a
+*   chip clicked and then scrolled out of the tree does not `setState` on a
+*   component React has already thrown away.
+*
+* @example
+* ```tsx
+* import { useFlash } from "@alexkroman1/aai-ui";
+*
+* function SaveNote({ onSave }: { onSave: () => Promise<void> }) {
+*   const { value: note, flash } = useFlash<string>();
+*   return (
+*     <button type="button" onClick={() => void onSave().then(() => flash("Saved"))}>
+*       {note ?? "Save"}
+*     </button>
+*   );
+* }
+* ```
+*
+* @typeParam T - What is being flashed.
+* @param ms - How long the value stays up. Defaults to 1500ms, which is what
+*   every caller wanted: long enough to read a word, short enough that the
+*   control is back to its real label before the reader looks again.
+*
+* @public
+*/
+function useFlash(ms = FLASH_MS) {
+	const [value, setValue] = useState(null);
+	const timer = useRef(void 0);
+	useEffect(() => () => clearTimeout(timer.current), []);
+	const flash = (next) => {
+		setValue(next);
+		clearTimeout(timer.current);
+		timer.current = setTimeout(() => setValue(null), ms);
+	};
+	return {
+		value,
+		flash
+	};
+}
+//#endregion
+//#region src/use-copy.ts
+/**
+* Copy-to-clipboard with a per-item flash on the button that triggered it.
+*
+* Anywhere a UI hands the reader a string to paste somewhere else — a session
+* URL, a webhook, a `curl` line — the button wants the same three things, and
+* two of them are easy to get wrong:
+*
+* - The flash is keyed by the copied TEXT, so one row's "Copied" does not light
+*   up every button beside it.
+* - A FAILED write is reported rather than swallowed. There is no clipboard in
+*   an insecure context, and a browser may refuse the permission; a `catch`
+*   that does nothing leaves a button that visibly does nothing when clicked,
+*   which reads as a broken page rather than as a blocked capability.
+* - The single-timer / clear-on-unmount half is {@link useFlash}'s.
+*/
+/**
+* One copier for a group of copy buttons.
+*
+* @remarks
+* Call it ONCE per group and pass the {@link UseCopyResult} down, rather than once per
+* button: the flash is shared, so clicking a second row clears the first row's
+* "Copied" — which is what makes a list of URLs readable, since two rows
+* claiming to be on the clipboard is a lie about one of them.
+*
+* A chip whose idle text is its own name rather than the word "Copy" passes
+* that name to {@link UseCopyResult.label}; the two outcome words are fixed, for the
+* reason that member's own doc gives.
+*
+* @example
+* ```tsx
+* import { useCopy } from "@alexkroman1/aai-ui";
+*
+* function UrlList({ urls }: { urls: readonly string[] }) {
+*   const copier = useCopy();
+*   return (
+*     <ul>
+*       {urls.map((url) => (
+*         <li key={url}>
+*           <code>{url}</code>
+*           <button type="button" onClick={() => copier.copy(url)}>
+*             {copier.label(url)}
+*           </button>
+*         </li>
+*       ))}
+*     </ul>
+*   );
+* }
+* ```
+*
+* @public
+*/
+function useCopy() {
+	const { value: copied, flash } = useFlash();
+	const copy = (text) => {
+		const write = navigator.clipboard?.writeText(text);
+		if (!write) {
+			flash({
+				text,
+				ok: false
+			});
+			return;
+		}
+		write.then(() => flash({
+			text,
+			ok: true
+		}), () => flash({
+			text,
+			ok: false
+		}));
+	};
+	const label = (text, idle = "Copy") => {
+		if (copied?.text !== text) return idle;
+		return copied.ok ? "Copied" : "Failed";
+	};
+	return {
+		copy,
+		label,
+		didCopy: (text) => copied?.text === text && copied.ok
+	};
+}
+//#endregion
+//#region src/components/url-chips.tsx
+/** @jsxImportSource react */
+/**
+* A compact labeled chip showing a URL. Click to copy.
+*
+* The label is what makes a pair of these readable — on its own a bare URL
+* leaves you guessing whether it's the page or the socket. It also carries the
+* copy OUTCOME, which is the whole reason the flash is `useCopy`'s rather than
+* this file's: the hand-rolled version swallowed a rejected write, so on an
+* insecure context or a denied permission the chip changed nothing at all and
+* read as a dead button.
+*
+* @internal
+*/
+function UrlChip({ label, url, hint, testId, className }) {
+	const theme = useTheme();
+	const copier = useCopy();
+	return /* @__PURE__ */ jsxs("button", {
+		type: "button",
+		onClick: () => copier.copy(url),
+		title: `${hint} (click to copy)\n${url}`,
+		className: clsx("flex items-center gap-1.5 min-w-0 appearance-none m-0 px-2 py-1 rounded-aai border cursor-pointer text-[11px] leading-none font-aai-mono", FOCUS_RING, className),
+		style: {
+			background: inkTint(theme.text, theme.surface, 3),
+			borderColor: theme.border,
+			color: inkTint(theme.text, theme.surface, 65),
+			...focusRingStyle(theme.primary)
+		},
+		"data-testid": testId,
+		children: [/* @__PURE__ */ jsx("span", {
+			className: "uppercase tracking-wide shrink-0",
+			style: { color: inkTint(theme.text, theme.surface, 75) },
+			children: copier.label(url, label)
+		}), /* @__PURE__ */ jsx("span", {
+			className: "truncate",
+			"data-testid": `${testId}-url`,
+			children: url
+		})]
+	});
+}
+/**
+* The session's shareable UI URL — the page this UI is served from, what
+* you'd send someone to talk to the agent.
+*
+* @internal
+*/
+function UiUrlChip({ className }) {
+	return /* @__PURE__ */ jsx(UrlChip, {
+		label: "UI",
+		url: pageBaseUrl(),
+		hint: "Shareable UI",
+		testId: "ui-url-chip",
+		className
+	});
+}
+/**
+* The session's programmatic WebSocket endpoint — the URL a script or backend
+* can connect to directly instead of using this UI.
+*
+* @internal
+*/
+function ApiUrlChip({ className }) {
+	const apiUrl = useSessionSelector((s) => s.apiUrl);
+	return /* @__PURE__ */ jsx(UrlChip, {
+		label: "API",
+		url: apiUrl,
+		hint: "API endpoint",
+		testId: "api-url-chip",
+		className
+	});
+}
+/**
+* The UI and API URLs side by side. They answer the same question — "how do I
+* reach this agent?" — so they belong together and each needs its label to be
+* told apart. Rendered by the default shell in every session mode (S2S,
+* pipeline).
+*
+* @internal
+*/
+function SessionUrlChips({ className }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: clsx("flex items-center gap-1.5 min-w-0", className),
+		children: [/* @__PURE__ */ jsx(UiUrlChip, { className: "min-w-0 flex-1" }), /* @__PURE__ */ jsx(ApiUrlChip, { className: "min-w-0 flex-1" })]
+	});
+}
+//#endregion
+export { useFlash as a, useCopy as i, SessionUrlChips as n, UiUrlChip as r, ApiUrlChip as t };

package/dist/use-conversation.d.ts

@@ -88,7 +88,7 @@ export type UseConversationResult = {
  * Subscribe to the conversation: the interleaved exchange, the streaming
  * utterance, the live transcript and the thinking rule — with no markup.
  *
- * Must be used inside the provider `client()` installs.
+ * Must be used inside the provider `mountClient()` installs.
  *
  * @example A custom bubble, keeping every rule `<MessageList>` knows
  * ```tsx

package/dist/use-copy.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Copy-to-clipboard with a per-item flash on the button that triggered it.
+ *
+ * Anywhere a UI hands the reader a string to paste somewhere else — a session
+ * URL, a webhook, a `curl` line — the button wants the same three things, and
+ * two of them are easy to get wrong:
+ *
+ * - The flash is keyed by the copied TEXT, so one row's "Copied" does not light
+ *   up every button beside it.
+ * - A FAILED write is reported rather than swallowed. There is no clipboard in
+ *   an insecure context, and a browser may refuse the permission; a `catch`
+ *   that does nothing leaves a button that visibly does nothing when clicked,
+ *   which reads as a broken page rather than as a blocked capability.
+ * - The single-timer / clear-on-unmount half is {@link useFlash}'s.
+ */
+/**
+ * What {@link useCopy} hands back — the click handler and the two readings a
+ * button needs off one shared flash.
+ *
+ * @public
+ */
+export type UseCopyResult = {
+    /** Copy `text`, flashing the button that owns it. */
+    copy: (text: string) => void;
+    /**
+     * The button label for `text` — `idle` until it is clicked, then `"Copied"`
+     * or `"Failed"` for the length of the flash.
+     *
+     * Only the idle word is the caller's: it is the button's NAME (`"Copy"`,
+     * `"UI"`, `"Webhook URL"`), where the other two are the OUTCOME and are the
+     * one bit of state a reader can see. A caller wanting other words for those
+     * reads {@link UseCopyResult.didCopy} and writes its own.
+     */
+    label: (text: string, idle?: string) => string;
+    /** True when `text` was the last thing copied, successfully. */
+    didCopy: (text: string) => boolean;
+};
+/**
+ * One copier for a group of copy buttons.
+ *
+ * @remarks
+ * Call it ONCE per group and pass the {@link UseCopyResult} down, rather than once per
+ * button: the flash is shared, so clicking a second row clears the first row's
+ * "Copied" — which is what makes a list of URLs readable, since two rows
+ * claiming to be on the clipboard is a lie about one of them.
+ *
+ * A chip whose idle text is its own name rather than the word "Copy" passes
+ * that name to {@link UseCopyResult.label}; the two outcome words are fixed, for the
+ * reason that member's own doc gives.
+ *
+ * @example
+ * ```tsx
+ * import { useCopy } from "@alexkroman1/aai-ui";
+ *
+ * function UrlList({ urls }: { urls: readonly string[] }) {
+ *   const copier = useCopy();
+ *   return (
+ *     <ul>
+ *       {urls.map((url) => (
+ *         <li key={url}>
+ *           <code>{url}</code>
+ *           <button type="button" onClick={() => copier.copy(url)}>
+ *             {copier.label(url)}
+ *           </button>
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function useCopy(): UseCopyResult;

package/dist/use-download-url.d.ts

@@ -57,7 +57,7 @@ export type UseDownloadUrlResult = {
  * @param uploadId - The id a completed run reported, or `undefined` before one
  *   exists — which is what a page passes straight through while it waits, and
  *   reports as idle rather than pending.
- * @param opts - See {@link UseDownloadUrlOptions}.
+ * @param options - See {@link UseDownloadUrlOptions}.
  * @returns See {@link UseDownloadUrlResult}.
  *
  * @example
@@ -81,4 +81,4 @@ export type UseDownloadUrlResult = {
  *
  * @public
  */
-export declare function useDownloadUrl(uploadId: string | undefined, opts?: UseDownloadUrlOptions): UseDownloadUrlResult;
+export declare function useDownloadUrl(uploadId: string | undefined, options?: UseDownloadUrlOptions): UseDownloadUrlResult;

package/dist/use-flash.d.ts

@@ -0,0 +1,61 @@
+/**
+ * A value that shows itself for a moment and then goes away.
+ *
+ * The "Copied" on a copy button, the "Saved" under an editor, the "Sent" on a
+ * submit. There were three hand-rolled copies of this — two in the studio
+ * front-end and one inside this package's own URL chips — each with the same
+ * 1500ms and the same comment explaining the same two things the naive version
+ * gets wrong. It is one primitive now, and it is PUBLIC because a custom chrome
+ * is exactly the caller that needs it: the moment a client renders its own copy
+ * button or its own save note, it is writing the timer again.
+ */
+/**
+ * What {@link useFlash} hands back.
+ *
+ * @typeParam T - What is being flashed. A `string` for a label; a record for a
+ *   flash that has to say WHICH thing it belongs to, as `useCopy` does.
+ *
+ * @public
+ */
+export type UseFlashResult<T> = {
+    /** What is being shown right now, or `null` between flashes. */
+    readonly value: T | null;
+    /** Show `value` for the hook's duration, replacing any flash already up. */
+    readonly flash: (value: T) => void;
+};
+/**
+ * A transient value: set it, and it clears itself after `ms`.
+ *
+ * @remarks
+ * The two things this holds that a `useState` plus a `setTimeout` at the call
+ * site reliably gets wrong:
+ *
+ * - **At most ONE live timer.** A second flash while the first is still up
+ *   re-arms rather than stacking, so the new value gets its full window
+ *   instead of being cleared early by the previous click's timeout.
+ * - **Nothing fires after unmount.** The timer is cleared on teardown, so a
+ *   chip clicked and then scrolled out of the tree does not `setState` on a
+ *   component React has already thrown away.
+ *
+ * @example
+ * ```tsx
+ * import { useFlash } from "@alexkroman1/aai-ui";
+ *
+ * function SaveNote({ onSave }: { onSave: () => Promise<void> }) {
+ *   const { value: note, flash } = useFlash<string>();
+ *   return (
+ *     <button type="button" onClick={() => void onSave().then(() => flash("Saved"))}>
+ *       {note ?? "Save"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ *
+ * @typeParam T - What is being flashed.
+ * @param ms - How long the value stays up. Defaults to 1500ms, which is what
+ *   every caller wanted: long enough to read a word, short enough that the
+ *   control is back to its real label before the reader looks again.
+ *
+ * @public
+ */
+export declare function useFlash<T>(ms?: number): UseFlashResult<T>;

package/dist/{use-user-transcript-DFTSEuZN.js → use-user-transcript-uyHhzy4d.js}

@@ -1,4 +1,5 @@
 import { useSessionSelector } from "./context.js";
+import { useMemo } from "react";
 //#region src/use-user-transcript.ts
 /**
 * `useUserTranscript` — what the caller is saying RIGHT NOW, read correctly.
@@ -57,11 +58,11 @@ const TRANSCRIBING_PLACEHOLDER = "…";
 */
 function useUserTranscript() {
 	const partial = useSessionSelector((snapshot) => snapshot.userTranscript);
-	return {
+	return useMemo(() => ({
 		speaking: partial !== null,
 		text: displayText(partial),
 		partial
-	};
+	}), [partial]);
 }
 /** The three cases, spelled out: silent, detected-but-wordless, and words. */
 function displayText(partial) {

package/dist/use-workflow-form.d.ts

@@ -31,7 +31,7 @@
  * `wait` here when the page really does want one request, and the run is
  * followed from the same id either way.
  */
-import type { AnyWorkflowDef, UploadParallel, UploadProgress, WorkflowOutputOf } from "@alexkroman1/aai/workflow-api";
+import type { AnyWorkflowDef, UploadParallelOption, UploadProgress, WorkflowOutputOf } from "@alexkroman1/aai/workflow-api";
 import type { FormValues } from "./components/form-types.ts";
 import type { WorkflowApi, WorkflowRun } from "./workflow-client.ts";
 import type { SubmitInputOf } from "./workflow-def-types.ts";
@@ -119,6 +119,38 @@ export type WorkflowSubmission<R = unknown, I = unknown> = {
     cancel: () => Promise<boolean>;
     /** The run, once started, followed to completion. */
     run: WorkflowRun<R> | undefined;
+    /**
+     * True from `submit()` on this mount until `reset()` — did THIS page start
+     * the run it is showing?
+     *
+     * A page needs it to say the right sentence and cannot derive it: a run
+     * ADOPTED by the mount-time lookup after a reload looks exactly like one this
+     * page started. Six templates kept a `useState(false)` next to this hook, set
+     * it in their `onSubmit` and mirrored it in their `onClear` — shadow state
+     * for a fact only this hook can know, since it is the thing that decides
+     * between `submit()` and the recovery lookup. One of the six grew a fourth
+     * branch and had to move the whole note into its own module with its own
+     * spec, which is what a seam missing one layer down looks like.
+     *
+     * The RAW fact rather than a derived "recovered", deliberately: with `run`
+     * these are three states, not two, and the third is the one a page most needs
+     * to explain. `startedHere` is "you pressed the button"; `!startedHere &&
+     * !run` is the mount-time lookup still going; `!startedHere && run` is a run
+     * this browser started earlier, now in front of somebody who did not press
+     * anything. A boolean meaning only the last of those cannot express the
+     * middle one.
+     *
+     * @example
+     * ```ts
+     * declare const submission: import("@alexkroman1/aai-ui").WorkflowSubmission;
+     * const note = submission.startedHere
+     *   ? "You can close this tab or reload it — this page will find the run again."
+     *   : submission.run === undefined
+     *     ? "Looking for a run this tab started earlier…"
+     *     : "Still working on the run this tab started earlier. Reloading is safe.";
+     * ```
+     */
+    startedHere: boolean;
     /**
      * True from `submit()` until the run reaches a terminal status.
      *
@@ -214,7 +246,7 @@ export type UseWorkflowSubmitOptions = {
      * the default costs nothing where it would not have paid. See
      * `UploadOptions.parallel`.
      */
-    parallel?: UploadParallel;
+    parallel?: UploadParallelOption;
 };
 /**
  * Start a workflow from a form, and follow the run it creates.
@@ -250,4 +282,4 @@ export type UseWorkflowSubmitOptions = {
  *
  * @public
  */
-export declare function useWorkflowSubmit<D extends AnyWorkflowDef>(workflow: string, opts?: UseWorkflowSubmitOptions): WorkflowSubmission<WorkflowOutputOf<D>, SubmitInputOf<D>>;
+export declare function useWorkflowSubmit<D extends AnyWorkflowDef>(workflow: string, options?: UseWorkflowSubmitOptions): WorkflowSubmission<WorkflowOutputOf<D>, SubmitInputOf<D>>;

package/dist/use-workflow-progress.d.ts

@@ -129,7 +129,7 @@ export declare const DEFAULT_PROGRESS_POLL_MS = 5000;
  *
  * @public
  */
-export declare function useWorkflowProgress<T = string>(runId: string | undefined, opts?: {
+export declare function useWorkflowProgress<T = string>(runId: string | undefined, options?: {
     api?: WorkflowApi;
     namespace?: string;
     startIndex?: number;