@abide/abide 0.28.0

package/src/lib/ui/runtime/createEffectNode.ts

@@ -0,0 +1,58 @@
+import { OWNER } from './OWNER.ts'
+import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
+import { runNode } from './runNode.ts'
+import { toTeardown } from './toTeardown.ts'
+import type { EffectResult } from './types/EffectResult.ts'
+import type { ReactiveNode } from './types/ReactiveNode.ts'
+import type { Teardown } from './types/Teardown.ts'
+import { unlinkDeps } from './unlinkDeps.ts'
+
+/*
+Creates an effect: a side-effecting node that runs once immediately (capturing
+its dependencies) and again whenever any of them change. The body may return a
+teardown — run before each re-run and on dispose — and may be async (its teardown
+then runs once the promise settles, never awaited). Returns a dispose that runs
+the final teardown and unlinks the node from the graph, so a torn-down effect
+leaves no back-links and no live resource — the open-on-first-read /
+close-on-last-reader lifecycle. When created inside a `scope()` build, the
+disposer is also registered with the owner so the whole component tears down
+together.
+*/
+export function createEffectNode(fn: () => EffectResult): () => void {
+    /* The body's teardown, replaced each run. Held in this closure rather than on
+       ReactiveNode so signals and computeds — which share the node shape and the
+       read/write hot path — pay nothing for a feature only effects use. */
+    let cleanup: Teardown | undefined
+    /* Runs the previous run's teardown before re-running and on dispose, exactly
+       once each. */
+    const runCleanup = (): void => {
+        if (cleanup !== undefined) {
+            const teardown = cleanup
+            cleanup = undefined
+            teardown()
+        }
+    }
+    const node: ReactiveNode = {
+        value: undefined,
+        compute: () => {
+            runCleanup()
+            cleanup = toTeardown(fn())
+        },
+        depsHead: undefined,
+        depsTail: undefined,
+        subsHead: undefined,
+        subsTail: undefined,
+        dirty: false,
+        isEffect: true,
+    }
+    runNode(node)
+    const dispose = () => {
+        runCleanup()
+        unlinkDeps(node)
+        REACTIVE_CONTEXT.pendingEffects.delete(node)
+    }
+    if (OWNER.current !== undefined) {
+        OWNER.current.push(dispose)
+    }
+    return dispose
+}

package/src/lib/ui/runtime/createSignalNode.ts

@@ -0,0 +1,16 @@
+import type { ReactiveNode } from './types/ReactiveNode.ts'
+
+/* Creates a writable leaf node holding `value` with no compute — the source a
+   document path or a `state()` cell is backed by. */
+export function createSignalNode(value: unknown): ReactiveNode {
+    return {
+        value,
+        compute: undefined,
+        depsHead: undefined,
+        depsTail: undefined,
+        subsHead: undefined,
+        subsTail: undefined,
+        dirty: false,
+        isEffect: false,
+    }
+}

package/src/lib/ui/runtime/detachLink.ts

@@ -0,0 +1,21 @@
+import type { ReactiveLink } from './types/ReactiveLink.ts'
+
+/*
+Removes an edge from its source's subscriber list — the `*Sub` splice of an O(1)
+unlink. Used when a recompute drops a dependency it no longer reads (`runNode`'s
+trim) and when a node tears down entirely (`unlinkDeps`). Leaves the edge's `*Dep`
+pointers alone; the caller owns the observer-side list it is walking.
+*/
+export function detachLink(link: ReactiveLink): void {
+    const { dep, prevSub, nextSub } = link
+    if (prevSub !== undefined) {
+        prevSub.nextSub = nextSub
+    } else {
+        dep.subsHead = nextSub
+    }
+    if (nextSub !== undefined) {
+        nextSub.prevSub = prevSub
+    } else {
+        dep.subsTail = prevSub
+    }
+}

package/src/lib/ui/runtime/endTracking.ts

@@ -0,0 +1,24 @@
+import { detachLink } from './detachLink.ts'
+import type { ReactiveNode } from './types/ReactiveNode.ts'
+
+/*
+Closes a dependency-capture pass: every edge trailing the recompute cursor
+(`depsTail`) is a dependency last run read but this run didn't, so unlink it from
+its source and truncate the list at the cursor. `track` advanced the cursor past
+each reused edge during compute, so the cursor is the new tail. A node that read
+nothing leaves the cursor at the start (`undefined`), dropping every edge.
+*/
+export function endTracking(node: ReactiveNode): void {
+    const cursor = node.depsTail
+    let stale = cursor === undefined ? node.depsHead : cursor.nextDep
+    while (stale !== undefined) {
+        const next = stale.nextDep
+        detachLink(stale)
+        stale = next
+    }
+    if (cursor !== undefined) {
+        cursor.nextDep = undefined
+    } else {
+        node.depsHead = undefined
+    }
+}

package/src/lib/ui/runtime/enterRenderPass.ts

@@ -0,0 +1,12 @@
+import { RENDER } from './RENDER.ts'
+
+/* Marks entry into a render/mount. The OUTERMOST one (depth 0) resets the block-id
+   counter so every render pass starts at 0; a child component's render/mount runs
+   at depth > 0 and continues the parent's counter. Pair with `exitRenderPass`. */
+// @readme plumbing
+export function enterRenderPass(): void {
+    if (RENDER.depth === 0) {
+        RENDER.blockId = 0
+    }
+    RENDER.depth += 1
+}

package/src/lib/ui/runtime/exitRenderPass.ts

@@ -0,0 +1,7 @@
+import { RENDER } from './RENDER.ts'
+
+/* Marks exit from a render/mount, unwinding the depth `enterRenderPass` raised. */
+// @readme plumbing
+export function exitRenderPass(): void {
+    RENDER.depth -= 1
+}

package/src/lib/ui/runtime/firstOutlet.ts

@@ -0,0 +1,22 @@
+import { OUTLET_TAG } from './OUTLET_TAG.ts'
+
+/*
+The first `<abide-outlet>` in `root`'s subtree, in document order — the position
+the router fills with the next layer of a route's layout chain. A depth-first walk
+over `children` rather than `querySelector`: the router runs against real DOM and
+the test mini-DOM alike, and only the former has `querySelector`. Tag comparison is
+case-insensitive (the real DOM uppercases `tagName`, the mini-DOM keeps it as
+created). Returns undefined when the layout declares no `<slot/>`.
+*/
+export function firstOutlet(root: Element): Element | undefined {
+    for (const child of root.children) {
+        if (child.tagName.toLowerCase() === OUTLET_TAG) {
+            return child
+        }
+        const nested = firstOutlet(child)
+        if (nested !== undefined) {
+            return nested
+        }
+    }
+    return undefined
+}

package/src/lib/ui/runtime/flushEffects.ts

@@ -0,0 +1,17 @@
+import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
+import { runNode } from './runNode.ts'
+
+/*
+Drains queued effects synchronously. Snapshots and clears the queue each pass so
+an effect that dirties further effects re-queues them for the next pass rather
+than mutating the set mid-iteration; loops until the graph settles.
+*/
+export function flushEffects(): void {
+    while (REACTIVE_CONTEXT.pendingEffects.size > 0) {
+        const batch = [...REACTIVE_CONTEXT.pendingEffects]
+        REACTIVE_CONTEXT.pendingEffects.clear()
+        for (const node of batch) {
+            runNode(node)
+        }
+    }
+}

package/src/lib/ui/runtime/hotInstances.ts

@@ -0,0 +1,10 @@
+import type { HotInstance } from './types/HotInstance.ts'
+
+/*
+Live component instances grouped by module id (`UiComponent.__abideId`).
+`mountChild` adds each instance it mounts while hot reload is active; `hotReplace`
+walks a module's set to swap every instance when that module is edited. The set's
+remove callback (filed with the mounting owner) drops an instance on unmount, so
+no stale record survives to be swapped into a detached host.
+*/
+export const hotInstances: Map<string, Set<HotInstance>> = new Map()

package/src/lib/ui/runtime/hotReloadEnabled.ts

@@ -0,0 +1,8 @@
+/*
+Whether abide-ui hot-module replacement is active. Off by default, so production
+and ordinary dev render exactly as before — `mountChild` takes the plain path.
+The dev client sets it true once the hot bridge is in place, switching every
+child mount onto the path that records its instance so an edited component can be
+disposed and re-run where it stands.
+*/
+export const hotReloadEnabled: { current: boolean } = { current: false }

package/src/lib/ui/runtime/hotReplace.ts

@@ -0,0 +1,25 @@
+import { hotInstances } from './hotInstances.ts'
+import type { UiComponent } from './types/UiComponent.ts'
+
+/*
+Swaps every live instance of an edited component to its new factory. Per instance:
+dispose the current scope and its DOM (the mount disposer clears the host), then
+re-run `next` into the same host with the same props — so state above the boundary
+survives (props are thunks that re-read the parent's live signals) while the
+component's own state resets. The hot module calls this on load with its freshly
+compiled `next`. Returns whether it swapped at least one instance: false (the edited
+component has none mounted — e.g. a router-mounted page, or a hidden branch) tells
+the caller to fall back to a full reload, since nothing on screen would update.
+*/
+export function hotReplace(moduleId: string, next: UiComponent): boolean {
+    const set = hotInstances.get(moduleId)
+    if (set === undefined || set.size === 0) {
+        return false
+    }
+    for (const instance of set) {
+        instance.dispose()
+        instance.factory = next
+        instance.dispose = next(instance.host, instance.props)
+    }
+    return true
+}

package/src/lib/ui/runtime/nextBlockId.ts

@@ -0,0 +1,11 @@
+import { RENDER } from './RENDER.ts'
+
+/* The next block id in the current render pass. `await`/`try` blocks draw from it
+   in document order — shared across a component and the children it inlines — so a
+   page id and a child component's id never collide in the global `RESUME` manifest. */
+// @readme plumbing
+export function nextBlockId(): number {
+    const id = RENDER.blockId
+    RENDER.blockId += 1
+    return id
+}

package/src/lib/ui/runtime/pathExists.ts

@@ -0,0 +1,23 @@
+/*
+Whether a `/`-joined path still resolves through `tree` — every segment present
+in its container. The `in` operator covers both shapes: an object key, an array's
+own index (in range) or its `length`. Distinguishes a path the tree no longer has
+(a deleted key, an out-of-range index after a shrink) from one holding a genuine
+`undefined`, which `valueAtPath` alone can't — used to evict dead reactive nodes.
+*/
+export function pathExists(tree: unknown, path: string): boolean {
+    if (path === '') {
+        return tree !== undefined
+    }
+    let current: unknown = tree
+    for (const segment of path.split('/')) {
+        if (current === null || typeof current !== 'object') {
+            return false
+        }
+        if (!(segment in current)) {
+            return false
+        }
+        current = (current as Record<string, unknown>)[segment]
+    }
+    return true
+}

package/src/lib/ui/runtime/readNode.ts

@@ -0,0 +1,17 @@
+import { runNode } from './runNode.ts'
+import { track } from './track.ts'
+import type { ReactiveNode } from './types/ReactiveNode.ts'
+
+/*
+Reads a node's current value and subscribes the running observer to it. A dirty
+computed recomputes first (lazy pull); a signal returns its stored value
+directly. Tracking happens after recompute so the reader links to the computed
+itself, not its transitive deps.
+*/
+export function readNode(node: ReactiveNode): unknown {
+    if (node.compute !== undefined && node.dirty) {
+        runNode(node)
+    }
+    track(node)
+    return node.value
+}

package/src/lib/ui/runtime/registerHotInstance.ts

@@ -0,0 +1,23 @@
+import { hotInstances } from './hotInstances.ts'
+import type { HotInstance } from './types/HotInstance.ts'
+
+/*
+Records a live component instance under its module id and returns a remove
+callback. `mountChild` files the remove with the mounting owner, so the instance
+leaves the registry when its parent (or branch/row) tears down — the module's set
+is dropped once empty, leaving no orphan keys.
+*/
+export function registerHotInstance(moduleId: string, instance: HotInstance): () => void {
+    let set = hotInstances.get(moduleId)
+    if (set === undefined) {
+        set = new Set()
+        hotInstances.set(moduleId, set)
+    }
+    set.add(instance)
+    return () => {
+        set.delete(instance)
+        if (set.size === 0) {
+            hotInstances.delete(moduleId)
+        }
+    }
+}

package/src/lib/ui/runtime/runNode.ts

@@ -0,0 +1,28 @@
+import { endTracking } from './endTracking.ts'
+import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
+import type { ReactiveNode } from './types/ReactiveNode.ts'
+
+/*
+Runs a compute node (computed or effect) with dependency capture. Rewinds the
+recompute cursor (`depsTail`) to the start of the dependency list, installs itself
+as the current observer so reads inside `compute` re-link via `track`, runs, then
+trims every edge `track` didn't reuse — last run's dependencies that weren't read
+this time. Re-capturing every run is what makes dependencies dynamic: a branch not
+taken this run leaves its edges past the cursor, so they are dropped here. Returns
+the fresh value (used by lazy computed reads).
+*/
+export function runNode(node: ReactiveNode): unknown {
+    /* Rewind: track() walks forward from here, reusing matching edges in order. */
+    node.depsTail = undefined
+    const previous = REACTIVE_CONTEXT.observer
+    REACTIVE_CONTEXT.observer = node
+    try {
+        node.value = node.compute?.()
+        node.dirty = false
+        return node.value
+    } finally {
+        REACTIVE_CONTEXT.observer = previous
+        /* Drop the edges `track` didn't reuse — last run's now-stale dependencies. */
+        endTracking(node)
+    }
+}

package/src/lib/ui/runtime/runtimePath.ts

@@ -0,0 +1,9 @@
+import { state } from '../state.ts'
+import type { State } from './types/State.ts'
+
+/* The current route as a reactive signal — read by `router` to pick the page,
+   written by `navigate`/`popstate`. Defaults to `/` where there is no location
+   (the server, which routes by request URL instead). */
+export const runtimePath: State<string> = state(
+    typeof location !== 'undefined' ? location.pathname + location.search + location.hash : '/',
+)

package/src/lib/ui/runtime/scope.ts

@@ -0,0 +1,24 @@
+import { OWNER } from './OWNER.ts'
+
+/*
+Runs `build` under a fresh ownership scope so every effect and listener created
+inside is collected, and returns a disposer that tears them all down in reverse
+order (children before parents). Save/restore of the previous owner makes scopes
+nest — a list row's scope sits inside its component's scope.
+*/
+export function scope(build: () => void): () => void {
+    const previous = OWNER.current
+    const disposers: Array<() => void> = []
+    OWNER.current = disposers
+    try {
+        build()
+    } finally {
+        OWNER.current = previous
+    }
+    return () => {
+        for (let index = disposers.length - 1; index >= 0; index -= 1) {
+            disposers[index]?.()
+        }
+        disposers.length = 0
+    }
+}

package/src/lib/ui/runtime/toTeardown.ts

@@ -0,0 +1,26 @@
+import type { EffectResult } from './types/EffectResult.ts'
+import type { Teardown } from './types/Teardown.ts'
+
+/*
+Normalises an effect/attachment body's return into a single callable teardown (or
+undefined when it returned nothing). A function is the teardown itself; a promise
+is wrapped so the teardown runs once it settles — chained, never awaited, so a
+dispose mid-setup still tears down without blocking the caller. Shared by
+`createEffectNode` (runs it on re-run + dispose) and `attach` (registers it with
+the owner scope).
+*/
+export function toTeardown(result: EffectResult): Teardown | undefined {
+    if (typeof result === 'function') {
+        return result
+    }
+    if (result instanceof Promise) {
+        return () => {
+            result.then((teardown) => {
+                if (typeof teardown === 'function') {
+                    teardown()
+                }
+            })
+        }
+    }
+    return undefined
+}

package/src/lib/ui/runtime/track.ts

@@ -0,0 +1,58 @@
+import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
+import type { ReactiveLink } from './types/ReactiveLink.ts'
+import type { ReactiveNode } from './types/ReactiveNode.ts'
+
+/*
+Links a node being read to the observer currently running, in both directions, so
+a later write to the node reaches the observer and a recompute can unlink it. A
+no-op outside any tracking scope — reads in plain code (and on the server)
+register nothing, so the same callable works tracked and untracked.
+
+Edge reuse keeps a settled observer allocation-free across runs. `depsTail` is the
+recompute cursor (rewound by `runNode` before compute); the edge just past it is
+what last run captured at this position. If that edge already points at `dep`, the
+observer is reading the same source in the same order as before — advance the
+cursor and reuse the edge, allocating nothing. Otherwise splice a fresh edge in at
+the cursor; `runNode` trims whatever stale edges trail the cursor when compute ends.
+
+A consecutive re-read of the same source (`dep` already the edge at the cursor) is
+absorbed by the reuse check, so `{x} … {x}` in one computation links `x` once.
+*/
+export function track(dep: ReactiveNode): void {
+    const sub = REACTIVE_CONTEXT.observer
+    if (sub === undefined) {
+        return
+    }
+    /* The edge to reuse: the one after the cursor, or the head when the cursor sits
+       at the start of this run. */
+    const reusable = sub.depsTail === undefined ? sub.depsHead : sub.depsTail.nextDep
+    if (reusable !== undefined && reusable.dep === dep) {
+        sub.depsTail = reusable
+        return
+    }
+    const link: ReactiveLink = {
+        dep,
+        sub,
+        prevDep: sub.depsTail,
+        nextDep: reusable,
+        prevSub: dep.subsTail,
+        nextSub: undefined,
+    }
+    /* Splice into the observer's dependency list at the cursor. */
+    if (sub.depsTail !== undefined) {
+        sub.depsTail.nextDep = link
+    } else {
+        sub.depsHead = link
+    }
+    if (reusable !== undefined) {
+        reusable.prevDep = link
+    }
+    sub.depsTail = link
+    /* Append onto the source's subscriber list (order there is irrelevant). */
+    if (dep.subsTail !== undefined) {
+        dep.subsTail.nextSub = link
+    } else {
+        dep.subsHead = link
+    }
+    dep.subsTail = link
+}

package/src/lib/ui/runtime/trigger.ts

@@ -0,0 +1,44 @@
+import { flushEffects } from './flushEffects.ts'
+import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
+import type { ReactiveNode } from './types/ReactiveNode.ts'
+
+/*
+Invalidates the observer cone of a just-written node: effect observers are
+queued, computed observers are marked dirty and recursed into (their value may
+now differ, so their own observers must learn of it). Recompute is lazy — a
+computed recomputes on next read — so this pass only invalidates and collects.
+
+The subscriber list is walked live: invalidate runs no compute and no effect, so
+nothing re-subscribes (the only mutators of a subscriber list, `track` and
+`runNode`, run inside compute execution, which only `flushEffects` reaches — after
+this pass). The re-subscribe hazard belongs to the flush, where `flushEffects`
+defends with its own snapshot. `nextSub` is read before recursing, so the walk
+holds no reference a downstream pass could invalidate.
+*/
+function invalidate(node: ReactiveNode): void {
+    let link = node.subsHead
+    while (link !== undefined) {
+        const observer = link.sub
+        const next = link.nextSub
+        if (observer.isEffect) {
+            REACTIVE_CONTEXT.pendingEffects.add(observer)
+        } else if (!observer.dirty) {
+            observer.dirty = true
+            invalidate(observer)
+        }
+        link = next
+    }
+}
+
+/*
+Propagates a change forward from a just-written node. Invalidation collects the
+whole cone first; the queued effects flush once, at the outermost trigger (or,
+inside a batch, when the batch owner exits) — never mid-propagation, so an effect
+never runs against a half-invalidated graph.
+*/
+export function trigger(node: ReactiveNode): void {
+    invalidate(node)
+    if (REACTIVE_CONTEXT.batchDepth === 0) {
+        flushEffects()
+    }
+}

package/src/lib/ui/runtime/types/Cell.ts

@@ -0,0 +1,5 @@
+/* A stable reactive accessor bound to one document path: `get` subscribes the
+   running observer, `set` mutates that path and wakes its readers — all path
+   resolution done once at bind time, so the access itself is string-free. This
+   is the shape the template compiler emits for a `{path}` read / write. */
+export type Cell<T> = { get: () => T; set: (value: T) => void }

package/src/lib/ui/runtime/types/Derived.ts

@@ -0,0 +1,3 @@
+/* A read-only reactive cell computed from other cells. Reading `.value`
+   subscribes the running observer and lazily recomputes if a dependency changed. */
+export type Derived<T> = { readonly value: T }

package/src/lib/ui/runtime/types/Doc.ts

@@ -0,0 +1,19 @@
+import type { Cell } from './Cell.ts'
+import type { Patch } from './Patch.ts'
+
+/*
+A reactive document: a single immutable tree addressed by path. `read` subscribes
+the running observer to a path and returns its current value; `apply` (and the
+`replace`/`add`/`remove` sugar) advances the tree by one patch and wakes exactly
+the readers whose paths the patch touched. `snapshot` returns the current root —
+plain, serializable data, which is what makes the document resumable.
+*/
+export type Doc = {
+    read: <T>(path: string) => T
+    cell: <T>(path: string) => Cell<T>
+    apply: (patch: Patch) => void
+    replace: (path: string, value: unknown) => void
+    add: (path: string, value: unknown) => void
+    remove: (path: string) => void
+    snapshot: () => unknown
+}

package/src/lib/ui/runtime/types/EffectResult.ts

@@ -0,0 +1,10 @@
+import type { Teardown } from './Teardown.ts'
+
+/*
+What an effect or attachment body returns: a teardown to run before its next run
+and on dispose, nothing, or — when the body is async — a promise of either. The
+async case tracks only the reads before its first `await`; reads after it are not
+captured by the reactive graph.
+*/
+// biome-ignore lint/suspicious/noConfusingVoidType: an effect body with no return is void; the union is the real contract
+export type EffectResult = void | Teardown | Promise<void | Teardown>

package/src/lib/ui/runtime/types/HotInstance.ts

@@ -0,0 +1,14 @@
+import type { UiComponent } from './UiComponent.ts'
+
+/*
+A live component instance the hot-reload registry tracks: its wrapper host, the
+factory that built it, the props (thunks re-read on a swap so the parent's live
+state still flows through), and the disposer for its current scope + DOM. A swap
+mutates `factory`/`dispose` in place (see `hotReplace`).
+*/
+export type HotInstance = {
+    host: Element
+    factory: UiComponent
+    props: Parameters<UiComponent>[1]
+    dispose: () => void
+}

package/src/lib/ui/runtime/types/NavVerdict.ts

@@ -0,0 +1,9 @@
+/* What the navigation probe decided after running the destination through the
+   server's app.handle: `mount` it client-side (handle() cleared it), `redirect`
+   to where handle() pointed (same-origin — the router re-probes there), or `reload`
+   via a full browser navigation (handle() blocked it, redirected cross-origin, or
+   the probe itself failed) so the server's real response is what the user sees. */
+export type NavVerdict =
+    | { kind: 'mount' }
+    | { kind: 'redirect'; path: string }
+    | { kind: 'reload'; url: string }

package/src/lib/ui/runtime/types/Patch.ts

@@ -0,0 +1,11 @@
+/*
+A serializable change against a document path. `replace` overwrites the value at
+a path; `add` inserts (into an array at an index or `-` to push, or sets an
+object key); `remove` deletes it. The path is `/`-joined segments; `''` is the
+document root. Being plain data is the whole point — a patch is the unit that
+flows from a transition to the DOM, to persistence, and over the wire.
+*/
+export type Patch =
+    | { op: 'replace'; path: string; value: unknown }
+    | { op: 'add'; path: string; value: unknown }
+    | { op: 'remove'; path: string }

package/src/lib/ui/runtime/types/ReactiveLink.ts

@@ -0,0 +1,21 @@
+import type { ReactiveNode } from './ReactiveNode.ts'
+
+/*
+One dependency edge in the reactive graph: `sub` (the observer) reads `dep` (the
+source). The edge is threaded into two intrusive doubly-linked lists at once — the
+source's list of subscribers (the `*Sub` pointers, walked forward on a write) and
+the observer's list of dependencies (the `*Dep` pointers, walked on recompute to
+reuse or drop edges). Replacing the former `Set` on each side makes link/unlink
+O(1) with no per-edge allocation once a node settles, and propagation a sequential
+pointer walk instead of a hashed-set iteration.
+*/
+export type ReactiveLink = {
+    dep: ReactiveNode
+    sub: ReactiveNode
+    /* Siblings in `sub`'s dependency list (the edges `sub` captured, in read order). */
+    prevDep: ReactiveLink | undefined
+    nextDep: ReactiveLink | undefined
+    /* Siblings in `dep`'s subscriber list (every observer reading `dep`). */
+    prevSub: ReactiveLink | undefined
+    nextSub: ReactiveLink | undefined
+}

package/src/lib/ui/runtime/types/ReactiveNode.ts

@@ -0,0 +1,25 @@
+import type { ReactiveLink } from './ReactiveLink.ts'
+
+/*
+A node in the reactive graph. A signal has a value and no compute; a computed has
+both; an effect has a compute and runs for its side effects. Dependencies (the
+nodes this node read on its last run) and subscribers (the nodes that read this
+one) are each held as an intrusive doubly-linked list of `ReactiveLink` edges
+rather than a `Set` — a write walks `subsHead → nextSub` forward to dependents, a
+recompute walks `depsHead → nextDep` to reuse still-live edges and drop stale
+back-links, both O(1) per edge with no allocation once the node settles.
+
+`depsTail` doubles as the recompute cursor: `runNode` rewinds it before compute
+and `track` advances it past each reused edge, so whatever trails it afterward is
+this run's stale dependencies, trimmed in one pass.
+*/
+export type ReactiveNode = {
+    value: unknown
+    compute: (() => unknown) | undefined
+    depsHead: ReactiveLink | undefined
+    depsTail: ReactiveLink | undefined
+    subsHead: ReactiveLink | undefined
+    subsTail: ReactiveLink | undefined
+    dirty: boolean
+    isEffect: boolean
+}

package/src/lib/ui/runtime/types/Route.ts

@@ -0,0 +1,8 @@
+/* A routable page: mounts into a host (optionally with props) and may return a
+   disposer the router calls when navigating away. A compiled `.abide` default
+   export also carries `hydrate` (adopt SSR in place) and `hydratable` (false when
+   the page has an `await` block), which the router uses for the initial render. */
+export type Route = ((host: Element, props?: unknown) => (() => void) | undefined) & {
+    hydrate?: (host: Element, props?: unknown) => () => void
+    hydratable?: boolean
+}