@alexkroman1/aai-ui 13.3.0 → 14.0.0

package/dist/internal.d.ts

@@ -1,5 +1,5 @@
 /**
- * `@alexkroman1/aai-ui/internal` — the plumbing `client()` and the default
+ * `@alexkroman1/aai-ui/internal` — the plumbing `mountClient()` and the default
  * client install for themselves, NOT part of the public client API and not
  * covered by semver. A `client.tsx` should never import from here; everything
  * an author writes a page or a custom chrome against lives on the root export
@@ -7,7 +7,7 @@
  *
  * These names used to ride on the root barrel, tagged `@internal` and nothing
  * else, which meant they were in a client author's autocomplete beside
- * `client()`, `<Form>`, `useAgentState` and `useWorkflowRun` — eight symbols an
+ * `mountClient()`, `<Form>`, `useAgentState` and `useWorkflowRun` — eight symbols an
  * author is invited to reach for and no capability contract covers. Keeping
  * them on their own subpath keeps the root importable surface the same shape as
  * the promise: what is on it is contracted.

package/dist/internal.js

@@ -1,8 +1,8 @@
-import { r as loadClientConfig, t as buildAgentUrl } from "./client-config-DD820zHn.js";
+import { r as loadClientConfig, t as buildAgentUrl } from "./client-config-DJQHnYjm.js";
 import { SessionProvider, ThemeProvider } from "./context.js";
-import { n as SessionUrlChips, r as UiUrlChip, t as ApiUrlChip } from "./url-chips-C2u7QPv8.js";
-import { t as TRANSCRIBING_PLACEHOLDER } from "./use-user-transcript-DFTSEuZN.js";
-import { t as ToolConfigContext } from "./tool-config-context-Bh8p3DtG.js";
-import { i as DEFAULT_PROGRESS_POLL_MS, n as MAX_MISSING_READS, t as DEFAULT_WORKFLOW_POLL_MS } from "./use-workflow-run-CXGEcM0l.js";
+import { n as SessionUrlChips, r as UiUrlChip, t as ApiUrlChip } from "./url-chips-BxhzZgk2.js";
+import { t as TRANSCRIBING_PLACEHOLDER } from "./use-user-transcript-uyHhzy4d.js";
+import { t as ToolConfigContext } from "./tool-config-context-Es4YUzV2.js";
+import { i as DEFAULT_PROGRESS_POLL_MS, n as MAX_MISSING_READS, t as DEFAULT_WORKFLOW_POLL_MS } from "./use-workflow-run-CP2ekKPV.js";
 import { VOICE_CAPTURE_CONSTRAINTS } from "./types.js";
 export { ApiUrlChip, DEFAULT_PROGRESS_POLL_MS, DEFAULT_WORKFLOW_POLL_MS, MAX_MISSING_READS, SessionProvider, SessionUrlChips, TRANSCRIBING_PLACEHOLDER, ThemeProvider, ToolConfigContext, UiUrlChip, VOICE_CAPTURE_CONSTRAINTS, buildAgentUrl, loadClientConfig };

package/dist/{message-list-C0pL7x41.js → message-list-CdOnSh5m.js}

@@ -1,7 +1,7 @@
 import { useSessionSelector, useTheme } from "./context.js";
-import { i as primaryTint, r as inkTint } from "./_colors-CZ6OlPbL.js";
-import { n as useUserTranscript } from "./use-user-transcript-DFTSEuZN.js";
-import { t as ToolCallBlock } from "./tool-call-block-Bunc6rCw.js";
+import { a as inkTint, o as primaryTint } from "./_colors-CpZO-88A.js";
+import { n as useUserTranscript } from "./use-user-transcript-uyHhzy4d.js";
+import { t as ToolCallBlock } from "./tool-call-block-C2t_5fpp.js";
 import clsx from "clsx";
 import { StickToBottom } from "use-stick-to-bottom";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -142,7 +142,7 @@ function isThinking(state, messages, toolCalls) {
 * Subscribe to the conversation: the interleaved exchange, the streaming
 * utterance, the live transcript and the thinking rule — with no markup.
 *
-* Must be used inside the provider `client()` installs.
+* Must be used inside the provider `mountClient()` installs.
 *
 * @example A custom bubble, keeping every rule `<MessageList>` knows
 * ```tsx
@@ -179,16 +179,23 @@ function useConversation() {
 	const toolCalls = useSessionSelector((s) => s.toolCalls);
 	const streaming = useSessionSelector((s) => s.agentTranscript);
 	const transcript = useUserTranscript();
-	return {
-		items: useMemo(() => interleave(messages, toolCalls), [messages, toolCalls]),
+	const items = useMemo(() => interleave(messages, toolCalls), [messages, toolCalls]);
+	const thinking = useMemo(() => isThinking(state, messages, toolCalls), [
+		state,
+		messages,
+		toolCalls
+	]);
+	return useMemo(() => ({
+		items,
 		streaming,
 		transcript,
-		thinking: useMemo(() => isThinking(state, messages, toolCalls), [
-			state,
-			messages,
-			toolCalls
-		])
-	};
+		thinking
+	}), [
+		items,
+		streaming,
+		transcript,
+		thinking
+	]);
 }
 //#endregion
 //#region src/components/markdown.tsx

package/dist/page.d.ts

@@ -1,15 +1,15 @@
 /** @jsxImportSource react */
 /**
- * `page()` — mount a WORKFLOW APP's UI: React, theme, no session.
+ * `mountPage()` — mount a WORKFLOW APP's UI: React, theme, no session.
  *
- * The twin of `client()` for an agent whose front door is a form rather than a
+ * The twin of `mountClient()` 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
+ * an option on `mountClient()` because of what `mountClient()` unavoidably does: it
+ * constructs a `BrowserSession`, 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.
+ * voice uses `mountClient()`; a page that wants neither audio nor a socket uses this.
  *
  * Authoring is otherwise identical — the file is still `client.tsx`, still
  * React, still Tailwind, still the same theme tokens — so a workflow app reads
@@ -19,7 +19,7 @@
 import { type ComponentType } from "react";
 import type { ClientTheme } from "./types.ts";
 /**
- * Configuration for {@link page}.
+ * Configuration for {@link mountPage}.
  *
  * @public
  */
@@ -33,14 +33,14 @@ export type PageConfig = {
     target?: string | HTMLElement;
     /**
      * Page title. Set only when given, so a title the HTML shell declared is never
-     * clobbered — the same rule `client()`'s custom-component tier follows.
+     * clobbered — the same rule `mountClient()`'s custom-component tier follows.
      */
     name?: string;
     /** Theme color overrides, read by the same tokens the voice components use. */
     theme?: ClientTheme;
 };
 /**
- * Handle returned by {@link page}. `Disposable`, so `using` works.
+ * Handle returned by {@link mountPage}. `Disposable`, so `using` works.
  *
  * @public
  */
@@ -59,7 +59,7 @@ export type PageHandle = {
  *
  * @example
  * ```tsx
- * import { createWorkflowApi, page, useWorkflowRun } from "@alexkroman1/aai-ui";
+ * import { createWorkflowApi, mountPage, useWorkflowRun } from "@alexkroman1/aai-ui";
  * import { useState } from "react";
  *
  * // Hoisted: a client built in render is a new object every render.
@@ -78,11 +78,11 @@ export type PageHandle = {
  *   );
  * }
  *
- * page({ name: "Digest", component: App });
+ * mountPage({ name: "Digest", component: App });
  * ```
  *
  * @throws If the target element is not found in the DOM.
  *
  * @public
  */
-export declare function page(config: PageConfig): PageHandle;
+export declare function mountPage(config: PageConfig): PageHandle;

package/dist/session-core-audio-setup.d.ts

@@ -1,7 +1,7 @@
 import type { SessionCommand } from "@alexkroman1/aai/protocol";
 import type { VoiceIO } from "./audio.ts";
 import type { SessionStateMachine } from "./session-core-state.ts";
-import type { ConnState, SessionSnapshot } from "./session-core-types.ts";
+import { type ConnState, type SessionSnapshot } from "./session-core-types.ts";
 /** Dependencies `initAudioCapture` needs from the owning session core. */
 export type AudioSetupDeps = {
     sendJson: (msg: SessionCommand) => void;

package/dist/session-core-dial.d.ts

@@ -22,8 +22,6 @@ export type DialOptions = {
     resumeSessionId?: string | undefined;
 };
 export type Dialer = {
-    /** The URL for the next attempt — partysocket's async provider. */
-    url(): Promise<string>;
     /** A socket for this attempt. */
     open(): InstanceType<WebSocketConstructor>;
     /**

package/dist/{session-core-C9elBIdu.js → session-core-gwePM95B.js}

@@ -1,4 +1,4 @@
-import { r as loadClientConfig, t as buildAgentUrl } from "./client-config-DD820zHn.js";
+import { r as loadClientConfig, t as buildAgentUrl } from "./client-config-DJQHnYjm.js";
 import { MIC_SEND_MAX_BUFFERED_BYTES } from "./types.js";
 import { SessionEventSchema, lenientParse } from "@alexkroman1/aai/protocol";
 import { errorMessage, safeJsonParse } from "@alexkroman1/aai";
@@ -6,6 +6,44 @@ import { omitUndefined } from "@alexkroman1/aai/utils";
 import { DEFAULT_MAX_HISTORY, WS_OPEN, createEpoch, toArgsRecord } from "@alexkroman1/aai/internal";
 import ReconnectingWebSocket from "partysocket/ws";
 import { and, assign, createActor, not, setup, stateIn } from "xstate";
+//#region src/session-core-types.ts
+/**
+* The two liveness fields at rest.
+*
+* `running` and `recording` ride with almost every state transition and were
+* spread as a pair of literals at seven sites across three modules — the same
+* shape `session-core-state.ts` folded `state` and `error` out of, one field
+* short. Naming it relates them: a transition that ends the call says so once,
+* and a reader looking for "what stops the mic" finds one symbol rather than a
+* grep.
+*
+* It is deliberately NOT the whole snapshot patch — a transition still supplies
+* its own `agentState.apply(...)` projection beside this.
+*/
+const STOPPED = {
+	running: false,
+	recording: false
+};
+/**
+* A turn boundary: end the current turn and settle whatever it was playing.
+*
+* The two calls are one fact and were written out at four sites — `cancel()`
+* and `reset()` here, `reply.cancelled` and `session.reset` on the server side
+* — where the pair is load-bearing in both halves. The bump stops a stale drain
+* continuation from stamping `"listening"` over a state the session has since
+* moved to; the flush settles the interrupted turn's `done()` so it cannot
+* strand.
+*
+* Two further sites bump WITHOUT flushing (`cleanupAudio`, a committed user
+* transcript) and stay spelled out, which is the point of naming this one: a
+* bump on its own now reads as a deliberate choice rather than a forgotten
+* flush.
+*/
+function bargeIn(conn) {
+	conn.turn.bump();
+	conn.voiceIO?.flush();
+}
+//#endregion
 //#region src/session-core-audio-setup.ts
 /**
 * Audio-path initialization for the voice session core.
@@ -60,11 +98,11 @@ async function initAudioCapture(conn, msg, deps) {
 				type: "FAILED",
 				error: {
 					code: "audio",
-					message
+					message,
+					fatal: false
 				}
 			}),
-			running: false,
-			recording: false
+			...STOPPED
 		});
 	};
 	try {
@@ -232,6 +270,55 @@ function applyResumeParams(wsUrl, resume, sessionId) {
 	return wsUrl;
 }
 //#endregion
+//#region src/_web-storage.ts
+/**
+* The store, or nothing.
+*
+* Not exported: a caller that reaches for the store itself has stepped outside
+* the guard, which is the whole point of this module.
+*/
+function storeFor(kind) {
+	return kind === "local" ? globalThis.localStorage : globalThis.sessionStorage;
+}
+/** The stored value, or undefined — for a missing entry and an absent store alike. */
+function storageGet(kind, key) {
+	try {
+		return storeFor(kind)?.getItem(key) ?? void 0;
+	} catch {
+		return;
+	}
+}
+/** Remember a value. A store that refuses is a no-op, never a throw. */
+function storageSet(kind, key, value) {
+	try {
+		storeFor(kind)?.setItem(key, value);
+	} catch {}
+}
+/** Forget a value. Nothing stored and no store are the same outcome. */
+function storageRemove(kind, key) {
+	try {
+		storeFor(kind)?.removeItem(key);
+	} catch {}
+}
+/**
+* A storage key namespaced by a URL.
+*
+* `target` is resolved against the document, so a relative path ("./", the
+* default-client case) and the absolute form of the same agent agree on one
+* key.
+*
+* @param prefix - The owning module's namespace, e.g. `"aai:session:"`.
+* @param target - What to resolve — an agent's `platformUrl`, or `"./"` for the
+*   page's own directory.
+*/
+function urlSlot(prefix, target) {
+	try {
+		return `${prefix}${new URL(target, globalThis.location?.href).href}`;
+	} catch {
+		return `${prefix}${target}`;
+	}
+}
+//#endregion
 //#region src/session-resume-store.ts
 /**
 * Where a session id survives a page RELOAD.
@@ -258,32 +345,22 @@ function applyResumeParams(wsUrl, resume, sessionId) {
 * Keyed by the agent's own URL, so two agents served from one origin — which is
 * every deployed agent, at `/:slug/` — cannot inherit each other's session.
 *
-* Every access is guarded: storage throws outright in some contexts (Safari
-* private mode, storage blocked by policy), and a session that cannot be
-* remembered must degrade to today's behaviour rather than failing to start.
+* Every access is guarded, and the guard lives in `_web-storage.ts`: a session
+* that cannot be remembered must degrade to today's behaviour rather than
+* failing to start.
 */
 const PREFIX = "aai:session:";
 /** One agent's slot in storage. */
 function keyFor(platformUrl) {
-	try {
-		return `${PREFIX}${new URL(platformUrl, globalThis.location?.href).href}`;
-	} catch {
-		return `${PREFIX}${platformUrl}`;
-	}
+	return urlSlot(PREFIX, platformUrl);
 }
 /** The stored session id for this agent, or undefined. @internal */
 function readStoredSessionId(platformUrl) {
-	try {
-		return globalThis.sessionStorage?.getItem(keyFor(platformUrl)) ?? void 0;
-	} catch {
-		return;
-	}
+	return storageGet("session", keyFor(platformUrl));
 }
 /** Remember this agent's session id for the next load. @internal */
 function writeStoredSessionId(platformUrl, sessionId) {
-	try {
-		globalThis.sessionStorage?.setItem(keyFor(platformUrl), sessionId);
-	} catch {}
+	storageSet("session", keyFor(platformUrl), sessionId);
 }
 /**
 * Forget it, so the next load is a NEW session.
@@ -295,9 +372,7 @@ function writeStoredSessionId(platformUrl, sessionId) {
 * @internal
 */
 function clearStoredSessionId(platformUrl) {
-	try {
-		globalThis.sessionStorage?.removeItem(keyFor(platformUrl));
-	} catch {}
+	storageRemove("session", keyFor(platformUrl));
 }
 //#endregion
 //#region src/session-core-dial.ts
@@ -363,7 +438,6 @@ function createDialer(options) {
 		return (cfg?.sessionUrl ? buildBrokeredWsUrl(cfg.sessionUrl, hasConnected, sessionId) : buildWsUrl(options.platformUrl, hasConnected, sessionId)).toString();
 	}
 	return {
-		url,
 		open: () => {
 			if (options.WebSocket) return new options.WebSocket(buildWsUrl(options.platformUrl, hasConnected, sessionId).toString());
 			return openReconnectingSocket(url);
@@ -407,7 +481,8 @@ function createDialer(options) {
 /** What the session reports once the budget below is spent. */
 const HANDSHAKE_ERROR = {
 	code: "connection",
-	message: "Agent did not complete the session handshake"
+	message: "Agent did not complete the session handshake",
+	fatal: false
 };
 /** How long an OPEN socket may go without a `config` frame. */
 const HANDSHAKE_TIMEOUT_MS = 1e4;
@@ -507,7 +582,7 @@ function appendCapped(list, item, cap) {
 *
 * Encapsulates the per-session dedup counters (`customEventSeq`,
 * `messageSeq`, `toolCallSeq`) that previously lived as closure locals in
-* `createSessionCore`. The turn-boundary epoch is NOT one of them: it lives
+* `createBrowserSession`. The turn-boundary epoch is NOT one of them: it lives
 * on `conn` because the session core bumps it on teardown too (see
 * `ConnState.turn`).
 */
@@ -611,7 +686,8 @@ function createMessageHandlers(deps) {
 		console.error("Agent error:", e.message);
 		const error = {
 			code: e.code,
-			message: e.message
+			message: e.message,
+			fatal: e.fatal !== false
 		};
 		if (e.fatal === false) updateState(agentState.apply({
 			type: "TURN_ERROR",
@@ -625,8 +701,7 @@ function createMessageHandlers(deps) {
 					type: "FATAL",
 					error
 				}),
-				running: false,
-				recording: false
+				...STOPPED
 			});
 		}
 	}
@@ -677,14 +752,12 @@ function createMessageHandlers(deps) {
 				toListening();
 				break;
 			case "reply.cancelled":
-				conn.turn.bump();
-				conn.voiceIO?.flush();
+				bargeIn(conn);
 				commitAgentTranscript();
 				toListening({ userTranscript: null });
 				break;
 			case "session.reset": {
-				conn.turn.bump();
-				conn.voiceIO?.flush();
+				bargeIn(conn);
 				const next = agentState.apply({ type: "RESET" });
 				updateState(agentState.fatal() ? next : {
 					...CLEARED_SESSION_STATE,
@@ -1000,27 +1073,27 @@ function createSessionStateMachine() {
 * Uses a subscribe/getSnapshot pattern for state management, compatible with
 * React's `useSyncExternalStore` and other external store integrations.
 *
-* Most clients never call this: `client()` creates a core and installs it in
+* Most clients never call this: `mountClient()` creates a core and installs it in
 * React context for the hooks. Reach for it directly when building a
 * non-React UI (or wiring the session into another framework's store).
 *
 * @example
 * ```ts
-* import { createSessionCore, type SessionSnapshot } from "@alexkroman1/aai-ui";
+* import { createBrowserSession, type SessionSnapshot } from "@alexkroman1/aai-ui";
 *
 * declare function render(snapshot: SessionSnapshot): void;
 *
-* const session = createSessionCore({ platformUrl: "https://host/my-agent/" });
+* const session = createBrowserSession({ platformUrl: "https://host/my-agent/" });
 * session.subscribe(() => render(session.getSnapshot()));
 * session.start();
 * ```
 *
 * @param options - Session configuration including the platform server URL.
-* @returns A {@link SessionCore} handle for controlling the session.
+* @returns A {@link BrowserSession} handle for controlling the session.
 *
 * @public
 */
-function createSessionCore(options) {
+function createBrowserSession(options) {
 	let currentSnapshot = {
 		...CLEARED_SESSION_STATE,
 		state: "disconnected",
@@ -1192,8 +1265,7 @@ function createSessionCore(options) {
 						type: "FAILED",
 						error: HANDSHAKE_ERROR
 					}),
-					running: false,
-					recording: false
+					...STOPPED
 				});
 			}
 		});
@@ -1232,24 +1304,22 @@ function createSessionCore(options) {
 					type: "FAILED",
 					error: {
 						code: "connection",
-						message: failure
+						message: failure,
+						fatal: false
 					}
 				}),
-				running: false,
-				recording: false
+				...STOPPED
 			});
 		}, { signal: sig });
 	}
 	function cancel() {
 		if (!openSocket()) return;
-		conn.turn.bump();
-		conn.voiceIO?.flush();
+		bargeIn(conn);
 		updateState(agentState.apply({ type: "LISTEN" }));
 		sendJson({ type: "cancel" });
 	}
 	function reset() {
-		conn.turn.bump();
-		conn.voiceIO?.flush();
+		bargeIn(conn);
 		if (openSocket()) {
 			sendJson({ type: "reset" });
 			return;
@@ -1261,8 +1331,7 @@ function createSessionCore(options) {
 		teardownConnection();
 		updateState({
 			...agentState.apply({ type: "DISCONNECT" }),
-			running: false,
-			recording: false
+			...STOPPED
 		});
 	}
 	function start() {
@@ -1286,10 +1355,13 @@ function createSessionCore(options) {
 			...CLEARED_SESSION_STATE,
 			...agentState.apply({ type: "END" }),
 			started: false,
-			running: false,
-			recording: false
+			...STOPPED
 		});
 	}
+	function restart() {
+		end();
+		start();
+	}
 	return {
 		getSnapshot,
 		subscribe,
@@ -1301,10 +1373,11 @@ function createSessionCore(options) {
 		start,
 		toggle,
 		end,
+		restart,
 		[Symbol.dispose]() {
 			disconnect();
 		}
 	};
 }
 //#endregion
-export { createSessionCore as t };
+export { urlSlot as i, storageGet as n, storageSet as r, createBrowserSession as t };

package/dist/session-core-messages.d.ts

@@ -1,5 +1,5 @@
 import type { SessionStateMachine } from "./session-core-state.ts";
-import type { ConnState, SessionSnapshot } from "./session-core-types.ts";
+import { type ConnState, type SessionSnapshot } from "./session-core-types.ts";
 /**
  * Snapshot fields cleared when a session's conversation state is wiped —
  * shared by the initial snapshot, `resetState()`, and `session.reset`.
@@ -56,7 +56,7 @@ type MessageHandlers = {
  *
  * Encapsulates the per-session dedup counters (`customEventSeq`,
  * `messageSeq`, `toolCallSeq`) that previously lived as closure locals in
- * `createSessionCore`. The turn-boundary epoch is NOT one of them: it lives
+ * `createBrowserSession`. The turn-boundary epoch is NOT one of them: it lives
  * on `conn` because the session core bumps it on teardown too (see
  * `ConnState.turn`).
  */

package/dist/session-core-types.d.ts

@@ -149,7 +149,7 @@ export type SessionSnapshot = {
  *
  * @public
  */
-export type SessionCore = {
+export type BrowserSession = {
     /** Return the current immutable state snapshot. */
     getSnapshot(): SessionSnapshot;
     /** Subscribe to state changes. Returns an unsubscribe function. */
@@ -195,6 +195,30 @@ export type SessionCore = {
      * per-session tool state, greeting included.
      */
     end(): void;
+    /**
+     * End the current call and immediately begin a new one — `end()` then
+     * `start()`, which is what "New Conversation" means for an agent that keeps
+     * SESSION-SCOPED STATE.
+     *
+     * `reset()` is the one whose name suggests this and it is not the same
+     * thing: it clears the transcript and reconnects, but the reconnect carries
+     * the same `?sessionId=`, so every `sessionSlot` on the server survives —
+     * the game world, the incident board, the cart. A caller who asked to start
+     * over gets a blank transcript in front of the old state. This drops the
+     * session id, so the next connect mints a fresh one and the greeting plays
+     * again.
+     *
+     * Three templates had each written `session.end(); session.start();` with
+     * the same paragraph explaining why `reset()` was wrong; the six on the
+     * stock shell could not, because {@link Controls} called `reset()` for them.
+     *
+     * @example
+     * ```ts
+     * declare const session: import("@alexkroman1/aai-ui").Session;
+     * session.restart();
+     * ```
+     */
+    restart(): void;
     /** Alias for `disconnect` for use with `using`. */
     [Symbol.dispose](): void;
 };
@@ -247,3 +271,36 @@ export type ConnState = {
      *  buffered during mic-permission never finishes playing. */
     preInitDone: boolean;
 };
+/**
+ * The two liveness fields at rest.
+ *
+ * `running` and `recording` ride with almost every state transition and were
+ * spread as a pair of literals at seven sites across three modules — the same
+ * shape `session-core-state.ts` folded `state` and `error` out of, one field
+ * short. Naming it relates them: a transition that ends the call says so once,
+ * and a reader looking for "what stops the mic" finds one symbol rather than a
+ * grep.
+ *
+ * It is deliberately NOT the whole snapshot patch — a transition still supplies
+ * its own `agentState.apply(...)` projection beside this.
+ */
+export declare const STOPPED: {
+    readonly running: false;
+    readonly recording: false;
+};
+/**
+ * A turn boundary: end the current turn and settle whatever it was playing.
+ *
+ * The two calls are one fact and were written out at four sites — `cancel()`
+ * and `reset()` here, `reply.cancelled` and `session.reset` on the server side
+ * — where the pair is load-bearing in both halves. The bump stops a stale drain
+ * continuation from stamping `"listening"` over a state the session has since
+ * moved to; the flush settles the interrupted turn's `done()` so it cannot
+ * strand.
+ *
+ * Two further sites bump WITHOUT flushing (`cleanupAudio`, a committed user
+ * transcript) and stay spelled out, which is the point of naming this one: a
+ * bump on its own now reads as a deliberate choice rather than a forgotten
+ * flush.
+ */
+export declare function bargeIn(conn: ConnState): void;

package/dist/session-core.d.ts

@@ -1,4 +1,4 @@
-import type { SessionCore } from "./session-core-types.ts";
+import { type BrowserSession } from "./session-core-types.ts";
 import { type VoiceSessionOptions } from "./types.ts";
 /**
  * Create a framework-agnostic voice session core that connects to an AAI
@@ -7,24 +7,24 @@ import { type VoiceSessionOptions } from "./types.ts";
  * Uses a subscribe/getSnapshot pattern for state management, compatible with
  * React's `useSyncExternalStore` and other external store integrations.
  *
- * Most clients never call this: `client()` creates a core and installs it in
+ * Most clients never call this: `mountClient()` creates a core and installs it in
  * React context for the hooks. Reach for it directly when building a
  * non-React UI (or wiring the session into another framework's store).
  *
  * @example
  * ```ts
- * import { createSessionCore, type SessionSnapshot } from "@alexkroman1/aai-ui";
+ * import { createBrowserSession, type SessionSnapshot } from "@alexkroman1/aai-ui";
  *
  * declare function render(snapshot: SessionSnapshot): void;
  *
- * const session = createSessionCore({ platformUrl: "https://host/my-agent/" });
+ * const session = createBrowserSession({ platformUrl: "https://host/my-agent/" });
  * session.subscribe(() => render(session.getSnapshot()));
  * session.start();
  * ```
  *
  * @param options - Session configuration including the platform server URL.
- * @returns A {@link SessionCore} handle for controlling the session.
+ * @returns A {@link BrowserSession} handle for controlling the session.
  *
  * @public
  */
-export declare function createSessionCore(options: VoiceSessionOptions): SessionCore;
+export declare function createBrowserSession(options: VoiceSessionOptions): BrowserSession;

package/dist/session-core.js

@@ -1,2 +1,2 @@
-import { t as createSessionCore } from "./session-core-C9elBIdu.js";
-export { createSessionCore };
+import { t as createBrowserSession } from "./session-core-gwePM95B.js";
+export { createBrowserSession };

package/dist/session-resume-store.d.ts

@@ -23,9 +23,9 @@
  * Keyed by the agent's own URL, so two agents served from one origin — which is
  * every deployed agent, at `/:slug/` — cannot inherit each other's session.
  *
- * Every access is guarded: storage throws outright in some contexts (Safari
- * private mode, storage blocked by policy), and a session that cannot be
- * remembered must degrade to today's behaviour rather than failing to start.
+ * Every access is guarded, and the guard lives in `_web-storage.ts`: a session
+ * that cannot be remembered must degrade to today's behaviour rather than
+ * failing to start.
  */
 /** The stored session id for this agent, or undefined. @internal */
 export declare function readStoredSessionId(platformUrl: string): string | undefined;