@astrale-os/shell-react 0.1.0

package/src/session/boot/status.ts

@@ -0,0 +1,32 @@
+/**
+ * BootStatus union + transitions (API §2). The provider's boot state machine:
+ * `connecting → ready` (with the resolved runtime) or `connecting → error`. The
+ * reducer is the single transition table children render behind.
+ */
+import type { ShellRuntime } from '../session.context'
+
+export type BootStatus = 'connecting' | 'ready' | 'error'
+
+export interface BootState {
+  readonly status: BootStatus
+  readonly error: unknown
+  readonly runtime: ShellRuntime | null
+}
+
+export type BootAction =
+  | { readonly type: 'connecting' }
+  | { readonly type: 'ready'; readonly runtime: ShellRuntime }
+  | { readonly type: 'error'; readonly error: unknown }
+
+export const INITIAL_BOOT: BootState = { status: 'connecting', error: undefined, runtime: null }
+
+export function bootReducer(state: BootState, action: BootAction): BootState {
+  switch (action.type) {
+    case 'connecting':
+      return state.status === 'connecting' && state.runtime === null ? state : INITIAL_BOOT
+    case 'ready':
+      return { status: 'ready', error: undefined, runtime: action.runtime }
+    case 'error':
+      return { status: 'error', error: action.error, runtime: null }
+  }
+}

package/src/session/connection/connection.hook.ts

@@ -0,0 +1,16 @@
+/**
+ * useConnection (API §3) — transport status + memory journal position + retry.
+ * Reads the provider-owned connection store for the subtree's Shell via
+ * `useSyncExternalStore` (rule 3). Throws outside a `<ShellProvider>`.
+ */
+import { useSyncExternalStore } from 'react'
+
+import type { ConnectionValue } from './connection.store'
+
+import { useShell } from '../shell.hook'
+import { connectionStore } from './connection.store'
+
+export function useConnection(): ConnectionValue {
+  const store = connectionStore(useShell())
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot)
+}

package/src/session/connection/connection.store.ts

@@ -0,0 +1,58 @@
+/**
+ * The connection store (API §3, rule 3). ONE per Shell — the provider owns it and
+ * registers its `retry`; `useConnection` reads it via `useSyncExternalStore` so
+ * connection churn re-renders only its subscribers. `status`/`seq` are a pinned
+ * stub ('ready'/0) until the transport-status + result-`seq` feed lands (G6).
+ */
+import type { Shell } from '@astrale-os/shell'
+
+export type ConnectionStatus = 'connecting' | 'ready' | 'reconnecting' | 'error'
+
+/** Transport + memory-journal status for the subtree (API §3). */
+export interface ConnectionValue {
+  readonly status: ConnectionStatus
+  readonly error: unknown
+  readonly seq: number
+  retry(): void
+}
+
+export interface ConnectionStore {
+  subscribe(cb: () => void): () => void
+  getSnapshot(): ConnectionValue
+  /** The provider registers its boot-retry here; a change re-stamps the snapshot. */
+  setRetry(retry: () => void): void
+}
+
+const NOOP_RETRY = (): void => {}
+
+function createConnectionStore(): ConnectionStore {
+  const listeners = new Set<() => void>()
+  let retry: () => void = NOOP_RETRY
+  let snapshot: ConnectionValue = { status: 'ready', error: undefined, seq: 0, retry }
+
+  return {
+    subscribe(cb) {
+      listeners.add(cb)
+      return () => listeners.delete(cb)
+    },
+    getSnapshot: () => snapshot,
+    setRetry(next) {
+      if (next === retry) return
+      retry = next
+      snapshot = { status: snapshot.status, error: snapshot.error, seq: snapshot.seq, retry }
+      for (const l of listeners) l()
+    },
+  }
+}
+
+const stores = new WeakMap<Shell, ConnectionStore>()
+
+/** The one connection store for a Shell (created on first touch). */
+export function connectionStore(shell: Shell): ConnectionStore {
+  let s = stores.get(shell)
+  if (s === undefined) {
+    s = createConnectionStore()
+    stores.set(shell, s)
+  }
+  return s
+}

package/src/session/index.ts

@@ -0,0 +1,8 @@
+// session — API §2 (provider) + §3 (session hooks). See SHELL_REACT_API.md.
+export { ShellProvider } from './provider'
+export type { ShellError, ShellProviderProps } from './provider'
+export { useShell } from './shell.hook'
+export { useKernelClient } from './kernel-client.hook'
+export { useKernelInstance } from './kernel-instance.hook'
+export type { KernelInstance } from './kernel-instance.hook'
+export { useConnection } from './connection/connection.hook'

package/src/session/kernel-client.hook.ts

@@ -0,0 +1,13 @@
+/**
+ * useKernelClient (API §3) — `shell.kernel`, the raw bound kernel view, untouched
+ * (the untyped floor). The TYPED handles `useKernel()`/`useDomain(schema)` live in
+ * the schema module (§6).
+ */
+import type { KernelClient } from '@astrale-os/shell'
+
+import { useShell } from './shell.hook'
+
+/** `shell.kernel` — the raw bound kernel view, untouched (untyped floor). */
+export function useKernelClient(): KernelClient {
+  return useShell().kernel
+}

package/src/session/kernel-instance.hook.ts

@@ -0,0 +1,22 @@
+import { useMemo } from 'react'
+
+import { useKernelClient } from './kernel-client.hook'
+
+export interface KernelInstance {
+  /** Kernel envelope endpoint this shell is bound to. */
+  readonly url: string
+  /** Current kernel credential. Never cache; read per request. */
+  token(): string
+}
+
+/** Low-level access for direct kernel-envelope calls and token exchange code. */
+export function useKernelInstance(): KernelInstance {
+  const kernel = useKernelClient()
+  return useMemo<KernelInstance>(
+    () => ({
+      url: kernel.url,
+      token: () => kernel.authToken(),
+    }),
+    [kernel],
+  )
+}

package/src/session/provider.tsx

@@ -0,0 +1,205 @@
+import type { MemoryEvent } from '@astrale-os/kernel-client/store'
+import type { Shell, ShellConfig } from '@astrale-os/shell'
+import type { ReactElement, ReactNode } from 'react'
+
+import { createShell } from '@astrale-os/shell'
+/**
+ * ShellProvider — the composition root (API §2, SPEC §5): owns the shell boot
+ * state machine (a config OR a prebuilt Shell; `createShell → init → whoami →
+ * ready`), seats `ShellContext` and `GraphContext`, and registers its boot-retry
+ * into the per-shell connection store. One live shell per mounted provider,
+ * StrictMode/HMR-safe (deferred teardown), keyed on config identity. Children
+ * render only at `ready`, so useShell/useSelf are synchronous below.
+ */
+import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react'
+
+import type { GraphMemory } from '../graph/graph.context'
+import type { BootRef } from './boot/ownership'
+import type { SelfNode } from './session.context'
+
+import { primeUser } from '../application/user/user.store'
+import { GraphContext } from '../graph/graph.context'
+import { baseMemoryFor, setMemoryErrorSink } from '../graph/memory/base'
+import { configIdentity, isShellConfig, resolveSelf } from './boot/boot'
+import { cancelTeardown, disposeShell, scheduleTeardown } from './boot/ownership'
+import { bootReducer, INITIAL_BOOT } from './boot/status'
+import { connectionStore } from './connection/connection.store'
+import { ShellContext } from './session.context'
+
+/** Global error channel payload (API §2). */
+export type ShellError =
+  | { kind: 'refresh'; shape: unknown; error: unknown }
+  | { kind: 'mutation'; mutationId: string; error: unknown }
+  | { kind: 'connection'; error: unknown }
+
+export interface ShellProviderProps {
+  /**
+   * Shell config — or a prebuilt Shell (tests, storybook). Keyed by identity: a
+   * config change disposes and reboots.
+   */
+  config: ShellConfig | Shell
+  /** Rendered until status === 'ready'. Default: null. */
+  fallback?: ReactNode
+  /** Rendered when boot fails; `retry` re-runs init. Default: rethrow to the nearest boundary. */
+  errorFallback?: (error: unknown, retry: () => void) => ReactNode
+  /** Global error channel: warm-read refresh failures, rolled-back mutations, watch drops. */
+  onError?: (error: ShellError) => void
+  children: ReactNode
+}
+
+/**
+ * Map a memory event to the documented `ShellError` union (API §2). `refresh`
+ * (warm-read revalidation failure) and `mutation` (rolled-back write) are the
+ * two the channel promises; `divergence`/`invariant` are Tier-0/dev tripwires
+ * outside the union and are not bridged here.
+ */
+function toShellError(event: MemoryEvent): ShellError | null {
+  switch (event.kind) {
+    case 'refresh':
+      return { kind: 'refresh', shape: event.shape, error: event.error }
+    case 'mutation':
+      return { kind: 'mutation', mutationId: event.mutationId, error: event.error }
+    default:
+      return null
+  }
+}
+
+export function ShellProvider(props: ShellProviderProps): ReactElement | null {
+  const { config, fallback, errorFallback, onError, children } = props
+
+  const [state, dispatch] = useReducer(bootReducer, INITIAL_BOOT)
+  const [attempt, setAttempt] = useState(0)
+
+  const bootRef = useRef<BootRef>({ key: null, shell: null, generation: 0 })
+  const configRef = useRef(config)
+  configRef.current = config
+  const onErrorRef = useRef(onError)
+  onErrorRef.current = onError
+
+  const configKey = configIdentity(config)
+
+  const startBoot = useCallback((ref: BootRef) => {
+    const generation = (ref.generation += 1)
+    dispatch({ type: 'connecting' })
+
+    let shell: Shell
+    const current = configRef.current
+    try {
+      shell = isShellConfig(current) ? createShell(current) : current
+    } catch (err) {
+      dispatch({ type: 'error', error: err })
+      onErrorRef.current?.({ kind: 'connection', error: err })
+      return
+    }
+    ref.shell = shell
+
+    void (async () => {
+      try {
+        await shell.init()
+        if (generation !== ref.generation) return
+        const self: SelfNode | null = await resolveSelf(shell)
+        if (generation !== ref.generation) return
+        // Pre-resolve the OS-plane user binding (API §2/§12.2) — NON-FATAL: a
+        // missing OS plane marks it unavailable without failing boot (whoami above
+        // stays the fatal gate). Seeds the user store so `useUser` is synchronous.
+        await primeUser(shell)
+        if (generation !== ref.generation) return
+        dispatch({ type: 'ready', runtime: { shell, self } })
+      } catch (err) {
+        if (generation !== ref.generation) return
+        dispatch({ type: 'error', error: err })
+        onErrorRef.current?.({ kind: 'connection', error: err })
+      }
+    })()
+  }, [])
+
+  useEffect(() => {
+    const ref = bootRef.current
+    // The shell this provider will run with once the effect settles: a prebuilt
+    // Shell is the config object itself; a config-built one is whatever this
+    // instance already booted (adopted on a StrictMode/HMR re-setup). Cancel any
+    // pending deferred teardown for it before deciding — this also cancels a
+    // teardown another provider scheduled for the SAME prebuilt Shell.
+    const current = configRef.current
+    const adopting = isShellConfig(current) ? ref.shell : current
+    if (adopting !== null) cancelTeardown(adopting)
+
+    if (ref.key !== configKey) {
+      // First boot, config change, or a retry that cleared the key: reboot fresh.
+      if (ref.shell !== null) {
+        cancelTeardown(ref.shell)
+        disposeShell(ref.shell)
+      }
+      ref.key = configKey
+      ref.shell = null
+      startBoot(ref)
+    }
+    // Same key already booting/booted → adopt (StrictMode's second setup).
+
+    return () => {
+      // Defer teardown one macrotask; a synchronous re-setup (StrictMode/HMR or a
+      // different provider adopting the same prebuilt Shell) cancels it first and
+      // keeps the same live shell.
+      if (ref.shell !== null) scheduleTeardown(ref.shell, ref)
+      else ref.key = null
+    }
+  }, [configKey, attempt, startBoot])
+
+  const retry = useCallback(() => {
+    const ref = bootRef.current
+    ref.generation += 1
+    if (ref.shell !== null) {
+      disposeShell(ref.shell)
+      ref.shell = null
+    }
+    ref.key = null
+    dispatch({ type: 'connecting' })
+    setAttempt((a) => a + 1)
+  }, [])
+
+  // The base (default-scope) memory for the booted Shell — the SAME instance
+  // the graph/schema/nav hooks read through `graph/memory/scope.ts`. Seated in
+  // `GraphContext` so selection's liveness has a source; null until ready.
+  const shell = state.runtime?.shell ?? null
+  const memory = useMemo<GraphMemory | null>(
+    () => (shell === null ? null : baseMemoryFor(shell)),
+    [shell],
+  )
+
+  // Bridge the memory's event channel onto the provider `onError` (API §2/§8):
+  // warm-refresh failures and rolled-back mutations surface here rather than being
+  // swallowed. Registered while the booted shell is live; cleared on teardown.
+  useEffect(() => {
+    if (shell === null) return
+    setMemoryErrorSink(shell, (event) => {
+      const mapped = toShellError(event)
+      if (mapped !== null) onErrorRef.current?.(mapped)
+    })
+    return () => setMemoryErrorSink(shell, null)
+  }, [shell])
+
+  // Register this provider's boot-retry into the shell's connection store (rule 3),
+  // so `useConnection().retry` re-runs boot. Status/seq stay a stub ('ready'/0)
+  // until the transport-status + result-`seq` feed lands, with no surface change.
+  useEffect(() => {
+    if (shell === null) return
+    connectionStore(shell).setRetry(retry)
+  }, [shell, retry])
+
+  if (state.status === 'error') {
+    // Wrapped in a fragment so the component's declared return type stays
+    // `ReactElement | null` — valid JSX under @types/react 18 AND 19 (the react
+    // peer range is >=18), even though `errorFallback`/`fallback` yield ReactNode.
+    if (errorFallback !== undefined) return <>{errorFallback(state.error, retry)}</>
+    throw state.error
+  }
+  if (state.status !== 'ready' || state.runtime === null) {
+    return fallback !== undefined ? <>{fallback}</> : null
+  }
+
+  return (
+    <ShellContext.Provider value={state.runtime}>
+      <GraphContext.Provider value={memory}>{children}</GraphContext.Provider>
+    </ShellContext.Provider>
+  )
+}

package/src/session/session.context.ts

@@ -0,0 +1,27 @@
+import type { KernelClient, Shell } from '@astrale-os/shell'
+
+/**
+ * ShellContext — the shell session seat. Holds ONLY the stable `Shell` for a
+ * provider subtree (plus the whoami resolved once at boot). Connection state is
+ * NOT here: it is a provider-owned store read via `useConnection` (rule 3).
+ */
+import { createContext } from 'react'
+
+/**
+ * whoami's node type, derived from the auth surface so shell-react needs no
+ * direct `@astrale-os/kernel-core` dependency (`Node` is not yet re-exported by
+ * kernel-client — API §14 G8). Swap for the blessed re-export when it lands.
+ */
+export type SelfNode = Awaited<ReturnType<KernelClient['auth']['whoami']>>
+
+/** The live shell for a provider subtree (and, later, an `<ActAs>` subtree). */
+export interface ShellRuntime {
+  readonly shell: Shell
+  /**
+   * whoami resolved at boot; the auth module (`useSelf`) reads it. Null when the
+   * bound kernel exposes no auth surface (a bare prebuilt Shell in tests).
+   */
+  readonly self: SelfNode | null
+}
+export const ShellContext = createContext<ShellRuntime | null>(null)
+ShellContext.displayName = 'AstraleShellContext'

package/src/session/shell.hook.ts

@@ -0,0 +1,19 @@
+import type { Shell } from '@astrale-os/shell'
+
+/**
+ * useShell (API §3) — the live shell for this subtree, read from ShellContext.
+ * Throws outside a `<ShellProvider>`. The imperative floor every other session
+ * hook builds on.
+ */
+import { useContext } from 'react'
+
+import { ShellContext } from './session.context'
+
+/** The live shell for this subtree. Throws outside a `<ShellProvider>`. */
+export function useShell(): Shell {
+  const runtime = useContext(ShellContext)
+  if (runtime === null) {
+    throw new Error('useShell must be used within a <ShellProvider>')
+  }
+  return runtime.shell
+}

package/src/window/adopt.ts

@@ -0,0 +1,57 @@
+/**
+ * Stash/adopt across re-key / re-parent (API §10). A live window handed off across
+ * an unmount so a remount can ADOPT it instead of closing + reloading it. Mirrors
+ * ShellProvider's deferred-teardown pattern: the unmounting host stashes the
+ * record, and either the remount takes it (one macrotask) or it disposes.
+ */
+import type { Window } from '@astrale-os/shell'
+
+import type { WindowState } from './lifecycle/states'
+import type { StageSlot } from './placement'
+
+export interface AdoptRecord {
+  readonly windowId: string
+  readonly window: Window
+  readonly slot: StageSlot
+  readonly state: WindowState
+  readonly targetId: string | undefined
+  /** Close the window, release its slot, drop it from the registry (fired if unadopted). */
+  dispose(): void
+}
+
+export interface AdoptStash {
+  /** Stash an unmounting host's live window; disposes after one macrotask if unadopted. */
+  stash(key: string, record: AdoptRecord): void
+  /** Reclaim a stashed window for a remount of the same source, cancelling its dispose. */
+  take(key: string): AdoptRecord | null
+}
+
+/** The pending-adoption registry — one per stage hub. */
+export function createAdoptStash(): AdoptStash {
+  const pendingAdopt = new Map<
+    string,
+    { record: AdoptRecord; timer: ReturnType<typeof setTimeout> }
+  >()
+  return {
+    stash(key, record) {
+      // Rapid same-key churn: an unclaimed prior stash disposes now.
+      const prior = pendingAdopt.get(key)
+      if (prior !== undefined) {
+        clearTimeout(prior.timer)
+        prior.record.dispose()
+      }
+      const timer = setTimeout(() => {
+        pendingAdopt.delete(key)
+        record.dispose()
+      }, 0)
+      pendingAdopt.set(key, { record, timer })
+    },
+    take(key) {
+      const entry = pendingAdopt.get(key)
+      if (entry === undefined) return null
+      clearTimeout(entry.timer)
+      pendingAdopt.delete(key)
+      return entry.record
+    },
+  }
+}

package/src/window/hooks/close-guard.hook.ts

@@ -0,0 +1,100 @@
+import type { Shell } from '@astrale-os/shell'
+
+/**
+ * useCloseGuard (API §10) — child-side willClose negotiation. The parent sends a
+ * `willClose` intent before closing; the guard answers `closeAck` (allow) or
+ * `closeRefuse` (veto, with reason). Guards stack per shell and the last-mounted
+ * one wins; a single shared subscription owns the reply so a `willClose` is
+ * answered exactly once regardless of how many guards are mounted.
+ */
+import { useEffect, useRef } from 'react'
+
+import { useShell } from '../../session/shell.hook'
+
+export type CloseVerdict = 'ack' | 'refuse' | { readonly refuse: string }
+export type CloseGuard = () => CloseVerdict | Promise<CloseVerdict>
+
+interface CloseGuardHub {
+  push(guard: CloseGuard): () => void
+}
+
+function sendAck(parent: NonNullable<Shell['parent']>): void {
+  parent.send({
+    type: 'intent',
+    version: 1,
+    envelope: { name: 'closeAck', payload: {}, sender: { windowId: 'self' } },
+  })
+}
+
+function sendRefuse(parent: NonNullable<Shell['parent']>, reason: string): void {
+  parent.send({
+    type: 'intent',
+    version: 1,
+    envelope: { name: 'closeRefuse', payload: { reason }, sender: { windowId: 'self' } },
+  })
+}
+
+const HUBS = new WeakMap<Shell, CloseGuardHub>()
+
+function getCloseGuardHub(shell: Shell): CloseGuardHub {
+  const existing = HUBS.get(shell)
+  if (existing !== undefined) return existing
+
+  const stack: CloseGuard[] = []
+  let off: (() => void) | null = null
+
+  function ensureSubscribed(): void {
+    if (off !== null) return
+    const parent = shell.parent
+    if (parent === null) return
+    off = parent.on('intent', (message) => {
+      if (message.envelope.name !== 'willClose') return
+      const guard = stack[stack.length - 1]
+      if (guard === undefined) return
+      void answer(parent, guard)
+    })
+  }
+
+  async function answer(parent: NonNullable<Shell['parent']>, guard: CloseGuard): Promise<void> {
+    let verdict: CloseVerdict
+    try {
+      verdict = await guard()
+    } catch {
+      // A throwing guard must not trap the user in the window — allow the close.
+      verdict = 'ack'
+    }
+    if (verdict === 'ack') sendAck(parent)
+    else if (verdict === 'refuse') sendRefuse(parent, '')
+    else sendRefuse(parent, verdict.refuse)
+  }
+
+  const hub: CloseGuardHub = {
+    push(guard) {
+      stack.push(guard)
+      ensureSubscribed()
+      return () => {
+        const i = stack.lastIndexOf(guard)
+        if (i >= 0) stack.splice(i, 1)
+        if (stack.length === 0 && off !== null) {
+          off()
+          off = null
+        }
+      }
+    },
+  }
+  HUBS.set(shell, hub)
+  return hub
+}
+
+export function useCloseGuard(guard: CloseGuard): void {
+  const shell = useShell()
+  const guardRef = useRef(guard)
+  guardRef.current = guard
+
+  useEffect(() => {
+    const hub = getCloseGuardHub(shell)
+    // Push a stable wrapper so a changed guard closure never re-registers
+    // (latest-handler semantics; unmount pops this exact entry).
+    return hub.push(() => guardRef.current())
+  }, [shell])
+}

package/src/window/hooks/target-node.hook.ts

@@ -0,0 +1,94 @@
+import type { KernelClient } from '@astrale-os/shell'
+
+/**
+ * useTargetNode (API §10) — inside a sandboxed view, the node it was opened on.
+ * The id starts from `shell.targetNodeId` (handshake) and a host `setTarget`
+ * intent retargets it; the id resolves to a live `Node` through the shell kernel.
+ *
+ * Honest subset (flagged): the read is a one-shot `kernel.get` re-run on id
+ * change, not a memory watch, so `live` is false. Once composed with `useNode(id)`
+ * it becomes real stale-while-revalidate liveness with no consumer change.
+ */
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+import type { ReadState } from '../../graph/memory/read/envelope'
+import type { Node } from '../lifecycle/mount'
+
+import { idleReadState } from '../../graph/memory/read/idle'
+import { useShell } from '../../session/shell.hook'
+
+export interface NodeResult extends ReadState {
+  readonly node: Node | null
+}
+
+/** Address a bare node id by graph id (`@<id>`); pass paths/anchors through. */
+function toRef(id: string): string {
+  return id.startsWith('/') || id.startsWith('@') ? id : `@${id}`
+}
+
+interface ReadSnapshot {
+  readonly node: Node | null
+  readonly pending: boolean
+  readonly error: unknown
+}
+
+const IDLE_READ: ReadSnapshot = { node: null, pending: false, error: undefined }
+
+export function useTargetNode(): NodeResult {
+  const shell = useShell()
+  const [id, setId] = useState<string | null>(() => shell.targetNodeId ?? null)
+
+  useEffect(() => {
+    const parent = shell.parent
+    if (parent === null) return
+    return parent.on('intent', (message) => {
+      if (message.envelope.name !== 'setTarget') return
+      const nodeId = (message.envelope.payload as { nodeId?: string }).nodeId
+      if (typeof nodeId === 'string') setId(nodeId)
+    })
+  }, [shell])
+
+  return useNodeRead(shell.kernel, id)
+}
+
+/** One-shot get + refetch, in the read envelope. The graph-module seam. */
+function useNodeRead(kernel: KernelClient, id: string | null): NodeResult {
+  const [snap, setSnap] = useState<ReadSnapshot>(IDLE_READ)
+  const aliveRef = useRef(true)
+  useEffect(() => {
+    aliveRef.current = true
+    return () => {
+      aliveRef.current = false
+    }
+  }, [])
+
+  const load = useCallback(async (): Promise<void> => {
+    if (id === null) {
+      if (aliveRef.current) setSnap(IDLE_READ)
+      return
+    }
+    if (aliveRef.current) setSnap((s) => ({ node: s.node, pending: true, error: undefined }))
+    try {
+      const node = await kernel.get(toRef(id))
+      if (aliveRef.current) setSnap({ node: node ?? null, pending: false, error: undefined })
+    } catch (error) {
+      if (aliveRef.current) setSnap((s) => ({ node: s.node, pending: false, error }))
+    }
+  }, [kernel, id])
+
+  useEffect(() => {
+    void load()
+  }, [load])
+
+  if (id === null) {
+    return { ...idleReadState(), node: null }
+  }
+  return {
+    node: snap.node,
+    pending: snap.pending,
+    error: snap.error,
+    live: false,
+    seq: 0,
+    refetch: load,
+  }
+}