@nifrajs/web 5.5.1 → 5.7.0

package/src/internal/invalidation.ts

@@ -0,0 +1,213 @@
+/**
+ * One invalidation pipeline for everything a write makes stale, in a fixed order: data caches (tags),
+ * then the page store (paths and tags), then the live publish (keys and tags), then the CDN. A failure
+ * in either cache stage stops before the publish: clients told to reload would read the stale data and
+ * move their watermarks past the change. Every stage is idempotent, so a retry repeats from the stage
+ * that failed.
+ *
+ * `withISR` owns the pipeline when it wraps the app; without it, `createWebApp` runs the publish
+ * stage alone. Never both.
+ */
+import type { CacheStore, CdnPurgeTarget, ISRPlatform } from "../isr.ts"
+import type { InvalidationOp } from "./invalidation-contract.ts"
+
+export type { InvalidationOp } from "./invalidation-contract.ts"
+
+export type InvalidationStage = "data" | "pages" | "publish" | "cdn"
+
+export interface StageReport {
+  readonly stage: InvalidationStage
+  readonly ok: boolean
+  readonly retryable: boolean
+  readonly error?: string
+  /** The CDN took the purge but has not applied it yet (rate limit or retry). */
+  readonly queued?: true
+}
+
+export interface InvalidationReport {
+  readonly id: string
+  readonly ok: boolean
+  readonly stages: readonly StageReport[]
+}
+
+/** What the pipeline calls on a page store: any {@link CacheStore} fits. */
+export interface PagePurge {
+  delete(key: string): Promise<void>
+  readonly invalidateTag?: ((tag: string) => Promise<void>) | undefined
+}
+
+export interface InvalidationTargets {
+  readonly dataCaches?: readonly { invalidateTag(tag: string): unknown }[] | undefined
+  readonly store?: PagePurge | undefined
+  /** The page store key of a path, as the cache wrapper computes it; `null` when never stored. */
+  readonly keyOf?: ((path: string, req: Request) => string | null) | undefined
+  readonly publish?: ((keys: readonly string[]) => Promise<void>) | undefined
+  readonly cdn?: CdnPurgeTarget | undefined
+}
+
+const ORDER: readonly InvalidationStage[] = ["data", "pages", "publish", "cdn"]
+/** Retry delays after a retryable failure; inline retries stop at {@link INLINE_DEADLINE_MS}. */
+const RETRY_MS = [200, 600, 1800]
+export const INLINE_DEADLINE_MS = 2000
+
+/** Run the stages from `from` once. */
+export async function runInvalidation(
+  op: InvalidationOp,
+  targets: InvalidationTargets,
+  req: Request,
+  platform: ISRPlatform | undefined,
+  from: InvalidationStage = "data",
+): Promise<InvalidationReport> {
+  const stages: StageReport[] = []
+  for (const stage of ORDER.slice(ORDER.indexOf(from))) {
+    // Decided before any await: a stage with nothing to do costs no turn of the event loop.
+    const running = startStage(stage, op, targets, req, platform)
+    if (running === undefined) continue
+    const report = await running
+    stages.push(report)
+    // A cache stage that failed leaves data a reload would read: nothing after it may run.
+    if (!report.ok && (stage === "data" || stage === "pages")) break
+  }
+  return { id: op.id, ok: stages.every((report) => report.ok), stages }
+}
+
+/** Start a stage's work for this operation; `undefined` when it has none. Never rejects. */
+function startStage(
+  stage: InvalidationStage,
+  op: InvalidationOp,
+  targets: InvalidationTargets,
+  req: Request,
+  platform: ISRPlatform | undefined,
+): Promise<StageReport> | undefined {
+  const done: StageReport = { stage, ok: true, retryable: false }
+  let work: Promise<StageReport>
+  switch (stage) {
+    case "data": {
+      const caches = targets.dataCaches
+      if (op.tags.length === 0 || caches === undefined) return undefined
+      work = (async () => {
+        for (const cache of caches) {
+          for (const tag of op.tags) await cache.invalidateTag(tag)
+        }
+        return done
+      })()
+      break
+    }
+    case "pages": {
+      const store = targets.store
+      if (store === undefined || op.paths.length + op.tags.length === 0) return undefined
+      work = (async (): Promise<StageReport> => {
+        if (op.tags.length > 0 && store.invalidateTag === undefined) {
+          return { stage, ok: false, retryable: false, error: "tag_invalidation_not_supported" }
+        }
+        for (const path of op.paths) {
+          const key = targets.keyOf?.(path, req) ?? null
+          if (key !== null) await store.delete(key)
+        }
+        for (const tag of op.tags) await store.invalidateTag?.(tag)
+        return done
+      })()
+      break
+    }
+    case "publish": {
+      const publish = targets.publish
+      if (publish === undefined || op.keys.length + op.tags.length === 0) return undefined
+      work = (async () => {
+        await publish([...new Set([...op.keys, ...op.tags])])
+        return done
+      })()
+      break
+    }
+    case "cdn": {
+      const cdn = targets.cdn
+      if (cdn === undefined || op.paths.length + op.tags.length === 0) return undefined
+      work = (async (): Promise<StageReport> => {
+        const outcome = await cdn.purge({ tags: op.tags, paths: op.paths }, platform)
+        return outcome.cdn === "failed"
+          ? {
+              stage,
+              ok: false,
+              retryable: outcome.retryable,
+              error: outcome.error ?? "cdn_purge_failed",
+            }
+          : outcome.cdn === "queued"
+            ? { stage, ok: true, retryable: false, queued: true }
+            : done
+      })()
+      break
+    }
+  }
+  return work.catch(() => ({ stage, ok: false, retryable: true, error: `${stage}_failed` }))
+}
+
+export interface SettleOptions {
+  readonly onError?: ((report: InvalidationReport) => void) | undefined
+  /** Tests drive time; production waits on timers. */
+  readonly clock?: { now(): number; sleep(ms: number): Promise<void> }
+}
+
+const realClock = {
+  now: () => Date.now(),
+  sleep: (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)),
+}
+
+/**
+ * Run the pipeline for a write; never throws and never changes the response. A retryable failure
+ * retries from the failed stage, under `waitUntil` when the platform has it, else inline until
+ * {@link INLINE_DEADLINE_MS}. A failure that remains is reported once.
+ */
+export async function settleInvalidation(
+  op: InvalidationOp,
+  targets: InvalidationTargets,
+  req: Request,
+  platform: ISRPlatform | undefined,
+  options: SettleOptions = {},
+): Promise<InvalidationReport> {
+  const onError = options.onError ?? logInvalidation
+  const clock = options.clock ?? realClock
+  const started = clock.now()
+  const first = await runInvalidation(op, targets, req, platform)
+  if (first.ok) return first
+  const failed = first.stages.find((report) => !report.ok)
+  if (failed === undefined || !failed.retryable) {
+    report(onError, first)
+    return first
+  }
+  const background = typeof platform?.waitUntil === "function"
+  const retry = async (): Promise<InvalidationReport> => {
+    let last = first
+    let stage = failed.stage
+    for (const delay of RETRY_MS) {
+      if (!background && clock.now() - started + delay >= INLINE_DEADLINE_MS) break
+      await clock.sleep(delay)
+      last = await runInvalidation(op, targets, req, platform, stage)
+      const next = last.stages.find((report) => !report.ok)
+      if (next === undefined) return last
+      if (!next.retryable) break
+      stage = next.stage
+    }
+    report(onError, last)
+    return last
+  }
+  if (background) {
+    platform?.waitUntil?.(retry())
+    return first
+  }
+  return retry()
+}
+
+function report(onError: (report: InvalidationReport) => void, value: InvalidationReport): void {
+  try {
+    onError(value)
+  } catch {
+    // A failing reporter must not reach the response.
+  }
+}
+
+/** The default report: the operation id and the stage, never a path, tag or key. */
+export function logInvalidation(report: InvalidationReport): void {
+  const failed = report.stages.find((stage) => !stage.ok)
+  console.error(
+    `[nifra/web] invalidation ${report.id} gave up at the ${failed?.stage ?? "unknown"} stage (${failed?.error ?? "failed"})`,
+  )
+}

package/src/internal/island-bindings.ts

@@ -0,0 +1,191 @@
+/**
+ * The declarative binding walker - attaches signal-driven behavior to SERVER-RENDERED markup.
+ * No VDOM, no hydration re-render: the HTML the server sent (e.g. via `@nifrajs/web-vanilla`) is
+ * already the initial state; bindings update it surgically when signals change. `bindIsland` runs it.
+ *
+ * The attribute set is CLOSED and documented - six bindings, no expression language. Values are
+ * signal/handler NAMES looked up in the island's scope, never evaluated code, so markup can't
+ * inject behavior:
+ *
+ *   data-bind-text="count"                  textContent ← String(signal())
+ *   data-bind-show="isOpen"                 hidden ← !signal()
+ *   data-bind-class="active:isOpen,b:sigB"  classList.toggle per pair
+ *   data-bind-attr="aria-expanded:isOpen"   setAttribute / removeAttribute (false/null remove);
+ *                                           never an `on*` handler or `srcdoc`, and a URL attribute
+ *                                           takes only an http(s)/mailto/tel or relative URL
+ *   data-bind-value="query"                 two-way <input>/<select>/<textarea> (input and change)
+ *   data-bind-on="click:inc,submit:save"    addEventListener per pair
+ *
+ * Nothing inside a `data-island-ignore` element binds or mounts: render user HTML there, so its
+ * markup cannot reach the island's handlers or signals.
+ *
+ * A binding belongs to its nearest island: an island never binds inside a nested island's host. The
+ * nested host element itself is still the outer island's markup, so the outer island may bind it.
+ */
+
+import { type Signal, watch } from "./island-signals.ts"
+
+export type IslandScope = {
+  readonly signals: Readonly<Record<string, Signal<unknown>>>
+  readonly handlers: Readonly<Record<string, (event: Event) => void>>
+}
+
+const warned = new Set<string>()
+/** Unknown names warn once (loud in dev, resilient in prod - progressive enhancement must not
+ * throw over a typo'd attribute) and the binding is skipped. */
+function warnOnce(kind: string, name: string): void {
+  const key = `${kind}:${name}`
+  if (warned.has(key)) return
+  warned.add(key)
+  console.warn(`[nifra/islands] unknown ${kind} ${JSON.stringify(name)} - binding skipped`)
+}
+
+// Own keys only: a name such as `constructor` must not resolve to what a plain object inherits.
+function named<V>(kind: string, record: Readonly<Record<string, V>>, name: string): V | undefined {
+  if (Object.hasOwn(record, name)) return record[name]
+  warnOnce(kind, name)
+  return undefined
+}
+
+/** Parse a `"key:name,key2:name2"` pair list (whitespace-tolerant). Malformed entries skip. */
+function pairs(spec: string): Array<[string, string]> {
+  const out: Array<[string, string]> = []
+  for (const part of spec.split(",")) {
+    const sep = part.indexOf(":")
+    if (sep <= 0) continue
+    const key = part.slice(0, sep).trim()
+    const name = part.slice(sep + 1).trim()
+    if (key && name) out.push([key, name])
+  }
+  return out
+}
+
+// A bound value is data (often from island state the markup carries), so an attribute that would run
+// it as code, or navigate to it as a script URL, is refused.
+const CODE_ATTRIBUTE = /^(?:on|srcdoc$)/i
+const URL_ATTRIBUTE =
+  /^(?:href|src|action|formaction|xlink:href|poster|data|background|cite|ping)$/i
+const SAFE_URL = /^(?:(?:https?|mailto|tel):|[^:/?#]*(?:[/?#]|$))/i
+
+/** The element surface the walker needs - structural, so tests can drive it without a real DOM. */
+export interface BindableElement {
+  getAttribute(name: string): string | null
+  setAttribute(name: string, value: string): void
+  removeAttribute(name: string): void
+  textContent: string | null
+  hidden: boolean
+  value?: string
+  readonly classList: { toggle(name: string, force?: boolean): unknown }
+  addEventListener(type: string, listener: (event: Event) => void): void
+  removeEventListener(type: string, listener: (event: Event) => void): void
+}
+
+export interface BindableRoot {
+  querySelectorAll(selector: string): Iterable<BindableElement>
+}
+
+/** Walk `root` and attach every `data-bind-*` binding against `scope`. Each binding's disposer
+ * (reactive effect or event listener) goes onto `stops` as it attaches, so a binding that throws
+ * midway leaves the earlier ones disposable; `stops` is returned. */
+export function bindScope(
+  root: BindableRoot,
+  scope: IslandScope,
+  stops: Array<() => void> = [],
+): Array<() => void> {
+  // Each element carrying `data-bind-<kind>` outside any ignored subtree and any nested island, with
+  // that attribute's value.
+  const each = (kind: string): Array<[BindableElement, string]> => {
+    const attribute = `data-bind-${kind}`
+    return [
+      ...root.querySelectorAll(
+        `[${attribute}]:not([data-island-ignore],[data-island-ignore] *,:scope [data-island] *)`,
+      ),
+    ].map((el) => [el, el.getAttribute(attribute) ?? ""])
+  }
+
+  for (const [el, name] of each("text")) {
+    const s = named("signal", scope.signals, name)
+    if (s) {
+      stops.push(
+        watch(s, (v) => {
+          el.textContent = String(v)
+        }),
+      )
+    }
+  }
+
+  for (const [el, name] of each("show")) {
+    const s = named("signal", scope.signals, name)
+    if (s) {
+      stops.push(
+        watch(s, (v) => {
+          el.hidden = !v
+        }),
+      )
+    }
+  }
+
+  for (const [el, spec] of each("class")) {
+    for (const [className, name] of pairs(spec)) {
+      const s = named("signal", scope.signals, name)
+      if (s) {
+        stops.push(
+          watch(s, (v) => {
+            el.classList.toggle(className, !!v)
+          }),
+        )
+      }
+    }
+  }
+
+  for (const [el, spec] of each("attr")) {
+    for (const [attr, name] of pairs(spec)) {
+      if (CODE_ATTRIBUTE.test(attr)) {
+        warnOnce("attribute", attr)
+        continue
+      }
+      const s = named("signal", scope.signals, name)
+      if (s) {
+        const isUrl = URL_ATTRIBUTE.test(attr)
+        stops.push(
+          watch(s, (v) => {
+            if (v === false || v == null || (isUrl && !SAFE_URL.test(String(v).trim())))
+              el.removeAttribute(attr)
+            else el.setAttribute(attr, String(v))
+          }),
+        )
+      }
+    }
+  }
+
+  for (const [el, name] of each("value")) {
+    const s = named("signal", scope.signals, name)
+    if (s) {
+      stops.push(
+        watch(s, (v) => {
+          const next = String(v)
+          // Skip same-value writes: resetting an input's value mid-typing moves the caret.
+          if (el.value !== next) el.value = next
+        }),
+      )
+      const input = (): void => s.set(el.value ?? "")
+      // A <select> commits on `change`, and browsers disagree on whether `input` comes first. The
+      // second event of a pair writes the same value, which the signal skips.
+      for (const type of ["input", "change"]) {
+        el.addEventListener(type, input)
+        stops.push(() => el.removeEventListener(type, input))
+      }
+    }
+  }
+
+  for (const [el, spec] of each("on")) {
+    for (const [event, name] of pairs(spec)) {
+      const handler = named("handler", scope.handlers, name)
+      if (handler === undefined) continue
+      el.addEventListener(event, handler)
+      stops.push(() => el.removeEventListener(event, handler))
+    }
+  }
+
+  return stops
+}

package/src/internal/island-list.ts

@@ -0,0 +1,92 @@
+import { effect, untrack } from "./island-signals.ts"
+
+/** The node surface `bindList` uses; an `Element` has it. */
+export interface ListNode {
+  remove(): void
+}
+
+/** The container surface `bindList` uses; an `Element` has it. */
+export interface ListContainer<E extends ListNode> {
+  replaceChildren(...nodes: E[]): void
+  insertBefore(node: E, before: E | null): unknown
+}
+
+/** How `bindList` turns items into keyed DOM. */
+export interface BindListOptions<T, E extends ListNode = HTMLElement> {
+  /** Stable and unique per item - never the array index, or a removal reuses the wrong node. */
+  key(item: T): string | number
+  create(item: T): E
+  /** Brings a node in line with its item: runs after `create` and on every later change. */
+  update?(el: E, item: T): void
+}
+
+/**
+ * Render a list signal (or any getter) into `container` with keyed reconciliation. A surviving item
+ * keeps its node, so focus, selection and input state survive a reorder. A render with no earlier
+ * nodes replaces the container's children; later renders move only the nodes outside the longest
+ * run already in order. `key`, `create` and `update` run untracked: a signal they read does not
+ * re-render the list. Returns the disposer; inside an island the binding also stops on unmount.
+ */
+export function bindList<T, E extends ListNode = HTMLElement>(
+  source: () => readonly T[],
+  // A DOM container's generic methods would drive E to `ListNode`; the row type comes from `create`.
+  container: ListContainer<NoInfer<E>>,
+  options: BindListOptions<T, E>,
+): () => void {
+  let nodes = new Map<string | number, E>()
+  // Each node's position in the last render; empty until a render leaves nodes to keep.
+  let at = new Map<E, number>()
+  return effect(() => {
+    const items = source()
+    untrack(() => {
+      const next = new Map<string | number, E>()
+      for (const item of items) {
+        const key = options.key(item)
+        if (next.has(key)) console.warn("[nifra/islands] bindList: duplicate key skipped", key)
+        else {
+          const el = nodes.get(key) ?? options.create(item)
+          options.update?.(el, item)
+          next.set(key, el)
+        }
+      }
+      const els = [...next.values()]
+      if (at.size === 0) container.replaceChildren(...els)
+      else {
+        for (const [key, el] of nodes) if (!next.has(key)) el.remove()
+        const stays = inOrder(els.map((el) => at.get(el) ?? -1))
+        let anchor: E | null = null
+        for (let i = els.length - 1; i >= 0; i--) {
+          const el = els[i]
+          if (el === undefined) continue
+          if (!stays.has(i)) container.insertBefore(el, anchor)
+          anchor = el
+        }
+      }
+      at = new Map(els.map((el, i) => [el, i]))
+      nodes = next
+    })
+  })
+}
+
+// The indexes of `old` (each node's previous position, -1 for a new node) on a longest increasing
+// run: those nodes already sit in order, and every other node is moved.
+function inOrder(old: readonly number[]): Set<number> {
+  // tails[n] is the index ending the best run of length n + 1; back links each run.
+  const tails: number[] = []
+  const back: number[] = []
+  old.forEach((o, i) => {
+    if (o < 0) return
+    let lo = 0
+    let hi = tails.length
+    while (lo < hi) {
+      const mid = (lo + hi) >> 1
+      if ((old[tails[mid] ?? 0] ?? 0) < o) lo = mid + 1
+      else hi = mid
+    }
+    back[i] = tails[lo - 1] ?? -1
+    tails[lo] = i
+  })
+  const stays = new Set<number>()
+  for (let i = tails.at(-1) ?? -1; i >= 0; i = back[i] ?? -1) stays.add(i)
+  return stays
+}

package/src/internal/island-mount.ts

@@ -0,0 +1,68 @@
+import {
+  type IslandStrategy,
+  MAX_MEDIA_QUERY_LENGTH,
+  scheduleTrigger,
+} from "@nifrajs/island-trigger"
+import type { IslandCleanup, IslandEnhancer } from "../islands.ts"
+import { owned } from "./island-owner.ts"
+
+function readProps(el: HTMLElement): unknown {
+  const raw = el.dataset.islandProps
+  if (raw === undefined || raw === "") return undefined
+  try {
+    return JSON.parse(raw)
+  } catch {
+    return undefined
+  }
+}
+
+/** Own one host so removing a subtree can stop its islands without disturbing retained siblings. */
+export function mountIsland(
+  el: HTMLElement,
+  enhancers: Readonly<Record<string, IslandEnhancer<never>>>,
+): IslandCleanup | undefined {
+  const id = el.dataset.island
+  if (id === undefined || el.dataset.islandMounted !== undefined) return undefined
+  const enhancer = Object.hasOwn(enhancers, id) ? enhancers[id] : undefined
+  if (enhancer === undefined) return undefined
+  const strategyAttr = el.dataset.islandStrategy
+  const media = el.dataset.islandMedia
+  const strategy: IslandStrategy | undefined =
+    strategyAttr === "idle" || strategyAttr === "visible" || strategyAttr === "load"
+      ? strategyAttr
+      : strategyAttr === "media" &&
+          media !== undefined &&
+          media.length > 0 &&
+          media.length <= MAX_MEDIA_QUERY_LENGTH
+        ? { media }
+        : strategyAttr === undefined
+          ? "load"
+          : undefined
+  // Invalid markers must stay inert, including untrusted oversized media queries.
+  if (strategy === undefined) return undefined
+  const disposers: Array<() => void> = []
+  el.dataset.islandMounted = ""
+  disposers.push(() => {
+    delete el.dataset.islandMounted
+  })
+  const props = readProps(el)
+  const run = (): void => {
+    try {
+      // biome-ignore lint/plugin/requireSafetyCommentForTypeAssertion: enhancer props are the authored SSR contract, as in defineIsland
+      const cleanup = owned(disposers, () => enhancer(el, props as never))
+      if (typeof cleanup === "function") disposers.push(cleanup)
+    } catch (err) {
+      console.error(`[nifra/islands] enhancer "${id}" failed:`, err)
+    }
+  }
+  disposers.push(scheduleTrigger(strategy, run, { target: el }))
+  return () => {
+    for (const dispose of disposers.splice(0)) {
+      try {
+        dispose()
+      } catch {
+        // Best-effort teardown: one failing cleanup must not block the rest.
+      }
+    }
+  }
+}

package/src/internal/island-owner.ts

@@ -0,0 +1,20 @@
+// The disposer list of the island whose enhancer is running, so every effect, computed, list binding
+// and resource it creates stops when the island unmounts. A separate module so an imperative-only
+// island bundle carries no signal code.
+let owner: Array<() => void> | undefined
+
+/** Run `fn` with every disposer it registers pushed onto `kids`. */
+export function owned<T>(kids: Array<() => void>, fn: () => T): T {
+  const prev = owner
+  owner = kids
+  try {
+    return fn()
+  } finally {
+    owner = prev
+  }
+}
+
+/** Register `stop` with the running island, if any. Outside an enhancer it stays the caller's. */
+export function adopt(stop: () => void): void {
+  owner?.push(stop)
+}

package/src/internal/island-resource.ts

@@ -0,0 +1,76 @@
+import { adopt } from "./island-owner.ts"
+import { effect, signal, untrack } from "./island-signals.ts"
+
+/** An async value's state. `status` narrows `value` and `error`, so no branch can be skipped. */
+export type ResourceState<T> =
+  | { readonly status: "pending"; readonly value: undefined; readonly error: undefined }
+  | { readonly status: "ready"; readonly value: T; readonly error: undefined }
+  | { readonly status: "error"; readonly value: undefined; readonly error: unknown }
+
+/** Call it to read the current state (tracking, like a signal). */
+export type Resource<T> = {
+  (): ResourceState<T>
+  /** Fetch the current key again; once disposed, nothing. */
+  refetch(): void
+  /** Stop refetching and abort the request in flight; its result is dropped. */
+  dispose(): void
+}
+
+const PENDING = { status: "pending", value: undefined, error: undefined } as const
+
+/**
+ * An async value keyed by `source`. `source` runs tracked, so a write to any signal it reads starts a
+ * new fetch; `fetcher` runs untracked with that key, so nothing it reads (before or after an `await`)
+ * is a dependency. A newer fetch aborts the older one and only the newest result lands. Inside an
+ * island, unmounting disposes it: the request in flight is aborted and its late result dropped.
+ */
+export function resource<K, T>(
+  source: () => K,
+  fetcher: (key: K, abort: AbortSignal) => Promise<T>,
+): Resource<T> {
+  const state = signal<ResourceState<T>>(PENDING)
+  let generation = 0
+  let live = true
+  let controller: AbortController | undefined
+  let key: K
+  const run = (): void => {
+    const mine = ++generation
+    controller?.abort()
+    const active = new AbortController()
+    controller = active
+    state.set(PENDING)
+    let pending: Promise<T>
+    try {
+      pending = fetcher(key, active.signal)
+    } catch (error) {
+      pending = Promise.reject(error)
+    }
+    pending.then(
+      (value) => {
+        if (mine === generation) state.set({ status: "ready", value, error: undefined })
+      },
+      (error) => {
+        // A superseded or aborted fetch is not an error the reader should see.
+        if (mine === generation && !active.signal.aborted)
+          state.set({ status: "error", value: undefined, error })
+      },
+    )
+  }
+  const stop = effect(() => {
+    key = source()
+    untrack(run)
+  })
+  // biome-ignore lint/plugin/requireSafetyCommentForTypeAssertion: `refetch` and `dispose` are assigned below
+  const read = (() => state()) as Resource<T>
+  read.refetch = () => {
+    if (live) untrack(run)
+  }
+  read.dispose = () => {
+    live = false
+    stop()
+    generation++
+    controller?.abort()
+  }
+  adopt(read.dispose)
+  return read
+}