@abide/abide 0.46.0 → 0.48.0

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

@@ -0,0 +1,21 @@
+import type { CacheSnapshotEntry } from './CacheSnapshotEntry.ts'
+import type { SsrBootState } from './SsrBootState.ts'
+
+/*
+The `window.__SSR__` payload: the single contract between the server's SSR state tag
+(`createUiPageRenderer.stateTag`) and the client entry (`startClient`). Both sides
+import THIS type — the server stamps its object with `satisfies SsrPayload` (an unknown
+or mis-typed field is a compile error) and the client reads through it — so the
+write-set and read-set can't drift apart on a matching-string-key handshake.
+
+Three partitions:
+  - `SsrBootState` fields seed ambient slots via the exhaustive `seedBootState` map;
+  - `cache` is the inline warm-seed partition, drained through `seedResolved`;
+  - `route`/`params` are stamped for inspectability and are NOT read by the client
+    (the router re-resolves the route from the URL).
+*/
+export type SsrPayload = SsrBootState & {
+    route: string
+    params: Record<string, string>
+    cache?: CacheSnapshotEntry[]
+}

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

@@ -1,24 +1,24 @@
 import type { TailHooks } from './TailHooks.ts'
 
 /*
-The thing `tail()` reads from: an AsyncIterable carrying a stable `name`
-used as the subscription registry key. Both `Socket<T>` (the declared
-broadcast primitive) and the result of `fn.stream(args)` (per-call HTTP
-stream consumer) satisfy this shape, so tail() can share one iterator
-across multiple readers regardless of source.
+A named async stream: an AsyncIterable carrying a stable `name` used as the
+subscription registry key. Both `Socket<T>` (the declared broadcast
+primitive) and a streaming rpc's bare call (a `jsonl`/`sse` handler makes
+the call return the stream itself) satisfy this shape, so the consume path
+(`watch` → `cache.on`) and the stream probes (`pending`/`refreshing`/
+`done`/`error`) handle either source through one contract.
 
 The name on a Socket comes from the file path under `src/server/sockets/`.
-The name on an fn.stream(args) result is `keyForRemoteCall(method, url,
-args)` — the same key cache() uses — so two readers of the same remote-call
-args dedupe to one underlying fetch.
+The name on a streaming rpc call is `keyForRemoteCall(method, url, args)` —
+the same key the smart call's cache store uses — so two readers of the same
+remote-call args dedupe to one underlying fetch.
 
 `tail` is the optional retention capability: a source that keeps a tail of
 recent frames hands back an iterable seeded with at most the last `count`
-before going live. Sockets implement it verbatim; one-shot rpc streams omit
-it. The tail() consumer uses it to bound replay to what the reader will
-keep — it never requires it. Implementers must signal `hooks.replayed`
-in-band once the seed portion is delivered (even when empty) so window
-readers can commit atomically; see TailHooks.
+before going live. Sockets implement it verbatim (it also backs the socket's
+HTTP/SSE read face); one-shot rpc streams omit it. Implementers must signal
+`hooks.replayed` in-band once the seed portion is delivered (even when
+empty) so a seeded reader can commit its window atomically; see TailHooks.
 */
 export interface Subscribable<T> extends AsyncIterable<T> {
     readonly name: string

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

@@ -1,5 +1,6 @@
 /*
-Hooks a tail() reader passes to a Subscribable's retention capability.
+Hooks a `tail(count, hooks)` caller passes to a Subscribable's retention
+capability.
 `replayed` must be signalled in-band exactly once per iteration — after the
 last replayed frame, before any live frame, and even when nothing was
 replayed — so a window reader can commit its seed atomically instead of

package/src/lib/shared/url.ts

@@ -50,12 +50,17 @@ no bracket segments yields {}, which collapses the params slot away. The
 catch-all branch recurses on its head too, so `[name]` segments before a
 `[...rest]` are kept.
 */
-export type PathParams<P extends string> = P extends `${infer Head}[...${infer Rest}]${infer Tail}`
-    ? PathParams<Head> & { [K in Rest]: string | number } & PathParams<Tail>
-    : P extends `${string}[${infer Name}]${infer Tail}`
-      ? { [K in Name]: string | number } & PathParams<Tail>
-      : // biome-ignore lint/complexity/noBannedTypes: {} is the "no params" base case — keyof {} is never, which collapses the params slot; Record<string, never> would not (keyof is string)
-        {}
+export type PathParams<P extends string> = P extends `${infer Head}[[${infer Name}]]${infer Tail}`
+    ? Name extends `...${infer Rest}`
+        ? // `[[...rest]]` normalizes to a plain catch-all (see parseRouteSegments)
+          PathParams<Head> & { [K in Rest]: string | number } & PathParams<Tail>
+        : PathParams<Head> & { [K in Name]?: string | number } & PathParams<Tail>
+    : P extends `${infer Head}[...${infer Rest}]${infer Tail}`
+      ? PathParams<Head> & { [K in Rest]: string | number } & PathParams<Tail>
+      : P extends `${string}[${infer Name}]${infer Tail}`
+        ? { [K in Name]: string | number } & PathParams<Tail>
+        : // biome-ignore lint/complexity/noBannedTypes: {} is the "no params" base case — keyof {} is never, which collapses the params slot; Record<string, never> would not (keyof is string)
+          {}
 
 /*
 Resolves any in-app URL to its base-correct, typed form — the single chokepoint
@@ -93,22 +98,32 @@ export function url(path: string, first?: Query, second?: Query): string {
     return appendQuery(prefixed, query)
 }
 
-/* Substitutes `[name]` / `[...rest]` segments with their stringified, URL-encoded
-   param values (matching the query side, which encodes too). A `[name]` value is
-   encoded whole so `/`, `?`, `#`, and spaces can't alter the path structure; a
-   `[...rest]` catch-all keeps its `/` separators and encodes each sub-segment. */
+/* Substitutes `[name]` / `[[name]]` / `[...rest]` segments with their stringified,
+   URL-encoded param values (matching the query side, which encodes too). A `[name]`
+   value is encoded whole so `/`, `?`, `#`, and spaces can't alter the path structure;
+   a `[...rest]` catch-all keeps its `/` separators and encodes each sub-segment. An
+   absent `[[optional]]` — undefined OR empty string, since the matcher never captures
+   an empty optional segment — drops its segment (and slash) entirely; a path that
+   empties out (`/[[lang]]` with no lang) resolves to the root. Dropping empty here
+   also avoids emitting a `//about` that a browser reads as a protocol-relative URL. */
 function interpolate(segments: RouteSegment[], params: Query): string {
-    return segments
+    const resolved = segments
         .map((segment) => {
             if (segment.kind === 'literal') {
                 return segment.value
             }
-            const value = String(params[segment.name])
+            const value = params[segment.name]
+            if (segment.optional && (value === undefined || value === '')) {
+                return undefined
+            }
+            const text = String(value)
             return segment.catchAll
-                ? value.split('/').map(encodeURIComponent).join('/')
-                : encodeURIComponent(value)
+                ? text.split('/').map(encodeURIComponent).join('/')
+                : encodeURIComponent(text)
         })
+        .filter((part) => part !== undefined)
         .join('/')
+    return resolved === '' ? '/' : resolved
 }
 
 /* Appends a `?`-query built from the same encoder buildRpcRequest uses, or nothing. */

package/src/lib/shared/wakeHydrationPeeks.ts

@@ -0,0 +1,20 @@
+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/shared/writeTestSocketsDts.ts

@@ -8,7 +8,7 @@ Emits a `.d.ts` that augments createTestApp's `SocketClient` interface with one
 entry per $socket, keyed by socket name (the same key `app.sockets.<name>`
 resolves at runtime). The `socket(...)` helper statically returns `Socket<T>`,
 so each entry is the export's own type directly — `app.sockets.chat` types as
-`Socket<ChatMessage>`, iterable for the live stream with `.tail`/`.publish`.
+`Socket<ChatMessage>`, iterable for the live stream with `.tail`/`.broadcast`.
 Written to `src/.abide/testSockets.d.ts` like its rpc sibling.
 */
 export async function writeTestSocketsDts({

package/src/lib/test/createScriptedSurface.ts

@@ -1,4 +1,4 @@
-import type { ToolResult } from '../mcp/mcpSurface.ts'
+import type { ToolResult } from '../mcp/types/ToolResult.ts'
 import type { AgentSurface } from '../server/agent.ts'
 
 type ScriptedTool = {

package/src/lib/test/createTestApp.ts

@@ -31,18 +31,18 @@ import { ensureRegistriesLoaded } from '../server/runtime/registryManifests.ts'
 import { requestContext } from '../server/runtime/requestContext.ts'
 import { resolvePageSnapshot } from '../server/runtime/resolvePageSnapshot.ts'
 import { serverSlot } from '../server/runtime/serverSlot.ts'
-import type { Socket } from '../server/sockets/types/Socket.ts'
 import { baseSlot } from '../shared/baseSlot.ts'
 import { buildRpcProxy } from '../shared/buildRpcProxy.ts'
 import { buildRpcRequest } from '../shared/buildRpcRequest.ts'
 import { cacheStoreSlot } from '../shared/cacheStoreSlot.ts'
 import { commandNameForUrl } from '../shared/commandNameForUrl.ts'
 import { createCacheStore } from '../shared/createCacheStore.ts'
-import { globalCacheStoreSlot } from '../shared/globalCacheStoreSlot.ts'
 import { HEALTH_PATH } from '../shared/HEALTH_PATH.ts'
 import { pageSlot } from '../shared/pageSlot.ts'
 import { SOCKETS_PATH } from '../shared/SOCKETS_PATH.ts'
+import { sharedCacheStoreSlot } from '../shared/sharedCacheStoreSlot.ts'
 import type { RemoteFunction } from '../shared/types/RemoteFunction.ts'
+import type { Socket } from '../shared/types/Socket.ts'
 import { createTestSocketChannel } from './createTestSocketChannel.ts'
 
 /*
@@ -72,7 +72,7 @@ export type TestApp = {
     /* Rpc calls over HTTP, keyed by command name: `app.rpc.getProduct({ id })`. */
     rpc: RpcClient
     /* Sockets keyed by name: `app.sockets.ticker` is the Socket — iterate it for
-       the live stream, `.tail(n)` to seed, `.publish(m)` to send. */
+       the live stream, `.tail(n)` to seed, `.broadcast(m)` to send. */
     sockets: SocketClient
     /* The /__abide/health payload, decoded. */
     health: () => Promise<unknown>
@@ -98,15 +98,15 @@ leaking the request-scope/cache/page resolvers into the next test file.
 export async function createTestApp(): Promise<TestApp> {
     const previous = {
         cacheResolver: cacheStoreSlot.resolver,
-        globalResolver: globalCacheStoreSlot.resolver,
+        sharedResolver: sharedCacheStoreSlot.resolver,
         pageResolver: pageSlot.resolver,
         baseResolver: baseSlot.resolver,
         activeServer: serverSlot.active,
     }
 
-    cacheStoreSlot.resolver = () => requestContext.getStore()?.cache
-    const globalStore = createCacheStore()
-    globalCacheStoreSlot.resolver = () => globalStore
+    const sharedStore = createCacheStore()
+    sharedCacheStoreSlot.resolver = () => sharedStore
+    cacheStoreSlot.resolver = () => requestContext.getStore()?.cache ?? sharedStore
     pageSlot.resolver = resolvePageSnapshot
 
     /* Eager env validation, exactly as serverEntry: a top-level env(schema) in
@@ -185,7 +185,7 @@ export async function createTestApp(): Promise<TestApp> {
         channel?.close()
         server.stop(true)
         cacheStoreSlot.resolver = previous.cacheResolver
-        globalCacheStoreSlot.resolver = previous.globalResolver
+        sharedCacheStoreSlot.resolver = previous.sharedResolver
         pageSlot.resolver = previous.pageResolver
         baseSlot.resolver = previous.baseResolver
         serverSlot.active = previous.activeServer

package/src/lib/test/createTestSocketChannel.ts

@@ -1,10 +1,10 @@
-import type { Socket } from '../server/sockets/types/Socket.ts'
-import type { SocketClientFrame } from '../server/sockets/types/SocketClientFrame.ts'
-import type { SocketServerFrame } from '../server/sockets/types/SocketServerFrame.ts'
 import { buildSocketOverChannel } from '../shared/buildSocketOverChannel.ts'
 import { createSocketSubRegistry } from '../shared/createSocketSubRegistry.ts'
 import { decodeRefJson } from '../shared/decodeRefJson.ts'
 import { encodeRefJson } from '../shared/encodeRefJson.ts'
+import type { Socket } from '../shared/types/Socket.ts'
+import type { SocketClientFrame } from '../shared/types/SocketClientFrame.ts'
+import type { SocketServerFrame } from '../shared/types/SocketServerFrame.ts'
 
 /*
 Test-side substitute for the browser socketChannel: one ws to the booted

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

@@ -1,9 +1,8 @@
-/* The callee names the `.abide` compiler recognises as reactive declarations
-   (`scope().state(...)`, `scope().linked(...)`, `scope().computed(...)`, and the destructuring
-   `const {…} = props()`): the shared "is this a reactive binding" allowlist read by
-   the desugarer, the nested-script scoper, and the type-checking shadow. How each
-   lowers — a serializable doc slot vs a `.value` cell — is decided per-site; this is
-   only the membership set, so a new primitive is a single edit here. */
+/* 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',

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

@@ -13,13 +13,16 @@ flip to its `$$` alias, set `alias` here in lockstep.
 */
 export const UI_RUNTIME_IMPORTS: { name: string; specifier: string; alias?: string }[] = [
     { name: 'snippet', specifier: 'shared/snippet', alias: '$$snippet' },
-    /* `scope` is author-facing (`scope().state(...)`) but lowers to `$$scope` shadowably:
-       `referenceFor` rewrites a bare `scope` read to `$$scope` only when not lexically
-       shadowed, so the aliased import is the binding that emitted code resolves to. */
-    { name: 'scope', specifier: 'ui/scope', alias: '$$scope' },
-    { name: 'enterScope', specifier: 'ui/enterScope', alias: '$$enterScope' },
-    { name: 'exitScope', specifier: 'ui/exitScope', alias: '$$exitScope' },
+    /* `scope` is the internal lowering host (no longer author-facing), imported from the
+       plumbing `ui/currentScope` path and lowered to the reserved `$$scope` alias:
+       `referenceFor` rewrites a bare `scope` read (compiler-generated) to `$$scope` only
+       when not lexically shadowed, so the aliased import is the binding emitted code
+       resolves to. `enterScope`/`exitScope` bracket an SSR render's scope (plumbing paths). */
+    { name: 'scope', specifier: 'ui/currentScope', alias: '$$scope' },
+    { name: 'enterScope', specifier: 'ui/enterRenderScope', alias: '$$enterScope' },
+    { name: 'exitScope', specifier: 'ui/exitRenderScope', alias: '$$exitScope' },
     { name: 'effect', specifier: 'ui/effect', alias: '$$effect' },
+    { name: 'watch', specifier: 'ui/watch', alias: '$$watch' },
     { name: 'mount', specifier: 'ui/dom/mount', alias: '$$mount' },
     { name: 'appendText', specifier: 'ui/dom/appendText', alias: '$$appendText' },
     { name: 'appendTextAt', specifier: 'ui/dom/appendTextAt', alias: '$$appendTextAt' },
@@ -31,11 +34,11 @@ export const UI_RUNTIME_IMPORTS: { name: string; specifier: string; alias?: stri
     { name: 'attr', specifier: 'ui/dom/attr', alias: '$$attr' },
     { name: 'on', specifier: 'ui/dom/on', alias: '$$on' },
     { name: 'attach', specifier: 'ui/dom/attach', alias: '$$attach' },
+    { name: 'bindSelectValue', specifier: 'ui/dom/bindSelectValue', alias: '$$bindSelectValue' },
     { name: 'each', specifier: 'ui/dom/each', alias: '$$each' },
     { name: 'eachAsync', specifier: 'ui/dom/eachAsync', alias: '$$eachAsync' },
     { name: 'when', specifier: 'ui/dom/when', alias: '$$when' },
     { name: 'awaitBlock', specifier: 'ui/dom/awaitBlock', alias: '$$awaitBlock' },
-    { name: 'deferResume', specifier: 'ui/deferResume', alias: '$$deferResume' },
     { name: 'tryBlock', specifier: 'ui/dom/tryBlock', alias: '$$tryBlock' },
     { name: 'switchBlock', specifier: 'ui/dom/switchBlock', alias: '$$switchBlock' },
     { name: 'mountSlot', specifier: 'ui/dom/mountSlot', alias: '$$mountSlot' },

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

@@ -1,6 +1,6 @@
 import { relative } from 'node:path'
 import type { BunPlugin } from 'bun'
-import { fileName } from '../../shared/fileName.ts'
+import { isLayoutFile } from '../../shared/isLayoutFile.ts'
 import { messageFromError } from '../../shared/messageFromError.ts'
 import { AbideCompileError } from './AbideCompileError.ts'
 import { compileModule } from './compileModule.ts'
@@ -42,7 +42,7 @@ export const abideUiPlugin: BunPlugin = {
         build.onLoad({ filter: /\.abide$/ }, async (args) => {
             const source = await Bun.file(args.path).text()
             const moduleId = relative(nearestProjectRoot(args.path, process.cwd()), args.path)
-            const isLayout = fileName(args.path) === 'layout.abide'
+            const isLayout = isLayoutFile(args.path)
             /* Bun frames a plugin throw at `<file>:0` regardless of the real spot, so
                carry the component path + resolved line:col in the message — otherwise a
                control-flow / compile error reads as `:0` and (in deep imports) can look

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

@@ -29,6 +29,12 @@ export function analyzeComponent(source: string, scopeSeed?: string): AnalyzedCo
     const scriptBody = (scriptMatch?.[1] ?? '').trim()
     const template = source.replace(/^\s*<script[^>]*>[\s\S]*?<\/script>/, '').trim()
 
+    /* Parse the template first so the nested branch `<script>`s are in hand before the
+       leading script lowers: their raw code feeds the dead-import usage check, keeping a
+       reactive import (`state`) alive when only a nested branch uses it (its
+       `state.computed(...)` stays literal, unlike the desugared leading script). */
+    const { nodes } = parseTemplate(template)
+    const nestedScriptCode = collectNestedScriptCode(nodes)
     /* `lowerScript` parses the script ONCE and chains signal desugaring, reference
        renaming, and doc-access lowering over that single tree, then hoists top-level
        imports off the tree structurally — imports live at module scope, not inside the
@@ -40,17 +46,16 @@ export function analyzeComponent(source: string, scopeSeed?: string): AnalyzedCo
         stateNames,
         derivedNames,
         computedNames,
-    } = lowerScript(scriptBody)
-    /* The parser keeps each `<style>` as an in-place node (one inside an expression
-       is text, never a node). `annotateScopes` mutates the tree — assigning each
-       style its scope attribute and stamping covered elements — and returns the
-       scoped CSS per block for the bundler. */
-    const { nodes } = parseTemplate(template)
+        droppedReactiveImports,
+    } = lowerScript(scriptBody, nestedScriptCode)
+    /* `annotateScopes` mutates the tree — assigning each style its scope attribute and
+       stamping covered elements — and returns the scoped CSS per block for the bundler. */
     const styles = annotateScopes(nodes, [], scopeSeed, { count: 0 })
     return {
         script,
         ssrScript,
         imports,
+        droppedReactiveImports,
         stateNames,
         derivedNames,
         computedNames,
@@ -68,6 +73,23 @@ function childrenOf(node: TemplateNode): TemplateNode[] | undefined {
     return 'children' in node ? node.children : undefined
 }
 
+/* The concatenated source of every nested `<script>` anywhere in the tree — the branch-local
+   reactive blocks. Used only to keep the leading script's reactive imports alive when a nested
+   branch is their sole consumer; the raw text is enough to spot the identifier reference. */
+function collectNestedScriptCode(nodes: TemplateNode[]): string {
+    let code = ''
+    for (const node of nodes) {
+        if (node.kind === 'script') {
+            code += `\n${node.code}`
+        }
+        const children = childrenOf(node)
+        if (children !== undefined) {
+            code += collectNestedScriptCode(children)
+        }
+    }
+    return code
+}
+
 /*
 Walks `nodes` in source order, scoping each `<style>` to its sibling subtree: a
 style among a sibling list covers every element in that list AND every descendant

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

@@ -121,6 +121,24 @@ ${options.moduleId === undefined ? '' : `component.__abideId = ${JSON.stringify(
         /* setParentNodes */ true,
     )
     const referenced = collectIdentifiers(bodySource)
+    /* Independent backstop on the reactive-import drop (`deadReactiveImport`): it decides an
+       import is dead from the leading script's own lowered body plus the nested scripts' raw
+       text. This re-checks the SAME question against the FINAL generated output — so a drop that
+       stranded a live reference (e.g. a nested branch's literal `state.computed`) surfaces as a
+       located compile error, not a runtime `ReferenceError: state is not defined`. Mirrors
+       `assertRuntimeHelpersBound`, which guards the parallel runtime-helper drop. Uses VALUE
+       references (not every identifier): the SSR return object `{ html, state, awaits, resume }`
+       names a property `state`, which is not a use of the reactive binding. */
+    if (analyzed.droppedReactiveImports.size > 0) {
+        const valueReferences = collectValueReferences(bodySource)
+        for (const name of analyzed.droppedReactiveImports) {
+            if (valueReferences.has(name)) {
+                throw new Error(
+                    `[abide] component module generation dropped the reactive import \`${name}\` as unused, but the generated output still references it — the dead-import filter undercounted. Please report this with the component source.`,
+                )
+            }
+        }
+    }
     const keptImports = UI_RUNTIME_IMPORTS.filter((entry) =>
         referenced.has(entry.alias ?? entry.name),
     )
@@ -168,24 +186,90 @@ function indent(body: string): string {
         .split('\n')
         .map((line) => {
             const indented = insideTemplateLiteral || line === '' ? line : `    ${line}`
-            if (unescapedBacktickCount(line) % 2 === 1) {
-                insideTemplateLiteral = !insideTemplateLiteral
-            }
+            insideTemplateLiteral = templateLiteralStateAfter(line, insideTemplateLiteral)
             return indented
         })
         .join('\n')
 }
 
-/* Counts backticks not preceded by a backslash — the template-literal delimiters
-   on a line, ignoring escaped `\`` inside one. */
-function unescapedBacktickCount(line: string): number {
-    let count = 0
-    for (let index = 0; index < line.length; index += 1) {
-        if (line[index] === '`' && line[index - 1] !== '\\') {
-            count += 1
+/* Whether the line ENDS inside a multi-line template literal, given whether it
+   STARTED inside one. A plain backtick-parity count is wrong: a backtick inside a
+   double-quoted string literal (the JSON.stringify'd skeleton markup, e.g.
+   `$$skeleton(host, "<p>tick \`here</p>")`) is not a template delimiter, but counting
+   it would flip the in-literal state and mis-indent a later real template literal's
+   significant whitespace. So skip `'…'`/`"…"` strings when outside a template, and treat
+   a template's `${…}` interpolation as code (its own strings/backticks don't toggle the
+   outer literal). Escapes are honoured throughout. */
+function templateLiteralStateAfter(line: string, startInside: boolean): boolean {
+    let inside = startInside
+    let index = 0
+    while (index < line.length) {
+        const char = line[index]
+        if (char === '\\') {
+            index += 2
+            continue
         }
+        if (inside) {
+            if (char === '`') {
+                inside = false
+            } else if (char === '$' && line[index + 1] === '{') {
+                index = skipInterpolation(line, index + 2)
+                continue
+            }
+            index += 1
+            continue
+        }
+        if (char === '`') {
+            inside = true
+        } else if (char === '"' || char === "'") {
+            index = skipQuoted(line, index + 1, char)
+            continue
+        }
+        index += 1
     }
-    return count
+    return inside
+}
+
+/* Advances past a `'…'`/`"…"` string opened at `index` (the char after the quote),
+   returning the index after the closing quote (or end of line). Emitted JS string
+   literals never carry a raw newline, so they always close on their own line. */
+function skipQuoted(line: string, index: number, quote: string): number {
+    while (index < line.length) {
+        if (line[index] === '\\') {
+            index += 2
+            continue
+        }
+        if (line[index] === quote) {
+            return index + 1
+        }
+        index += 1
+    }
+    return index
+}
+
+/* Advances past a template `${…}` interpolation opened at `index` (the char after `{`),
+   returning the index after the matching `}` (or end of line). Balances nested braces and
+   skips nested strings/templates so their delimiters don't leak into the outer scan. */
+function skipInterpolation(line: string, index: number): number {
+    let depth = 1
+    while (index < line.length && depth > 0) {
+        const char = line[index]
+        if (char === '\\') {
+            index += 2
+            continue
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            index = skipQuoted(line, index + 1, char)
+            continue
+        }
+        if (char === '{') {
+            depth += 1
+        } else if (char === '}') {
+            depth -= 1
+        }
+        index += 1
+    }
+    return index
 }
 
 /* The identifier names a generated module references — every Identifier node, walked
@@ -209,3 +293,45 @@ function collectIdentifiers(source: ts.SourceFile): Set<string> {
     visit(source)
     return names
 }
+
+/* The identifiers a module references AS VALUES — the subset of `collectIdentifiers` that
+   excludes name-only positions: a property name (`obj.state`), an object-literal key
+   (`{ state: v }`), and a declaration/import binding name (the definition, not a use). Used by
+   the reactive-import backstop, where a bare identifier presence over-counts: the synthesized
+   SSR return `{ html, state, awaits, resume }` names a property `state` that is not a use of the
+   reactive binding, so the raw-identifier set would false-positive. */
+function collectValueReferences(source: ts.SourceFile): Set<string> {
+    const names = new Set<string>()
+    const visit = (node: ts.Node): void => {
+        if (ts.isIdentifier(node) && isValuePosition(node)) {
+            names.add(node.text)
+        }
+        node.forEachChild(visit)
+    }
+    visit(source)
+    return names
+}
+
+/* True when `id` stands in a value position — i.e. a reference to a binding, not a name that
+   merely labels a property or declares a binding. */
+function isValuePosition(id: ts.Identifier): boolean {
+    const parent = id.parent
+    if (ts.isPropertyAccessExpression(parent) && parent.name === id) {
+        return false
+    }
+    if (ts.isPropertyAssignment(parent) && parent.name === id) {
+        return false
+    }
+    if (
+        (ts.isVariableDeclaration(parent) ||
+            ts.isParameter(parent) ||
+            ts.isFunctionDeclaration(parent) ||
+            ts.isBindingElement(parent) ||
+            ts.isImportSpecifier(parent) ||
+            ts.isImportClause(parent)) &&
+        parent.name === id
+    ) {
+        return false
+    }
+    return true
+}