iterate 0.3.0 → 0.4.0

package/dist/sdk/itx/react.mjs

@@ -1,383 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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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"}