@abide/abide 0.43.1 → 0.44.1

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

@@ -1,20 +1,33 @@
 import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
+import type { ReactiveNode } from './types/ReactiveNode.ts'
 import { updateIfNecessary } from './updateIfNecessary.ts'
 
 /*
 Drains queued effects synchronously. Each is queued when it first leaves CLEAN, but
 runs only if `updateIfNecessary` finds a dependency that truly changed — a CHECK
 effect whose deps all memoised back to equal values settles to CLEAN without
-running its body. Snapshots and clears the queue each pass so an effect that dirties
-further effects re-queues them for the next pass rather than mutating the set
-mid-iteration; loops until the graph settles.
+running its body. Double-buffers the queue each pass — swaps in a fresh array and
+drains the captured one — so an effect that dirties further effects re-queues them
+for the next pass rather than mutating the array mid-iteration; loops until the
+graph settles. The swap reuses the drained array as the next spare, so a steady
+flush allocates nothing.
 */
 export function flushEffects(): void {
-    while (REACTIVE_CONTEXT.pendingEffects.size > 0) {
-        const batch = [...REACTIVE_CONTEXT.pendingEffects]
-        REACTIVE_CONTEXT.pendingEffects.clear()
-        for (const node of batch) {
-            updateIfNecessary(node)
-        }
+    /* Empty-queue fast path allocates nothing — only the length check, matching the
+       old `Set.size` guard. Hot: a write with no subscribed effect (e.g. a reconcile's
+       index-cell write nobody reads) still calls here at batch-exit, thousands of times
+       per list op; the spare array below must not be born on that path. */
+    if (REACTIVE_CONTEXT.pendingEffects.length === 0) {
+        return
     }
+    let spare: ReactiveNode[] = []
+    do {
+        const batch = REACTIVE_CONTEXT.pendingEffects
+        REACTIVE_CONTEXT.pendingEffects = spare
+        for (let index = 0; index < batch.length; index += 1) {
+            updateIfNecessary(batch[index] as ReactiveNode)
+        }
+        batch.length = 0
+        spare = batch
+    } while (REACTIVE_CONTEXT.pendingEffects.length > 0)
 }

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

@@ -2,7 +2,7 @@ import type { AbideHistoryState } from './types/AbideHistoryState.ts'
 
 /*
 Per-history-entry scroll buckets for manual scroll restoration. The browser's own
-restoration is disabled (`history.scrollRestoration = 'manual'` at router boot)
+restoration is disabled (`history.scrollRestoration = 'manual'` after the first build/hydration)
 because the router tears the page down and rebuilds it AFTER the browser would have
 restored scroll — so the offset is lost against a node that no longer exists. Instead
 each history entry carries a monotonic id (stamped into `history.state.abideEntry` by

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

@@ -15,8 +15,10 @@ observer is reading the same source in the same order as before — advance the
 cursor and reuse the edge, allocating nothing. Otherwise splice a fresh edge in at
 the cursor; `runNode` trims whatever stale edges trail the cursor when compute ends.
 
-A consecutive re-read of the same source (`dep` already the edge at the cursor) is
-absorbed by the reuse check, so `{x} … {x}` in one computation links `x` once.
+On re-runs, an edge whose `dep` matches the next slot in the established list is
+reused in-place (cursor advances, no allocation). New edges are still appended for
+reads that extend the list or find a mismatched slot — including a second consecutive
+read of the same source when no matching edge yet follows the cursor.
 */
 export function track(dep: ReactiveNode): void {
     const sub = REACTIVE_CONTEXT.observer

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

@@ -15,27 +15,41 @@ reaches). `nextSub` is read before recursing so the walk holds no edge a deeper
 pass could detach.
 */
 function mark(node: ReactiveNode, status: number): void {
-    if (node.status >= status) {
-        return
-    }
-    const wasClean = node.status === NODE_STATE.CLEAN
-    node.status = status
-    if (node.isEffect) {
-        if (wasClean) {
-            REACTIVE_CONTEXT.pendingEffects.add(node)
+    /* Tail-iterative down the subscriber cone: a node with a single subscriber (a
+       linear computed chain) advances by reassigning `node` instead of recursing, so a
+       deep chain costs a loop, not a 500-frame call stack. Only a true fan-out (>1
+       subscriber) recurses, and only for the extra branches. */
+    let nextStatus = status
+    for (;;) {
+        if (node.status >= nextStatus) {
+            return
         }
-        return
-    }
-    /* A computed propagates CHECK to its subscribers only on its first move out of
-       CLEAN — they are already CHECK on any later upgrade, so re-walking is wasted. */
-    if (!wasClean) {
-        return
-    }
-    let link = node.subsHead
-    while (link !== undefined) {
-        const next = link.nextSub
-        mark(link.sub, NODE_STATE.CHECK)
-        link = next
+        const wasClean = node.status === NODE_STATE.CLEAN
+        node.status = nextStatus
+        if (node.isEffect) {
+            if (wasClean) {
+                REACTIVE_CONTEXT.pendingEffects.push(node)
+            }
+            return
+        }
+        /* A computed propagates CHECK to its subscribers only on its first move out of
+           CLEAN — they are already CHECK on any later upgrade, so re-walking is wasted. */
+        if (!wasClean) {
+            return
+        }
+        const head = node.subsHead
+        if (head === undefined) {
+            return
+        }
+        /* Recurse into every branch but the last; continue the loop on the last, so the
+           common single-subscriber chain never recurses. */
+        let link = head
+        while (link.nextSub !== undefined) {
+            mark(link.sub, NODE_STATE.CHECK)
+            link = link.nextSub
+        }
+        node = link.sub
+        nextStatus = NODE_STATE.CHECK
     }
 }
 

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

@@ -1,8 +1,8 @@
 /* A routable page/layout. Callable to mount directly into a host (the direct-mount
    API), but the router instead uses `build` — the bare client build — to fill the
    layer into its outlet boundary as a marker range (no `<abide-outlet>` wrapper; see
-   `fillBoundary`/`outlet`). `hydratable` (false when the page has an `await` block)
-   tells the router whether the first paint adopts the SSR DOM in place. */
+   `fillBoundary`/`outlet`). `hydratable` (always true for compiled components; undefined on manually-constructed
+   Route objects) tells the router whether the first paint adopts the SSR DOM in place. */
 export type Route = ((host: Element, props?: unknown) => (() => void) | undefined) & {
     build: (host: Node, props?: unknown) => void
     hydratable?: boolean

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

@@ -10,8 +10,9 @@ page/route registries carry — abide-ui's compiled-component shape.
 export type UiComponent = ((host: Element, props?: UiProps) => () => void) & {
     /* `ctx` is the request-local block-id counter, threaded so a child's ids share the
        page's depth-first numbering; omitted at the top level (a fresh counter defaults
-       in). Returns a Promise when the component has an inline `await` (a blocking `{#await
-       … then}` block or a child render); otherwise renders synchronously. Callers `await`
+       in). Returns a Promise when the component contains an inline `await` — a blocking
+       `{#await … then}` block, a child-component render, a `<slot>` read, or a
+       top-level `await` in the author script; otherwise renders synchronously. Callers `await`
        it either way (awaiting a sync value just returns it). */
     render: (props?: UiProps, ctx?: RenderContext) => SsrRender | Promise<SsrRender>
     hydrate?: (host: Element, props?: UiProps) => () => void

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

@@ -1,14 +1,11 @@
 /*
-What a component is invoked with. Two real shapes flow through the one parameter.
-A top-level page/layout is called by the router (client) and `renderChain` (SSR)
-with its decoded route params — a plain string map. A nested child is called by
-the compiler-emitted `mountChild` with a map of reactive thunks (each authored
-prop, read in the body as `$props[name]?.()`) plus an optional `$children` slot
-builder carrying the component's `<slot>` markup, mounting into the host element
-it is handed.
+What a component is invoked with. A top-level page/layout is called by the router
+(client) and `renderChain` (SSR) with its route params as reactive thunks, shaped
+identically to the thunk map `mountChild` passes a nested child — so `props()` reads
+(`$props[name]?.()`) work uniformly on both. `$children` is the slot builder a parent
+component passes (carrying the component's `{children()}` content), or `CHILD_PRESENT`
+the router/SSR set on a layout that has a child layer below it.
 */
-export type UiProps =
-    | Record<string, string>
-    | (Record<string, () => unknown> & {
-          $children?: (host: Element) => void
-      })
+export type UiProps = Record<string, (() => unknown) | ((host: Element) => void)> & {
+    $children?: (host: Element) => void
+}

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

@@ -17,13 +17,25 @@ export function walkPath(tree: unknown, path: string): PathWalk {
     if (path === '') {
         return { exists: tree !== undefined, value: tree }
     }
+    /* A path with no `~` carries no escape in any segment, so the per-segment
+       unescape is skipped wholesale — the case for every plain-identifier path. */
+    const escaped = path.includes('~')
     let current: unknown = tree
-    for (const rawSegment of path.split('/')) {
-        const segment = unescapeKey(rawSegment)
+    /* Scan `/`-separated segments by index, no `split` array allocated — this runs
+       once per candidate on the structural descend scan, the hot path's hot loop. */
+    let start = 0
+    for (;;) {
+        const slash = path.indexOf('/', start)
+        const end = slash === -1 ? path.length : slash
+        const raw = path.slice(start, end)
+        const segment = escaped ? unescapeKey(raw) : raw
         if (current === null || typeof current !== 'object' || !(segment in current)) {
             return { exists: false, value: undefined }
         }
         current = (current as Record<string, unknown>)[segment]
+        if (slash === -1) {
+            return { exists: true, value: current }
+        }
+        start = slash + 1
     }
-    return { exists: true, value: current }
 }

package/src/lib/ui/startClient.ts

@@ -1,26 +1,41 @@
 import { createCacheStore } from '../shared/createCacheStore.ts'
+import { healthSeedSlot } from '../shared/healthSeedSlot.ts'
+import { rpcTimeoutSlot } from '../shared/rpcTimeoutSlot.ts'
+import { setAppName } from '../shared/setAppName.ts'
 import { setBaseResolver } from '../shared/setBaseResolver.ts'
 import { setCacheStoreResolver } from '../shared/setCacheStoreResolver.ts'
 import { setGlobalCacheStoreResolver } from '../shared/setGlobalCacheStoreResolver.ts'
 import { setPageResolver } from '../shared/setPageResolver.ts'
 import type { CacheSnapshotEntry } from '../shared/types/CacheSnapshotEntry.ts'
 import type { StreamedResolution } from '../shared/types/StreamedResolution.ts'
-import { installHotBridge } from './installHotBridge.ts'
-import { installInspectorBridge } from './installInspectorBridge.ts'
 import { probeNavigation } from './probeNavigation.ts'
+
+/* Build-time flag the production client defines false (see build.ts `define`) so the dev-only
+   hot bridge — and the entire DOM runtime it statically pulls in for re-builds — is dead-code-
+   eliminated, not even emitted as a chunk. Dev defines it true; the test preload sets it on
+   globalThis so the bare reference resolves there. */
+declare const __ABIDE_DEV__: boolean
+
 import { router } from './router.ts'
 import { clientPage } from './runtime/clientPage.ts'
 import type { RouteLoader } from './runtime/types/RouteLoader.ts'
 import { seedResolved } from './seedResolved.ts'
 
 /* The server's __SSR__ payload this entry consumes. */
-type SsrPayload = { cache?: CacheSnapshotEntry[]; base?: string }
+type SsrPayload = {
+    cache?: CacheSnapshotEntry[]
+    base?: string
+    app?: string
+    health?: Record<string, unknown>
+    clientTimeout?: number
+}
 
 /*
 The official abide-ui client entry. Reads the server's `window.__SSR__` payload,
 seeds a tab-scoped cache store from the inline snapshot (so a warm `cache()` read
-resolves synchronously and the matching `<template await>` adopts the SSR DOM with
-no re-fetch), installs the mount base, and starts the router — which imports the
+resolves synchronously and the matching `{#await}` adopts the SSR DOM with
+no re-fetch), installs the mount base, seeds the per-page __SSR__ stamps (app
+name, health, RPC timeout), and starts the router — which imports the
 current route's chunk, adopts the server-rendered `#app`, then drives SPA
 navigation — importing each further page's chunk on first visit and probing the
 destination through the server's app.handle so auth/redirect gating still applies.
@@ -37,19 +52,31 @@ export function startClient(
     if (target === null) {
         throw new Error('[abide] startClient: missing #app target')
     }
-    /* Dev only: the live-reload script sets `__abideDev` before this module runs,
-       so the runtime bridge is in place before any component mounts and records
-       its instances (mountChild) for hot replacement. */
-    if ((globalThis as { __abideDev?: boolean }).__abideDev) {
-        installHotBridge()
+    /* Dev only: the live-reload script sets `__abideDev` before this module runs, so the
+       runtime bridge is in place before any component mounts and records its instances
+       (mountChild) for hot replacement. Lazy-imported and `__ABIDE_DEV__`-gated so the
+       bridge (and the DOM runtime it drags in) is fully dead-code-eliminated in production
+       rather than shipped behind a runtime flag the minifier can't prove false. */
+    if (__ABIDE_DEV__ && (globalThis as { __abideDev?: boolean }).__abideDev) {
+        import('./installHotBridge.ts').then((module) => module.installHotBridge())
     }
-    /* Inspector only: the server injects `__abideInspect` when ABIDE_ENABLE_INSPECTOR
-       is on, so the scope/router bridge arms before the router builds any scope. */
+    /* Inspector only: the server injects `__abideInspect` when ABIDE_ENABLE_INSPECTOR is on,
+       so the scope/router bridge arms before the router builds any scope. Inspector can be
+       enabled in production, so this stays a lazy chunk (not `__ABIDE_DEV__`-gated) — emitted
+       but fetched only when the flag is set, never weighing down the default client load. */
     if ((globalThis as { __abideInspect?: boolean }).__abideInspect) {
-        installInspectorBridge()
+        import('./installInspectorBridge.ts').then((module) => module.installInspectorBridge())
     }
     const ssr = (globalThis as { __SSR__?: SsrPayload }).__SSR__ ?? {}
     setBaseResolver(() => ssr.base ?? '')
+    /* Seed the per-page __SSR__ stamps into their shared slots before mount: the app
+       name (default log channel), the health payload (so health()'s first probe is warm),
+       and the env-configured RPC timeout (ABIDE_CLIENT_TIMEOUT, shipped per request).
+       Without this the browser falls back to channel 'app', a cold first health probe,
+       and unbounded RPC fetches. */
+    setAppName(ssr.app)
+    healthSeedSlot.payload = ssr.health
+    rpcTimeoutSlot.ms = ssr.clientTimeout
     /* The `page` proxy reads route/params/url off the router-updated snapshot. */
     setPageResolver(() => clientPage.value)
 
@@ -61,7 +88,7 @@ export function startClient(
        (inline — reads settled at render-return, in __SSR__) and `__abideResumeCache` (pending
        {#await} reads whose `__abideResolve(...)` chunks the stream pushed during parse, before
        this deferred bundle ran). A warm entry lets a `cache()` read resolve synchronously so
-       `<template await>` adopts without a refetch; a miss marker re-fetches live. */
+       `{#await}` adopts without a refetch; a miss marker re-fetches live. */
     const streamed =
         (globalThis as { __abideResumeCache?: StreamedResolution[] }).__abideResumeCache ?? []
     for (const resolution of [...(ssr.cache ?? []), ...streamed]) {

package/src/lib/ui/state.ts

@@ -7,9 +7,9 @@ import { writeNode } from './runtime/writeNode.ts'
 A writable reactive cell — abide's from-scratch reactive primitive, with no
 compiler sigil and no external reactivity-library import. `.value` is a
 plain getter/setter over a signal node, so a read/write shows up as exactly that
-in a stack trace. The compiler's job (later) is only to auto-deref `{cell}` in
-templates and tag this declaration as a serializable manifest slot; the runtime
-needs no magic.
+in a stack trace. The compiler enforces scope attachment (bare `state()` is a compile
+error — use `scope().state()`), desugars plain `state(initial)` to a serializable `model`
+doc slot, and keeps `state(initial, transform)` as a `.value` cell; the runtime needs no magic.
 
 `transform` is an optional coercion gate on the write path: every `.value =`
 runs it and stores what it returns, with `previous` for clamp-relative writes or

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

@@ -17,9 +17,9 @@ methods so a scope is a passable value: `<Child parentScope={scope} />`.
 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. `id` is the scope's identity for the
-boundary-crossing capabilities — `persist()` defaults its key to it. `scope()` is
-the ONLY public entry; everything else is a method reached through it (the
-`history`/`persist`/`sync` helpers it composes are internal).
+boundary-crossing capabilities — `persist()` defaults its key to it. `scope()` is the only user-facing public entry; `effect` is also exported
+but only for generated binding code and the SSR strip (tagged plumbing). The
+`history`/`persist`/`sync` helpers it composes are internal.
 */
 export type Scope = {
     readonly id: string

package/src/serverBuildPlugins.ts

@@ -1,12 +1,14 @@
 import type { BunPlugin } from 'bun'
 import { abideResolverPlugin } from './abideResolverPlugin.ts'
 import { abideUiPlugin } from './lib/ui/compile/abideUiPlugin.ts'
+import { zodCjsPlugin } from './zodCjsPlugin.ts'
 
 /*
-The server-target Bun.build plugin pair shared by compile / buildCli / bundleApp:
-the abide-ui `.abide` loader (so SSR `render()` resolves) plus abide's virtual-
-module resolver. `embedAssets` flips on the gzip asset embed used by the
-standalone server binary; the CLI + launcher builds leave it off.
+The server-target Bun.build plugin set shared by compile / buildCli / bundleApp:
+the abide-ui `.abide` loader (so SSR `render()` resolves), abide's virtual-module
+resolver, and the zod→CommonJS shim that works around bun's broken ESM-cycle
+bundling (see zodCjsPlugin). `embedAssets` flips on the gzip asset embed used by
+the standalone server binary; the CLI + launcher builds leave it off.
 */
 export function serverBuildPlugins({
     cwd,
@@ -15,5 +17,9 @@ export function serverBuildPlugins({
     cwd: string
     embedAssets?: boolean
 }): BunPlugin[] {
-    return [abideUiPlugin, abideResolverPlugin({ cwd, embedAssets, target: 'server' })]
+    return [
+        zodCjsPlugin(cwd),
+        abideUiPlugin,
+        abideResolverPlugin({ cwd, embedAssets, target: 'server' }),
+    ]
 }

package/src/zodCjsPlugin.ts

@@ -0,0 +1,51 @@
+import { existsSync } from 'node:fs'
+import { dirname } from 'node:path'
+import type { BunPlugin } from 'bun'
+
+/*
+Routes every `zod` import in a server bundle to zod's CommonJS build.
+
+zod v4's ESM is reached through two subpaths (`zod` and `zod/v4/core`) whose
+modules form an initialization cycle. Bun's bundler emits a broken init order
+for that cycle (oven-sh/bun#31586, closed as not-planned), so a bundled binary
+crashes (`<helper> is not defined`) or — for a lazily imported module — silently
+fails to evaluate, which drops every rpc whose module imports zod from the
+registry. It only bites bundled output; `abide dev` runs unbundled and is fine.
+
+zod ships a parallel CommonJS build (`index.cjs`, `v4/core/index.cjs`, …), and
+CommonJS resolves circular requires through a mutating `module.exports` with no
+temporal-dead-zone, so the cycle initializes correctly. Resolving each zod
+specifier to its `.cjs` sibling makes bun bundle zod as CommonJS and sidesteps
+the bug while keeping zod v4. Server-only: the client bundle strips zod from rpc
+modules (they become remote proxies), and dev never bundles.
+*/
+export function zodCjsPlugin(cwd: string): BunPlugin {
+    /*
+    The (specifier, importer-dir) → cjs path mapping is deterministic per build —
+    zod's location doesn't move mid-build, and the filter fires for every zod
+    import in every module. Memoise on a `${path}\0${from}` key (mirrors the
+    resolver's resolveExtension cache) so the fs round-trips (resolveSync +
+    existsSync) run once per unique pair instead of once per import.
+    */
+    const cjsPathCache = new Map<string, string>()
+    return {
+        name: 'abide-zod-cjs',
+        setup(build) {
+            build.onResolve({ filter: /^zod($|\/)/ }, (args) => {
+                /* Resolve from the importer (or cwd for the entry) to zod's ESM
+                   target, then swap to its `.cjs` sibling when one exists. */
+                const from = args.importer ? dirname(args.importer) : cwd
+                const key = `${args.path}\0${from}`
+                const cached = cjsPathCache.get(key)
+                if (cached !== undefined) {
+                    return { path: cached }
+                }
+                const resolved = Bun.resolveSync(args.path, from)
+                const cjs = resolved.replace(/\.js$/, '.cjs')
+                const path = existsSync(cjs) ? cjs : resolved
+                cjsPathCache.set(key, path)
+                return { path }
+            })
+        },
+    }
+}

package/template/.zed/settings.json

@@ -1,4 +1,10 @@
 {
   "auto_install_extensions": { "abide": true },
-  "semantic_tokens": "combined"
+  "semantic_tokens": "combined",
+  "global_lsp_settings": {
+    "semantic_token_rules": [
+      { "token_type": "tag", "style": ["tag"] },
+      { "token_type": "attribute", "style": ["attribute"] }
+    ]
+  }
 }

package/template/package.json

@@ -14,5 +14,8 @@
     },
     "dependencies": {
         "@abide/abide": "^0.27.0"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.3.14"
     }
 }

package/template/src/ui/pages/layout.abide

@@ -1,8 +1,8 @@
 <script>
 /*
 Root layout. A layout.abide wraps every page at or below its folder — here
-src/ui/pages/, so it wraps the whole app. The page lands in the <slot/> outlet;
-the resolver finds it by filename (no per-page import), and the client router
+src/ui/pages/, so it wraps the whole app. The page renders where this layout
+calls {children()}; the resolver finds it by filename (no per-page import), and the client router
 keeps it mounted across navigation, so this chrome never re-mounts. A nested
 layout.abide (in a subfolder) wraps inside this one. Runs on the server during
 SSR and on the client after hydration.
@@ -16,6 +16,4 @@ import '../app.css'
         <a href="/about">About</a>
     </nav>
 </header>
-<main>
-    <slot></slot>
-</main>
+<main>{children()}</main>

package/src/lib/shared/matchesDebugPattern.ts

@@ -1,16 +0,0 @@
-/*
-One DEBUG pattern against one channel name, npm-debug conventions:
-`*` matches everything, `abide:*` matches 'abide' and every 'abide:…'
-sub-channel, anything else matches exactly. Negation (`-` prefix) is the
-caller's concern — patterns arrive here already stripped.
-*/
-export function matchesDebugPattern(name: string, pattern: string): boolean {
-    if (pattern === '*') {
-        return true
-    }
-    if (pattern.endsWith(':*')) {
-        const prefix = pattern.slice(0, -2)
-        return name === prefix || name.startsWith(`${prefix}:`)
-    }
-    return pattern === name
-}

package/src/lib/shared/parseDebugPatterns.ts

@@ -1,21 +0,0 @@
-/*
-DEBUG's comma list, parsed once per distinct string — the gate runs on every
-log emission, and the env never changes server-side. A single-slot memo
-suffices: the browser's abide-debug localStorage toggle produces a new string
-that misses the memo and reparses.
-*/
-let lastEnv: string | undefined
-let lastPatterns: string[] = []
-
-export function parseDebugPatterns(env: string | undefined): string[] {
-    if (env !== lastEnv) {
-        lastEnv = env
-        lastPatterns = env
-            ? env
-                  .split(',')
-                  .map((raw) => raw.trim())
-                  .filter((pattern) => pattern !== '')
-            : []
-    }
-    return lastPatterns
-}