@abide/abide 0.49.0 → 0.50.0

package/src/lib/ui/types/Scope.ts

@@ -3,7 +3,7 @@ import type { effect } from '../effect.ts'
 import type { linked } from '../linked.ts'
 import type { Patch } from '../runtime/types/Patch.ts'
 import type { state } from '../state.ts'
-import type { SyncTransport } from './SyncTransport.ts'
+import type { trackedComputed } from '../trackedComputed.ts'
 
 /*
 A lexical scope: the unit that owns a region's reactive data, its lifetime, and
@@ -14,21 +14,14 @@ surface is the imported `state`/`state.linked`/`state.computed`/`effect` (see
 scope (`$$scope().derive`/`.linked`/`.effect`, `state.share`/`.shared` → `share`/
 `shared`). The data surface MIRRORS `Doc` (read/replace/add/remove/derive/apply/
 snapshot) so the compiler can target a scope as a component's data binding directly;
-it nests (`child`/`root`) and passes values down the tree as context (`share`/`shared`).
+it passes values down the tree as context (`share`/`shared`).
 
-The reactive primitives and capabilities remain on this internal shape because the
-lowered runtime calls them (`$$scope().linked(...)`, generated undo/persist) — they are
-withdrawn from the AUTHOR-facing public surface (docs/examples), not the runtime object.
-Capabilities route where the scope's changes go: `record()` to an undo journal,
-`persist()` to durable storage, `broadcast()` to peers — declared once, then `undo`/
-`redo` act on a recorded scope. The `history`/`persist`/`sync` helpers it composes are
-internal.
+The reactive primitives remain on this internal shape because the lowered runtime calls
+them (`$$scope().linked(...)`) — they are withdrawn from the AUTHOR-facing public surface
+(docs/examples), not the runtime object.
 */
 export type Scope = {
     readonly id: string
-    /* Dev-only display name (the host component/element it mounted into) for the
-       inspector's Reactive tab; undefined for SSR/detached/child scopes. */
-    readonly label?: string
     readonly parent: Scope | undefined
     /* data — mirrors Doc */
     read: <T>(path: string) => T
@@ -54,15 +47,15 @@ export type Scope = {
     state: typeof state
     linked: typeof linked
     computed: typeof computed
+    /* The eager stream-classifying read-only computed a bare-call `computed(getStream())`
+       lowers to — auto-tracks a stream/promise producer, falls back to a lazy computed. */
+    trackedComputed: typeof trackedComputed
     effect: typeof effect
     /* Adopts a teardown into this scope's lifetime — the build's reactivity stopper
        (effects/listeners), run first on `dispose` (before children, before capabilities).
        Internal: the mount core registers the build's disposer here so a component has ONE
        teardown (`dispose`) rather than a separate stop + dispose composed at every site. */
     own: (dispose: () => void) => void
-    /* tree */
-    child: (initial?: unknown) => Scope
-    root: () => Scope
     /* context — values shared DOWN the tree (not in the reactive doc, which doesn't
        inherit): `share` puts a named value on this scope; `shared` reads the closest
        ancestor (self included) that has the key, undefined if none. The value is held
@@ -70,15 +63,6 @@ export type Scope = {
        plain object snapshot. */
     share: (key: string, value: unknown) => void
     shared: <T>(key: string) => T | undefined
-    /* capabilities — enable where the scope's changes go */
-    record: (options?: { limit?: number }) => void
-    persist: (key?: string) => void
-    broadcast: (transport: SyncTransport) => void
-    /* undo/redo — act on a recorded scope */
-    undo: () => void
-    redo: () => void
-    canUndo: () => boolean
-    canRedo: () => boolean
     /* lifetime */
     dispose: () => void
 }

package/src/lib/ui/watch.ts

@@ -1,8 +1,8 @@
 import { cache } from '../shared/cache.ts'
 import { REMOTE_FUNCTION } from '../shared/REMOTE_FUNCTION.ts'
 import type { CacheOnContext } from '../shared/types/CacheOnContext.ts'
+import type { NamedAsyncIterable } from '../shared/types/NamedAsyncIterable.ts'
 import type { RemoteFunction } from '../shared/types/RemoteFunction.ts'
-import type { Subscribable } from '../shared/types/Subscribable.ts'
 import { effect } from './effect.ts'
 import { generationGuard } from './runtime/generationGuard.ts'
 import type { EffectResult } from './runtime/types/EffectResult.ts'
@@ -40,7 +40,7 @@ export function watch(
     handler: (values: unknown[]) => void,
 ): () => void
 export function watch<Frame>(
-    source: Subscribable<Frame>,
+    source: NamedAsyncIterable<Frame>,
     handler: (frame: Frame, context: CacheOnContext) => void | Promise<void>,
 ): () => void
 export function watch<Args, Return>(
@@ -74,7 +74,7 @@ export function watch(
        existing cache.on loop is the single implementation this branch delegates to. */
     if (isSubscribable(source)) {
         return cache.on(
-            source as Subscribable<unknown>,
+            source as NamedAsyncIterable<unknown>,
             handler as (frame: unknown, context: CacheOnContext) => void | Promise<void>,
         )
     }

package/src/serverEntry.ts

@@ -33,8 +33,11 @@ import { cacheStoreSlot } from './lib/shared/cacheStoreSlot.ts'
 import { createCacheStore } from './lib/shared/createCacheStore.ts'
 import { loadEnvFromDataDir } from './lib/shared/loadEnvFromDataDir.ts'
 import { pageSlot } from './lib/shared/pageSlot.ts'
+import { pendingAsyncCellsSlot } from './lib/shared/pendingAsyncCellsSlot.ts'
+import { resolvedCellsSlot } from './lib/shared/resolvedCellsSlot.ts'
 import { runningAsStandaloneBinary } from './lib/shared/runningAsStandaloneBinary.ts'
 import { sharedCacheStoreSlot } from './lib/shared/sharedCacheStoreSlot.ts'
+import { streamedCellsSlot } from './lib/shared/streamedCellsSlot.ts'
 
 /*
 Resolve config into process.env before anything reads it (createServer reads
@@ -76,6 +79,17 @@ sharedCacheStoreSlot.resolver = () => sharedCacheStore
 
 cacheStoreSlot.resolver = () => requestContext.getStore()?.cache ?? sharedCacheStore
 
+/* One process-wide fallback list for reads with no request in flight (boot/cron/socket) —
+   real requests each carry their own `pendingAsyncCells`, so the SSR barrier drains a
+   per-request list and concurrent renders never cross-contaminate. */
+const sharedPendingAsyncCells = { promises: [] }
+pendingAsyncCellsSlot.resolver = () =>
+    requestContext.getStore()?.pendingAsyncCells ?? sharedPendingAsyncCells
+const sharedResolvedCells = { entries: [] }
+resolvedCellsSlot.resolver = () => requestContext.getStore()?.resolvedCells ?? sharedResolvedCells
+const sharedStreamedCells = { entries: [] }
+streamedCellsSlot.resolver = () => requestContext.getStore()?.streamedCells ?? sharedStreamedCells
+
 pageSlot.resolver = resolvePageSnapshot
 
 await createServer({

package/template/src/server/rpc/getHello.ts

@@ -6,17 +6,18 @@ the HTTP method. The bundler swaps the runtime per build target: direct call on
 the server, fetch over the network on the client.
 
 Args (what the caller passes in) come from the handler's parameter type —
-either an inline annotation or an explicit `GET<{ id: string }>(...)`
-generic. Return (what the caller receives after Content-Type-driven
-decoding) is inferred from the handler's return type via the
-`TypedResponse<T>` brand on `json`/`error`/`redirect`/`jsonl`/`sse`, so
-plain `GET(() => json({...}))` already types end-to-end.
+annotate the parameter and the body infers; a typed generic on the helper is a
+compile error. Return (what the caller receives after Content-Type-driven
+decoding) is inferred from the handler's return type via the `TypedResponse<T>`
+brand on `json`/`error`/`redirect`/`jsonl`/`sse`, so plain
+`GET(() => json({...}))` already types end-to-end.
 
-For inbound validation pass a Standard Schema as `inputSchema` in the
-second argument: `GET(fn, { inputSchema })`. Args then infers from the
-schema's output type and the server replies with 422 on validation
-failure. An optional `outputSchema` describes the success body for the
-OpenAPI 200 response and the MCP tool output.
+For inbound validation pass a Standard Schema under `schemas.input` in the
+second argument: `GET(fn, { schemas: { input } })`. Args then infers from the
+schema's output type and the server replies with 422 on validation failure. An
+optional `schemas.output` describes the success body for the OpenAPI 200
+response and the MCP tool output; without one the handler's return type is
+projected to JSON Schema.
 
 `json(...)` from `abide/server/json` is a thin wrapper over `Response.json`
 that defaults `Cache-Control: no-store`, since intermediary caches shouldn't
@@ -24,10 +25,11 @@ memoise rpc replies (the framework's per-request cache handles in-process
 dedupe). Other helpers are siblings, one per file: `abide/server/error`,
 `abide/server/redirect`, `abide/server/sse`, `abide/server/jsonl`.
 
-Every rpc value also exposes `.raw(args?)` (returns the underlying
+Every rpc value also exposes `.raw(args?, init?)` (returns the underlying
 `Response`) for callers that need headers or status. A streaming rpc — a
-jsonl/sse handler — returns a `Subscribable` over the frames from its bare
-call (`fn(args)`); iterate it with `for await` or react to it with `watch(fn(args), frame => …)`.
+jsonl/sse handler — returns a `NamedAsyncIterable` over the frames from its bare
+call (`fn(args)`); iterate it with `for await` or react to it with
+`watch(fn(args), frame => …)`.
 */
 
 import { GET } from '@abide/abide/server/GET'

package/template/test/app.test.ts

@@ -5,7 +5,7 @@ same wiring as `abide start`, no fixtures) and hands back the whole surface:
   app.fetch(path)        — pages and raw HTTP, origin + mount base resolved
   app.rpc.<name>(args)   — RPCs over the real pipeline (CSRF, cookies, base),
                            typed and decoded; .raw(args) for the Response
-  app.sockets.<name>     — a live Socket: iterate it (for await), .peek(), .broadcast(m)
+  app.sockets.<name>     — a live Socket: iterate it (for await), .peek(), .publish(m)
   app.health()           — the /__abide/health payload
 
 `app.rpc` / `app.sockets` are typed from your own RPCs and sockets — generated

package/src/lib/server/runtime/devHotModuleResponse.ts

@@ -1,41 +0,0 @@
-import { resolve } from 'node:path'
-import { NO_STORE } from '../../shared/CACHE_CONTROL_VALUES.ts'
-import { isLayoutFile } from '../../shared/isLayoutFile.ts'
-import { compileModule } from '../../ui/compile/compileModule.ts'
-
-// Reused across requests — strips the embedded author TypeScript to browser JS.
-const TRANSPILER = new Bun.Transpiler({ loader: 'ts' })
-
-/*
-Serves one edited `.abide`'s hot module (dev component HMR). Compiles it in hot
-mode — runtime sourced from `window.__abide`, self-invoking `hotReplace` — and
-transpiles the embedded author TypeScript to plain JS the browser can import
-directly (the normal pipeline relies on the bundler's `ts` loader for this). The
-browser imports this in place of a reload; on load it swaps the component's live
-instances. The id is guarded as a project-relative `.abide` under cwd; a bad
-module ID returns 400; a missing file 404s so the client falls back to a reload.
-*/
-export async function devHotModuleResponse(moduleId: string): Promise<Response> {
-    const root = process.cwd()
-    const path = resolve(root, moduleId)
-    if (!moduleId.endsWith('.abide') || !path.startsWith(`${root}/`)) {
-        return new Response('bad request', { status: 400 })
-    }
-    const source = await Bun.file(path)
-        .text()
-        .catch(() => undefined)
-    if (source === undefined) {
-        return new Response('not found', { status: 404 })
-    }
-    const { code } = compileModule(source, {
-        isLayout: isLayoutFile(moduleId),
-        moduleId,
-        hot: true,
-    })
-    return new Response(TRANSPILER.transformSync(code), {
-        headers: {
-            'Content-Type': 'application/javascript; charset=utf-8',
-            'Cache-Control': NO_STORE,
-        },
-    })
-}

package/src/lib/shared/DEV_HOT_PREFIX.ts

@@ -1,7 +0,0 @@
-/*
-Path prefix of the dev-only component hot-module endpoint (`/__abide/hot/<moduleId>`).
-The browser imports `<prefix><moduleId>?v=<hash>` to fetch one edited component's
-hot module instead of reloading. Shared so the server route (createServer) and the
-live-reload client (DEV_RELOAD_CLIENT_SCRIPT) agree.
-*/
-export const DEV_HOT_PREFIX = '/__abide/hot/'

package/src/lib/shared/UNREACHABLE_STATUSES.ts

@@ -1,13 +0,0 @@
-/*
-HTTP statuses that mean "the server didn't process this request" — the gateway /
-availability family. A response with one of these is treated like a transport failure
-by a durable RPC: the call still throws (the error framework is unchanged), and the
-request is parked for replay on recovery. Everything else (4xx, 500, …) means the
-server received and handled it — that flows to the error framework, never the outbox.
-
-  502 Bad Gateway · 503 Service Unavailable · 504 Gateway Timeout (abide's own client
-  timeout surfaces here too) · 520–527, 530 — Cloudflare/CDN origin-unreachable.
-*/
-export const UNREACHABLE_STATUSES: ReadonlySet<number> = new Set([
-    502, 503, 504, 520, 521, 522, 523, 524, 525, 526, 527, 530,
-])

package/src/lib/shared/hasReplayableRequest.ts

@@ -1,17 +0,0 @@
-import { isReplayableMethod } from './isReplayableMethod.ts'
-import type { CacheEntry } from './types/CacheEntry.ts'
-
-/*
-Whether a cache entry carries a wire request that can be replayed from a warm
-snapshot — a replayable (GET-only) method, so the seed never re-fires a write or
-loses a body. Producer entries (no request) and write methods fail it.
-
-The request half of snapshot shippability, factored out so the two gates that
-need it cannot drift: `snapshotShippable` composes it with `settled` for the
-store-filter sites, and `snapshotEntryFromCache` calls it alone — its
-streaming-drain caller hands it still-pending entries it then awaits, so it can't
-require `settled` up front.
-*/
-export function hasReplayableRequest(entry: CacheEntry): boolean {
-    return entry.request !== undefined && isReplayableMethod(entry.request.method.toUpperCase())
-}

package/src/lib/shared/hydratingSlot.ts

@@ -1,12 +0,0 @@
-/*
-Set true only while the client adopts the server-rendered DOM (the hydration
-render pass — see the router's hydrate branch and `hydrate`). Read by `peek`: the
-server materializes no cache value (materializeRetained/cacheEntryFromSnapshot are
-client-only), so server-side peek is uniformly undefined and the SSR render always
-shows the fallback. A snapshot-seeded warm value surfacing DURING hydration would
-diverge from that server text and corrupt the claimed text node, so peek withholds
-it until the pass ends — `wakeHydrationPeeks` then re-runs the scope on the now-
-congruent value. A plain boolean, save/restore-nested so a child hydrate can't clear
-an outer pass early; false on the server (no hydration) and after boot.
-*/
-export const hydratingSlot: { active: boolean } = { active: false }

package/src/lib/shared/outboxProbeSlot.ts

@@ -1,20 +0,0 @@
-/*
-Internal slot the browser outbox registry registers its prober into, so the
-shared pending() probe can count parked durable-rpc writes without shared/
-importing browser/. Mirrors tailProbeSlot. The prober reads the doc-backed
-queue entries (reactive inside scope().computed() / scope().effect()) and reports whether any
-undelivered entry matches the selector: a durable rpc selector (carries a
-`url`) narrows to its own queue, the bare form spans every registered queue,
-optional args narrow to one parked call by structural compare. Outbox state is
-pending-only — a parked write has no value, so it never contributes to
-refreshing(); probeRegistries reads this slot only on its `field === 'pending'`
-branch, which is why the slot mirrors tailProbeSlot but reports a bare boolean
-rather than a { pending, refreshing } pair. When no prober is registered (server
-render, or no durable rpc was ever used) pending() sees no parked writes,
-exactly as on the server where there are no client queues.
-*/
-export const outboxProbeSlot: {
-    probe: ((selector: unknown, args: unknown) => boolean) | undefined
-} = {
-    probe: undefined,
-}

package/src/lib/shared/types/Outbox.ts

@@ -1,9 +0,0 @@
-import type { OutboxEntry } from './OutboxEntry.ts'
-
-/*
-The `.outbox` face on a durable RPC's client proxy: callable to read the reactive list
-of undelivered entries (`rpc.outbox()`), with an awaitable `retry()` that drains the whole
-queue and resolves when the replay settles. Server-side there is no client queue, so the
-face is absent.
-*/
-export type Outbox<Args> = (() => OutboxEntry<Args>[]) & { retry: () => Promise<void> }

package/src/lib/shared/types/OutboxEntry.ts

@@ -1,27 +0,0 @@
-/* The lifecycle status of a parked mutation: waiting to (re)send, or currently sending.
-   A write lives in the outbox ONLY while it can't reach the server; the instant the server
-   responds at all — a 2xx OR a real 4xx/500 — the entry leaves the queue, so there is no
-   terminal `error` state. Only the unreachable family (transport failure / 502/503/504/52x)
-   keeps it `queued`. */
-export type OutboxStatus = 'queued' | 'sending'
-
-/* One durable, replayable mutation in an RPC's outbox — parked because the original
-   call couldn't reach the server (transport failure, or a 502/503/504/52x). `controller`
-   is the entry's own abort handle (cancel = `controller.abort()`); `request` is the
-   synthesized, persisted Request the drain re-sends; `args` is the typed input (for
-   rendering); `error` is why it's parked (the `kind: 'queued'` HttpError from the
-   unreachable attempt); `retry()` kicks a FIFO drain. `settled` is the eventual outcome
-   of THIS write as if the original call had reached the server — it resolves with the
-   decoded result on delivery and rejects with the real HttpError on a server refusal (or
-   an AbortError on cancel). It may stay pending indefinitely if the write is never
-   replayed; reading it is what arms it (a never-read `settled` never rejects). */
-export type OutboxEntry<Args> = {
-    id: string
-    controller: AbortController
-    request: Request
-    args: Args
-    status: OutboxStatus
-    error?: unknown
-    retry: () => Promise<void>
-    settled: Promise<unknown>
-}

package/src/lib/shared/types/SmartReadOptions.ts

@@ -1,36 +0,0 @@
-/*
-Second-argument options for the smart bare rpc call (`getFoo(args, opts)`). The
-call is cached/coalesced/reactive with SWR always on for replayable reads, so
-these govern retention and the refetch clock — NOT transport. Per-call transport
-options (signal/keepalive/priority/cache/headers) live on `.raw(args, init)`.
-
-Fetch reads:
-- `ttl` — retention/staleness in ms. Default: 0 on the server (coalesce-only —
-  the request is the atomic unit, nothing is retained past it), Infinity on the
-  client (retain until invalidate/refresh — the tab is the atomic unit). On the
-  client, N ms marks a staleness deadline: the retained value goes stale after N
-  ms and the next access triggers a background revalidation (stale stays visible,
-  `refreshing()` true); the display value is never dropped. On the server, N ms
-  is a plain expiry and only takes effect in the shared store (pair with `shared`).
-- `tags` — free-form invalidation-group labels (see the selector grammar).
-- `throttle` / `debounce` — rate-limit the background refetch clock (set one, not
-  both). Leading-edge-then-coalesce, or fire-after-quiet respectively.
-- `shared` — opts the entry into the process-level store instead of the default
-  request-scoped one (server) — a store that outlives every request. It selects
-  the store only; it does NOT retain (pair it with `ttl` to memoise across
-  requests). The shared store is keyed by method+url+args, never by user, so do
-  not put per-user data in it — it would be served to other users. Omit `shared`
-  for per-request data. Write only `shared: true`; there is no `false` form. On
-  the client there is a single tab store, so the flag is a no-op there.
-
-Streaming reads (jsonl/sse):
-- `n` — how many retained frames to replay before going live.
-*/
-export type SmartReadOptions = {
-    ttl?: number
-    tags?: string[]
-    throttle?: number
-    debounce?: number
-    shared?: boolean
-    n?: number
-}

package/src/lib/shared/wakeHydrationPeeks.ts

@@ -1,20 +0,0 @@
-import { cacheStores } from './cacheStores.ts'
-
-/*
-Fired once when the outermost hydration pass ends (see the router's hydrate branch
-and `hydrate`). During the pass `peek` withheld every snapshot-seeded warm value
-for SSR congruence (see hydratingSlot); now that the pass is over those values are
-congruent to show, so re-run the scopes that read them. A peek scope taps the exact
-call key's lifecycle channel (peek's trackLifecycle), so marking every live entry's
-key wakes them — cheap, one-time, and harmless for non-peek lifecycle readers (they
-recompute the same value). Marks by key, not the bare store-wide channel, because a
-peek(fn, args) scope taps the per-key prefix channel, which a keyless mark misses.
-*/
-export function wakeHydrationPeeks(): void {
-    const stores = cacheStores()
-    for (const store of stores) {
-        for (const key of store.entries.keys()) {
-            store.markLifecycle(key)
-        }
-    }
-}

package/src/lib/ui/COMPONENT_WRAPPER_PREFIX.ts

@@ -1,5 +0,0 @@
-/* The `abide-` tag prefix on framework-owned custom elements (the router's
-   `abide-outlet`, the streaming `abide-resolve`/`abide-cache` fragments). `scopeLabel`
-   strips it to derive the bare name from a framework-owned host tag (e.g. `abide-resolve` → `resolve`). Child components no longer mount into
-   an `abide-<name>` wrapper — they build as marker ranges (see `mountRange`). */
-export const COMPONENT_WRAPPER_PREFIX = 'abide-'

package/src/lib/ui/compile/REACTIVE_CALLEES.ts

@@ -1,11 +0,0 @@
-/* The author-facing reactive primitive names (`state`, `state.linked`, `state.computed`,
-   and the destructuring `const {…} = props()`). The compiler no longer reads this —
-   recognition is import-resolved (see `resolveReactiveExport.ts`). It remains the canonical
-   inventory the docs surface-weighting tool enumerates (`scripts/surfaceWeight.ts`), so the
-   grammar's "primitives" bucket stays in sync with the language without hardcoding a list. */
-export const REACTIVE_CALLEES: ReadonlySet<string> = new Set([
-    'state',
-    'linked',
-    'computed',
-    'props',
-])

package/src/lib/ui/compile/assertRuntimeHelpersBound.ts

@@ -1,80 +0,0 @@
-import ts from 'typescript'
-import { UI_RUNTIME_IMPORTS } from './UI_RUNTIME_IMPORTS.ts'
-
-/*
-Independent backstop on the per-component dead-import filter (`compileModule`). The filter
-decides which runtime helpers to import by reading the generated output's identifiers; if it
-ever undercounts — as a raw token scan once did, mis-reading the tail of a module after a
-`${…}` template substitution — a helper gets CALLED but never imported, and the bundle throws
-`ReferenceError` the instant `build()` runs. The router escalates that into a reload loop, so
-the failure is both opaque and unrecoverable.
-
-This re-derives the same question a DIFFERENT way (so it can't share the filter's blind spot):
-walk the final module's AST, find every call whose callee is a bare runtime-helper identifier,
-and require that name to be imported or locally bound. A helper name inside a string / template /
-comment is not a `CallExpression` callee, so a docs component quoting framework code
-(`mount(...)` in a snippet) never false-positives. Compile-time only; never on the hot path.
-*/
-/* `module` is either the source string (standalone use — parsed here) or the already-parsed
-   tree of the bodies WITHOUT the prepended import block (compile pipeline — shares the one
-   parse the dead-import filter made). In the latter case the import block's bindings aren't in
-   the tree, so `importedHelpers` supplies the helper names that block will bind. */
-export function assertRuntimeHelpersBound(
-    module: string | ts.SourceFile,
-    importedHelpers: Set<string>,
-    context: string,
-): void {
-    /* The EMITTED local names (the `$$` alias when set) — codegen calls those, and the
-       aliased import binds them, so the bound/called check must use the same form. */
-    const helperNames = new Set(UI_RUNTIME_IMPORTS.map((entry) => entry.alias ?? entry.name))
-    const source =
-        typeof module === 'string'
-            ? ts.createSourceFile(
-                  'module.ts',
-                  module,
-                  ts.ScriptTarget.Latest,
-                  /* setParentNodes */ true,
-              )
-            : module
-    /* Names a bare call can resolve to: the import block's helper bindings (supplied when the
-       tree omits them) plus every import binding and declared name in the tree. Collected
-       generously (any identifier in a binding position) — over-approximating the bound set only
-       risks missing a defect, never raising a false alarm on valid output. */
-    const bound = new Set<string>(importedHelpers)
-    const calledHelpers: { name: string; position: number }[] = []
-    const visit = (node: ts.Node): void => {
-        if (
-            (ts.isVariableDeclaration(node) ||
-                ts.isFunctionDeclaration(node) ||
-                ts.isParameter(node) ||
-                ts.isBindingElement(node) ||
-                ts.isImportSpecifier(node) ||
-                ts.isImportClause(node) ||
-                ts.isNamespaceImport(node)) &&
-            node.name !== undefined &&
-            ts.isIdentifier(node.name)
-        ) {
-            bound.add(node.name.text)
-        }
-        if (
-            ts.isCallExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            helperNames.has(node.expression.text)
-        ) {
-            calledHelpers.push({
-                name: node.expression.text,
-                position: node.expression.getStart(source),
-            })
-        }
-        node.forEachChild(visit)
-    }
-    visit(source)
-
-    const unbound = calledHelpers.find((call) => !bound.has(call.name))
-    if (unbound !== undefined) {
-        const { line, character } = source.getLineAndCharacterOfPosition(unbound.position)
-        throw new Error(
-            `[abide] ${context} calls runtime helper \`${unbound.name}\` at line ${line + 1}:${character + 1} but never imports it — the dead-import filter dropped it. Please report this with the component source.\nOutput:\n${source.text}`,
-        )
-    }
-}