@alexkroman1/aai-ui 13.2.0 → 13.3.0

package/dist/index.js

@@ -1,17 +1,17 @@
-import { n as fetchClientConfig } from "./client-config-BT_kWID5.js";
-import { i as AutoScroll, n as Markdown, r as useConversation, t as MessageList } from "./message-list-BJYyuIcR.js";
+import { n as fetchClientConfig } from "./client-config-DD820zHn.js";
+import { i as AutoScroll, n as Markdown, r as useConversation, t as MessageList } from "./message-list-C0pL7x41.js";
 import { ThemeProvider, useSession, useSessionSelector, useTheme } from "./context.js";
-import { r as inkTint } from "./_colors-j8XMToi9.js";
+import { r as inkTint } from "./_colors-CZ6OlPbL.js";
 import { Button } from "./components/button.js";
-import { n as ConsoleShell, t as ChatView } from "./chat-view-DDTtrh7N.js";
-import { n as setPageTitle } from "./_utils-B6498_bm.js";
+import { n as ConsoleShell, t as ChatView } from "./chat-view-Bv5VFJIE.js";
+import { n as setPageTitle } from "./_utils-CyzjK0gW.js";
 import { Controls } from "./components/controls.js";
-import { n as useUserTranscript } from "./use-user-transcript-C14qWFu2.js";
-import { n as ToolCallRow } from "./tool-call-block-tcPQAkcP.js";
+import { n as useUserTranscript } from "./use-user-transcript-DFTSEuZN.js";
+import { n as ToolCallRow } from "./tool-call-block-Bunc6rCw.js";
 import { SidebarLayout } from "./components/sidebar-layout.js";
 import { StartScreen } from "./components/start-screen.js";
-import { a as useWorkflowRun, c as isTerminal, n as useWorkflowProgress, o as useWorkflowApiRef, s as createWorkflowApi } from "./use-workflow-progress-Cu0SxMyg.js";
-import { t as createSessionCore } from "./session-core-DxBYsfHA.js";
+import { a as useWorkflowProgress, c as isTerminal, o as useWorkflowApiRef, r as useWorkflowRun, s as createWorkflowApi } from "./use-workflow-run-CXGEcM0l.js";
+import { t as createSessionCore } from "./session-core-C9elBIdu.js";
 import { client, mountRoot, resolveContainer } from "./define-client.js";
 import { useAgentState, useEvent, useToolCallStart, useToolResult } from "./hooks.js";
 import clsx from "clsx";
@@ -20,7 +20,7 @@ import { createContext, createElement, useCallback, useContext, useEffect, useId
 import { errorMessage } from "@alexkroman1/aai";
 import { formatBytes, isRecord, omitUndefined } from "@alexkroman1/aai/utils";
 import { createEpoch } from "@alexkroman1/aai/internal";
-//#region components/_form-readiness.ts
+//#region src/components/_form-readiness.ts
 /**
 * Whether a form's own fields exist yet.
 *
@@ -106,7 +106,7 @@ function useDeclareFieldsPending(pending) {
 	]);
 }
 //#endregion
-//#region components/_form-values.ts
+//#region src/components/_form-values.ts
 /**
 * Read one `<form>`'s named controls into a plain object.
 *
@@ -201,7 +201,7 @@ function dataUrl(file) {
 	});
 }
 //#endregion
-//#region components/form-fields.tsx
+//#region src/components/form-fields.tsx
 /** @jsxImportSource react */
 /**
 * The controls a form is made of — the shell, the six fields, and the styling
@@ -512,7 +512,7 @@ function FileField({ name, label, hint, className, read = "none", upload = false
 	});
 }
 //#endregion
-//#region components/form.tsx
+//#region src/components/form.tsx
 /** @jsxImportSource react */
 /**
 * Simple forms, for the pages that are not conversations.
@@ -654,7 +654,7 @@ function SubmitButton({ children, pending = false, pendingLabel = "Working…",
 	});
 }
 //#endregion
-//#region components/upload-progress.tsx
+//#region src/components/upload-progress.tsx
 /** @jsxImportSource react */
 /**
 * The track behind the fill, as a tint of the theme's own ink.
@@ -766,1287 +766,1341 @@ function UploadProgressBar({ upload, onPause, onResume, className }) {
 	});
 }
 //#endregion
-//#region _recover-run.ts
+//#region src/use-workflows.ts
 /**
-* Finding a run again when the page has lost its id.
-*
-* A run is durable and a page is not — which `useWorkflowRun`'s doc says, and
-* which was only half true of the hooks above it: the run id lived in plain
-* `useState`, so a refresh (or a same-tab navigation, or a crashed tab) left a
-* live run with nothing anywhere able to name it. The run really did continue;
-* the person really could not get back to it.
-*
-* `StartOptions.key` is the handle that survives that, and it always was — a
-* caller's own name for a run, indexed by the agent, read back with
-* `find(workflow, key)`. What was missing is the two lines that ASK. This is
-* them, plus the four decisions they turn out to carry.
-*
-* ## It is a MOUNT-time act, not "whenever there is no run"
-*
-* The tempting spelling is "if we hold no run id, look one up", and it breaks
-* `reset()`: a form put back to its initial state holds no run id, so the next
-* pass would re-adopt the very run the person had just dismissed — a Clear
-* button that clears nothing. So the lookup runs once per mount (and again only
-* if the KEY changes, which is a different person's run), and every later
-* absence of a run id is taken at face value.
-*
-* ## The lookup NEVER wins a race against a submit
+* The agent's declared workflows — what a form is rendered FROM.
 *
-* A person who reloads and immediately submits has started the run they want,
-* and an answer that was already in flight names an older one. The caller
-* therefore adopts through `current ?? found`: the recovered id fills an empty
-* slot and never replaces a full one.
+* Split out of `use-workflow-form.ts` at the 500-line cap, along the seam that
+* file's own doc already drew: it held "the two hooks a FORM needs", and only
+* one of them is about a RUN. This is the other one, and it shares nothing with
+* its former neighbours but the client ref every hook here uses — no state, no
+* run id, no upload.
+*/
+/**
+* Read the agent's declared workflows.
 *
-* ## A failed lookup is REPORTED
+* What `<WorkflowFields>` renders a form FROM: each summary carries the JSON
+* Schema of that workflow's input, converted server-side precisely so a browser
+* can read it.
 *
-* The alternative is a page that quietly shows an empty form to somebody whose
-* run is live, who then starts a second one — the duplicated work the key
-* exists to prevent, and on a workflow app that is real money. A person who has
-* never run anything pays a banner they can ignore. Same trade as
-* `useWorkflows`, for the same reason: an empty answer here is a confident
-* false statement.
+* The failure is reported rather than swallowed, because the alternative is an
+* empty list — which renders as a form with no fields and reads as "this agent
+* declares no workflows" about an agent that was merely unreachable.
 *
-* ## It is OPT-IN
+* @example
+* ```tsx
+* import { useWorkflows } from "@alexkroman1/aai-ui";
 *
-* A `key` on its own still means only "record this with the run", which is what
-* a voice agent's `ctx.workflows.start({ key })` means and what a page passing
-* an account id may well want. Adopting a run is a decision about the PAGE, so
-* it is `recover: true` and the two together read as what they do.
-*/
-/**
-* Look up the newest run for a key, once, as the component mounts.
+* // A page rendering its own chrome from the listing — a picker, say. A form
+* // for ONE workflow wants `<WorkflowFields workflow="name" />` instead,
+* // which does this lookup itself.
+* function WorkflowPicker({ onPick }: { onPick: (name: string) => void }) {
+*   const { workflows, loading, error } = useWorkflows();
+*   if (loading) return <p>Loading…</p>;
+*   if (error !== undefined) return <p role="alert">{error}</p>;
+*   return (
+*     <ul>
+*       {workflows.map((summary) => (
+*         <li key={summary.name}>
+*           <button type="button" onClick={() => onPick(summary.name)}>
+*             {summary.description ?? summary.name}
+*           </button>
+*         </li>
+*       ))}
+*     </ul>
+*   );
+* }
+* ```
 *
-* @param opts - See {@link RecoverRunOptions}.
-* @returns Whether the lookup is still out. A caller folds it into its own
-*   `pending`, because a form offering Submit while a live run is arriving is a
-*   form inviting a second one.
+* @param opts - See {@link UseWorkflowsOptions}.
+* @returns The listing, its loading flag and its failure — see
+* {@link UseWorkflowsResult}.
 *
-* @internal
+* @public
 */
-function useRecoveredRun(opts) {
-	const { workflow, key, enabled, getClient } = opts;
-	const [recovering, setRecovering] = useState(enabled && key !== void 0);
-	const handlers = useRef(opts);
-	handlers.current = opts;
+function useWorkflows(opts = {}) {
+	const { api, skip = false } = opts;
+	const [state, setState] = useState({
+		workflows: [],
+		loading: !skip,
+		error: void 0
+	});
+	const getClient = useWorkflowApiRef(api);
 	useEffect(() => {
-		if (!enabled || key === void 0) return;
+		if (skip) return;
 		let cancelled = false;
-		setRecovering(true);
-		getClient().find(workflow, key, { limit: 1 }).then((found) => {
-			if (cancelled) return;
-			const newest = found[0];
-			if (newest !== void 0) handlers.current.onFound(newest.runId);
-			setRecovering(false);
+		getClient().list().then((workflows) => {
+			if (!cancelled) setState({
+				workflows,
+				loading: false,
+				error: void 0
+			});
 		}).catch((err) => {
 			if (cancelled) return;
-			handlers.current.onError(errorMessage(err));
-			setRecovering(false);
+			setState({
+				workflows: [],
+				loading: false,
+				error: errorMessage(err)
+			});
 		});
 		return () => {
 			cancelled = true;
 		};
-	}, [
-		enabled,
-		key,
-		workflow,
-		getClient
-	]);
-	return recovering;
+	}, [skip, getClient]);
+	return state;
 }
 //#endregion
-//#region _run-controls.ts
+//#region src/components/workflow-fields.tsx
+/** @jsxImportSource react */
 /**
-* The two things a page does TO a run it started, bound to the run it has.
-*
-* `useWorkflowSubmit` and `useWorkflowStream` both hold a run id and neither
-* handed it back, so a page that wanted "send it now" or "stop" had to hold an
-* `api` of its own purely to write `api.wake(runId)` — which is the whole reason
-* the two raw-primitive template pages keep a client at module scope. That is a
-* page carrying the transport to make up for a hook withholding its own state.
+* A form built from a workflow's declared input schema.
 *
-* Both calls answer rather than fail when there is nothing to act on — `0`
-* sleeps ended, `false` this call did not end it — which is the SDK's own
-* contract for them (two tabs pressing Stop is ordinary), and it is what lets
-* the no-run case be the same answer rather than a special one a caller has to
-* branch on.
-*/
-/**
-* Bind `wake` and `cancel` to whatever run the hook is currently following.
+* `GET workflows` reports each workflow's `inputSchema` as JSON Schema — the
+* zod schema an author wrote in `agent.ts`, converted at listing time precisely
+* so a browser can read it. This is what reads it: one `<WorkflowFields>` and a
+* workflow's form matches its schema by construction, so adding a field to the
+* schema adds it to the page and nothing can drift.
 *
-* @param runId - The live run, or `undefined` before one exists.
-* @param getClient - The stable getter from `useWorkflowApiRef`.
-* @returns Two callbacks, stable while `runId` is.
+* ## It covers SCALARS, and says so rather than guessing
 *
-* @internal
+* A string, number, integer, boolean or enum has one obvious control each. A
+* nested object or an array does not — every choice (a JSON textarea, a repeater,
+* a comma-separated string) is a guess about what the author meant, and a guess
+* that produces a value the schema then rejects is worse than no field at all.
+* So those are SKIPPED, and the fields for them are written by hand: every field
+* in this package is a plain named control, so a hand-written one composes with
+* a generated one inside the same {@link Form}.
 */
-function useRunControls(runId, getClient) {
-	return {
-		wake: useCallback(async () => {
-			if (runId === void 0) return 0;
-			return await getClient().wake(runId);
-		}, [runId, getClient]),
-		cancel: useCallback(async () => {
-			if (runId === void 0) return false;
-			return await getClient().cancel(runId);
-		}, [runId, getClient])
-	};
-}
-//#endregion
-//#region _upload-recall.ts
 /**
-* Where an upload's ID survives a page RELOAD.
-*
-* A streamed upload is resumable because its id outlives the attempt that began
-* it — `_upload-files.ts` says so, and `_upload-session.ts` turns that into a
-* pause a person can press. Both of them hold the id in MEMORY: the walk's
-* `UploadSession` lives in a `useRef`, so a reload was the one interruption the
-* mechanism could not survive. Everything else was already in place — the windows
-* were still in the store, the agent could still name them
-* (`UploadInfo.ranges`), and the id was minted in the browser — and the browser
-* had thrown away the only name for them. So a person who refreshed at 90% of a
-* 200 MB recording sent the whole file again, which is the one interruption they
-* are most likely to cause on purpose.
-*
-* This is that name, written down. It is what tus-js-client's `urlStorage` and
-* Uppy's Golden Retriever sell, in the shape `session-resume-store.ts` already
-* uses for a session id.
+* Render one field per scalar property of a workflow's input schema.
 *
-* ## A FINGERPRINT, because a `File` has no name a page can address
+* Pass the workflow's NAME and the schema is fetched here; pass a
+* {@link WorkflowSummary} you already hold and nothing is fetched. The name form
+* is the one a page usually wants — it is the same string the submit hook takes,
+* and the alternative is three lines (`useWorkflows()`, a `.find()` by name, and
+* folding that lookup's error into the form's) whose only product is this
+* component's argument.
 *
-* A file from a picker carries no path and no handle, so the key is what
-* tus-js-client fingerprints on: size, last-modified, type and name. Two
-* different files agreeing on all four is the case this cannot tell apart — and
-* the reason NOTHING here decides to resume. `_upload-files.ts` asks the agent
-* what the id actually holds before sending a byte to it, so a wrong hit costs
-* one `GET` and a fresh id rather than a corrupted upload.
+* Renders nothing when the workflow declared no schema — a workflow with no
+* declared input takes anything, and a form for "anything" is not a form — and
+* nothing while a named lookup is still in flight, so the hand-written fields
+* beside it are not reordered when the schema lands.
 *
-* ## `sessionStorage`, deliberately
+* @example
+* ```tsx no-check
+* import { Form, SubmitButton, WorkflowFields, useWorkflowSubmit }
+*   from "@alexkroman1/aai-ui";
+* import type { transcribe } from "./agent.ts";
 *
-* The same call `session-resume-store.ts` makes, for a reason that happens to be
-* stronger here: a reload and a same-tab navigation are exactly what this is for,
-* and an id from yesterday names an upload the agent's sweep has very likely
-* already collected. A tab is also the boundary the walk itself has — two tabs
-* uploading the same recording are two submissions.
+* function StartRun() {
+*   const { submitForm, pending, error } = useWorkflowSubmit<typeof transcribe>("transcribe");
+*   return (
+*     <Form onSubmit={submitForm} error={error}>
+*       <WorkflowFields workflow="transcribe" />
+*       <SubmitButton pending={pending}>Transcribe</SubmitButton>
+*     </Form>
+*   );
+* }
+* ```
 *
-* Every access is guarded. Storage throws outright in Safari private mode and
-* under a blocking policy, and an upload that cannot be REMEMBERED must degrade
-* to the upload we would have done anyway rather than failing to start.
-*/
-const PREFIX$1 = "aai:upload:";
-/**
-* How many ids one form keeps.
+* @param props - Field-set props.
 *
-* A cap rather than an expiry, because `sessionStorage` already expires with the
-* tab and an entry is ~80 bytes. What it bounds is the long-lived tab that
-* submits a hundred files: the oldest go first, and the id most likely to be
-* worth resuming is the one written last.
+* @public
 */
-const MAX_REMEMBERED = 32;
-/** One form's slot in storage. */
-function keyFor(scope) {
-	return `${PREFIX$1}${scope}`;
+function WorkflowFields({ workflow }) {
+	const { workflows, loading } = useWorkflows(typeof workflow === "string" ? {} : { skip: true });
+	const summary = typeof workflow === "string" ? workflows.find((entry) => entry.name === workflow) : workflow;
+	useDeclareFieldsPending(loading);
+	const schema = asObjectSchema(summary?.inputSchema);
+	if (!schema?.properties) return null;
+	const required = new Set(schema.required ?? []);
+	const uploads = new Set(summary?.uploads ?? []);
+	return /* @__PURE__ */ jsx(Fragment, { children: Object.entries(schema.properties).map(([name, property]) => /* @__PURE__ */ jsx(SchemaField, {
+		name,
+		property,
+		required: required.has(name),
+		upload: uploads.has(name)
+	}, name)) });
 }
-/**
-* What names this file across a reload.
-*
-* The four fields a browser gives a picked file that do not change between loads.
-* `name` last because it is the one a person can read in a debugger.
-*/
-function fingerprint(file) {
-	return `${file.size}:${file.lastModified}:${file.type}:${file.name}`;
-}
-/** This scope's remembered ids, or nothing at all — a parse failure is nothing. */
-function read(scope) {
-	try {
-		const raw = globalThis.sessionStorage?.getItem(keyFor(scope));
-		if (raw === null || raw === void 0) return {};
-		const parsed = JSON.parse(raw);
-		return isRecord(parsed) ? parsed : {};
-	} catch {
-		return {};
+/** One property's control, or nothing when its type has no obvious one. */
+function SchemaField({ name, property, required, upload = false }) {
+	const label = humanize(name);
+	const hint = property.description === void 0 ? {} : { hint: property.description };
+	const defaults = property.default === void 0 ? {} : { defaultValue: String(property.default) };
+	if (upload) return /* @__PURE__ */ jsx(FileField, {
+		name,
+		label,
+		required,
+		upload: true,
+		...hint
+	});
+	if (Array.isArray(property.enum) && property.enum.length > 0) return /* @__PURE__ */ jsx(SelectField, {
+		name,
+		label,
+		required,
+		options: property.enum.map((value) => String(value)),
+		...hint,
+		...defaults
+	});
+	const type = typeOf(property);
+	switch (type) {
+		case "boolean": return /* @__PURE__ */ jsx(CheckboxField, {
+			name,
+			label,
+			defaultChecked: property.default === true,
+			...hint
+		});
+		case "number":
+		case "integer": return /* @__PURE__ */ jsx(NumberField, {
+			name,
+			label,
+			required,
+			step: type === "integer" ? 1 : "any",
+			...hint,
+			...defaults
+		});
+		case "string": return /* @__PURE__ */ jsx(TextField, {
+			name,
+			label,
+			required,
+			...hint,
+			...defaults
+		});
+		default: return null;
 	}
 }
-function write(scope, entries) {
-	try {
-		globalThis.sessionStorage?.setItem(keyFor(scope), JSON.stringify(entries));
-	} catch {}
+/** A property's type, taking the first non-null member of a union. */
+function typeOf(property) {
+	const { type } = property;
+	if (typeof type === "string") return type;
+	return Array.isArray(type) ? type.find((member) => member !== "null") : void 0;
+}
+/** The listing's `unknown` schema as the object shape this reads, when it is one. */
+function asObjectSchema(schema) {
+	return isRecord(schema) ? schema : void 0;
 }
 /**
-* The id this file was last being stored under in this tab, if any.
-*
-* A hit is a CANDIDATE and never a decision — see the module doc.
+* A property name as a label — `recordingId` → `Recording id`.
 *
-* @internal
+* A default, not a policy: a schema whose labels matter should carry a
+* `.describe()`, and an author who wants exact control writes the field.
 */
-function recallUploadId(scope, file) {
-	const found = read(scope)[fingerprint(file)];
-	return typeof found === "string" ? found : void 0;
+function humanize(name) {
+	const spaced = name.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").trim().toLowerCase();
+	return spaced.charAt(0).toUpperCase() + spaced.slice(1);
 }
+//#endregion
+//#region src/components/workflow-progress.tsx
+/** @jsxImportSource react */
 /**
-* Remember the id this file is being stored under.
+* What a run has said so far, rendered.
 *
-* Called before the first byte leaves rather than after the last one lands: the
-* reload this exists for happens in between, and an id written at the end is an
-* id written for the one case that did not need it.
+* The complement of a status line, and the reason both exist: a run is
+* `running` for its whole life, so a one-round job and a ten-round one look
+* identical while they happen. These lines come from the run itself (`report()`
+* in a `"use step"` body), which is the only channel a workflow has before it
+* produces an output.
 *
-* @internal
+* Three rules are baked in, and they are why this is a component rather than
+* three lines each page writes for itself — the two templates that had written
+* it had written all three, comments included:
+*
+* - **It renders nothing until there is something to render.** `supported` is
+*   what keeps this from being an empty box forever on an agent deployed before
+*   progress streams existed: "wrote nothing yet" and "serves no stream" are
+*   indistinguishable from the chunk list alone.
+* - **The lines are TEXT, not elements.** They are append-only and two rounds
+*   legitimately produce identical text, so there is no stable per-line key to
+*   give React. Joining sidesteps the question instead of suppressing the lint
+*   rule that asks it.
+* - **They REPLAY.** Chunks are retained with the run, so a reload mid-run —
+*   or opening a finished run tomorrow — shows how it got there rather than an
+*   empty box. That is `useWorkflowProgress`'s doing; this is what makes it
+*   visible.
+*
+* @example
+* ```tsx
+* import { WorkflowProgress } from "@alexkroman1/aai-ui";
+*
+* function RunPanel({ runId }: { runId: string }) {
+*   return <WorkflowProgress runId={runId} />;
+* }
+* ```
+*
+* @param props - Progress-log props.
+*
+* @public
 */
-function rememberUploadId(scope, file, id) {
-	const entries = read(scope);
-	const key = fingerprint(file);
-	delete entries[key];
-	entries[key] = id;
-	const keys = Object.keys(entries);
-	for (const stale of keys.slice(0, Math.max(0, keys.length - MAX_REMEMBERED))) delete entries[stale];
-	write(scope, entries);
+function WorkflowProgress({ runId, api, className, placeholder, lines }) {
+	const { progress, streaming, supported } = useWorkflowProgress(runId, omitUndefined({ api }));
+	const shown = lines === void 0 ? progress : progress.slice(Math.max(progress.length - lines, 0));
+	if (!supported || shown.length === 0) return placeholder ?? null;
+	return /* @__PURE__ */ jsxs("pre", {
+		className: clsx(className ?? "whitespace-pre-wrap border-l pl-4 text-xs opacity-70"),
+		children: [shown.join("\n"), streaming && "\n…"]
+	});
 }
+//#endregion
+//#region src/page.tsx
+/** @jsxImportSource react */
 /**
-* Forget it: the agent holds nothing resumable under this id.
+* `page()` — mount a WORKFLOW APP's UI: React, theme, no session.
 *
-* The other half of the agent deciding. Without it a swept upload is re-read on
-* every submission of the same file for the life of the tab, which is a round
-* trip spent learning the same 404.
+* The twin of `client()` for an agent whose front door is a form rather than a
+* microphone (`workflowApp()`). It is a separate entry rather than
+* an option on `client()` because of what `client()` unavoidably does: it
+* constructs a `SessionCore`, which owns a WebSocket URL provider, an audio
+* graph, and a microphone request. A flag would have to make all of that
+* conditional, and every session hook would then have to answer "what does this
+* mean with no session?" — so the honest split is two mounts. A page that wants
+* voice uses `client()`; a page that wants neither audio nor a socket uses this.
 *
-* @internal
+* Authoring is otherwise identical — the file is still `client.tsx`, still
+* React, still Tailwind, still the same theme tokens — so a workflow app reads
+* like every other agent. What it reaches for instead of `useSession()` is
+* `createWorkflowApi()` / `useWorkflowRun()`.
 */
-function forgetUploadId(scope, file) {
-	const entries = read(scope);
-	const key = fingerprint(file);
-	if (!(key in entries)) return;
-	delete entries[key];
-	write(scope, entries);
-}
-//#endregion
-//#region _upload-session.ts
-/** Whether this rejection is an abort, in either of the two shapes runtimes throw. */
-function isAbortError(err) {
-	return err instanceof Error && err.name === "AbortError";
-}
-/** A fresh upload id: a capability, so it is random rather than derived. */
-function randomUploadId() {
-	return crypto.randomUUID().replaceAll("-", "");
-}
 /**
-* Send one file, waiting out however many pauses the person takes.
+* Mount a page for an agent whose work happens in workflows.
 *
-* The loop from the module doc, written once: both hooks need exactly this and a
-* second copy of it is a second place for the abort/pause distinction to be got
-* wrong. `send` is handed whether this attempt must CLAIM the id as its own —
-* false the first time, since a fresh id has nothing to resume and saying
-* otherwise waives the refusal that makes a caller-chosen id safe.
+* There is deliberately no session, no microphone, and no socket: the component
+* talks to the agent over the workflow HTTP API
+* (`createWorkflowApi`/`useWorkflowRun`), which is durable and outlives the tab.
 *
-* Throws whatever `send` threw, except an abort the gate caused. A cancelled gate
-* throws too: the caller distinguishes it by reading `gate.cancelled`, which is
-* how an abandoned submission unwinds without being reported as a failure.
+* @example
+* ```tsx
+* import { createWorkflowApi, page, useWorkflowRun } from "@alexkroman1/aai-ui";
+* import { useState } from "react";
+*
+* // Hoisted: a client built in render is a new object every render.
+* const api = createWorkflowApi();
+*
+* function App() {
+*   const [runId, setRunId] = useState<string>();
+*   const { run } = useWorkflowRun(runId, { api });
+*   return (
+*     <button
+*       type="button"
+*       onClick={() => void api.start("digest", { topic: "ai" }).then(setRunId)}
+*     >
+*       {run ? run.status : "Start"}
+*     </button>
+*   );
+* }
+*
+* page({ name: "Digest", component: App });
+* ```
+*
+* @throws If the target element is not found in the DOM.
+*
+* @public
 */
-async function sendThroughGate(gate, send) {
-	let tried = false;
-	for (;;) {
-		await gate.settle();
-		if (gate.cancelled) throw new Error("Upload cancelled.");
-		const resume = tried;
-		tried = true;
-		try {
-			await send(resume);
-			return;
-		} catch (err) {
-			if (gate.cancelled || !isAbortError(err)) throw err;
-		}
-	}
+function page(config) {
+	const container = resolveContainer(config.target);
+	setPageTitle(config.name);
+	return mountRoot(container, createElement(ThemeProvider, { value: config.theme }, createElement(config.component)));
 }
+//#endregion
+//#region src/use-download-url.ts
 /**
-* A gate, open.
+* `useDownloadUrl` — an upload id a run produced, as something `<audio>`,
+* `<img>` or `<a download>` will accept.
 *
-* One per upload rather than one per hook: the id and the windows already stored
-* belong to a file, so a gate that outlived its file would resume something else.
-*/
-function createUploadGate() {
-	let controller = new AbortController();
-	let paused = false;
-	let cancelled = false;
-	let open;
-	let closed;
-	return {
-		get paused() {
-			return paused;
-		},
-		get cancelled() {
-			return cancelled;
-		},
-		get signal() {
-			return controller.signal;
-		},
-		pause() {
-			if (paused || cancelled) return;
-			paused = true;
-			const gate = Promise.withResolvers();
-			closed = gate.promise;
-			open = gate.resolve;
-			controller.abort();
-		},
-		resume() {
-			if (!paused || cancelled) return;
-			paused = false;
-			controller = new AbortController();
-			open?.();
-			open = void 0;
-			closed = void 0;
-		},
-		cancel() {
-			if (cancelled) return;
-			cancelled = true;
-			paused = false;
-			controller.abort();
-			open?.();
-			open = void 0;
-			closed = void 0;
-		},
-		async settle() {
-			if (closed) await closed;
-		}
-	};
-}
-//#endregion
-//#region _workflow-files.ts
-/**
-* Which of a submitted form's values are FILES.
+* `api.download(id)` resolves a `Blob`, and it has to: the byte route takes the
+* same bearer every workflow route does, and neither `<audio src>` nor
+* `<a href>` can send one. So every page that plays back what a run WROTE ends
+* up at the same four lines — `download` → `createObjectURL` → state — and the
+* two that are really the point are the two the four lines are wrapped in:
 *
-* Its own module because both submit hooks need the identical answer and then do
-* two different things with it — `useWorkflowSubmit` stores each file and passes
-* its id, `useWorkflowStream` cuts it into parts and passes the group they share.
-* A second copy of this predicate would be a form field that one hook treats as a
-* file and the other does not, which is invisible until the run reads the wrong
-* kind of string.
-*/
-/**
-* The files a submitted field carries, if that is what it carries.
+* - **`URL.revokeObjectURL` on cleanup.** An object URL pins its blob for the
+*   life of the DOCUMENT. Miss it and every completed run's audio stays resident
+*   until the tab closes, which on a page people run all day is a leak measured
+*   in the size of the files.
+* - **A `cancelled` flag.** A second run settling while the first download is
+*   still in flight otherwise sets state from the stale one, and the page plays
+*   the previous run's audio under the current run's transcript — a wrong answer
+*   that looks like a right one.
 *
-* An array counts only when it is files ALL the way through — a mixed array is
-* some other field's value that happens to contain one, and turning half of it
-* into ids would corrupt it silently.
+* Two templates had written this hook, identically, doc paragraph included, and
+* `aai-ui` exported no download helper at all. Both also faked `pending` by
+* checking `url === undefined && error === undefined`, which reads "idle" and
+* "downloading" as the same thing — so this reports it.
 */
-function filesOf(value) {
-	if (value instanceof File) return [value];
-	if (!Array.isArray(value)) return [];
-	const files = value.filter((one) => one instanceof File);
-	return files.length > 0 && files.length === value.length ? files : [];
-}
+/** No id: nothing pending, nothing to show. A shared object so `setState` no-ops. */
+const IDLE = { pending: false };
+/** Bytes in flight. Shared for the same reason as {@link IDLE}. */
+const PENDING = { pending: true };
 /**
-* The input properties still carrying a `File` — i.e. the ones that CANNOT survive
-* being sent.
+* Read an upload's bytes and hand back a URL a DOM element can use.
 *
-* A run input is JSON, and `JSON.stringify(new File(…))` is `{}` — no `toJSON`, no
-* own enumerable properties. So a File left in a payload does not fail to send: it
-* arrives as an empty object, and the workflow rejects it against whatever its own
-* schema says the property should be. Measured in production as
-* `Invalid input for workflow "transcribe": recording: Invalid input` — a message
-* about a type, on a form where the user had picked a perfectly good file.
+* @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}.
+* @returns See {@link UseDownloadUrlResult}.
 *
-* Exported beside {@link filesOf} because it is the same question asked at the
-* other end: that one decides which fields to UPLOAD, this one checks that none
-* were missed. Both hooks are the callers.
-*/
-function fileFields(input) {
-	if (!isRecord(input)) return [];
-	return Object.entries(input).filter(([, value]) => filesOf(value).length > 0).map(([key]) => key);
-}
-//#endregion
-//#region _upload-files.ts
-/**
-* Turning a form's `File`s into stored upload ids, pauses and all.
+* @example
+* ```tsx no-check
+* import { useDownloadUrl, useWorkflowSubmit } from "@alexkroman1/aai-ui";
+* import type { spokenSummary } from "./agent.ts";
 *
-* Split out of `use-workflow-form.ts` for the 500-line cap, and the seam is a
-* real one: that module is the two HOOKS and the state between them, where this
-* is the walk over a submitted input — which is the only part of it that knows
-* what a `File` is, holds a loop, and survives being re-entered.
+* function Playback() {
+*   const { run } = useWorkflowSubmit<typeof spokenSummary>("spokenSummary");
+*   const output = run?.status === "completed" ? run.output : undefined;
+*   const audio = useDownloadUrl(output?.audio);
+*   if (audio.pending) return <p>Fetching audio…</p>;
+*   if (audio.error !== undefined) return <p role="alert">{audio.error}</p>;
+*   return audio.url === undefined ? null : (
+*     <a href={audio.url} download="summary.mp3">
+*       Download
+*     </a>
+*   );
+* }
+* ```
 *
-* `_`-internal. `useWorkflowSubmit` is the only caller; `useWorkflowStream` sends
-* one file rather than walking an input and shares only the gate underneath both
-* (`_upload-session.ts`).
+* @public
 */
-/** A fresh session for one submission of `workflow`. */
-function createUploadSession(workflow) {
-	return {
-		scope: workflow,
-		ids: /* @__PURE__ */ new Map(),
-		stored: /* @__PURE__ */ new Map(),
-		tried: /* @__PURE__ */ new Set(),
-		gate: createUploadGate()
-	};
+function useDownloadUrl(uploadId, opts = {}) {
+	const [state, setState] = useState(IDLE);
+	const getClient = useWorkflowApiRef(opts.api);
+	useEffect(() => {
+		if (uploadId === void 0) {
+			setState(IDLE);
+			return;
+		}
+		let cancelled = false;
+		let objectUrl;
+		setState(PENDING);
+		getClient().download(uploadId).then((blob) => {
+			if (cancelled) return;
+			objectUrl = URL.createObjectURL(blob);
+			setState({
+				url: objectUrl,
+				pending: false
+			});
+		}).catch((err) => {
+			if (!cancelled) setState({
+				error: errorMessage(err),
+				pending: false
+			});
+		});
+		return () => {
+			cancelled = true;
+			if (objectUrl !== void 0) URL.revokeObjectURL(objectUrl);
+		};
+	}, [uploadId, getClient]);
+	return state;
 }
+//#endregion
+//#region src/use-run-key.ts
 /**
-* The id to store this file under: the one a previous page load was using, or a
-* fresh one.
+* The handle a page keeps on the runs it started, across a reload.
 *
-* **The AGENT decides, never the fingerprint.** Two files can agree on every
-* field `_upload-recall.ts` keys by, so the recalled id is a candidate that has to
-* be checked before a byte is sent to it — and the check is cheap and exact,
-* because `uploadInfo` is the same record a resume already reads.
+* `useWorkflowSubmit` is what makes a run survivable — the run id is that
+* hook's own state, so a refresh loses it while the run carries on — and the
+* `key` is what it looks the run up BY, because it is a lookup CAPABILITY:
+* there is no per-user filtering behind `find`, so the key IS the scoping
+* mechanism. Choosing one is easy to get wrong in three separate ways, and six
+* shipped templates had each written the same twenty lines to get it right.
+* This is those lines.
+*
+* **`useWorkflowSubmit` now mints one for itself** ({@link useDefaultRunKey}),
+* so a page resumes its own run across a reload with nothing written at the
+* call site — six of six page templates passed `useRunKey()` and
+* `recover: true`, which is a default in the wrong place. The hook stays
+* PUBLIC for the page that wants to choose: an app with accounts passes the
+* ACCOUNT's own id instead, and a run then follows the person to a new device,
+* which is a promise only a login can keep; a page whose run outlives the tab
+* passes `useRunKey({ storage: "local" })`.
 *
-* Three answers, and the third is why this is not just a storage lookup:
+* ## Three properties, and the rejected alternatives are why each one matters
 *
-* - **Complete.** Every byte is in from a load that is gone, so there is nothing
-*   to send: the caller takes the id and starts the run. This is the refresh that
-*   costs one `GET` instead of a second 200 MB upload.
-* - **Unfinished, with windows.** `UploadInfo.ranges` is what makes an
-*   upload resumable at all, so the id is reused and the attempt claims it.
-* - **Anything else.** A 404 (swept, or never seen), a failure, or an unfinished
-*   upload reporting NO windows — which is a partial single `PUT`, and a second
-*   `PUT` to that id is a 409 rather than an append (`streamUploadFile`). Reusing
-*   it would turn a reload into a failure the person cannot clear, so the entry is
-*   dropped and the file gets a fresh id.
-*/
-async function claimId(api, session, file) {
-	const remembered = recallUploadId(session.scope, file);
-	if (remembered === void 0) return {
-		id: randomUploadId(),
-		complete: false
-	};
-	const info = await api.uploadInfo(remembered).catch(() => void 0);
-	if (info?.complete === true) return {
-		id: remembered,
-		complete: true
-	};
-	if (info !== void 0 && (info.ranges?.length ?? 0) > 0) {
-		session.tried.add(file);
-		return {
-			id: remembered,
-			complete: false
-		};
-	}
-	forgetUploadId(session.scope, file);
-	return {
-		id: randomUploadId(),
-		complete: false
-	};
-}
-/**
-* Replace every `File` in a submitted form with the id of a stored upload,
-* reporting how far each one has got.
+* - **Opaque** — `crypto.randomUUID()`, never derived from what was submitted.
+*   A key derived from the input collides the moment two people submit the same
+*   thing, and they then recover each other's runs; it also carries what they
+*   typed into a lookup token the platform deliberately stopped logging.
+* - **Short.** A `randomUUID` is 36 characters, well inside the 256 that
+*   `POST /workflows/runs` allows a key.
+* - **Minted once per load and written back for the next one**, which is the
+*   whole mechanism: the load that presses the button records the key with the
+*   run, and the load after it finds the run by producing the same key.
 *
-* Sequential rather than `Promise.all`: these are large bodies, and a form with
-* two 200 MB recordings should send them one after another rather than compete
-* for the same connection. That is also what makes a single bar honest — one
-* file is in flight at a time, and `index`/`count` say which.
+* Storage rather than the page's own URL, for all of them. A `?key=` parameter
+* survives more (a new tab, a bookmark, a shared link) and that is the problem:
+* a URL is pasted into chats, copied into referrers and kept in history, and
+* what a leaked one buys is somebody else's work — reading it, and `cancel()` on
+* it. An app with accounts should pass the ACCOUNT's own id here instead, and
+* then a run follows the person to a new device, which is a promise only a login
+* can keep.
 *
-* Anything that is not a `File` (or an array of them) passes through untouched,
-* so this is invisible to every form that has none — including one whose values
-* are not an object at all, which `submit` accepts.
+* ## The storage is the caller's decision, and it is not a detail
 *
-* ## `uploadStream`, not `upload`, and the id is the reason
+* `"session"` (the default) dies with the tab, which covers exactly the
+* interruption most pages have — a reload, a same-tab navigation, a crashed tab
+* — and is the same lifetime as this package's other two stores, the session
+* resume id (`session-resume-store.ts`) and the upload recall
+* (`_upload-recall.ts`), so both halves of a reload make the same promise.
 *
-* The difference between the two calls is only who mints the id — and that is
-* exactly what decides whether an interrupted upload can be picked up again. An
-* `upload` mints its own at the END and hands it back, so a caller whose upload
-* died has nothing to name what was stored and no choice but to send the file
-* again. A `uploadStream` is told the id up front, so the windows already in the
-* store are addressable, which is what both a pause and a server restart need.
+* `"local"` is for a run that outlives all of that BY DESIGN — one that sleeps
+* between digests and may live a month, where closing the browser on Tuesday and
+* coming back on Friday to press Stop is the ordinary case rather than an edge
+* one, and a tab-scoped key would answer that with an empty form beside a run
+* still posting somewhere. It is as far as a key can go without a login, and no
+* further. `podcast-digest` is that template, and the reason this hook is still
+* called by name anywhere; the other five take the tab-scoped default the
+* submit hook mints for them.
 *
-* Nothing else about the submission changes: the run is still started after the
-* last byte lands, so the incomplete record a streamed upload leaves along the
-* way is one nobody reads.
+* ## Anything ELSE a page stores back must be VALIDATED on read
+*
+* This key needs no validation, and it is worth saying why, because it is the
+* exception: any string is a legal key, so a value from storage can only fail to
+* match a run. A page that remembers something more — which MODE submitted, say
+* — is remembering a value it will turn into a name, and storage hands back a
+* string some earlier version of that page wrote: a renamed mode, a hand-edited
+* value, a slot another app on the origin happens to share. Unchecked, that
+* starts a run called `undefined` and answers a 400 nobody typed. Check it
+* against the page's own list on the way out (`recalledMode` in
+* `transcription-workflow/recover.ts` is the worked example) — the recall is the
+* page's, the validation is not optional.
+*
+* ## The slot is keyed by the page's own URL
+*
+* Every deployed agent is served from one origin at `/:slug/`, so a fixed name
+* would have two agents scaffolded from the same template recover each other's
+* runs. The key is the page's own directory — resolved through `"./"`, which
+* drops the query and the hash, since a reload carrying `?foo` or `#bar` has to
+* find the same key. Same call `session-resume-store.ts` makes, for the same
+* reason.
+*
+* One key per PAGE is right even for a page driving several workflows: `find` is
+* scoped by workflow as well as by key, so three hooks sharing one key recover
+* three separate runs. `transcription-workflow` is that page.
+*
+* Every access is guarded. Storage THROWS outright in some contexts (Safari
+* private mode, an iframe blocked by policy) and is ABSENT in others (any
+* server-side render), and a page that cannot remember its key must degrade to
+* the behaviour it would have had anyway — one run per load — rather than
+* failing to render.
 */
-async function uploadFiles(api, input, report, parallel, session) {
-	if (!isRecord(input)) return input;
-	const entries = Object.entries(input);
-	const count = entries.reduce((total, [, value]) => total + filesOf(value).length, 0);
-	let index = 0;
-	const store = async (file) => {
-		index += 1;
-		const done = session.stored.get(file);
-		if (done !== void 0) return done;
-		const position = {
-			name: file.name,
-			index,
-			count
-		};
-		const known = session.ids.get(file);
-		const claimed = known === void 0 ? await claimId(api, session, file) : {
-			id: known,
-			complete: false
-		};
-		const id = claimed.id;
-		if (known === void 0) {
-			session.ids.set(file, id);
-			rememberUploadId(session.scope, file, id);
-		}
-		if (claimed.complete) {
-			report({
-				...position,
-				loaded: file.size,
-				total: file.size,
-				fraction: 1,
-				paused: false
-			});
-			session.stored.set(file, id);
-			return id;
-		}
-		await sendThroughGate(session.gate, async (resume) => {
-			await api.uploadStream(id, file, {
-				name: file.name,
-				signal: session.gate.signal,
-				onProgress: (progress) => report({
-					...position,
-					...progress,
-					paused: session.gate.paused
-				}),
-				...omitUndefined({
-					parallel,
-					resume: resume || session.tried.has(file) ? true : void 0
-				})
-			});
-		});
-		session.stored.set(file, id);
-		return id;
-	};
-	const out = {};
-	for (const [name, value] of entries) {
-		if (value instanceof File) {
-			out[name] = await store(value);
-			continue;
-		}
-		const chosen = filesOf(value);
-		if (chosen.length === 0) {
-			out[name] = value;
-			continue;
-		}
-		const ids = [];
-		for (const file of chosen) ids.push(await store(file));
-		out[name] = ids;
+/** Where a run key lives, namespaced like this package's two other stores. */
+const PREFIX$1 = "aai:run-key:";
+/** This page's own slot — see "The slot is keyed by the page's own URL". */
+function slotFor() {
+	const href = globalThis.location?.href;
+	if (href === void 0) return PREFIX$1;
+	try {
+		return `${PREFIX$1}${new URL("./", href).href}`;
+	} catch {
+		return `${PREFIX$1}${href}`;
 	}
-	return out;
 }
-//#endregion
-//#region _upload-pause.ts
 /**
-* The two buttons a page puts over a live upload, bound to whichever gate the
-* submission is currently holding.
+* Read the key this page already has, or mint and remember one.
 *
-* `useWorkflowSubmit` and `useWorkflowStream` both own an {@link UploadGate} and
-* both reported the pause the same way: park the gate, then fold `paused` into
-* the status the bar is already drawing. Folded rather than replaced, because
-* everything else about that status — which file, how far, of how many — is
-* still true. Two copies of that rule are two copies that can stop agreeing
-* about what a paused bar says.
+* Not exported: a page that wants a key wants it for the life of a component,
+* which is what the hook is. Calling this per render would mint a fresh key and
+* hand `recover` one nothing was ever started under.
 */
+function mintRunKey(storage) {
+	try {
+		const store = storage === "local" ? globalThis.localStorage : globalThis.sessionStorage;
+		const slot = slotFor();
+		const stored = store?.getItem(slot);
+		if (stored !== null && stored !== void 0) return stored;
+		const minted = crypto.randomUUID();
+		store?.setItem(slot, minted);
+		return minted;
+	} catch {
+		return crypto.randomUUID();
+	}
+}
 /**
-* Bind pause/resume to the live submission's gate.
+* The key `useWorkflowSubmit` uses when the page named none.
 *
-* @param getGate - Reads the gate out of the caller's ref, so the callbacks stay
-*   stable across submissions rather than being re-created per gate.
-* @param setUpload - The status setter the progress bar renders from.
+* Two things it does that a plain `useRunKey()` at the call site cannot, and
+* both are about a page that DID name one:
+*
+* - **It mints nothing when the caller has a key.** Minting writes to storage,
+*   so an unconditional `useRunKey()` inside the hook would leave a slot behind
+*   on every page that passes an account id and never reads it back.
+* - **It stays reactive to the caller's key.** A key that arrives late — an
+*   account id resolved after a login — must reach the lookup, which re-asks on
+*   a changed key by design; freezing it into `useState` would pin the page to
+*   whatever it held on its first render.
+*
+* The minted half is still frozen for the component's life, which is what
+* `useRunKey` freezes it for: a fresh key per render would record every run
+* under a name the next load cannot produce.
+*
+* @param explicit - The caller's own key, or undefined for a page with none.
+* @returns The key to record runs under and look them up by.
 *
 * @internal
 */
-function useUploadPause(getGate, setUpload) {
-	const setPaused = useCallback((paused) => {
-		setUpload((current) => current ? {
-			...current,
-			paused
-		} : current);
-	}, [setUpload]);
-	return {
-		pauseUpload: useCallback(() => {
-			getGate()?.pause();
-			setPaused(true);
-		}, [getGate, setPaused]),
-		resumeUpload: useCallback(() => {
-			getGate()?.resume();
-			setPaused(false);
-		}, [getGate, setPaused])
-	};
+function useDefaultRunKey(explicit) {
+	const [minted] = useState(() => explicit === void 0 ? mintRunKey("session") : crypto.randomUUID());
+	return explicit ?? minted;
 }
-//#endregion
-//#region use-workflow-form.ts
 /**
-* The two hooks a FORM needs, as against the one a status view does.
+* A lookup key for `useWorkflowSubmit({ key })`, stable across reloads.
 *
-* `useWorkflowRun` (`workflow-client.ts`) watches a run you already have.
-* These two are what comes before it: `useWorkflows` reads the declared
-* workflows so `<WorkflowFields>` can render a form from a schema, and
-* `useWorkflowSubmit` starts a run and hands the id straight to
-* `useWorkflowRun`.
+* @param options - See the module doc for the whole argument. The storage kind
+*   is read once, when the key is minted: a value that changed afterwards would
+*   be asking to move a key that has already been recorded with a run.
+* @returns The key to record runs under and to look them up by — the same one
+*   for the life of the component, and for the next load in the same tab (or the
+*   same browser, under `"local"`).
+*/
+function useRunKey(options = {}) {
+	const { storage = "session" } = options;
+	const [key] = useState(() => mintRunKey(storage));
+	return key;
+}
+//#endregion
+//#region src/_recover-run.ts
+/**
+* Finding a run again when the page has lost its id.
 *
-* ## `useWorkflowSubmit` — a form's two halves in one hook
+* A run is durable and a page is not — which `useWorkflowRun`'s doc says, and
+* which was only half true of the hooks above it: the run id lived in plain
+* `useState`, so a refresh (or a same-tab navigation, or a crashed tab) left a
+* live run with nothing anywhere able to name it. The run really did continue;
+* the person really could not get back to it.
 *
-* A page that submits a workflow always needs the same four pieces of state:
-* the run id, whether a submit is in flight, whether the RUN is still going, and
-* whichever of the two failed. `link-digest` writes them out by hand, which is
-* the right shape for a template teaching the primitives and the wrong shape to
-* write a third time — and it is easy to get subtly wrong: dropping the previous
-* run id before the new `POST` returns is what stops a finished result sitting
-* under a form that is already submitting again.
+* `StartOptions.key` is the handle that survives that, and it always was — a
+* caller's own name for a run, indexed by the agent, read back with
+* `find(workflow, key)`. What was missing is the two lines that ASK. This is
+* them, plus the four decisions they turn out to carry.
 *
-* So this is `api.start` plus {@link useWorkflowRun}, with the state between
-* them. It adds no transport of its own and holds no run state of its own; the
-* watching (stream first, poll as its fallback, terminal stops) is entirely
-* `useWorkflowRun`'s, and `run` here IS its run.
+* ## It is a MOUNT-time act, not "whenever there is no run"
 *
-* ## Why it starts ASYNCHRONOUSLY even though a synchronous call exists
+* The tempting spelling is "if we hold no run id, look one up", and it breaks
+* `reset()`: a form put back to its initial state holds no run id, so the next
+* pass would re-adopt the very run the person had just dismissed — a Clear
+* button that clears nothing. So the lookup runs once per mount (and again only
+* if the KEY changes, which is a different person's run), and every later
+* absence of a run id is taken at face value.
 *
-* `api.startAndWait` would collapse this to one request, and it is the wrong
-* default for a page: it holds a socket open for up to a minute, answers nothing
-* until it settles, and a page has `useWorkflowRun` — which survives a reload,
-* shows progress, and costs one stream. The synchronous call is for callers with
-* nowhere to put a watch (a script, a cron, a form POST from a server). Pass
-* `wait` here when the page really does want one request, and the run is
-* followed from the same id either way.
-*/
-/**
-* Read the agent's declared workflows.
+* ## The lookup NEVER wins a race against a submit
 *
-* What `<WorkflowFields>` renders a form FROM: each summary carries the JSON
-* Schema of that workflow's input, converted server-side precisely so a browser
-* can read it.
+* A person who reloads and immediately submits has started the run they want,
+* and an answer that was already in flight names an older one. The caller
+* therefore adopts through `current ?? found`: the recovered id fills an empty
+* slot and never replaces a full one.
 *
-* The failure is reported rather than swallowed, because the alternative is an
-* empty list — which renders as a form with no fields and reads as "this agent
-* declares no workflows" about an agent that was merely unreachable.
+* ## A failed lookup is REPORTED
 *
-* @example
-* ```tsx
-* import { useWorkflows } from "@alexkroman1/aai-ui";
+* The alternative is a page that quietly shows an empty form to somebody whose
+* run is live, who then starts a second one — the duplicated work the key
+* exists to prevent, and on a workflow app that is real money. A person who has
+* never run anything pays a banner they can ignore. Same trade as
+* `useWorkflows`, for the same reason: an empty answer here is a confident
+* false statement.
 *
-* // A page rendering its own chrome from the listing — a picker, say. A form
-* // for ONE workflow wants `<WorkflowFields workflow="name" />` instead,
-* // which does this lookup itself.
-* function WorkflowPicker({ onPick }: { onPick: (name: string) => void }) {
-*   const { workflows, loading, error } = useWorkflows();
-*   if (loading) return <p>Loading…</p>;
-*   if (error !== undefined) return <p role="alert">{error}</p>;
-*   return (
-*     <ul>
-*       {workflows.map((summary) => (
-*         <li key={summary.name}>
-*           <button type="button" onClick={() => onPick(summary.name)}>
-*             {summary.description ?? summary.name}
-*           </button>
-*         </li>
-*       ))}
-*     </ul>
-*   );
-* }
-* ```
+* ## It is ON by default, and it used to be opt-in
 *
-* @param opts - See {@link UseWorkflowsOptions}.
-* @returns The listing, its loading flag and its failure — see
-* {@link UseWorkflowsResult}.
+* The argument for opt-in was that a `key` on its own means only "record this
+* with the run" — which is what a voice agent's `ctx.workflows.start({ key })`
+* means, there being no page to put a run back on. A FORM is the other case: it
+* is the page, and losing the run is the thing it cannot recover from. Six of
+* six page templates wrote `useRunKey()` and `recover: true` together, which is
+* the same shape `session-resume-store.ts` names on the voice side — a default
+* in the wrong place — so `useWorkflowSubmit` now mints the key and asks.
 *
-* @public
+* `enabled` remains, because `recover: false` remains: a page whose form must
+* always open empty says so, and then nothing here runs.
 */
-function useWorkflows(opts = {}) {
-	const { api, skip = false } = opts;
-	const [state, setState] = useState({
-		workflows: [],
-		loading: !skip,
-		error: void 0
-	});
-	const getClient = useWorkflowApiRef(api);
+/**
+* Look up the newest run for a key, once, as the component mounts.
+*
+* @param opts - See {@link RecoverRunOptions}.
+* @returns Whether the lookup is still out. A caller folds it into its own
+*   `pending`, because a form offering Submit while a live run is arriving is a
+*   form inviting a second one.
+*
+* @internal
+*/
+function useRecoveredRun(opts) {
+	const { workflow, key, enabled, getClient } = opts;
+	const [recovering, setRecovering] = useState(enabled && key !== void 0);
+	const handlers = useRef(opts);
+	handlers.current = opts;
 	useEffect(() => {
-		if (skip) return;
+		if (!enabled || key === void 0) return;
 		let cancelled = false;
-		getClient().list().then((workflows) => {
-			if (!cancelled) setState({
-				workflows,
-				loading: false,
-				error: void 0
-			});
+		setRecovering(true);
+		getClient().find(workflow, key, { limit: 1 }).then((found) => {
+			if (cancelled) return;
+			const newest = found[0];
+			if (newest !== void 0) handlers.current.onFound(newest.runId);
+			setRecovering(false);
 		}).catch((err) => {
 			if (cancelled) return;
-			setState({
-				workflows: [],
-				loading: false,
-				error: errorMessage(err)
-			});
+			handlers.current.onError(errorMessage(err));
+			setRecovering(false);
 		});
 		return () => {
 			cancelled = true;
 		};
-	}, [skip, getClient]);
-	return state;
+	}, [
+		enabled,
+		key,
+		workflow,
+		getClient
+	]);
+	return recovering;
 }
+//#endregion
+//#region src/_run-controls.ts
 /**
-* Start a workflow from a form, and follow the run it creates.
-*
-* @typeParam D - The workflow DEFINITION, which types both halves of the
-*   submission: `submit(input)` takes what the workflow's schema parses to, and
-*   `run.status === "completed"` narrows to a typed `run.output`.
+* The two things a page does TO a run it started, bound to the run it has.
 *
-*   It used to be the OUTPUT type alone, and the asymmetry was the bug: a page
-*   already wrote `WorkflowOutputOf<typeof digest>` to get the output, while
-*   `submit` took `unknown`, so `submit({ ur1: 42 })` compiled and arrived as a
-*   400 in the browser. Naming the def instead types the input from the same
-*   declaration — and `import type` is ERASED, so it costs the bundle nothing.
-*   Passing an output type where a def belongs is now a compile error rather
-*   than a silent loss of typing, which is the point.
+* `useWorkflowSubmit` and `useWorkflowStream` both hold a run id and neither
+* handed it back, so a page that wanted "send it now" or "stop" had to hold an
+* `api` of its own purely to write `api.wake(runId)` — which is the whole reason
+* the two raw-primitive template pages keep a client at module scope. That is a
+* page carrying the transport to make up for a hook withholding its own state.
 *
-* @example
-* ```tsx no-check
-* import { Form, SubmitButton, TextField, useWorkflowSubmit } from "@alexkroman1/aai-ui";
-* import type { digest } from "./agent.ts";
+* Both calls answer rather than fail when there is nothing to act on — `0`
+* sleeps ended, `false` this call did not end it — which is the SDK's own
+* contract for them (two tabs pressing Stop is ordinary), and it is what lets
+* the no-run case be the same answer rather than a special one a caller has to
+* branch on.
+*/
+/**
+* Bind `wake` and `cancel` to whatever run the hook is currently following.
 *
-* function DigestForm() {
-*   const { submit, run, pending, error } = useWorkflowSubmit<typeof digest>("digest");
-*   return (
-*     <Form onSubmit={(values) => submit(values)} error={error}>
-*       <TextField name="url" label="Link" type="url" required />
-*       <SubmitButton pending={pending}>Digest</SubmitButton>
-*       {run?.status === "completed" && <p>{run.output.title}</p>}
-*     </Form>
-*   );
-* }
-* ```
+* @param runId - The live run, or `undefined` before one exists.
+* @param getClient - The stable getter from `useWorkflowApiRef`.
+* @returns Two callbacks, stable while `runId` is.
 *
-* @public
+* @internal
 */
-function useWorkflowSubmit(workflow, opts = {}) {
-	const { api, key, recover = false, wait, intervalMs, parallel } = opts;
-	const [runId, setRunId] = useState(void 0);
-	const [starting, setStarting] = useState(false);
-	const [startError, setStartError] = useState(void 0);
-	const [upload, setUpload] = useState(void 0);
-	const session = useRef(void 0);
-	const getClient = useWorkflowApiRef(api);
-	const tracked = useWorkflowRun(runId, omitUndefined({
-		api,
-		intervalMs
-	}));
-	const { wake, cancel } = useRunControls(runId, getClient);
-	const recovering = useRecoveredRun({
-		workflow,
-		key,
-		enabled: recover,
-		getClient,
-		onFound: (found) => {
-			setRunId((current) => current ?? found);
-		},
-		onError: setStartError
-	});
-	const submit = useCallback(async (input) => {
-		const client = getClient();
-		setStarting(true);
-		setStartError(void 0);
-		setRunId(void 0);
-		session.current?.gate.cancel();
-		const current = createUploadSession(workflow);
-		session.current = current;
-		try {
-			const options = omitUndefined({ key });
-			const started = await uploadFiles(client, input, setUpload, parallel, current);
-			setRunId(wait === void 0 ? await client.start(workflow, started, options) : (await client.startAndWait(workflow, started, {
-				...options,
-				wait
-			})).runId);
-		} catch (err) {
-			if (!current.gate.cancelled) setStartError(errorMessage(err));
-		} finally {
-			if (session.current === current) {
-				session.current = void 0;
-				setStarting(false);
-				setUpload(void 0);
-			}
-		}
-	}, [
-		workflow,
-		key,
-		wait,
-		parallel,
-		getClient
-	]);
-	const reset = useCallback(() => {
-		session.current?.gate.cancel();
-		session.current = void 0;
-		setRunId(void 0);
-		setStartError(void 0);
-		setUpload(void 0);
-	}, []);
-	const { pauseUpload, resumeUpload } = useUploadPause(useCallback(() => session.current?.gate, []), setUpload);
+function useRunControls(runId, getClient) {
 	return {
-		submit,
-		submitForm: submit,
-		reset,
-		wake,
-		cancel,
-		pauseUpload,
-		resumeUpload,
-		run: tracked.run,
-		pending: recovering || starting || tracked.polling,
-		upload,
-		error: startError ?? tracked.error
+		wake: useCallback(async () => {
+			if (runId === void 0) return 0;
+			return await getClient().wake(runId);
+		}, [runId, getClient]),
+		cancel: useCallback(async () => {
+			if (runId === void 0) return false;
+			return await getClient().cancel(runId);
+		}, [runId, getClient])
 	};
 }
 //#endregion
-//#region components/workflow-fields.tsx
-/** @jsxImportSource react */
+//#region src/_upload-recall.ts
 /**
-* A form built from a workflow's declared input schema.
-*
-* `GET workflows` reports each workflow's `inputSchema` as JSON Schema — the
-* zod schema an author wrote in `agent.ts`, converted at listing time precisely
-* so a browser can read it. This is what reads it: one `<WorkflowFields>` and a
-* workflow's form matches its schema by construction, so adding a field to the
-* schema adds it to the page and nothing can drift.
-*
-* ## It covers SCALARS, and says so rather than guessing
+* Where an upload's ID survives a page RELOAD.
 *
-* A string, number, integer, boolean or enum has one obvious control each. A
-* nested object or an array does not — every choice (a JSON textarea, a repeater,
-* a comma-separated string) is a guess about what the author meant, and a guess
-* that produces a value the schema then rejects is worse than no field at all.
-* So those are SKIPPED, and the fields for them are written by hand: every field
-* in this package is a plain named control, so a hand-written one composes with
-* a generated one inside the same {@link Form}.
-*/
-/**
-* Render one field per scalar property of a workflow's input schema.
+* A streamed upload is resumable because its id outlives the attempt that began
+* it — `_upload-files.ts` says so, and `_upload-session.ts` turns that into a
+* pause a person can press. Both of them hold the id in MEMORY: the walk's
+* `UploadSession` lives in a `useRef`, so a reload was the one interruption the
+* mechanism could not survive. Everything else was already in place — the windows
+* were still in the store, the agent could still name them
+* (`UploadInfo.ranges`), and the id was minted in the browser — and the browser
+* had thrown away the only name for them. So a person who refreshed at 90% of a
+* 200 MB recording sent the whole file again, which is the one interruption they
+* are most likely to cause on purpose.
 *
-* Pass the workflow's NAME and the schema is fetched here; pass a
-* {@link WorkflowSummary} you already hold and nothing is fetched. The name form
-* is the one a page usually wants — it is the same string the submit hook takes,
-* and the alternative is three lines (`useWorkflows()`, a `.find()` by name, and
-* folding that lookup's error into the form's) whose only product is this
-* component's argument.
+* This is that name, written down. It is what tus-js-client's `urlStorage` and
+* Uppy's Golden Retriever sell, in the shape `session-resume-store.ts` already
+* uses for a session id.
 *
-* Renders nothing when the workflow declared no schema — a workflow with no
-* declared input takes anything, and a form for "anything" is not a form — and
-* nothing while a named lookup is still in flight, so the hand-written fields
-* beside it are not reordered when the schema lands.
+* ## A FINGERPRINT, because a `File` has no name a page can address
 *
-* @example
-* ```tsx no-check
-* import { Form, SubmitButton, WorkflowFields, useWorkflowSubmit }
-*   from "@alexkroman1/aai-ui";
-* import type { transcribe } from "./agent.ts";
+* A file from a picker carries no path and no handle, so the key is what
+* tus-js-client fingerprints on: size, last-modified, type and name. Two
+* different files agreeing on all four is the case this cannot tell apart — and
+* the reason NOTHING here decides to resume. `_upload-files.ts` asks the agent
+* what the id actually holds before sending a byte to it, so a wrong hit costs
+* one `GET` and a fresh id rather than a corrupted upload.
 *
-* function StartRun() {
-*   const { submitForm, pending, error } = useWorkflowSubmit<typeof transcribe>("transcribe");
-*   return (
-*     <Form onSubmit={submitForm} error={error}>
-*       <WorkflowFields workflow="transcribe" />
-*       <SubmitButton pending={pending}>Transcribe</SubmitButton>
-*     </Form>
-*   );
-* }
-* ```
+* ## `sessionStorage`, deliberately
 *
-* @param props - Field-set props.
+* The same call `session-resume-store.ts` makes, for a reason that happens to be
+* stronger here: a reload and a same-tab navigation are exactly what this is for,
+* and an id from yesterday names an upload the agent's sweep has very likely
+* already collected. A tab is also the boundary the walk itself has — two tabs
+* uploading the same recording are two submissions.
 *
-* @public
+* Every access is guarded. Storage throws outright in Safari private mode and
+* under a blocking policy, and an upload that cannot be REMEMBERED must degrade
+* to the upload we would have done anyway rather than failing to start.
 */
-function WorkflowFields({ workflow }) {
-	const { workflows, loading } = useWorkflows(typeof workflow === "string" ? {} : { skip: true });
-	const summary = typeof workflow === "string" ? workflows.find((entry) => entry.name === workflow) : workflow;
-	useDeclareFieldsPending(loading);
-	const schema = asObjectSchema(summary?.inputSchema);
-	if (!schema?.properties) return null;
-	const required = new Set(schema.required ?? []);
-	const uploads = new Set(summary?.uploads ?? []);
-	return /* @__PURE__ */ jsx(Fragment, { children: Object.entries(schema.properties).map(([name, property]) => /* @__PURE__ */ jsx(SchemaField, {
-		name,
-		property,
-		required: required.has(name),
-		upload: uploads.has(name)
-	}, name)) });
-}
-/** One property's control, or nothing when its type has no obvious one. */
-function SchemaField({ name, property, required, upload = false }) {
-	const label = humanize(name);
-	const hint = property.description === void 0 ? {} : { hint: property.description };
-	const defaults = property.default === void 0 ? {} : { defaultValue: String(property.default) };
-	if (upload) return /* @__PURE__ */ jsx(FileField, {
-		name,
-		label,
-		required,
-		upload: true,
-		...hint
-	});
-	if (Array.isArray(property.enum) && property.enum.length > 0) return /* @__PURE__ */ jsx(SelectField, {
-		name,
-		label,
-		required,
-		options: property.enum.map((value) => String(value)),
-		...hint,
-		...defaults
-	});
-	const type = typeOf(property);
-	switch (type) {
-		case "boolean": return /* @__PURE__ */ jsx(CheckboxField, {
-			name,
-			label,
-			defaultChecked: property.default === true,
-			...hint
-		});
-		case "number":
-		case "integer": return /* @__PURE__ */ jsx(NumberField, {
-			name,
-			label,
-			required,
-			step: type === "integer" ? 1 : "any",
-			...hint,
-			...defaults
-		});
-		case "string": return /* @__PURE__ */ jsx(TextField, {
-			name,
-			label,
-			required,
-			...hint,
-			...defaults
-		});
-		default: return null;
-	}
-}
-/** A property's type, taking the first non-null member of a union. */
-function typeOf(property) {
-	const { type } = property;
-	if (typeof type === "string") return type;
-	return Array.isArray(type) ? type.find((member) => member !== "null") : void 0;
-}
-/** The listing's `unknown` schema as the object shape this reads, when it is one. */
-function asObjectSchema(schema) {
-	return isRecord(schema) ? schema : void 0;
-}
+const PREFIX = "aai:upload:";
 /**
-* A property name as a label — `recordingId` → `Recording id`.
+* How many ids one form keeps.
 *
-* A default, not a policy: a schema whose labels matter should carry a
-* `.describe()`, and an author who wants exact control writes the field.
+* A cap rather than an expiry, because `sessionStorage` already expires with the
+* tab and an entry is ~80 bytes. What it bounds is the long-lived tab that
+* submits a hundred files: the oldest go first, and the id most likely to be
+* worth resuming is the one written last.
 */
-function humanize(name) {
-	const spaced = name.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").trim().toLowerCase();
-	return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+const MAX_REMEMBERED = 32;
+/** One form's slot in storage. */
+function keyFor(scope) {
+	return `${PREFIX}${scope}`;
 }
-//#endregion
-//#region components/workflow-progress.tsx
-/** @jsxImportSource react */
 /**
-* What a run has said so far, rendered.
-*
-* The complement of a status line, and the reason both exist: a run is
-* `running` for its whole life, so a one-round job and a ten-round one look
-* identical while they happen. These lines come from the run itself (`report()`
-* in a `"use step"` body), which is the only channel a workflow has before it
-* produces an output.
-*
-* Three rules are baked in, and they are why this is a component rather than
-* three lines each page writes for itself — the two templates that had written
-* it had written all three, comments included:
-*
-* - **It renders nothing until there is something to render.** `supported` is
-*   what keeps this from being an empty box forever on an agent deployed before
-*   progress streams existed: "wrote nothing yet" and "serves no stream" are
-*   indistinguishable from the chunk list alone.
-* - **The lines are TEXT, not elements.** They are append-only and two rounds
-*   legitimately produce identical text, so there is no stable per-line key to
-*   give React. Joining sidesteps the question instead of suppressing the lint
-*   rule that asks it.
-* - **They REPLAY.** Chunks are retained with the run, so a reload mid-run —
-*   or opening a finished run tomorrow — shows how it got there rather than an
-*   empty box. That is `useWorkflowProgress`'s doing; this is what makes it
-*   visible.
-*
-* @example
-* ```tsx
-* import { WorkflowProgress } from "@alexkroman1/aai-ui";
-*
-* function RunPanel({ runId }: { runId: string }) {
-*   return <WorkflowProgress runId={runId} />;
-* }
-* ```
-*
-* @param props - Progress-log props.
+* What names this file across a reload.
 *
-* @public
+* The four fields a browser gives a picked file that do not change between loads.
+* `name` last because it is the one a person can read in a debugger.
 */
-function WorkflowProgress({ runId, api, className, placeholder, lines }) {
-	const { progress, streaming, supported } = useWorkflowProgress(runId, omitUndefined({ api }));
-	const shown = lines === void 0 ? progress : progress.slice(Math.max(progress.length - lines, 0));
-	if (!supported || shown.length === 0) return placeholder ?? null;
-	return /* @__PURE__ */ jsxs("pre", {
-		className: clsx(className ?? "whitespace-pre-wrap border-l pl-4 text-xs opacity-70"),
-		children: [shown.join("\n"), streaming && "\n…"]
-	});
+function fingerprint(file) {
+	return `${file.size}:${file.lastModified}:${file.type}:${file.name}`;
+}
+/** This scope's remembered ids, or nothing at all — a parse failure is nothing. */
+function read(scope) {
+	try {
+		const raw = globalThis.sessionStorage?.getItem(keyFor(scope));
+		if (raw === null || raw === void 0) return {};
+		const parsed = JSON.parse(raw);
+		return isRecord(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function write(scope, entries) {
+	try {
+		globalThis.sessionStorage?.setItem(keyFor(scope), JSON.stringify(entries));
+	} catch {}
 }
-//#endregion
-//#region page.tsx
-/** @jsxImportSource react */
 /**
-* `page()` — mount a WORKFLOW APP's UI: React, theme, no session.
+* The id this file was last being stored under in this tab, if any.
 *
-* The twin of `client()` for an agent whose front door is a form rather than a
-* microphone (`workflowApp()`). It is a separate entry rather than
-* an option on `client()` because of what `client()` unavoidably does: it
-* constructs a `SessionCore`, which owns a WebSocket URL provider, an audio
-* graph, and a microphone request. A flag would have to make all of that
-* conditional, and every session hook would then have to answer "what does this
-* mean with no session?" — so the honest split is two mounts. A page that wants
-* voice uses `client()`; a page that wants neither audio nor a socket uses this.
+* A hit is a CANDIDATE and never a decision — see the module doc.
 *
-* Authoring is otherwise identical — the file is still `client.tsx`, still
-* React, still Tailwind, still the same theme tokens — so a workflow app reads
-* like every other agent. What it reaches for instead of `useSession()` is
-* `createWorkflowApi()` / `useWorkflowRun()`.
+* @internal
 */
+function recallUploadId(scope, file) {
+	const found = read(scope)[fingerprint(file)];
+	return typeof found === "string" ? found : void 0;
+}
 /**
-* Mount a page for an agent whose work happens in workflows.
-*
-* There is deliberately no session, no microphone, and no socket: the component
-* talks to the agent over the workflow HTTP API
-* (`createWorkflowApi`/`useWorkflowRun`), which is durable and outlives the tab.
-*
-* @example
-* ```tsx
-* import { createWorkflowApi, page, useWorkflowRun } from "@alexkroman1/aai-ui";
-* import { useState } from "react";
-*
-* // Hoisted: a client built in render is a new object every render.
-* const api = createWorkflowApi();
+* Remember the id this file is being stored under.
 *
-* function App() {
-*   const [runId, setRunId] = useState<string>();
-*   const { run } = useWorkflowRun(runId, { api });
-*   return (
-*     <button
-*       type="button"
-*       onClick={() => void api.start("digest", { topic: "ai" }).then(setRunId)}
-*     >
-*       {run ? run.status : "Start"}
-*     </button>
-*   );
-* }
+* Called before the first byte leaves rather than after the last one lands: the
+* reload this exists for happens in between, and an id written at the end is an
+* id written for the one case that did not need it.
 *
-* page({ name: "Digest", component: App });
-* ```
+* @internal
+*/
+function rememberUploadId(scope, file, id) {
+	const entries = read(scope);
+	const key = fingerprint(file);
+	delete entries[key];
+	entries[key] = id;
+	const keys = Object.keys(entries);
+	for (const stale of keys.slice(0, Math.max(0, keys.length - MAX_REMEMBERED))) delete entries[stale];
+	write(scope, entries);
+}
+/**
+* Forget it: the agent holds nothing resumable under this id.
 *
-* @throws If the target element is not found in the DOM.
+* The other half of the agent deciding. Without it a swept upload is re-read on
+* every submission of the same file for the life of the tab, which is a round
+* trip spent learning the same 404.
 *
-* @public
+* @internal
 */
-function page(config) {
-	const container = resolveContainer(config.target);
-	setPageTitle(config.name);
-	return mountRoot(container, createElement(ThemeProvider, { value: config.theme }, createElement(config.component)));
+function forgetUploadId(scope, file) {
+	const entries = read(scope);
+	const key = fingerprint(file);
+	if (!(key in entries)) return;
+	delete entries[key];
+	write(scope, entries);
 }
 //#endregion
-//#region use-download-url.ts
+//#region src/_upload-session.ts
+/** Whether this rejection is an abort, in either of the two shapes runtimes throw. */
+function isAbortError(err) {
+	return err instanceof Error && err.name === "AbortError";
+}
+/** A fresh upload id: a capability, so it is random rather than derived. */
+function randomUploadId() {
+	return crypto.randomUUID().replaceAll("-", "");
+}
 /**
-* `useDownloadUrl` — an upload id a run produced, as something `<audio>`,
-* `<img>` or `<a download>` will accept.
-*
-* `api.download(id)` resolves a `Blob`, and it has to: the byte route takes the
-* same bearer every workflow route does, and neither `<audio src>` nor
-* `<a href>` can send one. So every page that plays back what a run WROTE ends
-* up at the same four lines — `download` → `createObjectURL` → state — and the
-* two that are really the point are the two the four lines are wrapped in:
+* Send one file, waiting out however many pauses the person takes.
 *
-* - **`URL.revokeObjectURL` on cleanup.** An object URL pins its blob for the
-*   life of the DOCUMENT. Miss it and every completed run's audio stays resident
-*   until the tab closes, which on a page people run all day is a leak measured
-*   in the size of the files.
-* - **A `cancelled` flag.** A second run settling while the first download is
-*   still in flight otherwise sets state from the stale one, and the page plays
-*   the previous run's audio under the current run's transcript — a wrong answer
-*   that looks like a right one.
+* The loop from the module doc, written once: both hooks need exactly this and a
+* second copy of it is a second place for the abort/pause distinction to be got
+* wrong. `send` is handed whether this attempt must CLAIM the id as its own —
+* false the first time, since a fresh id has nothing to resume and saying
+* otherwise waives the refusal that makes a caller-chosen id safe.
 *
-* Two templates had written this hook, identically, doc paragraph included, and
-* `aai-ui` exported no download helper at all. Both also faked `pending` by
-* checking `url === undefined && error === undefined`, which reads "idle" and
-* "downloading" as the same thing — so this reports it.
+* Throws whatever `send` threw, except an abort the gate caused. A cancelled gate
+* throws too: the caller distinguishes it by reading `gate.cancelled`, which is
+* how an abandoned submission unwinds without being reported as a failure.
 */
-/** No id: nothing pending, nothing to show. A shared object so `setState` no-ops. */
-const IDLE = { pending: false };
-/** Bytes in flight. Shared for the same reason as {@link IDLE}. */
-const PENDING = { pending: true };
+async function sendThroughGate(gate, send) {
+	let tried = false;
+	for (;;) {
+		await gate.settle();
+		if (gate.cancelled) throw new Error("Upload cancelled.");
+		const resume = tried;
+		tried = true;
+		try {
+			await send(resume);
+			return;
+		} catch (err) {
+			if (gate.cancelled || !isAbortError(err)) throw err;
+		}
+	}
+}
 /**
-* Read an upload's bytes and hand back a URL a DOM element can use.
-*
-* @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}.
-* @returns See {@link UseDownloadUrlResult}.
-*
-* @example
-* ```tsx no-check
-* import { useDownloadUrl, useWorkflowSubmit } from "@alexkroman1/aai-ui";
-* import type { spokenSummary } from "./agent.ts";
-*
-* function Playback() {
-*   const { run } = useWorkflowSubmit<typeof spokenSummary>("spokenSummary");
-*   const output = run?.status === "completed" ? run.output : undefined;
-*   const audio = useDownloadUrl(output?.audio);
-*   if (audio.pending) return <p>Fetching audio…</p>;
-*   if (audio.error !== undefined) return <p role="alert">{audio.error}</p>;
-*   return audio.url === undefined ? null : (
-*     <a href={audio.url} download="summary.mp3">
-*       Download
-*     </a>
-*   );
-* }
-* ```
+* A gate, open.
 *
-* @public
+* One per upload rather than one per hook: the id and the windows already stored
+* belong to a file, so a gate that outlived its file would resume something else.
 */
-function useDownloadUrl(uploadId, opts = {}) {
-	const [state, setState] = useState(IDLE);
-	const getClient = useWorkflowApiRef(opts.api);
-	useEffect(() => {
-		if (uploadId === void 0) {
-			setState(IDLE);
-			return;
-		}
-		let cancelled = false;
-		let objectUrl;
-		setState(PENDING);
-		getClient().download(uploadId).then((blob) => {
+function createUploadGate() {
+	let controller = new AbortController();
+	let paused = false;
+	let cancelled = false;
+	let open;
+	let closed;
+	return {
+		get paused() {
+			return paused;
+		},
+		get cancelled() {
+			return cancelled;
+		},
+		get signal() {
+			return controller.signal;
+		},
+		pause() {
+			if (paused || cancelled) return;
+			paused = true;
+			const gate = Promise.withResolvers();
+			closed = gate.promise;
+			open = gate.resolve;
+			controller.abort();
+		},
+		resume() {
+			if (!paused || cancelled) return;
+			paused = false;
+			controller = new AbortController();
+			open?.();
+			open = void 0;
+			closed = void 0;
+		},
+		cancel() {
 			if (cancelled) return;
-			objectUrl = URL.createObjectURL(blob);
-			setState({
-				url: objectUrl,
-				pending: false
-			});
-		}).catch((err) => {
-			if (!cancelled) setState({
-				error: errorMessage(err),
-				pending: false
-			});
-		});
-		return () => {
 			cancelled = true;
-			if (objectUrl !== void 0) URL.revokeObjectURL(objectUrl);
-		};
-	}, [uploadId, getClient]);
-	return state;
+			paused = false;
+			controller.abort();
+			open?.();
+			open = void 0;
+			closed = void 0;
+		},
+		async settle() {
+			if (closed) await closed;
+		}
+	};
 }
 //#endregion
-//#region use-run-key.ts
+//#region src/_workflow-files.ts
 /**
-* The handle a page keeps on the runs it started, across a reload.
-*
-* `useWorkflowSubmit({ key, recover: true })` is what makes a run survivable —
-* the run id is that hook's own state, so a refresh loses it while the run
-* carries on — and the `key` is deliberately the caller's to choose, because it
-* is a lookup CAPABILITY: there is no per-user filtering behind `find`, so the
-* key IS the scoping mechanism. Choosing one is easy to get wrong in three
-* separate ways, and six shipped templates had each written the same twenty
-* lines to get it right. This is those lines.
-*
-* ## Three properties, and the rejected alternatives are why each one matters
-*
-* - **Opaque** — `crypto.randomUUID()`, never derived from what was submitted.
-*   A key derived from the input collides the moment two people submit the same
-*   thing, and they then recover each other's runs; it also carries what they
-*   typed into a lookup token the platform deliberately stopped logging.
-* - **Short.** A `randomUUID` is 36 characters, well inside the 256 that
-*   `POST /workflows/runs` allows a key.
-* - **Minted once per load and written back for the next one**, which is the
-*   whole mechanism: the load that presses the button records the key with the
-*   run, and the load after it finds the run by producing the same key.
+* Which of a submitted form's values are FILES.
 *
-* Storage rather than the page's own URL, for all of them. A `?key=` parameter
-* survives more (a new tab, a bookmark, a shared link) and that is the problem:
-* a URL is pasted into chats, copied into referrers and kept in history, and
-* what a leaked one buys is somebody else's work — reading it, and `cancel()` on
-* it. An app with accounts should pass the ACCOUNT's own id here instead, and
-* then a run follows the person to a new device, which is a promise only a login
-* can keep.
+* Its own module because both submit hooks need the identical answer and then do
+* two different things with it — `useWorkflowSubmit` stores each file and passes
+* its id, `useWorkflowStream` cuts it into parts and passes the group they share.
+* A second copy of this predicate would be a form field that one hook treats as a
+* file and the other does not, which is invisible until the run reads the wrong
+* kind of string.
+*/
+/**
+* The files a submitted field carries, if that is what it carries.
 *
-* ## The storage is the caller's decision, and it is not a detail
+* An array counts only when it is files ALL the way through — a mixed array is
+* some other field's value that happens to contain one, and turning half of it
+* into ids would corrupt it silently.
+*/
+function filesOf(value) {
+	if (value instanceof File) return [value];
+	if (!Array.isArray(value)) return [];
+	const files = value.filter((one) => one instanceof File);
+	return files.length > 0 && files.length === value.length ? files : [];
+}
+/**
+* The input properties still carrying a `File` — i.e. the ones that CANNOT survive
+* being sent.
 *
-* `"session"` (the default) dies with the tab, which covers exactly the
-* interruption most pages have — a reload, a same-tab navigation, a crashed tab
-* — and is the same lifetime as this package's other two stores, the session
-* resume id (`session-resume-store.ts`) and the upload recall
-* (`_upload-recall.ts`), so both halves of a reload make the same promise.
+* A run input is JSON, and `JSON.stringify(new File(…))` is `{}` — no `toJSON`, no
+* own enumerable properties. So a File left in a payload does not fail to send: it
+* arrives as an empty object, and the workflow rejects it against whatever its own
+* schema says the property should be. Measured in production as
+* `Invalid input for workflow "transcribe": recording: Invalid input` — a message
+* about a type, on a form where the user had picked a perfectly good file.
 *
-* `"local"` is for a run that outlives all of that BY DESIGN — one that sleeps
-* between digests and may live a month, where closing the browser on Tuesday and
-* coming back on Friday to press Stop is the ordinary case rather than an edge
-* one, and a tab-scoped key would answer that with an empty form beside a run
-* still posting somewhere. It is as far as a key can go without a login, and no
-* further. `podcast-digest` is that template; the other five ship the default.
+* Exported beside {@link filesOf} because it is the same question asked at the
+* other end: that one decides which fields to UPLOAD, this one checks that none
+* were missed. Both hooks are the callers.
+*/
+function fileFields(input) {
+	if (!isRecord(input)) return [];
+	return Object.entries(input).filter(([, value]) => filesOf(value).length > 0).map(([key]) => key);
+}
+//#endregion
+//#region src/_upload-files.ts
+/**
+* Turning a form's `File`s into stored upload ids, pauses and all.
 *
-* ## Anything ELSE a page stores back must be VALIDATED on read
+* Split out of `use-workflow-form.ts` for the 500-line cap, and the seam is a
+* real one: that module is the two HOOKS and the state between them, where this
+* is the walk over a submitted input — which is the only part of it that knows
+* what a `File` is, holds a loop, and survives being re-entered.
 *
-* This key needs no validation, and it is worth saying why, because it is the
-* exception: any string is a legal key, so a value from storage can only fail to
-* match a run. A page that remembers something more — which MODE submitted, say
-* — is remembering a value it will turn into a name, and storage hands back a
-* string some earlier version of that page wrote: a renamed mode, a hand-edited
-* value, a slot another app on the origin happens to share. Unchecked, that
-* starts a run called `undefined` and answers a 400 nobody typed. Check it
-* against the page's own list on the way out (`recalledMode` in
-* `transcription-workflow/recover.ts` is the worked example) — the recall is the
-* page's, the validation is not optional.
+* `_`-internal. `useWorkflowSubmit` is the only caller; `useWorkflowStream` sends
+* one file rather than walking an input and shares only the gate underneath both
+* (`_upload-session.ts`).
+*/
+/** A fresh session for one submission of `workflow`. */
+function createUploadSession(workflow) {
+	return {
+		scope: workflow,
+		ids: /* @__PURE__ */ new Map(),
+		stored: /* @__PURE__ */ new Map(),
+		tried: /* @__PURE__ */ new Set(),
+		gate: createUploadGate()
+	};
+}
+/**
+* The id to store this file under: the one a previous page load was using, or a
+* fresh one.
 *
-* ## The slot is keyed by the page's own URL
+* **The AGENT decides, never the fingerprint.** Two files can agree on every
+* field `_upload-recall.ts` keys by, so the recalled id is a candidate that has to
+* be checked before a byte is sent to it — and the check is cheap and exact,
+* because `uploadInfo` is the same record a resume already reads.
 *
-* Every deployed agent is served from one origin at `/:slug/`, so a fixed name
-* would have two agents scaffolded from the same template recover each other's
-* runs. The key is the page's own directory — resolved through `"./"`, which
-* drops the query and the hash, since a reload carrying `?foo` or `#bar` has to
-* find the same key. Same call `session-resume-store.ts` makes, for the same
-* reason.
+* Three answers, and the third is why this is not just a storage lookup:
 *
-* One key per PAGE is right even for a page driving several workflows: `find` is
-* scoped by workflow as well as by key, so three hooks sharing one key recover
-* three separate runs. `transcription-workflow` is that page.
-*
-* Every access is guarded. Storage THROWS outright in some contexts (Safari
-* private mode, an iframe blocked by policy) and is ABSENT in others (any
-* server-side render), and a page that cannot remember its key must degrade to
-* the behaviour it would have had anyway — one run per load — rather than
-* failing to render.
+* - **Complete.** Every byte is in from a load that is gone, so there is nothing
+*   to send: the caller takes the id and starts the run. This is the refresh that
+*   costs one `GET` instead of a second 200 MB upload.
+* - **Unfinished, with windows.** `UploadInfo.ranges` is what makes an
+*   upload resumable at all, so the id is reused and the attempt claims it.
+* - **Anything else.** A 404 (swept, or never seen), a failure, or an unfinished
+*   upload reporting NO windows — which is a partial single `PUT`, and a second
+*   `PUT` to that id is a 409 rather than an append (`streamUploadFile`). Reusing
+*   it would turn a reload into a failure the person cannot clear, so the entry is
+*   dropped and the file gets a fresh id.
 */
-/** Where a run key lives, namespaced like this package's two other stores. */
-const PREFIX = "aai:run-key:";
-/** This page's own slot — see "The slot is keyed by the page's own URL". */
-function slotFor() {
-	const href = globalThis.location?.href;
-	if (href === void 0) return PREFIX;
-	try {
-		return `${PREFIX}${new URL("./", href).href}`;
-	} catch {
-		return `${PREFIX}${href}`;
+async function claimId(api, session, file) {
+	const remembered = recallUploadId(session.scope, file);
+	if (remembered === void 0) return {
+		id: randomUploadId(),
+		complete: false
+	};
+	const info = await api.uploadInfo(remembered).catch(() => void 0);
+	if (info?.complete === true) return {
+		id: remembered,
+		complete: true
+	};
+	if (info !== void 0 && (info.ranges?.length ?? 0) > 0) {
+		session.tried.add(file);
+		return {
+			id: remembered,
+			complete: false
+		};
 	}
+	forgetUploadId(session.scope, file);
+	return {
+		id: randomUploadId(),
+		complete: false
+	};
 }
 /**
-* Read the key this page already has, or mint and remember one.
+* Replace every `File` in a submitted form with the id of a stored upload,
+* reporting how far each one has got.
 *
-* Not exported: a page that wants a key wants it for the life of a component,
-* which is what the hook is. Calling this per render would mint a fresh key and
-* hand `recover` one nothing was ever started under.
+* Sequential rather than `Promise.all`: these are large bodies, and a form with
+* two 200 MB recordings should send them one after another rather than compete
+* for the same connection. That is also what makes a single bar honest — one
+* file is in flight at a time, and `index`/`count` say which.
+*
+* Anything that is not a `File` (or an array of them) passes through untouched,
+* so this is invisible to every form that has none — including one whose values
+* are not an object at all, which `submit` accepts.
+*
+* ## `uploadStream`, not `upload`, and the id is the reason
+*
+* The difference between the two calls is only who mints the id — and that is
+* exactly what decides whether an interrupted upload can be picked up again. An
+* `upload` mints its own at the END and hands it back, so a caller whose upload
+* died has nothing to name what was stored and no choice but to send the file
+* again. A `uploadStream` is told the id up front, so the windows already in the
+* store are addressable, which is what both a pause and a server restart need.
+*
+* Nothing else about the submission changes: the run is still started after the
+* last byte lands, so the incomplete record a streamed upload leaves along the
+* way is one nobody reads.
 */
-function mintRunKey(storage) {
-	try {
-		const store = storage === "local" ? globalThis.localStorage : globalThis.sessionStorage;
-		const slot = slotFor();
-		const stored = store?.getItem(slot);
-		if (stored !== null && stored !== void 0) return stored;
-		const minted = crypto.randomUUID();
-		store?.setItem(slot, minted);
-		return minted;
-	} catch {
-		return crypto.randomUUID();
+async function uploadFiles(api, input, report, parallel, session) {
+	if (!isRecord(input)) return input;
+	const entries = Object.entries(input);
+	const count = entries.reduce((total, [, value]) => total + filesOf(value).length, 0);
+	let index = 0;
+	const store = async (file) => {
+		index += 1;
+		const done = session.stored.get(file);
+		if (done !== void 0) return done;
+		const position = {
+			name: file.name,
+			index,
+			count
+		};
+		const known = session.ids.get(file);
+		const claimed = known === void 0 ? await claimId(api, session, file) : {
+			id: known,
+			complete: false
+		};
+		const id = claimed.id;
+		if (known === void 0) {
+			session.ids.set(file, id);
+			rememberUploadId(session.scope, file, id);
+		}
+		if (claimed.complete) {
+			report({
+				...position,
+				loaded: file.size,
+				total: file.size,
+				fraction: 1,
+				paused: false
+			});
+			session.stored.set(file, id);
+			return id;
+		}
+		await sendThroughGate(session.gate, async (resume) => {
+			await api.uploadStream(id, file, {
+				name: file.name,
+				signal: session.gate.signal,
+				onProgress: (progress) => report({
+					...position,
+					...progress,
+					paused: session.gate.paused
+				}),
+				...omitUndefined({
+					parallel,
+					resume: resume || session.tried.has(file) ? true : void 0
+				})
+			});
+		});
+		session.stored.set(file, id);
+		return id;
+	};
+	const out = {};
+	for (const [name, value] of entries) {
+		if (value instanceof File) {
+			out[name] = await store(value);
+			continue;
+		}
+		const chosen = filesOf(value);
+		if (chosen.length === 0) {
+			out[name] = value;
+			continue;
+		}
+		const ids = [];
+		for (const file of chosen) ids.push(await store(file));
+		out[name] = ids;
 	}
+	return out;
 }
+//#endregion
+//#region src/_upload-pause.ts
 /**
-* A lookup key for `useWorkflowSubmit({ key, recover: true })`, stable across
-* reloads.
+* The two buttons a page puts over a live upload, bound to whichever gate the
+* submission is currently holding.
 *
-* @param options - See the module doc for the whole argument. The storage kind
-*   is read once, when the key is minted: a value that changed afterwards would
-*   be asking to move a key that has already been recorded with a run.
-* @returns The key to record runs under and to look them up by — the same one
-*   for the life of the component, and for the next load in the same tab (or the
-*   same browser, under `"local"`).
+* `useWorkflowSubmit` and `useWorkflowStream` both own an {@link UploadGate} and
+* both reported the pause the same way: park the gate, then fold `paused` into
+* the status the bar is already drawing. Folded rather than replaced, because
+* everything else about that status — which file, how far, of how many — is
+* still true. Two copies of that rule are two copies that can stop agreeing
+* about what a paused bar says.
 */
-function useRunKey(options = {}) {
-	const { storage = "session" } = options;
-	const [key] = useState(() => mintRunKey(storage));
-	return key;
+/**
+* Bind pause/resume to the live submission's gate.
+*
+* @param getGate - Reads the gate out of the caller's ref, so the callbacks stay
+*   stable across submissions rather than being re-created per gate.
+* @param setUpload - The status setter the progress bar renders from.
+*
+* @internal
+*/
+function useUploadPause(getGate, setUpload) {
+	const setPaused = useCallback((paused) => {
+		setUpload((current) => current ? {
+			...current,
+			paused
+		} : current);
+	}, [setUpload]);
+	return {
+		pauseUpload: useCallback(() => {
+			getGate()?.pause();
+			setPaused(true);
+		}, [getGate, setPaused]),
+		resumeUpload: useCallback(() => {
+			getGate()?.resume();
+			setPaused(false);
+		}, [getGate, setPaused])
+	};
+}
+//#endregion
+//#region src/use-workflow-form.ts
+/**
+* The hook a FORM needs, as against the one a status view does.
+*
+* `useWorkflowRun` (`workflow-client.ts`) watches a run you already have.
+* This is what comes before it: `useWorkflowSubmit` starts a run and hands the
+* id straight to `useWorkflowRun`. Its sibling `useWorkflows` — the listing
+* `<WorkflowFields>` renders a form from — is `use-workflows.ts`.
+*
+* ## `useWorkflowSubmit` — a form's two halves in one hook
+*
+* A page that submits a workflow always needs the same four pieces of state:
+* the run id, whether a submit is in flight, whether the RUN is still going, and
+* whichever of the two failed. `link-digest` writes them out by hand, which is
+* the right shape for a template teaching the primitives and the wrong shape to
+* write a third time — and it is easy to get subtly wrong: dropping the previous
+* run id before the new `POST` returns is what stops a finished result sitting
+* under a form that is already submitting again.
+*
+* So this is `api.start` plus {@link useWorkflowRun}, with the state between
+* them. It adds no transport of its own and holds no run state of its own; the
+* watching (stream first, poll as its fallback, terminal stops) is entirely
+* `useWorkflowRun`'s, and `run` here IS its run.
+*
+* ## Why it starts ASYNCHRONOUSLY even though a synchronous call exists
+*
+* `api.startAndWait` would collapse this to one request, and it is the wrong
+* default for a page: it holds a socket open for up to a minute, answers nothing
+* until it settles, and a page has `useWorkflowRun` — which survives a reload,
+* shows progress, and costs one stream. The synchronous call is for callers with
+* nowhere to put a watch (a script, a cron, a form POST from a server). Pass
+* `wait` here when the page really does want one request, and the run is
+* followed from the same id either way.
+*/
+/**
+* Start a workflow from a form, and follow the run it creates.
+*
+* @typeParam D - The workflow DEFINITION, which types both halves of the
+*   submission: `submit(input)` takes what the workflow's schema parses to, and
+*   `run.status === "completed"` narrows to a typed `run.output`.
+*
+*   It used to be the OUTPUT type alone, and the asymmetry was the bug: a page
+*   already wrote `WorkflowOutputOf<typeof digest>` to get the output, while
+*   `submit` took `unknown`, so `submit({ ur1: 42 })` compiled and arrived as a
+*   400 in the browser. Naming the def instead types the input from the same
+*   declaration — and `import type` is ERASED, so it costs the bundle nothing.
+*   Passing an output type where a def belongs is now a compile error rather
+*   than a silent loss of typing, which is the point.
+*
+* @example
+* ```tsx no-check
+* import { Form, SubmitButton, TextField, useWorkflowSubmit } from "@alexkroman1/aai-ui";
+* import type { digest } from "./agent.ts";
+*
+* function DigestForm() {
+*   const { submit, run, pending, error } = useWorkflowSubmit<typeof digest>("digest");
+*   return (
+*     <Form onSubmit={(values) => submit(values)} error={error}>
+*       <TextField name="url" label="Link" type="url" required />
+*       <SubmitButton pending={pending}>Digest</SubmitButton>
+*       {run?.status === "completed" && <p>{run.output.title}</p>}
+*     </Form>
+*   );
+* }
+* ```
+*
+* @public
+*/
+function useWorkflowSubmit(workflow, opts = {}) {
+	const { api, recover = true, wait, intervalMs, parallel } = opts;
+	const key = useDefaultRunKey(opts.key);
+	const [runId, setRunId] = useState(void 0);
+	const [starting, setStarting] = useState(false);
+	const [startError, setStartError] = useState(void 0);
+	const [upload, setUpload] = useState(void 0);
+	const session = useRef(void 0);
+	const getClient = useWorkflowApiRef(api);
+	const tracked = useWorkflowRun(runId, omitUndefined({
+		api,
+		intervalMs
+	}));
+	const { wake, cancel } = useRunControls(runId, getClient);
+	const recovering = useRecoveredRun({
+		workflow,
+		key,
+		enabled: recover,
+		getClient,
+		onFound: (found) => {
+			setRunId((current) => current ?? found);
+		},
+		onError: setStartError
+	});
+	const submit = useCallback(async (input) => {
+		const client = getClient();
+		setStarting(true);
+		setStartError(void 0);
+		setRunId(void 0);
+		session.current?.gate.cancel();
+		const current = createUploadSession(workflow);
+		session.current = current;
+		try {
+			const options = omitUndefined({ key });
+			const started = await uploadFiles(client, input, setUpload, parallel, current);
+			setRunId(wait === void 0 ? await client.start(workflow, started, options) : (await client.startAndWait(workflow, started, {
+				...options,
+				wait
+			})).runId);
+		} catch (err) {
+			if (!current.gate.cancelled) setStartError(errorMessage(err));
+		} finally {
+			if (session.current === current) {
+				session.current = void 0;
+				setStarting(false);
+				setUpload(void 0);
+			}
+		}
+	}, [
+		workflow,
+		key,
+		wait,
+		parallel,
+		getClient
+	]);
+	const reset = useCallback(() => {
+		session.current?.gate.cancel();
+		session.current = void 0;
+		setRunId(void 0);
+		setStartError(void 0);
+		setUpload(void 0);
+	}, []);
+	const { pauseUpload, resumeUpload } = useUploadPause(useCallback(() => session.current?.gate, []), setUpload);
+	return {
+		submit,
+		submitForm: submit,
+		reset,
+		wake,
+		cancel,
+		pauseUpload,
+		resumeUpload,
+		run: tracked.run,
+		pending: recovering || starting || tracked.polling,
+		upload,
+		error: startError ?? tracked.error
+	};
 }
 //#endregion
-//#region use-workflow-runs.ts
+//#region src/use-workflow-runs.ts
 /**
 * The RUNS a workflow has had — the list a page shows beside its form.
 *
@@ -2144,7 +2198,7 @@ function useWorkflowRuns(workflow, opts = {}) {
 	};
 }
 //#endregion
-//#region use-workflow-stream.ts
+//#region src/use-workflow-stream.ts
 /**
 * Starting a run BEFORE its file has finished uploading.
 *
@@ -2423,7 +2477,7 @@ function fileAt(input, field) {
 	return filesOf(input[field])[0];
 }
 //#endregion
-//#region workflow-status-labels.ts
+//#region src/workflow-status-labels.ts
 /**
 * The default status line per {@link WorkflowRunStatus}.
 *