@abide/abide 0.43.1 → 0.44.1

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

@@ -3,7 +3,6 @@ import type { BunPlugin } from 'bun'
 import { fileName } from '../../shared/fileName.ts'
 import { messageFromError } from '../../shared/messageFromError.ts'
 import { AbideCompileError } from './AbideCompileError.ts'
-import { analyzeComponent } from './analyzeComponent.ts'
 import { compileModule } from './compileModule.ts'
 import { nearestProjectRoot } from './nearestProjectRoot.ts'
 import { offsetToLineColumn } from './offsetToLineColumn.ts'
@@ -15,7 +14,7 @@ only UI loader in the dev/build/preload pipeline; the emitted module's
 `abide/ui/*` imports resolve through the package exports.
 
 A `layout.abide` compiles as a layout: its `<slot/>` lowers to the router's page
-outlet (`<abide-outlet>`) rather than a passed-children slot — the file's role is
+outlet (a `<!--abide:outlet-->…<!--/abide:outlet-->` comment boundary the router fills) rather than a passed-children slot — the file's role is
 its name, so the loader flags it from the path stem.
 
 The emitted module embeds the component's `<script>` and `{expr}` bodies verbatim,
@@ -63,14 +62,17 @@ export const abideUiPlugin: BunPlugin = {
                     throw new Error(`${message.replace(/^\[abide\]\s*/, `[abide] ${at} — `)}`)
                 }
             }
-            const code = compileAbide(() => compileModule(source, { isLayout, moduleId }))
+            /* One compile pass yields both the module code and its scoped `<style>` blocks —
+               the styles come from the analysis `compileModule` already ran, so the loader no
+               longer re-analyzes the source just to recover them. */
+            const { code, styles } = compileAbide(() =>
+                compileModule(source, { isLayout, moduleId }),
+            )
             /* Browser build with `<style>`(s): concatenate every scoped block's CSS and
                pull it into the bundle via one virtual import, keyed by `moduleId` so the
-               registry id and the CSS id agree. */
-            const styles = compileAbide(() =>
-                toBrowser ? analyzeComponent(source, moduleId).styles : [],
-            )
-            if (styles.length === 0) {
+               registry id and the CSS id agree. Server builds skip the import (SSR styling
+               comes from the already-linked sheet). */
+            if (!toBrowser || styles.length === 0) {
                 return { contents: code, loader: 'ts' }
             }
             const virtual = `abide-style:${moduleId}`

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

@@ -15,18 +15,32 @@ and require that name to be imported or locally bound. A helper name inside a st
 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.
 */
-export function assertRuntimeHelpersBound(module: string, context: string): void {
-    const helperNames = new Set(UI_RUNTIME_IMPORTS.map((entry) => entry.name))
-    const source = ts.createSourceFile(
-        'module.ts',
-        module,
-        ts.ScriptTarget.Latest,
-        /* setParentNodes */ true,
-    )
-    /* Names a bare call can resolve to: every import binding plus every declared name.
-       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>()
+/* `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 (
@@ -60,7 +74,7 @@ export function assertRuntimeHelpersBound(module: string, context: string): void
     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${module}`,
+            `[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}`,
         )
     }
 }

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

@@ -1,4 +1,6 @@
+import { catchBinding } from './catchBinding.ts'
 import { resolveBranches } from './resolveBranches.ts'
+import type { Binding } from './types/Binding.ts'
 import type { TemplateNode } from './types/TemplateNode.ts'
 
 /* The structural shape of an `await` block, resolved ONCE from the node so the build and
@@ -23,6 +25,12 @@ export type AwaitPlan = {
     /* Neither catch nor finally → a rejection must surface (re-throw / `undefined` catch thunk)
        instead of rendering an empty branch. */
     surfaceRejection: boolean
+    /* The resolved branch's binding (`resolvedAs`, `reactive` — a `.value` cell on the
+       client, a re-settle updates it in place). One element. */
+    resolvedBindings: Binding[]
+    /* The catch branch's binding (`catchAs`, `plain`); empty when no catch branch. The
+       `finally` branch binds nothing, so it registers no binding. */
+    catchBindings: Binding[]
 }
 
 /* Resolves an `await` node's branches into the shared structural plan. */
@@ -35,14 +43,18 @@ export function awaitPlan(node: Extract<TemplateNode, { kind: 'await' }>): Await
     )
     const finallyChildren = finallyBranch?.children ?? []
     const nonBranch = node.children.filter((child) => child.kind !== 'branch')
+    const resolvedAs = (node.blocking ? node.as : thenBranch?.as) ?? '_value'
+    const catchAs = catchBranch?.as ?? '_error'
     return {
         blocking: node.blocking,
         pending: node.blocking ? [] : nonBranch,
         resolvedChildren: node.blocking ? nonBranch : (thenBranch?.children ?? []),
-        resolvedAs: (node.blocking ? node.as : thenBranch?.as) ?? '_value',
+        resolvedAs,
         catchChildren: catchBranch?.children ?? [],
-        catchAs: catchBranch?.as ?? '_error',
+        catchAs,
         finallyChildren,
         surfaceRejection: catchBranch === undefined && finallyChildren.length === 0,
+        resolvedBindings: [{ name: resolvedAs, classification: 'reactive' }],
+        catchBindings: catchBinding(catchAs, catchBranch !== undefined),
     }
 }

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

@@ -0,0 +1,8 @@
+import type { Binding } from './types/Binding.ts'
+
+/* A block's `catch` branch binding — the error name bound `plain`, or none when the block
+   has no catch branch. Shared by the await/each/try plans so the one catch-binding shape
+   stays single-source. */
+export function catchBinding(catchAs: string, hasCatch: boolean): Binding[] {
+    return hasCatch ? [{ name: catchAs, classification: 'plain' }] : []
+}

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

@@ -0,0 +1,108 @@
+import { interpolatedTemplateLiteral } from './interpolatedTemplateLiteral.ts'
+import type { TemplateAttr } from './types/TemplateAttr.ts'
+
+/*
+The one decision site for how an element's `class`/`style` base attribute composes
+with its `class:`/`style:` directives — lifted out of the two code-gen back-ends
+(`generateBuild`, `generateSSR`) so the load-bearing congruence (which attrs fold
+into a merged value, and HOW that value's parts concatenate) lives once. Each
+back-end RENDERS the returned plan differently — the build into a reactive `effect`,
+SSR into a pushed attribute string — but consults the same decision, so the markup
+the client clones and the server emits can never drift on the merge logic.
+
+The two back-ends differ ONLY in their merge TRIGGER, because their non-merge
+fallbacks differ: the build leaves a STATIC base in the cloned skeleton and toggles
+directives surgically, so it merges only when the base is INTERPOLATED (re-set on
+every update, which would wipe additive toggles) — `mergeClassBuild`/`mergeStyleBuild`.
+SSR must always emit ONE merged attribute string (a duplicate `class`/`style` is
+invalid), so it merges whenever a directive exists — `mergeClass`/`mergeStyle`. The
+PARTS that compose the value (`classParts`/`styleParts`) are identical either way, so
+they are built here once.
+
+`attrs` classified up front; `lower` rewrites the signal surface to `model` (the same
+transformer each back-end already threads through its expressions).
+*/
+
+/* The base class/style attribute (static or interpolated) found on the element. */
+type MergeBase =
+    | Extract<TemplateAttr, { kind: 'static' }>
+    | Extract<TemplateAttr, { kind: 'interpolated' }>
+    | undefined
+
+export type ClassStyleMergePlan = {
+    classBase: MergeBase
+    styleBase: MergeBase
+    classDirectives: Extract<TemplateAttr, { kind: 'class' }>[]
+    styleDirectives: Extract<TemplateAttr, { kind: 'style' }>[]
+    /* SSR trigger: merge whenever a directive exists (must emit one attribute). */
+    mergeClass: boolean
+    mergeStyle: boolean
+    /* Build trigger: merge only when the base is interpolated (a static base stays in
+       the skeleton + surgical toggles). */
+    mergeClassBuild: boolean
+    mergeStyleBuild: boolean
+    /* The JS expression list a merged value joins — base (if any) + directive parts.
+       `class` joins on a space (directive name when truthy); `style` joins on `;`
+       (`property:value`, String-coerced). Identical across back-ends. */
+    classParts: string[]
+    styleParts: string[]
+}
+
+/* The base class/style attribute (static or interpolated) for one property name. */
+function findBase(attrs: TemplateAttr[], name: 'class' | 'style'): MergeBase {
+    return attrs.find(
+        (attr): attr is NonNullable<MergeBase> =>
+            (attr.kind === 'static' || attr.kind === 'interpolated') && attr.name === name,
+    )
+}
+
+/* The base value as a lowered JS string expression, or undefined when there is no
+   base. A static base is a JSON string literal; an interpolated base is its
+   template-literal source run through `lower` (embedded signals → `model`). */
+function baseExpr(base: MergeBase, lower: (code: string) => string): string | undefined {
+    if (base === undefined) {
+        return undefined
+    }
+    return base.kind === 'static'
+        ? JSON.stringify(base.value)
+        : lower(interpolatedTemplateLiteral(base.parts))
+}
+
+/* Classifies an element's attrs into the class/style merge plan. */
+export function classStyleMergePlan(
+    attrs: TemplateAttr[],
+    lower: (code: string) => string,
+): ClassStyleMergePlan {
+    const classBase = findBase(attrs, 'class')
+    const styleBase = findBase(attrs, 'style')
+    const classDirectives = attrs.filter(
+        (attr): attr is Extract<TemplateAttr, { kind: 'class' }> => attr.kind === 'class',
+    )
+    const styleDirectives = attrs.filter(
+        (attr): attr is Extract<TemplateAttr, { kind: 'style' }> => attr.kind === 'style',
+    )
+    const classBaseExpr = baseExpr(classBase, lower)
+    const styleBaseExpr = baseExpr(styleBase, lower)
+    return {
+        classBase,
+        styleBase,
+        classDirectives,
+        styleDirectives,
+        mergeClass: classDirectives.length > 0,
+        mergeStyle: styleDirectives.length > 0,
+        mergeClassBuild: classBase?.kind === 'interpolated' && classDirectives.length > 0,
+        mergeStyleBuild: styleBase?.kind === 'interpolated' && styleDirectives.length > 0,
+        classParts: [
+            ...(classBaseExpr === undefined ? [] : [classBaseExpr]),
+            ...classDirectives.map(
+                (dir) => `((${lower(dir.code)}) ? ${JSON.stringify(dir.name)} : "")`,
+            ),
+        ],
+        styleParts: [
+            ...(styleBaseExpr === undefined ? [] : [styleBaseExpr]),
+            ...styleDirectives.map(
+                (dir) => `(${JSON.stringify(`${dir.property}:`)} + String(${lower(dir.code)}))`,
+            ),
+        ],
+    }
+}

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

@@ -25,6 +25,17 @@ export function collectAbideDiagnostics(shadow: ShadowProgram): AbideDiagnostic[
             })
             continue
         }
+        /* Shadow-raised author rules (e.g. importing a compiler-internal helper) are
+           already in source coordinates — emit them directly, no segment remap. */
+        for (const diagnostic of shadows.get(abidePath)?.diagnostics ?? []) {
+            diagnostics.push({
+                file: abidePath,
+                start: diagnostic.start,
+                length: diagnostic.length,
+                message: diagnostic.message,
+                category: ts.DiagnosticCategory.Error,
+            })
+        }
         const sourceFile = program.getSourceFile(`${abidePath}.ts`)
         const mappings = shadows.get(abidePath)?.mappings
         if (sourceFile === undefined || mappings === undefined) {

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

@@ -6,9 +6,9 @@ import type { AnalyzedComponent } from './types/AnalyzedComponent.ts'
 /*
 Compiles a single-file abide component into the body of a client build function.
 Runs the shared front-end (`analyzeComponent`), generates the DOM build from the
-template, and hoists static paths to cells. The returned body runs against a
-`host` element with `doc`/`state`/`computed`/`effect` and the dom bindings in
-scope and defines `model` itself. `compileModule` wraps it (and the SSR body) into
+template, and hoists static paths to cells. The returned body operates on `host`
+with the `$$`-prefixed dom bindings and `$$model` in scope (the latter emitted by
+`desugarSignals`). `compileModule` wraps it (and the SSR body) into
 a real module; tests wrap it with `new Function`.
 
 `analyzed` is a lazy default: a direct caller (tests) omits it and the front-end
@@ -26,5 +26,5 @@ export function compileComponent(
     /* The scoped CSS is bundled into the entry stylesheet (see `abideUiPlugin`), not
        injected at runtime; the build only needs the `data-a-…` scope attributes on
        elements, which `generateBuild` reads from each node's annotated `scopes`. */
-    return `${script}\n${hoistCells(build, 'model')}`
+    return `${script}\n${hoistCells(build, '$$model')}`
 }

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

@@ -5,6 +5,7 @@ import { assertRuntimeHelpersBound } from './assertRuntimeHelpersBound.ts'
 import { assertTranspiles } from './assertTranspiles.ts'
 import { compileComponent } from './compileComponent.ts'
 import { compileSSR } from './compileSSR.ts'
+import type { AnalyzedComponent } from './types/AnalyzedComponent.ts'
 import { UI_RUNTIME_IMPORTS } from './UI_RUNTIME_IMPORTS.ts'
 
 /*
@@ -26,7 +27,7 @@ what the `.abide` bundler loader emits.
 export function compileModule(
     source: string,
     options: { isLayout?: boolean; moduleId?: string; hot?: boolean } = {},
-): string {
+): { code: string; styles: AnalyzedComponent['styles'] } {
     const isLayout = options.isLayout ?? false
     /* Run the shared front-end once and feed it to both back-ends — the analysis is
        pure over (source, moduleId), so the client and SSR builds reuse one parse
@@ -44,20 +45,31 @@ export function compileModule(
        leaf components today; one importing children falls back to a reload (the dev
        layer decides what to hot-swap). */
     if (options.hot) {
-        const names = UI_RUNTIME_IMPORTS.map((entry) => entry.name).join(', ')
+        /* Bridge keys are the bare source names; bind each to its emitted local (`$$`
+           alias when set), so the hot body's `$$mountChild(...)` resolves. */
+        const names = UI_RUNTIME_IMPORTS.map((entry) =>
+            entry.alias === undefined || entry.alias === entry.name
+                ? entry.name
+                : `${entry.name}: ${entry.alias}`,
+        ).join(', ')
         const id = JSON.stringify(options.moduleId)
-        return `const { ${names}, hotReplace } = window.__abide
+        /* Hot mode never imports the scoped CSS (it reuses the live bundle's sheet), so
+           styles are empty here regardless of the analyzed blocks. */
+        return {
+            code: `const { ${names}, hotReplace } = window.__abide
 ${userImports}
 function build(host, $props) {
 ${body}
 }
 function component(host, $props) {
-    return mount(host, build, $props)
+    return $$mount(host, build, $props)
 }
 component.build = build
 component.__abideId = ${id}
 if (!hotReplace(${id}, component)) location.reload()
-`
+`,
+            styles: [],
+        }
     }
 
     const ssrBody = indent(compileSSR(source, isLayout, options.moduleId, analyzed))
@@ -66,12 +78,12 @@ ${body}
 }
 
 export default function component(host, $props) {
-    return mount(host, build, $props)
+    return $$mount(host, build, $props)
 }
 
 /* Adopt the server-rendered DOM in place instead of rebuilding it. */
 export function hydrateInto(host, $props) {
-    return hydrate(host, build, $props)
+    return $$hydrate(host, build, $props)
 }
 
 export function render($props, $ctx) {
@@ -95,9 +107,31 @@ ${options.moduleId === undefined ? '' : `component.__abideId = ${JSON.stringify(
        string/comment/HTML literal (e.g. an `on`-attribute in static markup) no longer
        forces a spurious import, so no per-surface scoping is needed: a client-only helper
        simply doesn't appear as an identifier in the SSR body. */
-    const referenced = collectIdentifiers(`${userImports}\n${body}\n${ssrBody}\n${moduleBody}`)
-    const importBlock = UI_RUNTIME_IMPORTS.filter((entry) => referenced.has(entry.name))
-        .map((entry) => `import { ${entry.name} } from '${ABIDE_PACKAGE_NAME}/${entry.specifier}'`)
+    /* Parse the generated bodies ONCE and feed the single tree to both AST passes: the
+       dead-import filter (`collectIdentifiers`) and the binding backstop
+       (`assertRuntimeHelpersBound`). The import block isn't in this tree yet — it is derived
+       from the filter's result — so the backstop is told the names that block will bind
+       (`importedHelpers`), which is exactly what it would have read from the prepended imports
+       had it re-parsed the whole module. `setParentNodes` is required by the backstop's
+       `getStart`/line lookups. */
+    const bodySource = ts.createSourceFile(
+        'module.ts',
+        `${userImports}\n${moduleBody}`,
+        ts.ScriptTarget.Latest,
+        /* setParentNodes */ true,
+    )
+    const referenced = collectIdentifiers(bodySource)
+    const keptImports = UI_RUNTIME_IMPORTS.filter((entry) =>
+        referenced.has(entry.alias ?? entry.name),
+    )
+    const importBlock = keptImports
+        .map((entry) => {
+            const local =
+                entry.alias === undefined || entry.alias === entry.name
+                    ? entry.name
+                    : `${entry.name} as ${entry.alias}`
+            return `import { ${local} } from '${ABIDE_PACKAGE_NAME}/${entry.specifier}'`
+        })
         .join('\n')
     const module = `${importBlock}
 ${userImports}
@@ -112,9 +146,15 @@ ${moduleBody}`
     /* `assertTranspiles` only proves the output PARSES — a call to an un-imported helper is
        valid syntax, so it slips through. This second guard proves the output is BOUND: every
        runtime helper it calls is actually imported (an independent check of the dead-import
-       filter above), turning a runtime `ReferenceError` into a located compile error. */
-    assertRuntimeHelpersBound(module, 'component module generation')
-    return module
+       filter above), turning a runtime `ReferenceError` into a located compile error. It walks
+       the SAME tree the filter just parsed, with the kept helper imports supplied as the bound
+       set the prepended import block provides. */
+    assertRuntimeHelpersBound(
+        bodySource,
+        new Set(keptImports.map((entry) => entry.alias ?? entry.name)),
+        'component module generation',
+    )
+    return { code: module, styles: analyzed.styles }
 }
 
 /* Indents a body block for embedding inside a wrapper function. Lines whose start
@@ -156,14 +196,9 @@ function unescapedBacktickCount(line: string): number {
    in a handler — leaves the scanner unable to find the substitution's closing `}` without
    the parser's re-scan, so a token-only pass mis-reads the rest of the module as template
    text and drops every helper referenced after it (an `import`-less `effect`/`mountChild`
-   → a `ReferenceError` at mount → the router's reload fallback → a refresh loop). */
-function collectIdentifiers(code: string): Set<string> {
-    const source = ts.createSourceFile(
-        'module.ts',
-        code,
-        ts.ScriptTarget.Latest,
-        /* setParentNodes */ false,
-    )
+   → a `ReferenceError` at mount → the router's reload fallback → a refresh loop). Takes the
+   already-parsed source so the one tree feeds this pass and the binding backstop both. */
+function collectIdentifiers(source: ts.SourceFile): Set<string> {
     const names = new Set<string>()
     const visit = (node: ts.Node): void => {
         if (ts.isIdentifier(node)) {

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

@@ -5,17 +5,20 @@ import type { AnalyzedComponent } from './types/AnalyzedComponent.ts'
 
 /*
 Compiles a component into the body of a server render function. Runs the shared
-front-end, then the SSR back-end, and returns `{ html, state, awaits }`:
+front-end, then the SSR back-end, and returns `{ html, state, awaits, resume }`:
 
   - `html`  — server-rendered markup (await blocks render their pending shell);
   - `state` — the document snapshot the client adopts on resume;
   - `awaits` — pending await blocks (id + promise + resolved/error renderers) that
-    `renderToStream` flushes out of order; empty for a fully synchronous component.
+    `renderToStream` flushes out of order; empty for a fully synchronous component;
+  - `resume` — blocking await values rendered inline, keyed by boundary id, seeded
+    into the hydration manifest.
 
 Effects are stripped — they are client lifecycle and emit no HTML, so the server
 render is a snapshot of the markup before any effect runs.
 
-Defines `model` with `doc`/`state`/`computed`/`effect` in scope. The block-id counter is
+Defines `$$model` via the lowered script; the reactive scope is entered via `$$enterScope`
+and exited in a `finally` block. The block-id counter is
 the request-local `$ctx` (threaded into child renders), not a module global — a blocking
 `await` block awaits its promise at its structural position and renders inline, so ids
 allocate depth-first like the client; render yields at that `await`, and a shared global
@@ -29,10 +32,9 @@ purely synchronous / streaming-await / try-only component returns `SsrRender` di
 framework always `await`s `render()`, so production is uniform either way; the sync return
 keeps static pages off the microtask queue and leaves the bulk of the SSR tests synchronous.
 
-The reactive scope brackets the body; it is entered synchronously before any inline `await`,
-so `const model = scope()` resolves correctly, and `model` is captured for the rest of the
-render (its reads are object-method calls, not scope lookups, so they stay correct across
-the awaits).
+The reactive scope brackets the body: `$$enterScope()` runs synchronously before any inline
+`await`, and `$$model` is captured for the rest of the render (its reads are object-method
+calls, not scope lookups, so they stay correct across the awaits).
 
 `analyzed` is a lazy default: a direct caller (tests) omits it and the front-end
 runs here, but `compileModule` shares one analysis across both back-ends.
@@ -51,9 +53,9 @@ export function compileSSR(
     /* `typeof model` guards a component with no reactive state (a pure-async or
        static component declares no `model`); its snapshot is then empty. */
     const body =
-        `const $scope = enterScope();\ntry {\n${lowered}\n${SSR_ESCAPE}\nconst $out = [];\nconst $awaits = [];\nconst $resume = {};\n${ssr}` +
-        `return { html: $out.join(''), state: (typeof model !== 'undefined' ? model.snapshot() : {}), awaits: $awaits, resume: $resume };\n` +
-        `} finally { exitScope($scope); }`
+        `const $scope = $$enterScope();\ntry {\n${lowered}\n${SSR_ESCAPE}\nconst $out = [];\nconst $awaits = [];\nconst $resume = {};\n${ssr}` +
+        `return { html: $out.join(''), state: (typeof $$model !== 'undefined' ? $$model.snapshot() : {}), awaits: $awaits, resume: $resume };\n` +
+        `} finally { $$exitScope($scope); }`
     /* An inline `await` — a blocking await block, a child render, a slot read, or a
        top-level `await` in the author script — forces an async wrapper. Match `await` as a
        standalone token (operator), so a no-space form (`await(x)`, `await[i]`, `` await`t` ``)