@abide/abide 0.36.0 → 0.38.0

package/src/lib/server/sockets/createSocketDispatcher.ts

@@ -170,7 +170,13 @@ export function createSocketDispatcher(sockets: SocketRoutes): SocketDispatcher
         can ask for "as many as available, up to N" — `0` (bare
         `for await`) replays nothing.
         */
-        send(ws, { type: 'replay', sub: frame.sub, messages: entry.snapshotTail(frame.replay) })
+        /*
+        A non-finite `replay` (NaN/Infinity from a buggy client) would make
+        snapshotTail's slice(NaN) leak the whole retained buffer — coerce it
+        to undefined, matching the REST `?tail=` guard below.
+        */
+        const replay = Number.isFinite(frame.replay) ? frame.replay : undefined
+        send(ws, { type: 'replay', sub: frame.sub, messages: entry.snapshotTail(replay) })
     }
 
     function handleUnsub(

package/src/lib/server/sockets/defineSocket.ts

@@ -176,7 +176,12 @@ export function defineSocket<T>(name: string, opts: SocketOptions = {}): Socket<
         clients,
         snapshotTail: (count?: number) => {
             pruneExpired(Date.now())
-            const start = count === undefined ? 0 : Math.max(0, buffer.length - count)
+            /* A non-finite count (NaN/Infinity) would make slice() leak the whole
+               buffer — treat it as absent (full tail), the same as count === undefined. */
+            const start =
+                count === undefined || !Number.isFinite(count)
+                    ? 0
+                    : Math.max(0, buffer.length - count)
             return buffer.slice(start).map((entry) => entry.value)
         },
     })

package/src/lib/shared/cache.ts

@@ -870,6 +870,12 @@ function fireRefetch(store: CacheStore, entry: CacheEntry): void {
             entry.promise = inflight
             entry.value = undefined
             entry.settled = true
+            /* Restart the freshness clock from the revalidation — without this the
+               entry keeps its original expiresAt and is evicted at the old deadline
+               despite holding fresh data. Mirrors registerEntry's settle path. */
+            if (entry.ttl !== undefined && entry.ttl !== 0) {
+                armTtlExpiry(store, entry, entry.ttl)
+            }
             store.markLifecycle(entry.key)
             emit(store, [entry.key])
         },

package/src/lib/shared/createPushIterator.ts

@@ -59,9 +59,14 @@ export function createPushIterator<T>(
             wake(slot)
             return
         }
-        // Drop the oldest pending value before exceeding the cap.
+        /* Drop the OLDEST value slot before exceeding the cap — never a control or
+           terminal slot (end/error/disconnect), which the contract guarantees are
+           never dropped. If the buffer holds only non-value slots, drop nothing. */
         if (slot.kind === 'value' && buffer.length >= maxBuffer) {
-            buffer.shift()
+            const oldestValue = buffer.findIndex((pending) => pending.kind === 'value')
+            if (oldestValue !== -1) {
+                buffer.splice(oldestValue, 1)
+            }
         }
         buffer.push(slot)
     }

package/src/lib/shared/emitLogRecord.ts

@@ -66,6 +66,15 @@ function formatElapsed(ms: number): string {
     return `+${ms.toFixed(2)}ms`
 }
 
+/* `14:23:01.072` — local wall-clock to the ms. Every record carries `ts`, so the
+   tsv line always leads with one; `+elapsedMs` still trails as the request-relative
+   timing — the two are different axes (when it happened vs how long it took). */
+function formatClock(ts: number): string {
+    const date = new Date(ts)
+    const pad = (value: number, width = 2): string => String(value).padStart(width, '0')
+    return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}`
+}
+
 /*
 Builds the record from the emission's own fields plus the ambient request
 scope (trace, elapsed, verb+path), then renders it through the active
@@ -123,11 +132,12 @@ function consoleFor(level: LogRecord['level']): (...args: unknown[]) => void {
 
 /*
 The unified tsv line (the default format): tab-separated
-`<trace8>	<verb path>	[channel] <message>	+0.00ms`. Inside a
-request scope the trace column leads and the elapsed-at-emission timing
-trails; a closing record emitted outside one (asset hits sidestep the scope)
-pads a blank trace column and trails its serve duration instead, so request
-lines stay aligned whatever produced them. Every record speaks on a channel
+`<clock>	<trace8>	<verb path>	[channel] <message>	+0.00ms`. The
+wall-clock leads every line (each record carries `ts`); inside a request scope
+the trace column follows and the elapsed-at-emission timing trails; a closing
+record emitted outside one (asset hits sidestep the scope) pads a blank trace
+column and trails its serve duration instead, so request lines stay aligned
+whatever produced them. Every record speaks on a channel
 (the app name, 'abide', or a diagnostic channel), shown as a dim `[name]`
 tag opening the message field. The verb+path pair is one field — it's the
 line's anchor unit — and the tag folds into the message field so field
@@ -136,6 +146,9 @@ positions stay stable for cut/awk consumers.
 function printTsv(record: LogRecord, voice?: LogVoice): void {
     const fields: string[] = []
     const closing = record.status !== undefined
+    /* Wall-clock leads every line — a stable first column, unlike the conditional
+       trace field, and the axis `+elapsedMs` can't give (when, not how-long). */
+    fields.push(dim(formatClock(record.ts)))
     if (record.trace) {
         fields.push(dim(record.trace.slice(0, 8)))
     } else if (closing) {

package/src/lib/ui/COMPONENT_WRAPPER_PREFIX.ts

@@ -0,0 +1,4 @@
+/* The tag prefix every component instance mounts into (`abide-<name>`). One source
+   for the compiler (componentWrapperTag) and the runtime opacity checks (skeleton,
+   scopeLabel) so the wrapper convention can't drift between build and hydrate. */
+export const COMPONENT_WRAPPER_PREFIX = 'abide-'

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

@@ -1,5 +1,6 @@
 import { relative } from 'node:path'
 import type { BunPlugin } from 'bun'
+import { messageFromError } from '../../shared/messageFromError.ts'
 import { AbideCompileError } from './AbideCompileError.ts'
 import { analyzeComponent } from './analyzeComponent.ts'
 import { compileModule } from './compileModule.ts'
@@ -57,7 +58,7 @@ export const abideUiPlugin: BunPlugin = {
                             : (({ line, column }) => `${moduleId}:${line}:${column}`)(
                                   offsetToLineColumn(source, offset),
                               )
-                    const message = error instanceof Error ? error.message : String(error)
+                    const message = messageFromError(error)
                     throw new Error(`${message.replace(/^\[abide\]\s*/, `[abide] ${at} — `)}`)
                 }
             }

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

@@ -0,0 +1,29 @@
+import { OUTLET_TAG } from '../runtime/OUTLET_TAG.ts'
+import type { TemplateNode } from './types/TemplateNode.ts'
+
+/*
+In a layout the `<slot/>` page outlet is a bare empty `OUTLET_TAG` element the router fills
+later. Rewriting it to an element node up front lets the static-clone path carry it as ordinary
+structure AND lets BOTH back-ends feed the same tree to `skeletonContext` — one decision site
+for "a layout slot is an outlet, not an anchor", instead of the client running `asOutlet` while
+SSR mirrors it with an inline special-case.
+
+The outlet is a structural mount container, not styled content, so it carries NO attrs and NO
+style scope — keeping it byte-identical to the placeholder `renderChain` folds the child layer
+into (an exact `<abide-outlet></abide-outlet>` string match). Stripping `scopes` is what makes
+the two back-ends agree: the SSR special-case emitted the outlet bare, but the client clone read
+the slot's annotated `scopes` and stamped them — a hydration mismatch for any scoped layout.
+
+Control-flow children are fresh build contexts (their own runtime mounts a nested slot), so they
+are not descended into — a `<slot>` inside an `{#if}` stays a slot node, handled at its own
+mount site in each back-end.
+*/
+export function asOutlet(node: TemplateNode): TemplateNode {
+    if (node.kind !== 'element') {
+        return node
+    }
+    if (node.tag === 'slot') {
+        return { ...node, tag: OUTLET_TAG, attrs: [], children: [], scopes: [] }
+    }
+    return { ...node, children: node.children.map(asOutlet) }
+}

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

@@ -1,23 +1,15 @@
-import { HTML_TAGS } from './HTML_TAGS.ts'
-
 /*
-The element tag a component instance mounts into. Normally the component name
-lowercased — readable in devtools, a real box like any abide wrapper. But a name
-that lowercases to a real HTML element (`Button`→`button`, `Input`→`input`) yields a
-wrapper with a content model the parser enforces: void elements self-close, and
-`<button>`/`<a>`/table/list/select families reject or foster the component's own
-markup as the wrapper's siblings — so on hydration the skeleton locates the wrapper
-empty, claims `null`, and `attr` throws on it. Those names map to a hyphenated
-custom-element tag (a custom element is never void and has no content model) made
-layout-transparent with `display:contents`, so the component's real root still lays
-out as a direct child of the parent the way the (parse-broken) wrapper would have.
-A name that is NOT a known HTML element (the common case — `Card`, `Dropdown`) is an
-inert unknown tag that holds any content untouched, so it stays as-is. Both back-ends
-call this so the SSR string and the client build agree on the wrapper.
+The element tag a component instance mounts into: always `abide-<name>` lowercased. The
+`abide-` prefix makes every wrapper a valid custom element (contains a hyphen) — never
+void, no content model — so it holds the component's own markup untouched and hydrates
+cleanly, regardless of whether the name collides with an HTML element (`Button`, `Input`).
+Emitted with `display:contents` (see the back-ends) so the wrapper stays out of layout: a
+pure mount host whose real root lays out as a direct child of the parent, keeping the
+component invisible to `grid`/`subgrid`/`flex`. Both back-ends call this so the SSR string
+and the client build agree on the wrapper.
 */
-export function componentWrapperTag(name: string): { tag: string; transparent: boolean } {
-    const lower = name.toLowerCase()
-    return HTML_TAGS.has(lower)
-        ? { tag: `abide-${lower}`, transparent: true }
-        : { tag: lower, transparent: false }
+import { COMPONENT_WRAPPER_PREFIX } from '../COMPONENT_WRAPPER_PREFIX.ts'
+
+export function componentWrapperTag(name: string): string {
+    return `${COMPONENT_WRAPPER_PREFIX}${name.toLowerCase()}`
 }

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

@@ -1,12 +1,13 @@
 import { HOLE_ATTRIBUTE } from '../runtime/HOLE_ATTRIBUTE.ts'
 import { OUTLET_TAG } from '../runtime/OUTLET_TAG.ts'
+import { asOutlet } from './asOutlet.ts'
 import { bindListenEvent } from './bindListenEvent.ts'
 import { componentWrapperTag } from './componentWrapperTag.ts'
 import { groupBindParts } from './groupBindParts.ts'
 import { isControlFlow } from './isControlFlow.ts'
-import { isTextLeaf } from './isTextLeaf.ts'
 import { lowerContext } from './lowerContext.ts'
 import { scopeAttr } from './scopeAttr.ts'
+import { skeletonContext } from './skeletonContext.ts'
 import { staticAttr } from './staticAttr.ts'
 import { staticTextPart } from './staticTextPart.ts'
 import type { TemplateNode } from './types/TemplateNode.ts'
@@ -32,6 +33,30 @@ export function generateBuild(
     let counter = 0
     const nextVar = (prefix: string): string => `${prefix}${counter++}`
 
+    /* In a layout, `<slot/>` outlets are rewritten to `OUTLET_TAG` elements up front
+       (`asOutlet`) so the static-clone path carries them as ordinary structure. `asOutlet`
+       CLONES every element it descends through and drops the slot's anchor hole, so the
+       shared skeleton context must walk THIS rewritten tree — the one the build traversal
+       below reads — or its node-keyed hole indices key the originals and never match. */
+    const rootNodes = isLayout ? nodes.map(asOutlet) : nodes
+
+    /* Per-node skeleton position from the SAME pass the SSR back-end reads — so the client's
+       anchor/text-leaf decisions consult one source of truth instead of re-deriving the
+       position structurally (the drift the shared context exists to prevent). */
+    const { markText, elIndex, anIndex } = skeletonContext(rootNodes)
+
+    /* The hole's index, assigned by the shared skeletonContext walk — the sole numberer. A
+       missing entry means this back-end reached a hole the shared walk didn't number: a
+       structural divergence between the two, surfaced loudly at compile time rather than as a
+       runtime hydration desync. */
+    function holeIndex(map: WeakMap<object, number>, key: object): number {
+        const index = map.get(key)
+        if (index === undefined) {
+            throw new Error('[abide] skeleton hole not numbered by the shared positional walk')
+        }
+        return index
+    }
+
     /* The shared signal→`model` lowering + branch-scoped nested-script deref scope. */
     const {
         expression: lowerExpression,
@@ -100,12 +125,7 @@ export function generateBuild(
        block or slot drops an `<!--a-->` anchor at its position and mounts there (see
        `anchorCursor`), so it can sit ANYWHERE among static siblings. Static descendants are
        plain markup. */
-    function skeletonMarkup(
-        node: TemplateNode,
-        skVar: string,
-        counter: { el: number; an: number },
-        binds: string[],
-    ): string {
+    function skeletonMarkup(node: TemplateNode, skVar: string, binds: string[]): string {
         if (node.kind === 'text') {
             /* Reactive text reached here is INTERLEAVED with element siblings (a text-leaf
                is bound via `generateChildren` instead). It can't be element-positioned, so
@@ -117,7 +137,7 @@ export function generateBuild(
                         return staticTextPart(part.value)
                     }
                     binds.push(
-                        `appendTextAt(${skVar}.an[${counter.an++}], () => (${lowerExpression(part.code)}));\n`,
+                        `appendTextAt(${skVar}.an[${holeIndex(anIndex, part)}], () => (${lowerExpression(part.code)}));\n`,
                     )
                     return '<!--a-->'
                 })
@@ -129,19 +149,18 @@ export function generateBuild(
                and returns the create insertion reference; the block's parent is the located
                element the anchor was cloned into (`anchor.parentNode`). */
             const anchorVar = nextVar('an')
-            binds.push(`const ${anchorVar} = ${skVar}.an[${counter.an++}];\n`)
+            binds.push(`const ${anchorVar} = ${skVar}.an[${holeIndex(anIndex, node)}];\n`)
             binds.push(generateChild(node, `${anchorVar}.parentNode`, `anchorCursor(${anchorVar})`))
             return '<!--a-->'
         }
         if (node.kind === 'component') {
             /* The wrapper element is a positioned hole in the skeleton; the child mounts
-               into the located node (idempotent display:contents for a transparent wrap,
-               static so it lives in the markup). */
-            const { tag, transparent } = componentWrapperTag(node.name)
-            const { code } = mountComponent(node, `${skVar}.el[${counter.el++}]`)
+               into the located node. display:contents (idempotent, static so it lives in
+               the markup) keeps the wrapper out of layout — a pure mount host. */
+            const tag = componentWrapperTag(node.name)
+            const { code } = mountComponent(node, `${skVar}.el[${holeIndex(elIndex, node)}]`)
             binds.push(code)
-            const style = transparent ? ' style="display:contents"' : ''
-            return `<${tag} ${HOLE_ATTRIBUTE}${style}></${tag}>`
+            return `<${tag} ${HOLE_ATTRIBUTE} style="display:contents"></${tag}>`
         }
         if (node.kind === 'script') {
             /* A nested `<script>` (scoped reactive block) emits no markup — its lowered body
@@ -164,7 +183,7 @@ export function generateBuild(
             /* A `<slot>` outlet at its position: an `<!--a-->` anchor, the slot's content
                mounted as a marker-bounded range (`mountSlot`) so it positions like a block. */
             const anchorVar = nextVar('an')
-            binds.push(`const ${anchorVar} = ${skVar}.an[${counter.an++}];\n`)
+            binds.push(`const ${anchorVar} = ${skVar}.an[${holeIndex(anIndex, node)}];\n`)
             const hostVar = nextVar('host')
             binds.push(
                 `mountSlot(${anchorVar}.parentNode, (${hostVar}) => {\n${generateSlot(node, hostVar)}}, anchorCursor(${anchorVar}));\n`,
@@ -172,13 +191,16 @@ export function generateBuild(
             return '<!--a-->'
         }
         const hasReactiveAttr = node.attrs.some((attr) => attr.kind !== 'static')
-        const hasReactiveText = node.children.some(
+        const reactiveTextChild = node.children.find(
             (child) => child.kind === 'text' && child.parts.some((part) => part.kind !== 'static'),
         )
         /* A text-leaf (only text/style children) with reactive text binds marker-free via
            `generateChildren` on the located element; otherwise reactive text is interleaved
-           and uses `<!--a-->` anchors during the child recursion below. */
-        const textLeafBind = hasReactiveText && isTextLeaf(node)
+           and uses `<!--a-->` anchors during the child recursion below. The shared context
+           records the leaf's text as NOT interleaved (`markText` false) — read that flag the
+           SSR back-end also reads, rather than re-deriving leaf-ness via `isTextLeaf` here. */
+        const textLeafBind =
+            reactiveTextChild !== undefined && markText.get(reactiveTextChild) === false
         let openTag = `<${node.tag}`
         let elVar = ''
         if (hasReactiveAttr || textLeafBind) {
@@ -186,7 +208,7 @@ export function generateBuild(
                index BEFORE recursing, so holes number in pre-order — the order the runtime's
                path walk produces them. */
             elVar = nextVar('el')
-            binds.push(`const ${elVar} = ${skVar}.el[${counter.el++}];\n`)
+            binds.push(`const ${elVar} = ${skVar}.el[${holeIndex(elIndex, node)}];\n`)
             openTag += ` ${HOLE_ATTRIBUTE}`
             for (const attr of node.attrs) {
                 if (attr.kind !== 'static') {
@@ -215,7 +237,7 @@ export function generateBuild(
         /* A nested `<script>` among the children scopes its bindings to this subtree (its
            later siblings auto-deref them); pop after. */
         const inner = withNestedScripts(node.children, () =>
-            node.children.map((child) => skeletonMarkup(child, skVar, counter, binds)).join(''),
+            node.children.map((child) => skeletonMarkup(child, skVar, binds)).join(''),
         )
         return `${openTag}${inner}</${node.tag}>`
     }
@@ -229,7 +251,7 @@ export function generateBuild(
     ): string {
         const skVar = nextVar('sk')
         const binds: string[] = []
-        const html = skeletonMarkup(node, skVar, { el: 0, an: 0 }, binds)
+        const html = skeletonMarkup(node, skVar, binds)
         return `const ${skVar} = skeleton(${parentVar}, ${JSON.stringify(html)});\n${binds.join('')}`
     }
 
@@ -586,20 +608,7 @@ export function generateBuild(
         )
     }
 
-    /* In a layout the `<slot/>` page outlet is a bare empty `OUTLET_TAG` element (the
-       router fills it later) — exactly the SSR placeholder. Rewriting it to an element
-       node up front lets the static-clone path carry it as ordinary structure. */
-    function asOutlet(node: TemplateNode): TemplateNode {
-        if (node.kind !== 'element') {
-            return node
-        }
-        if (node.tag === 'slot') {
-            return { ...node, tag: OUTLET_TAG, attrs: [], children: [] }
-        }
-        return { ...node, children: node.children.map(asOutlet) }
-    }
-
-    return generateChildren(isLayout ? nodes.map(asOutlet) : nodes, hostVar)
+    return generateChildren(rootNodes, hostVar)
 }
 
 /* A text node that is purely whitespace (no interpolation, only blank static

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

@@ -1,4 +1,5 @@
 import { OUTLET_TAG } from '../runtime/OUTLET_TAG.ts'
+import { asOutlet } from './asOutlet.ts'
 import { componentWrapperTag } from './componentWrapperTag.ts'
 import { groupBindParts } from './groupBindParts.ts'
 import { isControlFlow } from './isControlFlow.ts'
@@ -18,6 +19,17 @@ import { VOID_TAGS } from './VOID_TAGS.ts'
 const RANGE_OPEN = '<!--[-->'
 const RANGE_CLOSE = '<!--]-->'
 
+/* The `then`/`catch`/`finally` branch child of an await/try block, or undefined. */
+function branchNamed(
+    children: TemplateNode[],
+    which: 'then' | 'catch' | 'finally',
+): Extract<TemplateNode, { kind: 'branch' }> | undefined {
+    return children.find(
+        (child): child is Extract<TemplateNode, { kind: 'branch' }> =>
+            child.kind === 'branch' && child.branch === which,
+    )
+}
+
 /*
 Server code generator: turns the parsed template into statements that push HTML
 fragments onto an output array, reading the document synchronously (no DOM, no
@@ -64,11 +76,17 @@ export function generateSSR(
         return children.map((child) => generate(child, target)).join('')
     }
 
+    /* In a layout, rewrite `<slot/>` outlets to `OUTLET_TAG` elements up front (the same shared
+       `asOutlet` the client back-end runs), then drive both the skeleton context and the
+       traversal from this tree — one decision site for the outlet, and the outlet emitted bare
+       through the generic element path exactly as the client clones it. */
+    const rootNodes = isLayout ? nodes.map(asOutlet) : nodes
+
     /* Per-node skeleton position, computed once. Both back-ends read this single source of
        truth so their `<!--a-->` anchor placement cannot drift — the fresh-context boundaries
        (control-flow branches, component/slot/snippet content) are enumerated there, not
        re-tracked here as mutable state that a forgotten reset could leak past. */
-    const { inSkeleton, markText } = skeletonContext(nodes)
+    const { inSkeleton, markText } = skeletonContext(rootNodes)
 
     /* A control-flow branch's content, generated exactly like a normal child list so
        a branch holds ANY content (components, text, nested blocks). `generate` emits
@@ -184,7 +202,7 @@ export function generateSSR(
                the same wrapper the client mounts into, so SSR and client agree.
                Props pass as thunks; slot content passes as a string-returning
                `$children` the child invokes from its <slot>. */
-            const { tag, transparent } = componentWrapperTag(node.name)
+            const tag = componentWrapperTag(node.name)
             const parts = node.props.map(
                 (prop) => `${JSON.stringify(prop.name)}: () => (${lowerExpression(prop.code)})`,
             )
@@ -206,7 +224,7 @@ export function generateSSR(
                the enclosing render body, including from branch closures.) */
             const result = nextVar('$child')
             return (
-                push(target, `<${tag}${transparent ? ' style="display:contents"' : ''}>`) +
+                push(target, `<${tag} style="display:contents">`) +
                 `const ${result} = ${node.name}.render({ ${parts.join(', ')} });\n` +
                 `${target}.push(${result}.html);\n` +
                 `for (const $a of ${result}.awaits) { $awaits.push($a); }\n` +
@@ -214,8 +232,10 @@ export function generateSSR(
             )
         }
         if (node.kind === 'element' && node.tag === 'slot') {
-            /* A layout's `<slot/>` is the router's page outlet: emit an empty
-               placeholder the chain composer folds the child layer's html into. */
+            /* `asOutlet` already rewrote a layout's top-level/element-nested `<slot/>` to an
+               `OUTLET_TAG` element (handled by the generic path below), so a `slot` node reaching
+               here in a layout is control-flow-nested — emit the same bare outlet placeholder the
+               client's nested-slot path clones, which the chain composer folds the child into. */
             if (isLayout) {
                 return push(target, `<${OUTLET_TAG}></${OUTLET_TAG}>`)
             }
@@ -291,17 +311,12 @@ export function generateSSR(
        an empty boundary — its resolved branch is the children bound to `node.as` — and
        flags the entry so `renderToStream` settles it before the first flush. */
     function generateAwait(node: Extract<TemplateNode, { kind: 'await' }>, target: string): string {
-        const branchOf = (which: 'then' | 'catch' | 'finally') =>
-            node.children.find(
-                (child): child is Extract<TemplateNode, { kind: 'branch' }> =>
-                    child.kind === 'branch' && child.branch === which,
-            )
-        const catchBranch = branchOf('catch')
-        const finallyChildren = branchOf('finally')?.children ?? []
+        const catchBranch = branchNamed(node.children, 'catch')
+        const finallyChildren = branchNamed(node.children, 'finally')?.children ?? []
         /* Resolved branch + its bound value: the children directly when blocking, the
            `then` child when streaming. Pending (streaming only) is the non-branch
            children. */
-        const thenBranch = branchOf('then')
+        const thenBranch = branchNamed(node.children, 'then')
         const resolvedChildren = node.blocking
             ? node.children.filter((child) => child.kind !== 'branch')
             : (thenBranch?.children ?? [])
@@ -342,13 +357,8 @@ export function generateSSR(
        an enclosing boundary / the 500 / the stream). Boundary comments let hydration
        discard the server content if the client adoption fails. */
     function generateTry(node: Extract<TemplateNode, { kind: 'try' }>, target: string): string {
-        const branchOf = (which: 'catch' | 'finally') =>
-            node.children.find(
-                (child): child is Extract<TemplateNode, { kind: 'branch' }> =>
-                    child.kind === 'branch' && child.branch === which,
-            )
-        const catchBranch = branchOf('catch')
-        const finallyChildren = branchOf('finally')?.children ?? []
+        const catchBranch = branchNamed(node.children, 'catch')
+        const finallyChildren = branchNamed(node.children, 'finally')?.children ?? []
         const guarded = node.children.filter((child) => child.kind !== 'branch')
         const errName = catchBranch?.as ?? '_error'
         const id = nextVar('$tid')
@@ -371,5 +381,5 @@ export function generateSSR(
         return code
     }
 
-    return generateInto(nodes, '$out')
+    return generateInto(rootNodes, '$out')
 }

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

@@ -148,7 +148,7 @@ export function parseTemplate(source: string, baseOffset = 0): { nodes: Template
                 } else {
                     attrs.push({ kind: 'expression', name, code, loc })
                 }
-            } else {
+            } else if (source.charAt(cursor) === '"' || source.charAt(cursor) === "'") {
                 const quote = source.charAt(cursor)
                 cursor += 1
                 let value = ''
@@ -158,6 +158,15 @@ export function parseTemplate(source: string, baseOffset = 0): { nodes: Template
                 }
                 cursor += 1 // past closing quote
                 attrs.push({ kind: 'static', name, value })
+            } else {
+                /* Unquoted value (`<input type=text>`): runs to the next whitespace or
+                   `>`, per the HTML unquoted-attribute rule. No delimiter to consume. */
+                let value = ''
+                while (cursor < source.length && !/[\s>]/.test(source.charAt(cursor))) {
+                    value += source.charAt(cursor)
+                    cursor += 1
+                }
+                attrs.push({ kind: 'static', name, value })
             }
         }
         return attrs

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

@@ -35,8 +35,15 @@ export function renameSignalRefs(
         if (ts.isPropertyAccessExpression(node)) {
             skip.add(node.name)
         }
-        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
-            skip.add(node.name)
+        /* A declaration name is a binding, not a value read. A plain identifier is
+           skipped directly; a destructuring pattern's leaf names are collected so a
+           bound name shadowing a signal (`const { count } = …`) is never rewritten. */
+        if (ts.isVariableDeclaration(node)) {
+            if (ts.isIdentifier(node.name)) {
+                skip.add(node.name)
+            } else {
+                collectBindingIdentifiers(node.name, skip)
+            }
         }
         if (ts.isParameter(node) && ts.isIdentifier(node.name)) {
             skip.add(node.name)
@@ -180,6 +187,22 @@ function collectStatementBindings(statement: ts.Statement, into: Set<string>): v
     }
 }
 
+/* The identifier NODES a binding name binds — a plain identifier or the leaves of a
+   destructuring pattern (object/array, including nested patterns and rest elements).
+   For `{ a: b }` only the bound name `b` is a binding; `a` is the source property.
+   Feeds the skip set so a destructured name shadowing a signal is never rewritten. */
+function collectBindingIdentifiers(name: ts.BindingName, into: Set<ts.Node>): void {
+    if (ts.isIdentifier(name)) {
+        into.add(name)
+        return
+    }
+    for (const element of name.elements) {
+        if (ts.isBindingElement(element)) {
+            collectBindingIdentifiers(element.name, into)
+        }
+    }
+}
+
 /* Every identifier bound by a binding name — a plain identifier or the leaves of a
    destructuring pattern (object/array, including rest elements). */
 function collectBindingNames(name: ts.BindingName, into: Set<string>): void {