iterate 0.2.6 → 0.3.0

package/dist/sdk/itx/react.mjs

@@ -0,0 +1,383 @@
+import { a as disconnectIterateSession, c as reconnectIterateSession, d as retryFailedIterateSession, f as serverSnapshot, i as currentSnapshot, l as releaseItxConnection, m as watchItxConnection, n as connectIterateSession, o as isItxTransportError, p as subscribeSession, r as connectItx, s as projectStubFor, t as configureIterateSession, u as reportTransportSuspicion } from "../../itx-session-sjud8GiT.mjs";
+import { CapnWebProvider, useLiveState as useLiveState$1 } from "../capnweb/react.mjs";
+import { createContext, createElement, use, useCallback, useContext, useEffect, useState, useSyncExternalStore } from "react";
+import { QueryClient, useQuery, useSuspenseQuery } from "@tanstack/react-query";
+//#region src/itx/query-client.ts
+/**
+* One Query client policy for every Iterate React renderer.
+*
+* The browser dashboard and the OpenTUI client intentionally share these
+* defaults. Renderer-specific entrypoints own only where the provider mounts;
+* cache lifetime, refetch behavior, and mutation retries must not drift by
+* surface.
+*/
+function createIterateQueryClient() {
+	return new QueryClient({ defaultOptions: {
+		queries: {
+			staleTime: 60 * 1e3,
+			gcTime: 300 * 1e3,
+			retry: 1,
+			refetchOnWindowFocus: false,
+			refetchOnMount: true,
+			refetchOnReconnect: true
+		},
+		mutations: { retry: 0 }
+	} });
+}
+//#endregion
+//#region src/sdk/itx/react.ts
+/**
+* `iterate/sdk/itx/react` — hooks over the framework-free session keeper in
+* ../../itx/itx-session.ts (one WebSocket per tab, generations, invisible
+* reconnect — the session model lives there) plus TanStack Query for reads.
+*
+* Renderer-agnostic on purpose: nothing here touches the DOM, so the same
+* hooks run under react-dom (the OS dashboard), @opentui/react (the chat TUI),
+* and React Native — TanStack Query itself only uses React primitives. The
+* browser-specific pieces (cookie auth, window-derived URL, visibility/online
+* wake probes) live in the keeper behind runtime guards; non-browser apps
+* point the keeper at a deployment with `configureIterateSession`.
+*
+* ───────────────────────────────────────────────────────────────────────────
+* THE PRIMITIVES
+* ───────────────────────────────────────────────────────────────────────────
+*
+*   SESSION (the catalog authenticate() returned)
+*     useIterateSession()            in render; suspends once on first connect
+*     connectIterateSession()        imperative (handlers/closures); a Promise
+*
+*   ITX (a project capability handle — session.projects.get(slug))
+*     useItx(slug?)           in render; slug (or prj_ id) from the arg or <ProjectScope>
+*     connectItx(slug)        imperative; a Promise
+*
+*   READ ONCE   useItxQuery({ key, query })              project read; SUSPENDS
+*               useIterateSessionQuery({ key, query })   session read; NON-suspending (shell)
+*   LIVE STATE  useLiveState((itx) => itx.liveState, selector)  project snapshot + diffs
+*               useIterateSessionLiveState(...)                 session snapshot + diffs
+*   CONNECT     useStreamConnection((itx) => handle, deps)  raw event batches (escape hatch)
+*   MOUNT       <ProjectScope slug>   ambient project + reconnectable Cap'n Web provider
+*
+*   ACTIONS (mutations) — imperative on the handle, no extra primitive:
+*     const itx = useItx();
+*     <button onClick={() => itx.chat.sendMessage(text)} />
+*
+* RECONNECT, AS REACT SEES IT: components read an immutable Snapshot via
+* `useSyncExternalStore`; `snapshot.session` holds the LAST live session and is
+* kept across a transport gap. So `useIterateSession()` suspends exactly once —
+* first load, on the stable first-connect promise — and never again: when the
+* socket dies we keep showing the last session while a fresh generation connects
+* in the background, then swap when it establishes. TanStack keeps cached read
+* data through a reconnect (no re-suspend, no spinner); only an in-flight read
+* retries, on the transport-only policy — see useItxQuery. A stray action fired
+* during the sub-second gap rides the dead stub and rejects — the one accepted
+* edge.
+*
+* CONNECTING THROWS ON THE SERVER (never SSRs): a forever-pending `use()`
+* during streaming SSR would hang the response. Render itx consumers under an
+* `ssr: false` route or `<ClientOnly>` + `<Suspense>`.
+*/
+/** The ambient project slug for `useItx()` / `useItxQuery()` — set by <ProjectScope>. */
+const ProjectScopeContext = createContext(void 0);
+/**
+* The Session — the catalog `authenticate()` returned (`projects.list/create`,
+* admin `streams`). Suspends exactly ONCE, on first connect; a later reconnect
+* keeps returning the last session (no re-suspend — see module header).
+*/
+function useIterateSession() {
+	const snap = useSyncExternalStore(subscribeSession, currentSnapshot, serverSnapshot);
+	if (snap.session !== void 0) return snap.session;
+	return use(snap.connecting);
+}
+/**
+* The project itx for `slug` — `session.projects.get(slug)`, the real capnweb
+* stub. `slug` comes from the argument or the nearest <ProjectScope>; an
+* explicit argument wins. The returned stub's identity is stable within a socket
+* and changes once per reconnect (which re-runs effects/memos keyed on it).
+*
+*   const itx = useItx();               // ambient project (under <ProjectScope>)
+*   const itx = useItx("other-slug");   // a specific project
+*   const onSend = () => itx.chat.sendMessage(text);
+*/
+function useItx(explicitSlug) {
+	const scopedSlug = useContext(ProjectScopeContext);
+	const slug = explicitSlug ?? scopedSlug;
+	if (slug === void 0) throw new Error("useItx() needs a project: pass useItx(slug) or render under <ProjectScope slug>.");
+	return projectStubFor(useIterateSession(), slug);
+}
+/**
+* Set the ambient project for a subtree and provide its reconnectable Cap'n Web
+* root. The project-specific layer is deliberately only a connection factory;
+* live-state ownership and recovery live in `iterate/sdk/capnweb/react`.
+*
+* The provider dials in an effect, never during render, so this context remains
+* safe to render on the server. The duplicate belongs to the provider; the
+* lower-level session keeper keeps owning and reconnecting the shared socket
+* beneath it.
+*/
+function ProjectScope({ slug, children }) {
+	const makeConnection = useCallback(async () => (await connectItx(slug)).dup(), [slug]);
+	return createElement(ProjectScopeContext, { value: slug }, createElement(CapnWebProvider, { makeConnection }, children));
+}
+/**
+* The shared TanStack retry policy for itx reads: retry ONLY transport-close
+* failures (a fresh generation is already reconnecting), briefly — application
+* errors surface immediately.
+*/
+const itxTransportRetry = {
+	retry: (failureCount, error) => isItxTransportError(error) && failureCount < 3,
+	retryDelay: (failureCount) => Math.min(250 * 2 ** failureCount, 2e3)
+};
+/**
+* Read once through a project itx, suspending until it resolves. A thin adapter
+* over TanStack Query's `useSuspenseQuery`. `key` (prefixed with "itx"
+* internally) is the cache key — it must encode what the result is scoped to,
+* INCLUDING the project, so two projects' data can't collide: a per-project read
+* keys by the project, e.g. `["repo-files", projectId, repoPath]`. (The ambient
+* slug drives the CONNECTION, not the key — so a mutation invalidates with the
+* same `["itx", ...key]` it was written under.)
+*
+*   const files = useItxQuery({
+*     key: ["repo-files", projectId, repoPath],
+*     query: (itx) => itx.repos.get(repoPath).listFiles(),
+*   });
+*
+* The connection is resolved PER FETCH (never a render-captured stub — that
+* would pin a dead socket after a reconnect), and the per-fetch project stub is
+* disposed once the read resolves. A resolved query keeps its cached data across
+* a reconnect (no re-suspend, no spinner); only an in-flight read retries, on a
+* finite transport-only policy. Errors with no cached data throw to the nearest
+* error boundary; refetch after a mutation with
+* `queryClient.invalidateQueries({ queryKey: ["itx", ...key] })`.
+*/
+function useItxQuery({ key, query }) {
+	const slug = useContext(ProjectScopeContext);
+	if (slug === void 0) throw new Error("useItxQuery needs a project: render it under <ProjectScope slug>.");
+	return useSuspenseQuery({
+		queryKey: ["itx", ...key],
+		queryFn: async () => {
+			const itx = (await connectIterateSession()).projects.get(slug);
+			try {
+				return await query(itx);
+			} finally {
+				itx[Symbol.dispose]?.();
+			}
+		},
+		...itxTransportRetry
+	}).data;
+}
+/**
+* Read once through the SESSION (the catalog — `projects.list`, admin `streams`),
+* the session-scoped sibling of {@link useItxQuery}. NON-suspending: session
+* reads live in the always-mounted shell (sidebar, ⌘K, admin) which must not
+* suspend on the socket, so this returns the full TanStack result (`data`,
+* `isPending`, …) and accepts the usual options (`enabled`, `staleTime`). Same
+* `["itx", ...key]` namespace and the same transport-only retry as useItxQuery,
+* resolved per fetch (never a render-captured session stub).
+*
+*   const { data } = useIterateSessionQuery({ key: ["projects"], query: (s) => s.projects.list() });
+*/
+function useIterateSessionQuery({ key, query, enabled, staleTime }) {
+	return useQuery({
+		queryKey: ["itx", ...key],
+		queryFn: () => connectIterateSession().then(query),
+		...itxTransportRetry,
+		enabled,
+		staleTime
+	});
+}
+/**
+* Set up a live itx subscription (or any mount-scoped async itx work) and tear
+* it down on unmount. The itx is awaited INSIDE the effect (never in render),
+* so this hook NEVER suspends — and a reconnect silently re-runs the effect
+* (the effect is keyed on the session generation), whose first server push is
+* the recovery. A hand-rolled `useEffect` reaching itx through a closure would
+* omit that dep and not recover on reconnect. That generation dep is also the
+* whole retry story for a failed connection attempt: the failing connection attempt has already published
+* its (paced) successor, which re-runs the effect — no timer needed here.
+*
+*   useReconnectableEffect(async (itx, signal) => {
+*     const sub = await itx.streams.get("/logs").openConnection({ processEventBatch });
+*     if (signal.disposed) { sub.unsubscribe(); return; }
+*     return () => sub.unsubscribe();
+*   }, []);
+*
+* A late cleanup (setup resolved after this run was superseded) still executes.
+* `enabled: false` renders it fully inert.
+*/
+function useReconnectableEffect(setup, deps, connection, opts) {
+	const enabled = opts?.enabled ?? true;
+	const generation = useSyncExternalStore(subscribeSession, () => enabled ? currentSnapshot().generation : 0, () => 0);
+	useEffect(() => {
+		if (!enabled) return;
+		const signal = { disposed: false };
+		let cleanup;
+		if (connection.connect !== void 0) connection.connect().then((root) => {
+			if (signal.disposed) return;
+			setup(root, signal).then((late) => {
+				if (signal.disposed) late?.();
+				else cleanup = late;
+			}, (error) => {
+				if (!signal.disposed) console.error("reconnectable itx effect setup failed", error);
+			});
+		}, (error) => {
+			if (signal.disposed) return;
+			if (opts?.onConnectionError) opts.onConnectionError(error);
+			else console.error("reconnectable itx effect connect failed", error);
+		});
+		else {
+			const error = new Error(connection.missingMessage);
+			if (opts?.onConnectionError) opts.onConnectionError(error);
+			else console.error(error.message);
+		}
+		return () => {
+			signal.disposed = true;
+			cleanup?.();
+		};
+	}, [
+		enabled,
+		connection.key,
+		generation,
+		...deps
+	]);
+}
+/** How long useStreamConnection waits before retrying a failed open. */
+const CONNECTION_RETRY_MS = 1e4;
+/** An open RPC must either establish or give recovery ownership back to the hook. */
+const CONNECTION_TIMEOUT_MS = 15e3;
+const CONNECTION_TIMED_OUT = Symbol("itx-connection-timed-out");
+/** Shared reconnect and watchdog engine behind stream and live-state push APIs. */
+function useRecoveringConnection(open, deps, connection, enabled = true) {
+	const [epoch, setEpoch] = useState(0);
+	const [state, setState] = useState({ status: "connecting" });
+	useEffect(() => {
+		if (!enabled) setState({ status: "connecting" });
+	}, [enabled]);
+	useReconnectableEffect(async (root, signal) => {
+		setState({ status: "connecting" });
+		let openedConnection;
+		try {
+			const pending = open(root);
+			let timeout;
+			const result = await Promise.race([pending, new Promise((resolve) => {
+				timeout = setTimeout(() => resolve(CONNECTION_TIMED_OUT), CONNECTION_TIMEOUT_MS);
+			})]).finally(() => clearTimeout(timeout));
+			if (result === CONNECTION_TIMED_OUT) {
+				pending.then((late) => releaseItxConnection(late), () => {});
+				if (signal.disposed) return;
+				reportTransportSuspicion();
+				setState({ status: "connecting" });
+				const retry = setTimeout(() => setEpoch((current) => current + 1), CONNECTION_RETRY_MS);
+				return () => clearTimeout(retry);
+			}
+			openedConnection = result;
+		} catch (error) {
+			if (signal.disposed) return;
+			if (!isItxTransportError(error)) {
+				setState({
+					status: "error",
+					error: error instanceof Error ? error.message : String(error)
+				});
+				return;
+			}
+			setState({ status: "connecting" });
+			const retry = setTimeout(() => setEpoch((current) => current + 1), CONNECTION_RETRY_MS);
+			return () => clearTimeout(retry);
+		}
+		const dispose = () => releaseItxConnection(openedConnection);
+		if (signal.disposed) {
+			dispose();
+			return;
+		}
+		setState({ status: "live" });
+		const stopWatchdog = watchItxConnection(() => openedConnection.ping(), () => {
+			if (signal.disposed) return;
+			setState({ status: "connecting" });
+			setEpoch((current) => current + 1);
+		});
+		return () => {
+			stopWatchdog();
+			dispose();
+		};
+	}, [epoch, ...deps], connection, {
+		enabled,
+		onConnectionError: (error) => {
+			setState(isItxTransportError(error) ? { status: "connecting" } : {
+				status: "error",
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	});
+	const refresh = useCallback(() => {
+		setState({ status: "connecting" });
+		setEpoch((current) => current + 1);
+	}, []);
+	return {
+		...state,
+		refresh
+	};
+}
+/**
+* Hold one raw stream callback connection for the component's lifetime.
+* Reconnects, silent connection death, and transport-failed open attempts recover
+* through the shared watchdog; permanent failures remain in `"error"` until
+* `refresh()` or a reconnect. Reopening replays the first push, so callbacks
+* must be replay-tolerant. Teardown closes and disposes the handle.
+*
+* `enabled: false` is inert; `deps` reopen on change. `opts.slug` targets
+* a project outside the ambient {@link ProjectScope} without suspending.
+*/
+function useStreamConnection(open, deps, opts) {
+	const scopedSlug = useContext(ProjectScopeContext);
+	const slug = opts?.slug ?? scopedSlug;
+	return useRecoveringConnection(open, deps, {
+		key: slug,
+		...slug === void 0 ? { missingMessage: "useStreamConnection needs a project: pass { slug } or render under <ProjectScope slug>." } : { connect: () => connectItx(slug) }
+	}, opts?.enabled);
+}
+/**
+* THE live-state primitive: subscribe to any `.liveState` node, render the slice
+* you pick. The server pushes a snapshot then minimal diffs; this hook
+* reassembles them and hands back `selector(state)`.
+*
+*   const streams = useLiveState((itx) => itx.liveState, (s) => s.streamsIndex);
+*
+* THE SELECTOR CONTRACT — a pure function of the state, nothing else:
+* - Return a STABLE slice (`s => s.rows`), not a fresh object; map downstream.
+* - Do NOT close over props/state (`s => s.rows[props.id]`): selection is cached
+*   by STATE identity, so a closure-captured value going stale is invisible until
+*   the next push. Select the broader slice and index in render, or route the
+*   changing input through `deps`.
+*
+* `value` is `undefined` between mount and the first snapshot (one round trip);
+* render a loading row for that window. It never suspends — a reconnect keeps the
+* last value while the subscription silently re-establishes. `deps` (or a changed
+* `opts.slug`) re-point the hook at a different node, and the held value drops to
+* `undefined` immediately — the previous node's state is never shown against the
+* new one. To read a DIFFERENT project's live state from OUTSIDE its scope (⌘K in
+* the app shell), pass `opts.slug`.
+*/
+function useLiveState(live, selector, deps = [], opts) {
+	const scopedSlug = useContext(ProjectScopeContext);
+	const slug = opts?.slug ?? scopedSlug;
+	const useAmbientProvider = scopedSlug !== void 0 && (opts?.slug === void 0 || slug === scopedSlug);
+	const makeConnection = useCallback(async () => {
+		if (slug === void 0) throw new Error("useLiveState needs a project: pass { slug } or render under <ProjectScope slug>.");
+		return (await connectItx(slug)).dup();
+	}, [slug]);
+	return useLiveState$1(live, selector, deps, useAmbientProvider ? { enabled: opts?.enabled } : {
+		enabled: opts?.enabled,
+		makeConnection
+	});
+}
+/** Session-scoped sibling of {@link useLiveState}, for deployment-wide live nodes. */
+function useIterateSessionLiveState(live, selector, deps = [], opts) {
+	const makeConnection = useCallback(async () => (await connectIterateSession()).dup(), []);
+	return useLiveState$1(live, selector, deps, {
+		enabled: opts?.enabled,
+		makeConnection
+	});
+}
+//#endregion
+export { ProjectScope, configureIterateSession, connectIterateSession, connectItx, createIterateQueryClient, disconnectIterateSession, isItxTransportError, reconnectIterateSession, reportTransportSuspicion, retryFailedIterateSession, useIterateSession, useIterateSessionLiveState, useIterateSessionQuery, useItx, useItxQuery, useLiveState, useStreamConnection };
+
+//# sourceMappingURL=react.mjs.map

package/dist/sdk/itx/react.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.mjs","names":["useCapnWebLiveState"],"sources":["../../../src/itx/query-client.ts","../../../src/sdk/itx/react.ts"],"sourcesContent":["import { QueryClient } from \"@tanstack/react-query\";\n\n/**\n * One Query client policy for every Iterate React renderer.\n *\n * The browser dashboard and the OpenTUI client intentionally share these\n * defaults. Renderer-specific entrypoints own only where the provider mounts;\n * cache lifetime, refetch behavior, and mutation retries must not drift by\n * surface.\n */\nexport function createIterateQueryClient(): QueryClient {\n  return new QueryClient({\n    defaultOptions: {\n      queries: {\n        staleTime: 60 * 1000,\n        gcTime: 5 * 60 * 1000,\n        retry: 1,\n        refetchOnWindowFocus: false,\n        refetchOnMount: true,\n        refetchOnReconnect: true,\n      },\n      mutations: {\n        retry: 0,\n      },\n    },\n  });\n}\n","/**\n * `iterate/sdk/itx/react` — hooks over the framework-free session keeper in\n * ../../itx/itx-session.ts (one WebSocket per tab, generations, invisible\n * reconnect — the session model lives there) plus TanStack Query for reads.\n *\n * Renderer-agnostic on purpose: nothing here touches the DOM, so the same\n * hooks run under react-dom (the OS dashboard), @opentui/react (the chat TUI),\n * and React Native — TanStack Query itself only uses React primitives. The\n * browser-specific pieces (cookie auth, window-derived URL, visibility/online\n * wake probes) live in the keeper behind runtime guards; non-browser apps\n * point the keeper at a deployment with `configureIterateSession`.\n *\n * ───────────────────────────────────────────────────────────────────────────\n * THE PRIMITIVES\n * ───────────────────────────────────────────────────────────────────────────\n *\n *   SESSION (the catalog authenticate() returned)\n *     useIterateSession()            in render; suspends once on first connect\n *     connectIterateSession()        imperative (handlers/closures); a Promise\n *\n *   ITX (a project capability handle — session.projects.get(slug))\n *     useItx(slug?)           in render; slug (or prj_ id) from the arg or <ProjectScope>\n *     connectItx(slug)        imperative; a Promise\n *\n *   READ ONCE   useItxQuery({ key, query })              project read; SUSPENDS\n *               useIterateSessionQuery({ key, query })   session read; NON-suspending (shell)\n *   LIVE STATE  useLiveState((itx) => itx.liveState, selector)  project snapshot + diffs\n *               useIterateSessionLiveState(...)                 session snapshot + diffs\n *   CONNECT     useStreamConnection((itx) => handle, deps)  raw event batches (escape hatch)\n *   MOUNT       <ProjectScope slug>   ambient project + reconnectable Cap'n Web provider\n *\n *   ACTIONS (mutations) — imperative on the handle, no extra primitive:\n *     const itx = useItx();\n *     <button onClick={() => itx.chat.sendMessage(text)} />\n *\n * RECONNECT, AS REACT SEES IT: components read an immutable Snapshot via\n * `useSyncExternalStore`; `snapshot.session` holds the LAST live session and is\n * kept across a transport gap. So `useIterateSession()` suspends exactly once —\n * first load, on the stable first-connect promise — and never again: when the\n * socket dies we keep showing the last session while a fresh generation connects\n * in the background, then swap when it establishes. TanStack keeps cached read\n * data through a reconnect (no re-suspend, no spinner); only an in-flight read\n * retries, on the transport-only policy — see useItxQuery. A stray action fired\n * during the sub-second gap rides the dead stub and rejects — the one accepted\n * edge.\n *\n * CONNECTING THROWS ON THE SERVER (never SSRs): a forever-pending `use()`\n * during streaming SSR would hang the response. Render itx consumers under an\n * `ssr: false` route or `<ClientOnly>` + `<Suspense>`.\n */\n\n// oxlint-disable react/only-export-components -- the itx hooks are colocated with <ProjectScope> by design (see module header); this file is the whole itx React surface, not a Fast Refresh component module.\nimport {\n  createContext,\n  createElement,\n  use,\n  useCallback,\n  useContext,\n  useEffect,\n  useState,\n  useSyncExternalStore,\n  type ReactNode,\n} from \"react\";\nimport {\n  useQuery,\n  useSuspenseQuery,\n  type QueryKey,\n  type UseQueryResult,\n} from \"@tanstack/react-query\";\nimport type { LiveStateRpc } from \"../../itx-api.generated.ts\";\nimport {\n  CapnWebProvider,\n  useLiveState as useCapnWebLiveState,\n  type LiveStateStatus,\n} from \"../capnweb/react.tsx\";\nimport {\n  connectIterateSession,\n  connectItx,\n  currentSnapshot,\n  isItxTransportError,\n  projectStubFor,\n  releaseItxConnection,\n  reportTransportSuspicion,\n  serverSnapshot,\n  subscribeSession,\n  watchItxConnection,\n  type ItxRecoverableConnectionHandle,\n  type ProjectStub,\n  type SessionStub,\n} from \"../../itx/itx-session.ts\";\n\n// The React entry is one-stop: everything a component file needs — hooks AND\n// the imperative/keeper surface — importable from one place.\nexport {\n  configureIterateSession,\n  connectIterateSession,\n  connectItx,\n  disconnectIterateSession,\n  isItxTransportError,\n  reconnectIterateSession,\n  retryFailedIterateSession,\n  reportTransportSuspicion,\n  type Itx,\n  type ItxRecoverableConnectionHandle,\n  type IterateSessionConfig,\n  type ProjectStub,\n  type SessionStub,\n} from \"../../itx/itx-session.ts\";\nexport { createIterateQueryClient } from \"../../itx/query-client.ts\";\nexport type * from \"../../itx-api.generated.ts\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// 1. Connection: <ProjectScope> (ambient slug + pre-warm) + useIterateSession/useItx\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** The ambient project slug for `useItx()` / `useItxQuery()` — set by <ProjectScope>. */\nconst ProjectScopeContext = createContext<string | undefined>(undefined);\n\n/**\n * The Session — the catalog `authenticate()` returned (`projects.list/create`,\n * admin `streams`). Suspends exactly ONCE, on first connect; a later reconnect\n * keeps returning the last session (no re-suspend — see module header).\n */\nexport function useIterateSession(): SessionStub {\n  const snap = useSyncExternalStore(subscribeSession, currentSnapshot, serverSnapshot);\n  if (snap.session !== undefined) return snap.session;\n  return use(snap.connecting);\n}\n\n/**\n * The project itx for `slug` — `session.projects.get(slug)`, the real capnweb\n * stub. `slug` comes from the argument or the nearest <ProjectScope>; an\n * explicit argument wins. The returned stub's identity is stable within a socket\n * and changes once per reconnect (which re-runs effects/memos keyed on it).\n *\n *   const itx = useItx();               // ambient project (under <ProjectScope>)\n *   const itx = useItx(\"other-slug\");   // a specific project\n *   const onSend = () => itx.chat.sendMessage(text);\n */\nexport function useItx(explicitSlug?: string): ProjectStub {\n  // Read the scope UNCONDITIONALLY (rules-of-hooks): never behind a default arg.\n  const scopedSlug = useContext(ProjectScopeContext);\n  const slug = explicitSlug ?? scopedSlug;\n  if (slug === undefined) {\n    throw new Error(\n      \"useItx() needs a project: pass useItx(slug) or render under <ProjectScope slug>.\",\n    );\n  }\n  return projectStubFor(useIterateSession(), slug);\n}\n\n/**\n * Set the ambient project for a subtree and provide its reconnectable Cap'n Web\n * root. The project-specific layer is deliberately only a connection factory;\n * live-state ownership and recovery live in `iterate/sdk/capnweb/react`.\n *\n * The provider dials in an effect, never during render, so this context remains\n * safe to render on the server. The duplicate belongs to the provider; the\n * lower-level session keeper keeps owning and reconnecting the shared socket\n * beneath it.\n */\nexport function ProjectScope({ slug, children }: { slug: string; children?: ReactNode }) {\n  const makeConnection = useCallback(async () => (await connectItx(slug)).dup(), [slug]);\n  return createElement(\n    ProjectScopeContext,\n    { value: slug },\n    createElement(CapnWebProvider, { makeConnection }, children),\n  );\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// 2. Reads: useItxQuery() — suspends until resolved, then stale-while-revalidate\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * The shared TanStack retry policy for itx reads: retry ONLY transport-close\n * failures (a fresh generation is already reconnecting), briefly — application\n * errors surface immediately.\n */\nconst itxTransportRetry = {\n  retry: (failureCount: number, error: Error) => isItxTransportError(error) && failureCount < 3,\n  retryDelay: (failureCount: number) => Math.min(250 * 2 ** failureCount, 2_000),\n};\n\n/**\n * Read once through a project itx, suspending until it resolves. A thin adapter\n * over TanStack Query's `useSuspenseQuery`. `key` (prefixed with \"itx\"\n * internally) is the cache key — it must encode what the result is scoped to,\n * INCLUDING the project, so two projects' data can't collide: a per-project read\n * keys by the project, e.g. `[\"repo-files\", projectId, repoPath]`. (The ambient\n * slug drives the CONNECTION, not the key — so a mutation invalidates with the\n * same `[\"itx\", ...key]` it was written under.)\n *\n *   const files = useItxQuery({\n *     key: [\"repo-files\", projectId, repoPath],\n *     query: (itx) => itx.repos.get(repoPath).listFiles(),\n *   });\n *\n * The connection is resolved PER FETCH (never a render-captured stub — that\n * would pin a dead socket after a reconnect), and the per-fetch project stub is\n * disposed once the read resolves. A resolved query keeps its cached data across\n * a reconnect (no re-suspend, no spinner); only an in-flight read retries, on a\n * finite transport-only policy. Errors with no cached data throw to the nearest\n * error boundary; refetch after a mutation with\n * `queryClient.invalidateQueries({ queryKey: [\"itx\", ...key] })`.\n */\nexport function useItxQuery<T>({\n  key,\n  query,\n}: {\n  key: QueryKey;\n  query: (itx: ProjectStub) => Promise<T>;\n}): T {\n  const slug = useContext(ProjectScopeContext);\n  if (slug === undefined) {\n    throw new Error(\"useItxQuery needs a project: render it under <ProjectScope slug>.\");\n  }\n  return useSuspenseQuery({\n    queryKey: [\"itx\", ...key],\n    queryFn: async () => {\n      const session = await connectIterateSession();\n      const itx = session.projects.get(slug);\n      // `return await` is load-bearing: dispose only AFTER the RPC result has\n      // fully resolved (the serialized result is already pulled, so disposing\n      // the short-lived stub can't invalidate it).\n      try {\n        return await query(itx);\n      } finally {\n        (itx as Partial<Disposable>)[Symbol.dispose]?.();\n      }\n    },\n    ...itxTransportRetry,\n  }).data;\n}\n\n/**\n * Read once through the SESSION (the catalog — `projects.list`, admin `streams`),\n * the session-scoped sibling of {@link useItxQuery}. NON-suspending: session\n * reads live in the always-mounted shell (sidebar, ⌘K, admin) which must not\n * suspend on the socket, so this returns the full TanStack result (`data`,\n * `isPending`, …) and accepts the usual options (`enabled`, `staleTime`). Same\n * `[\"itx\", ...key]` namespace and the same transport-only retry as useItxQuery,\n * resolved per fetch (never a render-captured session stub).\n *\n *   const { data } = useIterateSessionQuery({ key: [\"projects\"], query: (s) => s.projects.list() });\n */\nexport function useIterateSessionQuery<T>({\n  key,\n  query,\n  enabled,\n  staleTime,\n}: {\n  key: QueryKey;\n  query: (session: SessionStub) => Promise<T>;\n  enabled?: boolean;\n  staleTime?: number;\n}): UseQueryResult<T> {\n  return useQuery({\n    queryKey: [\"itx\", ...key],\n    queryFn: () => connectIterateSession().then(query),\n    ...itxTransportRetry,\n    enabled,\n    staleTime,\n  });\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// 3. Live subscriptions: a reconnect-aware effect\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * The cancellation contract an async reconnectable setup\n * runs under. `disposed` flips the moment THIS run is superseded — unmount,\n * deps change, or a reconnect re-run — and it flips BEFORE the run's own\n * cleanup executes. Everything a setup does after an `await` must be gated on\n * it: without the shared signal, a run cancelled mid-await can't know, and its\n * late continuation would overwrite the successor's state.\n */\ntype ItxEffectSignal = { readonly disposed: boolean };\n\ntype RootConnection<Root> =\n  | { key: unknown; connect: () => Promise<Root> }\n  | { key: unknown; connect?: undefined; missingMessage: string };\n\n/**\n * Set up a live itx subscription (or any mount-scoped async itx work) and tear\n * it down on unmount. The itx is awaited INSIDE the effect (never in render),\n * so this hook NEVER suspends — and a reconnect silently re-runs the effect\n * (the effect is keyed on the session generation), whose first server push is\n * the recovery. A hand-rolled `useEffect` reaching itx through a closure would\n * omit that dep and not recover on reconnect. That generation dep is also the\n * whole retry story for a failed connection attempt: the failing connection attempt has already published\n * its (paced) successor, which re-runs the effect — no timer needed here.\n *\n *   useReconnectableEffect(async (itx, signal) => {\n *     const sub = await itx.streams.get(\"/logs\").openConnection({ processEventBatch });\n *     if (signal.disposed) { sub.unsubscribe(); return; }\n *     return () => sub.unsubscribe();\n *   }, []);\n *\n * A late cleanup (setup resolved after this run was superseded) still executes.\n * `enabled: false` renders it fully inert.\n */\nfunction useReconnectableEffect<Root>(\n  setup: (root: Root, signal: ItxEffectSignal) => Promise<void | (() => void)>,\n  deps: unknown[],\n  connection: RootConnection<Root>,\n  opts?: {\n    enabled?: boolean;\n    onConnectionError?: (error: unknown) => void;\n  },\n): void {\n  const enabled = opts?.enabled ?? true;\n  // A socket death replaces the generation; that number in the deps re-runs the\n  // effect on it (the reconnect recovery).\n  const generation = useSyncExternalStore(\n    subscribeSession,\n    () => (enabled ? currentSnapshot().generation : 0),\n    () => 0,\n  );\n  useEffect(() => {\n    if (!enabled) return;\n    const signal = { disposed: false };\n    let cleanup: void | (() => void);\n    if (connection.connect !== undefined) {\n      // Await the connection INSIDE the effect: mounting never suspends the tree.\n      connection.connect().then(\n        (root) => {\n          if (signal.disposed) return;\n          setup(root, signal).then(\n            (late) => {\n              // Setup resolved after this run was superseded: run its cleanup now.\n              if (signal.disposed) late?.();\n              else cleanup = late;\n            },\n            (error: unknown) => {\n              if (!signal.disposed) {\n                console.error(\"reconnectable itx effect setup failed\", error);\n              }\n            },\n          );\n        },\n        (error: unknown) => {\n          if (signal.disposed) return;\n          if (opts?.onConnectionError) opts.onConnectionError(error);\n          else console.error(\"reconnectable itx effect connect failed\", error);\n        },\n      );\n    } else {\n      const error = new Error(connection.missingMessage);\n      if (opts?.onConnectionError) opts.onConnectionError(error);\n      else console.error(error.message);\n    }\n    return () => {\n      signal.disposed = true;\n      cleanup?.();\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- connection key + caller's deps; setup/read factory are fresh per run\n  }, [enabled, connection.key, generation, ...deps]);\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// 4. Push connections: useStreamConnection() — recovery + watchdog; useLiveState()\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** How long useStreamConnection waits before retrying a failed open. */\nconst CONNECTION_RETRY_MS = 10_000;\n/** An open RPC must either establish or give recovery ownership back to the hook. */\nconst CONNECTION_TIMEOUT_MS = 15_000;\nconst CONNECTION_TIMED_OUT = Symbol(\"itx-connection-timed-out\");\n\nexport type ItxConnectionStatus = LiveStateStatus;\n\n/** Shared reconnect and watchdog engine behind stream and live-state push APIs. */\nfunction useRecoveringConnection<Root>(\n  open: (root: Root) => Promise<ItxRecoverableConnectionHandle>,\n  deps: unknown[],\n  connection: RootConnection<Root>,\n  enabled = true,\n): { status: ItxConnectionStatus; error?: string; refresh: () => void } {\n  const [epoch, setEpoch] = useState(0);\n  const [state, setState] = useState<{ status: ItxConnectionStatus; error?: string }>({\n    status: \"connecting\",\n  });\n\n  // Disabling makes the whole effect inert; reset status so a connection\n  // disabled after a live period doesn't keep reporting \"live\".\n  useEffect(() => {\n    if (!enabled) setState({ status: \"connecting\" });\n  }, [enabled]);\n\n  useReconnectableEffect(\n    async (root, signal) => {\n      setState({ status: \"connecting\" });\n\n      let openedConnection: ItxRecoverableConnectionHandle;\n      try {\n        const pending = open(root);\n        let timeout: ReturnType<typeof setTimeout> | undefined;\n        const result = await Promise.race([\n          pending,\n          new Promise<typeof CONNECTION_TIMED_OUT>((resolve) => {\n            timeout = setTimeout(() => resolve(CONNECTION_TIMED_OUT), CONNECTION_TIMEOUT_MS);\n          }),\n        ]).finally(() => clearTimeout(timeout));\n        if (result === CONNECTION_TIMED_OUT) {\n          // A transport can disappear after the server accepted the open but\n          // before the browser receives its handle. No handle means no ping\n          // watchdog, and a half-open WebSocket emits no close event: without\n          // this bound the UI stays \"connecting\" forever. REPORT the suspicion\n          // (never close the shared socket ourselves — the verifier two-strikes\n          // and, if genuinely half-open, reconnects, whose generation re-runs this\n          // effect); a straggler handle is closed AND disposed.\n          void pending.then(\n            (late) => releaseItxConnection(late),\n            () => {},\n          );\n          if (signal.disposed) return;\n          reportTransportSuspicion();\n          // This attempt is bounded and a retry is already scheduled, so the\n          // consumer remains in a recoverable connecting state rather than\n          // replacing already-loaded data with terminal error UI.\n          setState({ status: \"connecting\" });\n          // Retry regardless of the verifier's verdict: a wedged-but-alive\n          // server (cold DO) recovers on the next attempt, not on a reconnect.\n          const retry = setTimeout(() => setEpoch((current) => current + 1), CONNECTION_RETRY_MS);\n          return () => clearTimeout(retry);\n        }\n        openedConnection = result;\n      } catch (error) {\n        // The ONE cancellation signal: a run superseded mid-await (unmount,\n        // deps, reconnect) must not touch state its successor now owns.\n        if (signal.disposed) return;\n        if (!isItxTransportError(error)) {\n          setState({\n            status: \"error\",\n            error: error instanceof Error ? error.message : String(error),\n          });\n          return;\n        }\n        // Recoverable transport failures never become terminal UI errors. Keep\n        // already-loaded consumers rendered while this hook retries.\n        setState({ status: \"connecting\" });\n        const retry = setTimeout(() => setEpoch((current) => current + 1), CONNECTION_RETRY_MS);\n        return () => clearTimeout(retry);\n      }\n      const dispose = () => releaseItxConnection(openedConnection);\n      if (signal.disposed) {\n        dispose();\n        return;\n      }\n      setState({ status: \"live\" });\n\n      const stopWatchdog = watchItxConnection(\n        () => openedConnection.ping(),\n        () => {\n          if (signal.disposed) return;\n          setState({ status: \"connecting\" });\n          // Open again unconditionally. When only the server-side callback\n          // connection died, the shared transport is still fine and this is\n          // the whole recovery; on a transport timeout the\n          // verifier may be reconnecting, and the generation dep will also re-run\n          // this effect — the epoch bump covers both, and a doubled\n          // second open is idempotent by connection key.\n          setEpoch((current) => current + 1);\n        },\n      );\n\n      return () => {\n        stopWatchdog();\n        dispose();\n      };\n    },\n    [epoch, ...deps],\n    connection,\n    {\n      enabled,\n      // A failed connect never reaches setup, so without this the hook would sit\n      // on \"connecting\" forever. No timer: the failed connection attempt has already published\n      // a paced successor, and that generation dep re-runs the effect.\n      onConnectionError: (error) => {\n        setState(\n          isItxTransportError(error)\n            ? { status: \"connecting\" }\n            : {\n                status: \"error\",\n                error: error instanceof Error ? error.message : String(error),\n              },\n        );\n      },\n    },\n  );\n\n  // Stable identity: `refresh` lands in consumer deps and memoized children.\n  const refresh = useCallback(() => {\n    setState({ status: \"connecting\" });\n    setEpoch((current) => current + 1);\n  }, []);\n\n  return { ...state, refresh };\n}\n\n/**\n * Hold one raw stream callback connection for the component's lifetime.\n * Reconnects, silent connection death, and transport-failed open attempts recover\n * through the shared watchdog; permanent failures remain in `\"error\"` until\n * `refresh()` or a reconnect. Reopening replays the first push, so callbacks\n * must be replay-tolerant. Teardown closes and disposes the handle.\n *\n * `enabled: false` is inert; `deps` reopen on change. `opts.slug` targets\n * a project outside the ambient {@link ProjectScope} without suspending.\n */\nexport function useStreamConnection(\n  open: (itx: ProjectStub) => Promise<ItxRecoverableConnectionHandle>,\n  deps: unknown[],\n  opts?: { enabled?: boolean; slug?: string },\n): { status: ItxConnectionStatus; error?: string; refresh: () => void } {\n  const scopedSlug = useContext(ProjectScopeContext);\n  const slug = opts?.slug ?? scopedSlug;\n  return useRecoveringConnection(\n    open,\n    deps,\n    {\n      key: slug,\n      ...(slug === undefined\n        ? {\n            missingMessage:\n              \"useStreamConnection needs a project: pass { slug } or render under <ProjectScope slug>.\",\n          }\n        : { connect: () => connectItx(slug) }),\n    },\n    opts?.enabled,\n  );\n}\n\n/**\n * THE live-state primitive: subscribe to any `.liveState` node, render the slice\n * you pick. The server pushes a snapshot then minimal diffs; this hook\n * reassembles them and hands back `selector(state)`.\n *\n *   const streams = useLiveState((itx) => itx.liveState, (s) => s.streamsIndex);\n *\n * THE SELECTOR CONTRACT — a pure function of the state, nothing else:\n * - Return a STABLE slice (`s => s.rows`), not a fresh object; map downstream.\n * - Do NOT close over props/state (`s => s.rows[props.id]`): selection is cached\n *   by STATE identity, so a closure-captured value going stale is invisible until\n *   the next push. Select the broader slice and index in render, or route the\n *   changing input through `deps`.\n *\n * `value` is `undefined` between mount and the first snapshot (one round trip);\n * render a loading row for that window. It never suspends — a reconnect keeps the\n * last value while the subscription silently re-establishes. `deps` (or a changed\n * `opts.slug`) re-point the hook at a different node, and the held value drops to\n * `undefined` immediately — the previous node's state is never shown against the\n * new one. To read a DIFFERENT project's live state from OUTSIDE its scope (⌘K in\n * the app shell), pass `opts.slug`.\n */\nexport function useLiveState<State, Selected = State>(\n  live: (itx: ProjectStub) => LiveStateRpc<State>,\n  selector: (state: State) => Selected,\n  deps: unknown[] = [],\n  opts?: { slug?: string; enabled?: boolean },\n): {\n  value: Selected | undefined;\n  status: ItxConnectionStatus;\n  error?: string;\n  refresh: () => void;\n} {\n  const scopedSlug = useContext(ProjectScopeContext);\n  const slug = opts?.slug ?? scopedSlug;\n  const useAmbientProvider =\n    scopedSlug !== undefined && (opts?.slug === undefined || slug === scopedSlug);\n  const makeConnection = useCallback(async () => {\n    if (slug === undefined) {\n      throw new Error(\n        \"useLiveState needs a project: pass { slug } or render under <ProjectScope slug>.\",\n      );\n    }\n    return (await connectItx(slug)).dup();\n  }, [slug]);\n  return useCapnWebLiveState(\n    live,\n    selector,\n    deps,\n    useAmbientProvider ? { enabled: opts?.enabled } : { enabled: opts?.enabled, makeConnection },\n  );\n}\n\n/** Session-scoped sibling of {@link useLiveState}, for deployment-wide live nodes. */\nexport function useIterateSessionLiveState<State, Selected = State>(\n  live: (session: SessionStub) => LiveStateRpc<State>,\n  selector: (state: State) => Selected,\n  deps: unknown[] = [],\n  opts?: { enabled?: boolean },\n): {\n  value: Selected | undefined;\n  status: ItxConnectionStatus;\n  error?: string;\n  refresh: () => void;\n} {\n  const makeConnection = useCallback(async () => (await connectIterateSession()).dup(), []);\n  return useCapnWebLiveState(live, selector, deps, { enabled: opts?.enabled, makeConnection });\n}\n"],"mappings":"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"}