@workerdeck/react 0.23.0 → 1.1.0

package/build/index.mjs

@@ -10,40 +10,27 @@ const initialTranscriptState = {
 	totalCostUsd: 0,
 	lastSeq: 0
 };
-/**
-* The in-flight streamed text and thought — a singleton **per agent**, not per
-* session.
-*
-* It was one id for the whole stream, which was right while one thread streamed
-* at a time. It is not: with subagent text forwarded, a `Task` and the thread
-* that spawned it stream *concurrently*, and three parallel Tasks stream three
-* ways at once. Under one id every one of those deltas accumulates into the same
-* item — a row welding several agents' half-sentences together — and the first
-* `assistant_message` to land wipes all of them, including the ones still being
-* written.
-*
-* So the id carries the agent: `streaming` for the main thread (unchanged, so
-* nothing that keys off it moves) and `streaming:<parentToolUseId>` inside a
-* subagent.
-*/
 const STREAMING_ID = "streaming";
 const STREAMING_THINKING_ID = "streaming-thinking";
-const streamingTextId = (parentToolUseId) => parentToolUseId == null ? STREAMING_ID : `${STREAMING_ID}:${parentToolUseId}`;
-const streamingThinkingId = (parentToolUseId) => parentToolUseId == null ? STREAMING_THINKING_ID : `${STREAMING_THINKING_ID}:${parentToolUseId}`;
-/** Is this item an in-flight stream — anyone's? The turn's end finalizes every
-* one of them, since a subagent's last text is as unrecoverable as the main
-* thread's when a turn is interrupted. */
-const isStreamingItem = (item) => item.kind === "assistant_text" && item.id.startsWith(STREAMING_ID) || item.kind === "thinking" && item.id.startsWith(STREAMING_THINKING_ID);
+const LOCAL_COMMAND_OUTPUT = /^<local-command-(stdout|stderr)>([\s\S]*?)<\/local-command-\1>$/;
+const COMMAND_NAME = /<command-name>([\s\S]*?)<\/command-name>/;
+const COMMAND_ARGS = /<command-args>([\s\S]*?)<\/command-args>/;
+function streamingTextId(parentToolUseId) {
+	return parentToolUseId == null ? STREAMING_ID : `${STREAMING_ID}:${parentToolUseId}`;
+}
+function streamingThinkingId(parentToolUseId) {
+	return parentToolUseId == null ? STREAMING_THINKING_ID : `${STREAMING_THINKING_ID}:${parentToolUseId}`;
+}
+function isStreamingItem(item) {
+	return item.kind === "assistant_text" && item.id.startsWith(STREAMING_ID) || item.kind === "thinking" && item.id.startsWith(STREAMING_THINKING_ID);
+}
 function blockText(content) {
 	if (content === void 0) return "";
 	if (typeof content === "string") return content;
 	return content.map((part) => typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n");
 }
-/** The `image_ref` addresses in a result's content, or undefined when it holds
-* none — which is the common case, and is why this returns undefined rather than
-* an empty array: an absent field keeps the item byte-identical. */
 function imageRefsOf(content, seq) {
-	if (!Array.isArray(content)) return void 0;
+	if (!Array.isArray(content)) return;
 	const refs = content.flatMap((part) => part.type === "image_ref" ? [{
 		partIndex: Number(part.part_index),
 		mediaType: String(part.media_type ?? "application/octet-stream"),
@@ -58,7 +45,6 @@ function contentToBlocks(content) {
 		text: content
 	}] : content;
 }
-/** Render an execution's by-value output for the transcript. */
 function outputText(output) {
 	if (output.type === "text") return output.value;
 	try {
@@ -67,26 +53,9 @@ function outputText(output) {
 		return String(output.value);
 	}
 }
-/** CLI-side command output arrives as user text wrapped in local-command tags. */
-const LOCAL_COMMAND_OUTPUT = /^<local-command-(stdout|stderr)>([\s\S]*?)<\/local-command-\1>$/;
-/**
-* A slash command the person ran, as the CLI writes it into the transcript:
-* `<command-message>…</command-message><command-name>/wrapup</command-name>
-* <command-args>…</command-args>`, in whichever order.
-*
-* Rendered as the command line rather than hidden. It *is* a person's turn — it
-* is the reason everything after it happened — but the raw wrapper is markup
-* nobody typed, and it showed up verbatim in every resumed transcript. Not
-* suppressed in the runner for that same reason: hiding it would erase the
-* turn's cause and, since `transcriptActivity` counts a non-synthetic user
-* message as one row, silently disagree with the unread count.
-*/
-const COMMAND_NAME = /<command-name>([\s\S]*?)<\/command-name>/;
-const COMMAND_ARGS = /<command-args>([\s\S]*?)<\/command-args>/;
-/** The typed command line, or undefined when this is ordinary prose. */
 function slashCommandText(text) {
 	const name = COMMAND_NAME.exec(text)?.[1]?.trim();
-	if (!name) return void 0;
+	if (!name) return;
 	const args = COMMAND_ARGS.exec(text)?.[1]?.trim();
 	return args ? `${name} ${args}` : name;
 }
@@ -97,12 +66,6 @@ function upsert(items, item) {
 	next[index] = item;
 	return next;
 }
-/**
-* Seed transcript state from the attach snapshot (the `attached` frame's SessionInfo).
-* A promptless session emits no `system_init` until its first message, so fields like
-* `permissionMode` and `model` would otherwise stay empty — fill only what events
-* haven't set yet; the event stream stays authoritative.
-*/
 function seedFromSessionInfo(state, info) {
 	const engine = info.engine ?? state.engine;
 	return {
@@ -117,36 +80,12 @@ function seedFromSessionInfo(state, info) {
 		session: info
 	};
 }
-/**
-* The session's rate-limit windows in reading order: the session window, the
-* weekly window, then whichever per-model weekly windows it reports.
-*
-* The ordering and the drop-the-unknown rule are protocol's `orderUsageWindows`
-* — the dashboard renders the same windows straight off `ProfileInfo.usage`,
-* with no transcript anywhere near it, and two orderings would be one account
-* described two ways. This stays as the transcript-shaped door to it.
-*/
 function rateLimitWindows(state) {
 	return orderUsageWindows(mergeUsage({
 		rateLimits: state.rateLimits,
 		updatedAt: state.rateLimitsUpdatedAt
 	}, void 0));
 }
-/**
-* Put a fetched tool result back where its head was — the other half of
-* `truncateResults`.
-*
-* Into **transcript state**, not row-local state, and the three reasons are the
-* design: the copy button then copies the whole thing rather than the head, the
-* transcript cache retains it across a session switch, and no later event can
-* re-truncate it. The markers are cleared, so a hydrated result is
-* indistinguishable from one that was never cut and every renderer needs a
-* branch for exactly one state, not two.
-*
-* Keyed on `toolUseId`, which is the id the row already holds; `seq` is what the
-* *fetch* needed, not what the fold needs. Unknown id returns `state` unchanged
-* — a press answered after the session was cleared must not resurrect a row.
-*/
 function hydrateToolResult(state, toolUseId, text) {
 	let changed = false;
 	const items = state.items.map((item) => {
@@ -458,98 +397,33 @@ function applyEvent(state, event) {
 }
 //#endregion
 //#region src/lib/transcript-cache.ts
-/**
-* Module-scope cache of detached transcript states, so switching back to a
-* recently viewed session paints its transcript in the mount frame and
-* re-attaches with `afterSeq: lastSeq` — the wire replays only what happened
-* while the panel was away, instead of the whole event log.
-*
-* Module-scope for the same reason `useSessions` and the watermarks are: the
-* consumers that need it (the VS Code panel, the dashboard's session route)
-* remount `SessionPanel` per session, so any per-hook copy would die with the
-* unmount that is the entire point of surviving.
-*
-* Entries are the same `TranscriptState` objects the reducer held — retention,
-* not duplication — and the bound is what keeps retention from becoming a
-* leak. Eviction is least-recently-STORED: every detach stores, so store
-* recency is viewing recency, and reads don't need to reorder.
-*
-* Keys come from {@link transcriptCacheKey} and carry the client's
-* `identityKey` (gateway + auth headers), never the session id alone: a
-* session id is unique only within one gateway, and an entry must never be
-* readable through a client speaking as a different principal.
-*/
-/**
-* How many detached transcripts stay warm.
-*
-* Five covers the working set the feature exists for — an operator alternating
-* between the handful of sessions that are simultaneously working or awaiting
-* them — while keeping the pathological case (five `perf`-fixture-sized
-* transcripts of ~4k items each) in the tens of megabytes, no more than a few
-* times what the one mounted panel already holds. Too small degrades to
-* today's behaviour (a replay on switch-back); too large is memory held
-* forever in a webview — the asymmetry favours small.
-*/
 const MAX_ENTRIES = 5;
-const entries = /* @__PURE__ */ new Map();
-/** Cache key for one session as seen through one (gateway, principal). The
-* NUL separator is unambiguous: the identity key is `JSON.stringify` output,
-* which escapes control characters, so no two (identity, session) pairs can
-* spell the same key. */
+const entries$1 = /* @__PURE__ */ new Map();
 function transcriptCacheKey(client, sessionId) {
 	return `${client.identityKey}\u0000${sessionId}`;
 }
 function readTranscriptCache(key) {
-	return entries.get(key);
+	return entries$1.get(key);
 }
 function writeTranscriptCache(key, state) {
-	entries.delete(key);
-	entries.set(key, state);
-	if (entries.size > MAX_ENTRIES) {
-		const oldest = entries.keys().next().value;
-		if (oldest !== void 0) entries.delete(oldest);
+	entries$1.delete(key);
+	entries$1.set(key, state);
+	if (entries$1.size > MAX_ENTRIES) {
+		const oldest = entries$1.keys().next().value;
+		if (oldest !== void 0) entries$1.delete(oldest);
 	}
 }
 function deleteTranscriptCache(key) {
-	entries.delete(key);
+	entries$1.delete(key);
 }
-/**
-* Drop every cached transcript. For an embedder changing principals in place
-* (a logout that keeps the page alive) — entries are unreachable through the
-* new principal's client either way, but scrubbing them is free and final.
-*/
 function clearTranscriptCache() {
-	entries.clear();
+	entries$1.clear();
 }
 //#endregion
 //#region src/lib/attach-plan.ts
-/**
-* The attach effect's decisions, pure.
-*
-* `useClaudeSession` is never rendered in tests — this package deliberately
-* carries no jsdom and no testing-library — so the logic that used to live
-* inline in the attach effect (which state an attach holds, whether the
-* reducer must be re-seeded, which `afterSeq` to request, whether the parting
-* state may go back into the cache) is decided here, where plain vitest
-* reaches it, and the effect keeps only glue: read its refs into inputs,
-* apply the returned instructions, subscribe. The refs themselves stay in the
-* hook — a decision function that owned React state would be the untestable
-* thing again — so everything stateful arrives as a value and leaves as an
-* instruction.
-*/
-/**
-* Which (resync, client identity, session) a reducer state was seeded for.
-* One format, shared by the hook's mount initializer and {@link planAttach},
-* so the two sites cannot drift: a token that dropped `resyncSeq` would leave
-* the stale-log retry looking already-seeded, and the fresh replay would
-* compose into the condemned state the resync just discarded.
-*/
 function attachSeedToken(resyncSeq, key) {
 	return `${resyncSeq}:${key}`;
 }
-/**
-* Decide what one run of the attach effect does before it opens the socket.
-*/
 function planAttach(input) {
 	const seedToken = attachSeedToken(input.resyncSeq, input.key);
 	const warm = input.cacheEnabled && !input.skipCache ? input.warm : void 0;
@@ -562,107 +436,31 @@ function planAttach(input) {
 		...held.lastSeq > 0 ? { afterSeq: held.lastSeq } : {}
 	};
 }
-/**
-* Whether the effect's cleanup may keep the parting transcript warm for a
-* switch-back. Refused when caching is off; after a stale-log detection —
-* writing the condemned state back would re-poison the very retry that just
-* discarded it; and when there is nothing real to keep — `lastSeq === 0` also
-* protects an existing entry from being clobbered by a mount that never
-* finished attaching, and a state with no `session` never saw its attached
-* frame at all.
-*/
 function shouldWriteParting(input) {
 	return input.cacheEnabled && !input.skipCache && input.parting.lastSeq > 0 && input.parting.session !== void 0;
 }
 //#endregion
 //#region src/hooks/use-session.ts
-/** Session events drive the reducer; the attach snapshot seeds fields (permission
-* mode, model) that a promptless session's event stream doesn't carry yet. */
 function reduce(state, action) {
 	if (action.type === "transcript_seed") return action.state;
 	if (action.type === "transcript_hydrate_result") return hydrateToolResult(state, action.toolUseId, action.text);
 	return action.type === "attached" ? seedFromSessionInfo(state, action.session) : applyEvent(state, action);
 }
-/** Failed attempts in a row before "reconnecting…" stops being the honest word.
-* Three is ~3.5s of backoff — past a blip. Matches the iOS client. */
 const OFFLINE_AFTER_ATTEMPTS = 3;
-/**
-* The seq the initial attach replay ends on, or undefined when there is nothing
-* to hold for.
-*
-* This is an exact signal, not a heuristic: the `attached` frame is sent before
-* any replayed `event` frame and carries the runner's seq at attach time
-* (`session.lastSeq`), so the moment the frame arrives the client knows
-* precisely which seq the replay ends on. Every runner keeps its full event log
-* and always delivers the highest-seq event on a fresh replay (the
-* `conversation_reset` skip is strictly-below-the-reset, and the reset's seq is
-* itself ≤ lastSeq), so `TranscriptState.lastSeq >= target` means the replay
-* has landed. No quiet window or other arrival heuristic belongs here.
-*
-* Only a FRESH attach yields a target (`replayingFrom === 0`): a reconnect
-* replays into a transcript the reader is already looking at, and blanking it
-* mid-turn would be a worse bug than the flicker the hold exists to fix. A
-* brand-new session (`lastSeq === 0`) has nothing to replay and never holds.
-*/
 function initialReplayTarget(frame) {
 	return frame.replayingFrom === 0 && frame.session.lastSeq > 0 ? frame.session.lastSeq : void 0;
 }
-/**
-* Whether an attach frame describes a DIFFERENT event log than the transcript
-* `held` was built from — in which case attaching with `afterSeq: held.lastSeq`
-* has already gone wrong: every event in the new log has seq ≤ afterSeq, so
-* nothing will ever arrive and the stale rows would stand forever, with no
-* error. The only recovery is to forget the state and re-attach from seq 0.
-*
-* A log resets on routine paths, not corner cases: a dormant session
-* (claude/codex surviving a gateway restart) is rebuilt with a brand-new
-* runner whose log starts at 0 and refills from the engine's own store. Two
-* checks, each of which the other misses:
-*
-* - `session.lastSeq < held.lastSeq` — the server's log is shorter than what
-*   we hold. Within one log seq only grows, so this is proof of a reset. It
-*   catches a rebuilt runner that has not yet re-run far — but not one whose
-*   backfill already advanced past us.
-* - `session.createdAt !== held.session.createdAt` — a different runner
-*   incarnation. The claude and codex runners stamp `Date.now()` at
-*   construction, so a dormant rebuild always changes it; the provider runner
-*   restores `createdAt` from its snapshot precisely when it also restores
-*   the event log and seq counter (ai-sdk-runner's `#restore`), so equality
-*   truthfully means "same log" for every engine.
-*
-* A full replay (`replayingFrom === 0`) is never stale — it carries the whole
-* log, so the caller heals by resetting state and applying it — and holding
-* nothing (`held.lastSeq === 0`) has nothing to be stale about. That first
-* clause is also what makes the recovery loop-proof: the re-attach from 0 can
-* never re-trigger this predicate.
-*
-* Not cache-specific: a live handle reconnecting after a gateway restart
-* re-attaches with its own advanced `afterSeq` against the rebuilt log and
-* hits the identical silence, so the hook applies this to every attach frame.
-*/
 function staleAttach(frame, held) {
 	if (frame.replayingFrom === 0 || held.lastSeq === 0) return false;
 	if (frame.session.lastSeq < held.lastSeq) return true;
 	return held.session !== void 0 && frame.session.createdAt !== held.session.createdAt;
 }
-/**
-* Backstop for the replay hold: if the target seq has not landed after this
-* long, reveal what has arrived. On a healthy attach the target is always
-* reached (see {@link initialReplayTarget}); the backstop exists because a
-* blank panel forever would be a much worse failure than a visible stream, so
-* the hold is bounded no matter what a future filter or a lossy path does. It
-* runs from the attach — a per-event re-arm would be a quiet-window heuristic
-* in a new costume.
-*/
 const REPLAY_HOLD_MAX_MS = 1500;
-/** Attach to a session and maintain live transcript state. Detaches on unmount. */
 function useClaudeSession(client, sessionId, options) {
 	const [state, dispatch] = useReducer(reduce, void 0, () => (options?.cacheTranscript !== false && sessionId !== void 0 ? readTranscriptCache(transcriptCacheKey(client, sessionId)) : void 0) ?? initialTranscriptState);
 	const [connection, setConnection] = useState("reconnecting");
 	const [protocolMismatch, setProtocolMismatch] = useState();
-	/** Where the current attach's replay ends, while one is being held for. */
 	const [replayTarget, setReplayTarget] = useState();
-	/** Bumped to force a fresh attach from seq 0 after a stale-log detection. */
 	const [resyncSeq, setResyncSeq] = useState(0);
 	const [handleState, setHandleState] = useState();
 	const handleRef = useRef(null);
@@ -761,10 +559,11 @@ function useClaudeSession(client, sessionId, options) {
 		if (!result?.truncated || result.sourceSeq === void 0) return false;
 		try {
 			const full = await client.toolResult(sessionId, result.sourceSeq, toolUseId);
+			const text = typeof full.content === "string" ? full.content : (full.content ?? []).map((part) => typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n");
 			dispatch({
 				type: "transcript_hydrate_result",
 				toolUseId,
-				text: typeof full.content === "string" ? full.content : (full.content ?? []).map((part) => typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n")
+				text
 			});
 			return true;
 		} catch {
@@ -802,15 +601,6 @@ function useClaudeSession(client, sessionId, options) {
 		loadFullResult
 	]);
 }
-/**
-* The session's profile catalog, fetched once and only when it could matter —
-* i.e. when the engine has reported no models of its own.
-*
-* Fire-and-forget on purpose: an empty catalog is exactly the state a picker
-* already handles, so a failed or 404'd `/profiles` (a server predating them)
-* degrades to the old behaviour rather than raising an error about a list the
-* operator may never open.
-*/
 function useProfileModelFallback(client, sessionId, state) {
 	const [catalog, setCatalog] = useState([]);
 	const profile = state.session?.profile;
@@ -834,21 +624,102 @@ function useProfileModelFallback(client, sessionId, state) {
 	return hasReported ? reported : catalog;
 }
 //#endregion
-//#region src/hooks/use-attachments.ts
+//#region src/lib/profile-usage-cache.ts
 /**
-* How a media type reaches a model, in the capability record's vocabulary.
-* `undefined` means this build can't classify it — the upload still goes,
-* because the gateway's vocabulary is the authoritative one.
+* Last known profile usage, kept outside React so a session switch does not blank it.
+*
+* Usage belongs to the *account*, not the session, but it is fetched by a hook that lives inside the per-session
+* panel — so remounting that panel used to drop the authoritative reading to `undefined` for a whole round trip,
+* leaving only the newly-attached session's own replayed (and possibly days-old) numbers to render. That is the
+* "switching sessions resets my weekly usage to 1%, then it catches up" report.
+*
+* Keyed by client identity + profile because a different profile is a different account's plan, never a stale view
+* of this one. Same shape and reasoning as `transcript-cache.ts` next door.
 */
-function attachmentKind(mediaType) {
-	const type = mediaType.split(";")[0].trim().toLowerCase();
-	if (type.startsWith("image/")) return "image";
-	if (type === "application/pdf") return "pdf";
-	if (type.startsWith("text/")) return "text";
-	if (TEXTUAL_TYPES.has(type)) return "text";
+const entries = /* @__PURE__ */ new Map();
+function profileUsageCacheKey(client, profile) {
+	return `${client.identityKey}\u0000${profile}`;
+}
+function readProfileUsageCache(key) {
+	return entries.get(key);
+}
+function writeProfileUsageCache(key, usage) {
+	if (usage === void 0) return;
+	entries.set(key, usage);
+}
+function clearProfileUsageCache() {
+	entries.clear();
+}
+//#endregion
+//#region src/lib/draft-store.ts
+/**
+* Unsent composer text, kept per session on the client that typed it.
+*
+* A draft is not session state: it never reaches the gateway and never syncs between clients. Two people looking at
+* one session are each mid-sentence in their own way, and a half-written prompt is not something either of them
+* asked to publish.
+*
+* It is persisted rather than merely held in memory because the two ways drafts got lost are different failures. A
+* session switch remounts the composer, which a module-scope map alone would survive; a Vite HMR reload or a VS Code
+* `dev:host` webview re-render replaces the whole document, which it would not.
+*/
+const KEY = "workerdeck.drafts.v1";
+/** Drafts are a convenience, so the store stays small and drops the least recently touched first. */
+const MAX_DRAFTS = 20;
+let memory;
+function storage() {
+	try {
+		return globalThis.localStorage;
+	} catch {
+		return;
+	}
+}
+function load() {
+	if (memory) return memory;
+	memory = {};
+	const raw = storage()?.getItem(KEY);
+	if (raw) try {
+		const parsed = JSON.parse(raw);
+		for (const [key, draft] of Object.entries(parsed)) if (typeof draft?.text === "string" && typeof draft.savedAt === "number") memory[key] = draft;
+	} catch {}
+	return memory;
+}
+function persist(drafts) {
+	const entries = Object.entries(drafts);
+	if (entries.length > MAX_DRAFTS) {
+		entries.sort((a, b) => b[1].savedAt - a[1].savedAt);
+		for (const [key] of entries.slice(MAX_DRAFTS)) delete drafts[key];
+	}
+	try {
+		storage()?.setItem(KEY, JSON.stringify(drafts));
+	} catch {}
+}
+function draftKey(client, sessionId) {
+	return `${client.identityKey}\u0000${sessionId}`;
+}
+function readDraft(key) {
+	return load()[key]?.text ?? "";
+}
+function writeDraft(key, text, now = Date.now()) {
+	const drafts = load();
+	if (text.trim() === "") {
+		if (drafts[key] === void 0) return;
+		delete drafts[key];
+	} else drafts[key] = {
+		text,
+		savedAt: now
+	};
+	persist(drafts);
 }
-/** Textual types whose media type doesn't start with `text/` — mirrors core. */
-const TEXTUAL_TYPES = new Set([
+function clearDrafts() {
+	memory = {};
+	try {
+		storage()?.removeItem(KEY);
+	} catch {}
+}
+//#endregion
+//#region src/hooks/use-attachments.ts
+const TEXTUAL_TYPES = /* @__PURE__ */ new Set([
 	"application/json",
 	"application/xml",
 	"application/yaml",
@@ -859,26 +730,19 @@ const TEXTUAL_TYPES = new Set([
 	"application/x-sh",
 	"application/sql"
 ]);
-/** Longest edge an image is downscaled to before upload. Anthropic's own
-* recommendation, and the same number the iOS client uses — a phone photo is
-* several times this in each direction and costs tokens for nothing. */
 const MAX_IMAGE_EDGE = 1568;
-/**
-* Stage, upload and track files for the next message of a session.
-*
-* Refusals happen as early as they can be known: a kind the capability record
-* forswears never reaches the network (the gateway would 415 it), and everything
-* else is the gateway's call — its vocabulary is authoritative, so an unknown
-* media type is uploaded rather than guessed at.
-*/
+function attachmentKind(mediaType) {
+	const type = mediaType.split(";")[0].trim().toLowerCase();
+	if (type.startsWith("image/")) return "image";
+	if (type === "application/pdf") return "pdf";
+	if (type.startsWith("text/")) return "text";
+	if (TEXTUAL_TYPES.has(type)) return "text";
+}
 function useAttachments(client, sessionId, { capabilities, engine }) {
 	const [items, setItems] = useState([]);
 	const [error, setError] = useState();
 	const counter = useRef(0);
-	/** The originals, kept so a failed upload can be retried without re-picking. */
 	const fileByKey = useRef(/* @__PURE__ */ new Map());
-	/** Mirrors the live preview URLs so unmount can revoke them all — an unmount
-	* with blobs outstanding is a leak the GC does not clean up. */
 	const previewUrls = useRef([]);
 	previewUrls.current = items.flatMap((item) => item.previewUrl ? [item.previewUrl] : []);
 	const accepts = capabilities.attachments;
@@ -998,9 +862,6 @@ function useAttachments(client, sessionId, { capabilities, engine }) {
 		error
 	]);
 }
-/** What a file input should offer. The full set keeps the open door (anything —
-* the gateway refuses the rest with a clear message); a narrower record narrows
-* the browsing too, so most refusals never happen. */
 function acceptAttribute(kinds) {
 	if (kinds.length === 0) return "";
 	const parts = [];
@@ -1010,15 +871,6 @@ function acceptAttribute(kinds) {
 	return kinds.length === 3 ? "" : parts.join(",");
 }
 const imaging = globalThis;
-/**
-* The bytes to upload, and the type they are.
-*
-* Oversized images are redrawn to {@link MAX_IMAGE_EDGE} first: a modern phone
-* photo is 4000px on its long edge, which costs tokens for detail no model
-* reads, and often exceeds the gateway's per-file cap outright. Everything else
-* — and anything the browser can't decode — is uploaded as-is, so a failure here
-* is never worse than not trying.
-*/
 async function prepare(file) {
 	const mediaType = file.type || "application/octet-stream";
 	const { createImageBitmap, document } = imaging;
@@ -1071,14 +923,8 @@ async function prepare(file) {
 }
 //#endregion
 //#region src/lib/prompt-tokens.ts
-/** Characters a command name may contain after the slash. Deliberately excludes
-* `/`, so an absolute path pasted into a message (`/Users/me/…`) is not mistaken
-* for a command; `:` is in because namespaced skills (`dev:wrapup`) are spelled
-* that way. */
 const COMMAND_BODY = /^[A-Za-z0-9\-_.:]+$/;
-/** Trailing punctuation that belongs to the sentence, not the token — so
-* "see @README.md." styles the path and leaves the period alone. */
-const SENTENCE_TAIL = new Set([
+const SENTENCE_TAIL = /* @__PURE__ */ new Set([
 	".",
 	",",
 	";",
@@ -1091,12 +937,6 @@ const SENTENCE_TAIL = new Set([
 	"\"",
 	"'"
 ]);
-/**
-* Every token in a sent message.
-*
-* Stricter than what a composer completes: a bare `@` is a token being typed, but
-* in a sent message it is just an at sign.
-*/
 function scanPromptTokens(text) {
 	const tokens = [];
 	const words = /\S+/g;
@@ -1120,58 +960,64 @@ function scanPromptTokens(text) {
 	return tokens;
 }
 //#endregion
+//#region src/lib/async-guards.ts
+function useAliveRef() {
+	const alive = useRef(true);
+	useEffect(() => {
+		alive.current = true;
+		return () => {
+			alive.current = false;
+		};
+	}, []);
+	return alive;
+}
+function isRouteUnsupported(e) {
+	return e instanceof WorkerDeckError && e.status === 404;
+}
+//#endregion
 //#region src/lib/host-tree.ts
-/**
-* Flatten the loaded directories into the rows the tree shows.
-*
-* Pure, so the interesting part of a file tree — which nodes are visible at what
-* depth once a few directories are expanded and one of them is still loading —
-* is testable without a DOM or a gateway.
-*
-* Only *expanded* directories contribute children, and only if their listing has
-* arrived. An expanded-but-unlisted directory yields its own row with
-* `loading: true` and no children: expansion is a request the user already made,
-* so the row must say the answer is coming rather than look like an empty folder.
-*/
 function flattenHostTree(root, dirs, expanded) {
 	const rows = [];
-	const walk = (dir, depth) => {
-		const state = dirs.get(dir);
-		if (!state) return;
-		for (const entry of state.entries) {
-			if (entry.type !== "dir") {
-				rows.push({
-					entry,
-					depth
-				});
-				continue;
-			}
-			const isExpanded = expanded.has(entry.path);
-			const childState = dirs.get(entry.path);
+	const rootState = dirs.get(root);
+	if (!rootState) return rows;
+	const stack = [{
+		entries: rootState.entries,
+		index: 0,
+		depth: 0
+	}];
+	while (stack.length > 0) {
+		const frame = stack[stack.length - 1];
+		const entry = frame.entries[frame.index];
+		if (entry === void 0) {
+			stack.pop();
+			continue;
+		}
+		frame.index += 1;
+		const depth = frame.depth;
+		if (entry.type !== "dir") {
 			rows.push({
 				entry,
-				depth,
-				expanded: isExpanded,
-				loading: isExpanded && !childState,
-				truncated: isExpanded ? childState?.truncated : void 0
+				depth
 			});
-			if (isExpanded && childState) walk(entry.path, depth + 1);
+			continue;
 		}
-	};
-	walk(root, 0);
+		const isExpanded = expanded.has(entry.path);
+		const childState = dirs.get(entry.path);
+		rows.push({
+			entry,
+			depth,
+			expanded: isExpanded,
+			loading: isExpanded && !childState,
+			truncated: isExpanded ? childState?.truncated : void 0
+		});
+		if (isExpanded && childState) stack.push({
+			entries: childState.entries,
+			index: 0,
+			depth: depth + 1
+		});
+	}
 	return rows;
 }
-/**
-* Every ancestor of `path` below `root`, outermost first — the directories that
-* must be expanded for `path` to be on screen.
-*
-* Returns `[]` when `path` is not under `root` rather than guessing: revealing a
-* file the tree cannot contain is a no-op, not an error worth raising, and the
-* caller has no better answer either.
-*
-* The prefix test is on a **path boundary** (`root` + `/`), so `/src/app` is not
-* treated as living under `/src/a`.
-*/
 function ancestorsWithin(root, path) {
 	const base = root.endsWith("/") ? root.slice(0, -1) : root;
 	if (path === base || !path.startsWith(`${base}/`)) return [];
@@ -1186,19 +1032,6 @@ function ancestorsWithin(root, path) {
 }
 //#endregion
 //#region src/hooks/use-host-files.ts
-/**
-* Fuzzy file search rooted at a session's working directory — what an `@file`
-* picker needs.
-*
-* Deliberately session-scoped: the server's `hostFiles.roots` are the security
-* boundary, but what someone wants while talking to an agent is *this* project's
-* tree, so this never offers the roots list.
-*
-* A gateway that answers 404 once has answered for the session: host files are
-* either configured or they aren't, and the answer will not change while the cwd
-* holds. Asking again on every character would be a request per keystroke for a
-* feature that does not exist here.
-*/
 function useHostFileSearch(client, cwd) {
 	const [unsupported, setUnsupported] = useState(false);
 	const lastCwd = useRef(cwd);
@@ -1214,7 +1047,7 @@ function useHostFileSearch(client, cwd) {
 			const response = await client.findHostFiles(cwd, query, options?.limit ?? 8);
 			return options?.signal?.aborted ? [] : response.matches;
 		} catch (e) {
-			if (e instanceof WorkerDeckError && e.status === 404) setUnsupported(true);
+			if (isRouteUnsupported(e)) setUnsupported(true);
 			return [];
 		}
 	}, [
@@ -1227,13 +1060,6 @@ function useHostFileSearch(client, cwd) {
 		search
 	};
 }
-/**
-* Whether host files are served here, and whether they may be written.
-*
-* One request per client, cached for the life of the hook: the roots and the
-* write flag are gateway configuration, not session state, and they do not
-* change while the tab is open.
-*/
 function useHostFileRoots(client) {
 	const [result, setResult] = useState({
 		available: false,
@@ -1258,23 +1084,6 @@ function useHostFileRoots(client) {
 	}, [client]);
 	return result;
 }
-/**
-* An expandable file tree rooted at a session's working directory.
-*
-* Rooted at the cwd rather than at `/fs/roots` for the same reason
-* {@link useHostFileSearch} is: the roots are the *security* boundary the server
-* enforces on every request, but what someone wants while watching an agent work
-* is this project's tree. The roots may well be broader; showing them would
-* offer navigation to directories the session has nothing to do with.
-*
-* Listings are cached per directory and kept across a collapse, so reopening a
-* folder is instant and does not re-ask. That staleness is deliberate and
-* bounded: `refresh` exists, and knowing when to call it is the *next* problem
-* (the agent is editing this same tree), not something a tree can guess.
-*
-* Like the search hook, a 404 is answered once for the session: host files are
-* either configured here or they are not.
-*/
 function useHostFileTree(client, cwd) {
 	const [dirs, setDirs] = useState(() => /* @__PURE__ */ new Map());
 	const [expanded, setExpanded] = useState(() => /* @__PURE__ */ new Set());
@@ -1289,13 +1098,7 @@ function useHostFileTree(client, cwd) {
 		setUnsupported(false);
 		setError(void 0);
 	}, [cwd]);
-	const alive = useRef(true);
-	useEffect(() => {
-		alive.current = true;
-		return () => {
-			alive.current = false;
-		};
-	}, []);
+	const alive = useAliveRef();
 	const requested = useRef(/* @__PURE__ */ new Set());
 	const list = useCallback((target, { force = false } = {}) => {
 		if (unsupported) return;
@@ -1314,7 +1117,7 @@ function useHostFileTree(client, cwd) {
 		}).catch((e) => {
 			if (!alive.current) return;
 			requested.current.delete(target);
-			if (e instanceof WorkerDeckError && e.status === 404) {
+			if (isRouteUnsupported(e)) {
 				setUnsupported(true);
 				return;
 			}
@@ -1368,36 +1171,6 @@ function useHostFileTree(client, cwd) {
 }
 //#endregion
 //#region src/hooks/use-project-icons.ts
-/**
-* Project icon bytes for a list of sessions, as object URLs keyed by the icon's
-* own content hash.
-*
-* **Keyed by hash, and cached for the life of the page.** That is what the
-* wire's `ProjectIcon.image.hash` is for: every session in one project serves
-* identical bytes, so twelve rows of one repo cost one request, and two
-* *different* projects that happen to declare the same file cost one between
-* them. A hash names its bytes, so an entry can never go stale — editing the
-* icon changes the hash, which arrives on the next poll as a key this cache has
-* not seen. The old entry is dead weight rather than a wrong answer, and the
-* population is bounded by how many distinct icons an operator has open.
-*
-* The cache is **module scope on purpose**, like `useSessions`' store: the
-* sidebar and any other surface rendering rows mount this at once, and a
-* per-hook cache would be N copies each fetching the same bytes.
-*
-* A failure is cached as a failure. The route's 404 is the uniform "no icon"
-* (no project, a glyph, or one the gateway refused), so retrying it every poll
-* would be a request per session per poll for a picture that is never coming.
-*
-* Object URLs are never revoked, which is the same decision stated twice: they
-* are the cache. Revoking one would break every row still pointing at it, and
-* the whole point of hashing is that nothing here is ever superseded.
-*
-* The VS Code extension has the same three-set structure in `project-icons.ts`
-* and cannot share this one — its webview has no external `connect-src` at all,
-* so its bytes arrive as data URLs pushed from the extension host. One design,
-* two implementations, for a reason that is in the transport rather than here.
-*/
 const byHash = /* @__PURE__ */ new Map();
 const inFlight = /* @__PURE__ */ new Set();
 const failed = /* @__PURE__ */ new Set();
@@ -1427,39 +1200,34 @@ function useProjectIcons(rows, clientFor) {
 	return resolved;
 }
 //#endregion
-//#region src/hooks/use-profile-usage.ts
+//#region src/hooks/use-draft.ts
 /**
-* The gateway's per-profile plan usage, over REST.
-*
-* The session's own event stream carries a `rate_limit` reading only when the
-* engine volunteers one — for claude that is at a turn's edges and nowhere else,
-* so a session idle since yesterday replays yesterday's number, and a session
-* opened today knows nothing of what a sibling on the same account spent an hour
-* ago. `GET /profiles` answers the account-wide question, which is why this is a
-* poll and not a subscription: nothing pushes it.
-*
-* Polling and not attaching, deliberately — a second WebSocket per surface is
-* exactly what the bridge's "asks the first attached client" rule forbids, and
-* this is one small GET a minute.
-*
-* Self-disabling on a 404, like {@link useHostFileSearch}: a gateway without the
-* route will never grow one mid-session, so stop asking rather than log a miss
-* every minute.
+* Remember unsent composer text for a session. Purely local: it never reaches the gateway and never syncs between
+* clients, because a half-written prompt is not something anyone asked to publish.
 */
+function useDraft(client, sessionId) {
+	const key = sessionId ? draftKey(client, sessionId) : void 0;
+	return {
+		initialText: useMemo(() => key ? readDraft(key) : "", [key]),
+		save: useCallback((text) => {
+			if (key) writeDraft(key, text);
+		}, [key]),
+		clear: useCallback(() => {
+			if (key) writeDraft(key, "");
+		}, [key])
+	};
+}
+//#endregion
+//#region src/hooks/use-profile-usage.ts
 function useProfileUsage(client, profile, options = {}) {
 	const { intervalMs = 6e4, enabled = true } = options;
-	const [usage, setUsage] = useState();
+	const cacheKey = profile ? profileUsageCacheKey(client, profile) : void 0;
+	const [usage, setUsage] = useState(() => cacheKey ? readProfileUsageCache(cacheKey) : void 0);
 	const [unsupported, setUnsupported] = useState(false);
 	const [nonce, setNonce] = useState(0);
 	const refresh = useCallback(() => setNonce((n) => n + 1), []);
-	useEffect(() => setUsage(void 0), [client, profile]);
-	const alive = useRef(true);
-	useEffect(() => {
-		alive.current = true;
-		return () => {
-			alive.current = false;
-		};
-	}, []);
+	useEffect(() => setUsage(cacheKey ? readProfileUsageCache(cacheKey) : void 0), [cacheKey]);
+	const alive = useAliveRef();
 	useEffect(() => {
 		if (!profile || !enabled || unsupported) return;
 		let cancelled = false;
@@ -1467,10 +1235,12 @@ function useProfileUsage(client, profile, options = {}) {
 			if (globalThis.document?.hidden) return;
 			client.listProfiles().then((res) => {
 				if (cancelled || !alive.current) return;
-				setUsage(res.profiles.find((p) => p.name === profile)?.usage);
+				const next = res.profiles.find((p) => p.name === profile)?.usage;
+				if (cacheKey) writeProfileUsageCache(cacheKey, next);
+				setUsage(next);
 			}).catch((e) => {
 				if (cancelled || !alive.current) return;
-				if (e instanceof WorkerDeckError && e.status === 404) setUnsupported(true);
+				if (isRouteUnsupported(e)) setUnsupported(true);
 			});
 		};
 		load();
@@ -1485,7 +1255,8 @@ function useProfileUsage(client, profile, options = {}) {
 		enabled,
 		unsupported,
 		intervalMs,
-		nonce
+		nonce,
+		cacheKey
 	]);
 	return {
 		usage,
@@ -1494,18 +1265,6 @@ function useProfileUsage(client, profile, options = {}) {
 }
 //#endregion
 //#region src/hooks/use-session-info.ts
-/**
-* The registry's record of one session, over REST.
-*
-* Separate from {@link useClaudeSession} on purpose: that hook attaches a
-* WebSocket and streams a transcript, which is far more than a caller needs to
-* know a session's `cwd` or title — and a second attach would be a second
-* client on the bridge, which is the one thing the bridge's "asks the first
-* attached client" rule cannot tolerate.
-*
-* Fetched once per session id. The record is registry state, not a live feed;
-* anything that changes during a run arrives on the session's event stream.
-*/
 function useSessionInfo(client, sessionId) {
 	const [info, setInfo] = useState();
 	const [loading, setLoading] = useState(!!sessionId);
@@ -1542,39 +1301,13 @@ function useSessionInfo(client, sessionId) {
 }
 //#endregion
 //#region src/lib/open-files.ts
-/** Whether a tab has edits that are not on disk. Derived, so typing something
-* and undoing it back leaves the tab clean — which is what an editor should do
-* and what a boolean flag set on first keystroke would get wrong. */
 function isDirty(file) {
 	return file.draft !== void 0 && file.draft !== file.content;
 }
-/** What a tab would write: its edits if it has any, else what it read. */
 function currentText(file) {
 	return file.draft ?? file.content ?? "";
 }
 const initialOpenFilesState = { files: [] };
-/**
-* The tab strip and the editor's whole behaviour, as a pure function.
-*
-* The rules worth stating, because they are the ones a naive implementation
-* gets wrong:
-*
-* - **Opening an open path never re-reads it.** It focuses the tab. Re-reading
-*   would silently discard that tab's unsaved edits on a double click.
-* - **Closing the focused tab focuses its right-hand neighbour**, falling back
-*   to the left when it was last. Focusing "the first tab" instead is what makes
-*   closing several tabs in a row jump the user around.
-* - **A successful save is applied against the text that was sent**, not against
-*   the tab's current text. Typing during a save is normal; treating the write's
-*   completion as "the tab is now clean" would silently drop those keystrokes.
-* - **Nothing here discards edits implicitly.** `revert` and `loaded` are the
-*   only two things that clear a draft, and both are the direct result of
-*   someone asking for it. The conditional write exists so a browser edit cannot
-*   clobber the agent mid-run; this holds the same line in the other direction.
-*
-* Late results are addressed by path and dropped if that tab is gone, so a slow
-* read of a closed file cannot resurrect it.
-*/
 function openFilesReducer(state, action) {
 	switch (action.type) {
 		case "open": {
@@ -1666,8 +1399,6 @@ function openFilesReducer(state, action) {
 		}));
 	}
 }
-/** Replace one file in place, preserving tab order; a no-op if it was closed
-* while the request was in flight. */
 function patch(state, path, next) {
 	const index = state.files.findIndex((f) => f.path === path);
 	if (index === -1) return state;
@@ -1681,29 +1412,12 @@ function patch(state, path, next) {
 		files
 	};
 }
-/** Last path segment. Trailing slashes are not expected here — these are file
-* paths from `/fs/list` and `/fs/find` — but a bare `/` should still show as
-* something rather than as an empty tab. */
 function baseName(path) {
 	const trimmed = path.endsWith("/") ? path.slice(0, -1) : path;
 	return trimmed.slice(trimmed.lastIndexOf("/") + 1) || trimmed || path;
 }
 //#endregion
 //#region src/hooks/use-open-files.ts
-/**
-* The open-file tabs of a workspace: which files are open, which one is focused,
-* the bytes behind each, and the edits on top of them.
-*
-* Reads are fired from an effect keyed on "which tabs are still loading" rather
-* than from `open` itself, so the reducer stays pure and a tab that was opened,
-* closed and reopened does not carry a stale in-flight request with it.
-*
-* Deliberately **not** given the session's cwd: a tab is an absolute host path,
-* and where it came from — the tree, a search hit, a path in the transcript — is
-* the caller's business. Containment is the server's job on every `/fs/read` and
-* `/fs/write`, not something re-derived here from a directory this hook would
-* have to trust.
-*/
 function useOpenFiles(client) {
 	const [state, dispatch] = useReducer(openFilesReducer, initialOpenFilesState);
 	const requested = useRef(/* @__PURE__ */ new Set());
@@ -1720,7 +1434,7 @@ function useOpenFiles(client) {
 	}, [state]);
 	const pending = state.files.filter((f) => f.status === "loading").map((f) => f.path).join("\n");
 	const read = useCallback((path) => client.readHostFile(path).then((response) => {
-		if (!alive.current) return void 0;
+		if (!alive.current) return;
 		dispatch({
 			type: "loaded",
 			path,
@@ -1789,8 +1503,6 @@ function useOpenFiles(client) {
 			});
 		});
 	}, [read]);
-	/** One conditional write. Shared by `save` and `overwrite`, which differ only
-	* in where the hash came from. */
 	const write = useCallback(async (path, text, expectedHash) => {
 		try {
 			const response = await client.writeHostFile({
@@ -1868,14 +1580,6 @@ function useOpenFiles(client) {
 }
 //#endregion
 //#region src/lib/tool-host.ts
-/**
-* Answers server-bridged tool calls by executing them in this browser tab.
-* Framework-free — {@link useToolCallHost} is a thin React wrapper.
-*
-* The point is data locality: documents fetched or held client-side can be
-* evaluated here and never touch the server. The engine loads lazily, so a page
-* that never bridges a call never pays for the WASM guest.
-*/
 function createToolCallHost(handle, options = {}) {
 	const inFlight = /* @__PURE__ */ new Map();
 	let enginePromise;
@@ -1963,7 +1667,7 @@ function createToolCallHost(handle, options = {}) {
 			const sandbox = await import("@workerdeck/sandbox");
 			const vfs = sandbox.createVfs(frame.vfsSeed);
 			const timeoutMs = Math.min(frame.limits?.timeoutMs ?? Number.POSITIVE_INFINITY, options.timeoutMs ?? 5e3);
-			const memoryLimitBytes = Math.min(frame.limits?.memoryLimitBytes ?? Number.POSITIVE_INFINITY, options.memoryLimitBytes ?? 64 * 1024 * 1024);
+			const memoryLimitBytes = Math.min(frame.limits?.memoryLimitBytes ?? Number.POSITIVE_INFINITY, options.memoryLimitBytes ?? 67108864);
 			const result = options.execute ? await options.execute({
 				script,
 				vfs,
@@ -2036,19 +1740,12 @@ function createToolCallHost(handle, options = {}) {
 		inFlight.clear();
 	} };
 }
-/** The single-file browser build keeps this to one lazy chunk — no separate
-* .wasm fetch, and nothing at all until the first bridged call. */
 async function defaultLoadEngine() {
 	const [sandbox, variant] = await Promise.all([import("@workerdeck/sandbox"), import("@jitl/quickjs-singlefile-browser-release-asyncify")]);
 	return sandbox.loadEngine(variant);
 }
 //#endregion
 //#region src/hooks/use-tool-host.ts
-/**
-* React wrapper around {@link createToolCallHost}: subscribes while mounted and
-* exposes recent executions for rendering. All the logic lives in the
-* framework-free host — this only manages the subscription's lifetime.
-*/
 function useToolCallHost(handle, options = {}) {
 	const [executions, setExecutions] = useState([]);
 	const optionsRef = useRef(options);
@@ -2061,7 +1758,7 @@ function useToolCallHost(handle, options = {}) {
 				const client = optionsRef.current.clientTools;
 				if (!client) return base;
 				const clientNames = Object.keys(client);
-				return base ? [...new Set([...base, ...clientNames])] : clientNames;
+				return base ? [.../* @__PURE__ */ new Set([...base, ...clientNames])] : clientNames;
 			},
 			get clientTools() {
 				return optionsRef.current.clientTools;
@@ -2093,15 +1790,6 @@ function useToolCallHost(handle, options = {}) {
 }
 //#endregion
 //#region src/lib/recap.ts
-/**
-* Summarize the items from `fromIndex` onward — the boundary being the number
-* of items that existed when the session was last looked at.
-*
-* An out-of-range boundary is clamped rather than rejected: a transcript can
-* *shrink* (a `/clear`, a fresh attach after a compaction), and the honest
-* reading of "you last saw 40 items, there are now 12" is "everything here is
-* new", not a negative count.
-*/
 function summarizeSince(state, fromIndex) {
 	const start = Math.max(0, Math.min(fromIndex, state.items.length));
 	const fresh = state.items.slice(start);
@@ -2127,10 +1815,7 @@ function summarizeSince(state, fromIndex) {
 		case "file_delivered":
 			files += 1;
 			break;
-		case "notice":
-			if (item.level === "error") errors += 1;
-			break;
-		default: break;
+		case "notice": if (item.level === "error") errors += 1;
 	}
 	const toolNames = [...toolCounts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([name]) => name);
 	const pending = state.pendingApprovals?.length ?? 0;
@@ -2145,15 +1830,8 @@ function summarizeSince(state, fromIndex) {
 		any: turns + replies + tools + files + errors + pending > 0
 	};
 }
-/**
-* The recap as one line of text, in the order a person reads it: what got done,
-* what it used, what went wrong, what is waiting.
-*
-* Returns `undefined` when there is nothing to say, so a caller can render the
-* row or not on the value alone.
-*/
 function recapLine(summary) {
-	if (!summary.any) return void 0;
+	if (!summary.any) return;
 	const parts = [];
 	if (summary.turns > 0) parts.push(plural(summary.turns, "turn"));
 	else if (summary.replies > 0) parts.push(plural(summary.replies, "reply", "replies"));
@@ -2171,6 +1849,6 @@ function plural(count, one, many = `${one}s`) {
 	return `${count} ${count === 1 ? one : many}`;
 }
 //#endregion
-export { REPLAY_HOLD_MAX_MS, ancestorsWithin, applyEvent, attachmentKind, clearTranscriptCache, createToolCallHost, currentText, flattenHostTree, hydrateToolResult, initialOpenFilesState, initialReplayTarget, initialTranscriptState, isDirty, openFilesReducer, rateLimitWindows, recapLine, scanPromptTokens, seedFromSessionInfo, staleAttach, summarizeSince, useAttachments, useClaudeSession, useHostFileRoots, useHostFileSearch, useHostFileTree, useOpenFiles, useProfileUsage, useProjectIcons, useSessionInfo, useToolCallHost };
+export { REPLAY_HOLD_MAX_MS, ancestorsWithin, applyEvent, attachmentKind, clearDrafts, clearProfileUsageCache, clearTranscriptCache, createToolCallHost, currentText, flattenHostTree, hydrateToolResult, initialOpenFilesState, initialReplayTarget, initialTranscriptState, isDirty, openFilesReducer, rateLimitWindows, recapLine, scanPromptTokens, seedFromSessionInfo, staleAttach, summarizeSince, useAttachments, useClaudeSession, useDraft, useHostFileRoots, useHostFileSearch, useHostFileTree, useOpenFiles, useProfileUsage, useProjectIcons, useSessionInfo, useToolCallHost };
 
 //# sourceMappingURL=index.mjs.map