@abide/abide 0.43.1 → 0.44.1

package/CHANGELOG.md

@@ -1,5 +1,68 @@
 # abide
 
+## 0.44.1
+
+### Patch Changes
+
+- 767b415: 02-zod-plugin-memo ([`0e00b21`](https://github.com/briancray/abide/commit/0e00b217f99352a7d3def4841172c5bff287bc5c))
+- 767b415: 06-wakeSubtree-prefix-index ([`23ab920`](https://github.com/briancray/abide/commit/23ab9202fd0cb41e01811e78b76eac2843c9cf8f))
+- 767b415: 09-when-via-switch ([`48f8d50`](https://github.com/briancray/abide/commit/48f8d5063cf74060004ad38691f584abcff0cab2))
+- 767b415: 08-dts-codegen ([`5170542`](https://github.com/briancray/abide/commit/51705426e55a700140cc7bc38f7e21f30759fce3))
+- 767b415: 03-socket-publish-gate ([`56fae49`](https://github.com/briancray/abide/commit/56fae49bf393fdfb3aa35cecc618a39443354ce4))
+- 767b415: 10-cli-tokenizer ([`5e305c1`](https://github.com/briancray/abide/commit/5e305c154efd5f77d0a57e78831b72a30b4d9155))
+- 767b415: 14-resolver-slot-factory-JUDGMENT ([`6e00809`](https://github.com/briancray/abide/commit/6e00809c343e24599d54b2304a50a9cecd90619f))
+- 767b415: catch top-level await in a .abide <script> during abide check ([`76ff64e`](https://github.com/briancray/abide/commit/76ff64e9fb9ffed108ae2fde53f2ded2bf3a0abe))
+- 767b415: 12-warm-clone-PARTIAL ([`8e58e0b`](https://github.com/briancray/abide/commit/8e58e0b2c1891174cc809797f949f01619529b89))
+- 767b415: 05-compiler-double-pass ([`9216dae`](https://github.com/briancray/abide/commit/9216dae4c26e27fce49f39b116bd8b1dcf1dd226))
+- 767b415: 04-lsp-shadow-cache ([`9f9f5fc`](https://github.com/briancray/abide/commit/9f9f5fc84792204259d591fa4aff261b2a19c46d))
+- 767b415: 13-dev-rebuild-scoping-JUDGMENT ([`b5a1d49`](https://github.com/briancray/abide/commit/b5a1d49e6607a8fcf37efe03e9fe6f6b2c31ea45))
+- 767b415: gate skeleton fragment-staging on a connected parent ([`c9380ee`](https://github.com/briancray/abide/commit/c9380eebdd9f6773ccffd446665b1acbc78b1123))
+- 767b415: 07-debug-gate ([`c96466e`](https://github.com/briancray/abide/commit/c96466e73ea1f521d728b11aac44262530c3b09c))
+- 767b415: rename paint's escape var to avoid shadowing the global ([`caf1322`](https://github.com/briancray/abide/commit/caf1322adc6598bc6ea32e0ba9047ba768b6f5e1))
+- 767b415: reflow generateBuild attr-kind union to biome's multiline form ([`f9b3669`](https://github.com/briancray/abide/commit/f9b36690e4add2c955abb8f0127a9af9d513be53))
+- 767b415: 01-bugs-B1-B2 ([`fa8659d`](https://github.com/briancray/abide/commit/fa8659d276265c0fbb4f7ca0740fc74702f00168))
+- 767b415: address code-review findings ([`fb02df5`](https://github.com/briancray/abide/commit/fb02df58c924d7206fce35874cc80309949c9e59))
+- 767b415: 11-server-log-micro ([`fb689bc`](https://github.com/briancray/abide/commit/fb689bc05bee9ba127ddf206e925e3a9e04841fd))
+
+## 0.44.0
+
+### Minor Changes
+
+- 24444a8: add zod→CommonJS shim plugin for bun ESM-cycle bug ([`0424b20`](https://github.com/briancray/abide/commit/0424b20151f4d1a98d7b022bbacbbb974d469b47))
+- 24444a8: {children()} replaces the <slot> element ([`0bdfbe5`](https://github.com/briancray/abide/commit/0bdfbe5c3efd621492cdef09b745f9262c5be937))
+- 24444a8: type page params via props(); declare children in the shadow ([`2e58768`](https://github.com/briancray/abide/commit/2e58768cfbfb5a2be2aec48c77482e7bf5ee1b8d))
+- 24444a8: syntactic markup token classifier and zed grammar tokens ([`5cdef1f`](https://github.com/briancray/abide/commit/5cdef1f81762d9c1b8c63a418499335c6524b0a5))
+- 24444a8: {#snippet} block replaces <template name> declarations ([`620c2c3`](https://github.com/briancray/abide/commit/620c2c3ba7d8b797ccb770664db47468e4265131))
+- 24444a8: wire {#if children} lowering; migrate snippet/slot test fixtures ([`861b30b`](https://github.com/briancray/abide/commit/861b30be19deb83b5749b8bb2ca8dd526b29b1b3))
+- 24444a8: page/layout params as reactive props() thunks; layout {#if children} ([`991cea7`](https://github.com/briancray/abide/commit/991cea79a08b09508285769a35494b03111b5113))
+- 24444a8: attribute and prop value interpolation ([`ae0a3da`](https://github.com/briancray/abide/commit/ae0a3daa13411d6de71917efde4cb76c57c855c7))
+- 24444a8: {#if children} lowers children to $props.$children ([`f749f47`](https://github.com/briancray/abide/commit/f749f47836cdf69ccbc51d7b7fb9fafa7d7189a4))
+
+### Patch Changes
+
+- 24444a8: effect queue Set -> double-buffered array ([`03c6d09`](https://github.com/briancray/abide/commit/03c6d09334559a2a24c3c953cbf57e5f231ea9c6))
+- 24444a8: prune each reconcile by generation stamp, not a per-pass Set ([`1b48eed`](https://github.com/briancray/abide/commit/1b48eedc9b1657946321cad8c9843930b0bec5d0))
+- 24444a8: accumulated working-tree changes ([`1df2999`](https://github.com/briancray/abide/commit/1df2999b3f4b381334d365b1ff2df53711ad6b50))
+- 24444a8: Breaking: reserve $$ injected namespace, relocate html to abide/ui/html ([`1ef8c2a`](https://github.com/briancray/abide/commit/1ef8c2a047cfaf086df1676d498cdcd2bcbe45d0))
+- 24444a8: shadow block value-params on both back-ends ([`25f719a`](https://github.com/briancray/abide/commit/25f719a17c69aee71e2bc7884080231c35ef6578))
+- 24444a8: shared element-emission plan across build/SSR backends ([`2a6cec5`](https://github.com/briancray/abide/commit/2a6cec5361051c1da021dba50ce40a656106e5a7))
+- 24444a8: typed auto-popping shadow scope for compile lowering ([`2fd04a0`](https://github.com/briancray/abide/commit/2fd04a0ed8dc5453461efa0af920d046549a8877))
+- 24444a8: dedup deref-scope push/pop into withScoped ([`3552fff`](https://github.com/briancray/abide/commit/3552fffd2dc2e69708b8268b42609c4e971eb932))
+- 24444a8: lower await {:finally} outside the then/catch value-param shadow ([`4b33813`](https://github.com/briancray/abide/commit/4b33813433fc42455c6b069da1eb118d71b9af1b))
+- 24444a8: iterate mark down single-subscriber chains ([`4ca3fd4`](https://github.com/briancray/abide/commit/4ca3fd419d58667eb074dd033afc2e29b10f56cd))
+- 24444a8: unify warm-seed shippability + decode symmetry ([`5675e37`](https://github.com/briancray/abide/commit/5675e37ec240ab785e3e83eed7b2723f6dcce090))
+- 24444a8: accumulated feat/arch-deepening working-tree changes ([`60cef30`](https://github.com/briancray/abide/commit/60cef30c2405db94ded7e708abddf2c18b4db555))
+- 24444a8: clear typecheck and lint errors in the arch-deepening compile/dom backlog ([`782fb42`](https://github.com/briancray/abide/commit/782fb42769e495addd57904ccd1fb0148f81f9bb))
+- 24444a8: add eachPlan + snippetPlan, route structure through plans (phase 1) ([`8cfffcc`](https://github.com/briancray/abide/commit/8cfffcc958b63b62da51e670f8f8f4c64a3ca5e5))
+- 24444a8: {children()}/{#snippet}/props() route params ([`8f1dc89`](https://github.com/briancray/abide/commit/8f1dc89bfbf052c07082b939e893c9aee65aeea9))
+- 24444a8: single-source bindings via plans + withBindings, exhaustive dispatch (phase 2) ([`9228e30`](https://github.com/briancray/abide/commit/9228e30d4ba16c3ef1bc14b7d243b9628bde1b59))
+- 24444a8: resolve each key to its row once per reconcile ([`ce3e160`](https://github.com/briancray/abide/commit/ce3e160c8837ec5df4cf5cf625c1db50402defde))
+- 24444a8: reorganize kitchen-sink nav and refresh README/scaffold ([`e31ba15`](https://github.com/briancray/abide/commit/e31ba159d9cc1db88cdebb96f40ff8d5c89b7e0f))
+- 24444a8: scope the children slot reader through the signal transformer ([`e4a901d`](https://github.com/briancray/abide/commit/e4a901da9858f3b307363f98c97c3e72c3569640))
+- 24444a8: faster structural descend via no-alloc walkPath + suffix walk ([`ef14dac`](https://github.com/briancray/abide/commit/ef14dace7c4eb870fe9b0487d4111ecfe635831c))
+- 24444a8: elementPlan over skeletonContext, share emission decisions (phase 3) ([`f75703e`](https://github.com/briancray/abide/commit/f75703e0a276c37ce1fbbfde6b4c4b6064d551b8))
+- 24444a8: effect is not ambient — it is a scope primitive ([`f8942ed`](https://github.com/briancray/abide/commit/f8942ed675d6d6493b3d53bd1cc4e991d1d1b7dd))
+
 ## 0.43.1
 
 ### Patch Changes

package/README.md

@@ -1,29 +1,38 @@
 # abide
 
-**One typed declaration fans out to an HTTP endpoint, a CLI subcommand, an MCP tool, and an OpenAPI operation — and the same callable runs on the server and in the browser.**
+**One typed declaration fans out to HTTP, a CLI, an MCP tool, and an OpenAPI
+operation — and the same callable runs on the server and in the browser.**
 
-abide is a type-safe isomorphic framework on Bun and web standards. You declare an RPC, a socket, or a `.abide` component once; the bundler swaps the runtime per side (in-process on the server, a typed `fetch` proxy in the browser) so the name, the call, and the behaviour are identical wherever you import it. Built for humans *and* the machines that now read and drive software.
+abide is an isomorphic, multimodal HTTP framework for a single Bun runtime: you
+declare a typed RPC once and it becomes a browser fetch, an in-process SSR call,
+an MCP tool, a CLI subcommand, and an OpenAPI operation; the bundler swaps the
+runtime per side so the same name behaves the same on both. Built for humans
+*and* machines.
 
-- One direct dependency (TypeScript). Bun is the only runtime — no Node, no separate bundler, no dev server to wire up.
+- One direct dependency (TypeScript). One runtime (Bun ≥ 1.3).
+- `.abide` single-file components render on the server and hydrate in place.
 
 ## Quick start
 
 ```sh
-bunx abide scaffold my-app   # scaffolds the project, installs it, and starts dev
+bunx abide scaffold my-app   # scaffolds, installs, and starts the dev server
 ```
 
-Or read the runnable tour — every primitive below, live:
+Or clone the kitchen-sink example:
 
 ```sh
-git clone git@github.com:briancray/abide.git
+git clone https://github.com/briancray/abide
 cd abide/examples/kitchen-sink
 bun install
-bun dev
+bun run dev
 ```
 
 ## RPCs
 
-An RPC is one export per file under `src/server/rpc/`. The file path is the URL (`getMessages.ts` → `/rpc/getMessages`), and a Standard Schema (zod / valibot / arktype, unadapted) validates the args once and projects the same declaration into every surface.
+An RPC is one export under `src/server/rpc/`. The file path is the URL; the
+export's schema validates the args and projects the MCP tool, the CLI flags, and
+the OpenAPI operation. The schema contract is Standard Schema — pass a zod,
+valibot, or arktype schema directly, unadapted.
 
 ```ts
 // src/server/rpc/getMessages.ts
@@ -31,97 +40,212 @@ import { GET } from '@abide/abide/server/GET'
 import { json } from '@abide/abide/server/json'
 import { z } from 'zod'
 
-const inputSchema = z.object({ room: z.string() })
-
-export const getMessages = GET(({ room }) => json(db.messages(room)), { inputSchema })
+export const getMessages = GET(
+  async ({ channel }) => json(await db.recentMessages(channel)),
+  { inputSchema: z.object({ channel: z.coerce.string() }) },
+)
 ```
 
-That single declaration fans out:
+One declaration, every surface:
 
 ```text
-      export const getMessages = GET(fn, { inputSchema })
-                            │
-  ┌────────────┬────────────┬────────────┬────────────┐
-  ▼            ▼            ▼            ▼            ▼
-  SSR call     browser      MCP tool     CLI cmd      OpenAPI
-  cache(fn)()  fetch proxy  (read-only)  abide cli    /openapi.json
+                  export const getMessages = GET(fn, { inputSchema })
+                                     │
+       ┌───────────────┬─────────────┼─────────────┬───────────────┐
+       ▼               ▼             ▼             ▼               ▼
+   SSR call       browser fetch   MCP tool     CLI command     OpenAPI op
+ cache(fn)()     typed proxy    (read-only)   getMessages …  /openapi.json
+ (in-process)    (swapped fn())
 ```
 
-The schema is the gate: it unlocks the CLI and — for read-only methods (GET/HEAD) — the MCP tool automatically. A mutating method (POST/PUT/PATCH/DELETE) never auto-exposes to MCP; it opts in with `clients: { mcp: true }`. Consume a call four ways: `cache(getMessages)()` in-process (warm SSR + hydration), the swapped `fetch` proxy in the browser, `getMessages.raw(args)` for the untouched `Response`, and `getMessages.stream(args)` for a frame stream.
+A schema unlocks the CLI for any method and auto-exposes read-only methods
+(`GET`/`HEAD`) as MCP tools; a mutating method (`POST`/`PUT`/`PATCH`/`DELETE`)
+never auto-exposes to MCP — it needs an explicit `clients: { mcp: true }`.
+Consume the RPC four ways: `cache(getMessages)({ channel })` in-process during
+SSR, the swapped `fetch` proxy in the browser, `getMessages.raw(args)` for the
+underlying `Response`, and `getMessages.stream(args)` for a frame iterable.
 
-> Query args travel as strings — use `z.coerce.*` for numbers/booleans on GET/DELETE/HEAD. A per-RPC `timeout` (a 504 on every surface) is distinct from the client-wide `ABIDE_CLIENT_TIMEOUT`.
+> Query args travel as strings — validate with `z.coerce.*`. A per-RPC
+> `timeout` (504 on every surface) is distinct from the client-side
+> `ABIDE_CLIENT_TIMEOUT`.
 
 ## Sockets
 
-A socket is one broadcast topic per file under `src/server/sockets/`. A `Socket<T>` is an isomorphic `AsyncIterable<T>` — `for await (const m of chat)` is the live stream — and every socket multiplexes onto one WebSocket at `/__abide/sockets`.
+A socket is one broadcast topic per file under `src/server/sockets/`. A
+`Socket<T>` is an isomorphic `AsyncIterable<T>` — `for await (const m of chat)`
+is the live stream — and every socket multiplexes onto one WebSocket at
+`/__abide/sockets`.
 
 ```ts
 // src/server/sockets/chat.ts
 import { socket } from '@abide/abide/server/socket'
 import { z } from 'zod'
 
-const schema = z.object({ from: z.string(), text: z.string(), at: z.number() })
-
-// tail: retain the last 100 frames for late joiners; ttl: evict frames older than an hour.
-export const chat = socket({ schema, tail: 100, ttl: 3_600_000 })
-export type ChatMessage = z.infer<typeof schema>
+export const chat = socket({
+  schema: z.object({ id: z.string(), author: z.string(), text: z.string() }),
+  tail: 50,        // retain the last 50 frames for replay
+  ttl: 60_000,     // evict retained frames older than 60s
+})
 ```
 
-Each socket also has an HTTP face at `/__abide/sockets/<name>`: `GET` returns the retained tail, `POST` publishes (only when the socket declares `clientPublish`). `chat.publish(m)` is isomorphic — server-side it fans out in-process and to remote subscribers; client-side it sends a validated `pub` frame.
+Each socket also has an HTTP face at `/__abide/sockets/<name>`: `GET` returns the
+retained tail, `POST` publishes a frame (gated by `clientPublish`).
 
 ## Components
 
-A component is a `.abide` file: valid HTML with a `<script>`, `{#…}` control-flow blocks, `<template name>` snippets, `{expr}` bindings, and a component-scoped `<style>`. This page imports the RPC and socket above — `cache(getMessages)` seeds the list warm at SSR, `tail(chat)` layers live frames on top after hydration.
+A `.abide` component renders on the server and hydrates in the browser. The page
+below imports the RPC and the socket above and exercises the whole template
+grammar. Reactive state is reached through `scope()` — the documented default is
+to destructure it once at the top of the `<script>` and call the primitives bare.
 
 ```html
 <script>
-import { cache } from '@abide/abide/shared/cache'
-import { tail } from '@abide/abide/ui/tail'
-import { getMessages } from '$server/rpc/getMessages.ts'
-import { createMessage } from '$server/rpc/createMessage.ts'
-import { chat } from '$server/sockets/chat.ts'
-import Avatar from '$ui/Avatar.abide'
-
-const { room = 'lobby' } = props()
-const { state, computed } = scope()
-
-let draft = state('')
-let notify = state(true)
-const live = computed(() => tail(chat))            // read-only derived
-const ready = computed(() => draft.trim().length > 0)
-
-async function send(event: SubmitEvent) {
-    event.preventDefault()
-    await createMessage({ room, text: draft, notify })
+  import { cache } from '@abide/abide/shared/cache'
+  import { tail } from '@abide/abide/ui/tail'
+  import { html } from '@abide/abide/ui/html'
+  import { getMessages } from '$server/rpc/getMessages'
+  import { sendMessage } from '$server/rpc/sendMessage'
+  import { chat } from '$server/sockets/chat'
+  import Card from '$ui/Card.abide'
+  import Message from '$ui/Message.abide'
+  import Risky from '$ui/Risky.abide'
+
+  // props() is the ambient prop reader — no import; destructure with defaults + rest
+  const { channel = 'general', ...rest } = props()
+
+  // destructure-once: reach every reactive primitive through scope(), then call bare
+  const { state, computed, linked, effect } = scope()
+
+  let draft = state('')
+  let count = state(0)
+  let muted = state(false)
+  let topic = state('all')
+  const doubled = computed(() => count * 2)
+  const banner = linked(() => `# ${channel}`)
+
+  // live reads off the §3 socket: latest frame, plus a window of the last 20
+  const latest = tail(chat)
+  const recent = tail(chat, { last: 20 })
+
+  // effect runs client-only (stripped from SSR)
+  effect(() => {
+    document.title = `${channel} (${count})`
+  })
+
+  // an event handler calling a mutating RPC
+  async function send() {
+    await sendMessage({ channel, text: draft })
     draft = ''
-}
-</script>
+    count = count + 1
+  }
 
-<template name="row" args={{ msg }}>
-    <li><Avatar name={msg.from} /> {msg.text}</li>
-</template>
+  // the derived two-way binding's accessors
+  const get = () => count
+  const set = (value) => (count = Number(value))
 
-<form onsubmit={send}>
-    <input bind:value={draft} placeholder="message" />
-    <label><input type="checkbox" bind:checked={notify} /> notify</label>
-    <button disabled={!ready()}>Send</button>
-</form>
-
-{#if live()}<p class="muted">latest: {live().text}</p>{/if}
+  // an attachment: runs against the element at mount
+  const focus = (node) => node.focus()
+</script>
 
-{#await cache(getMessages)({ room })}
-    <p>Loading…</p>
-{:then messages}
+<main {...rest}>
+  <h1 class:muted={muted} style:opacity={muted ? 0.5 : 1}>{banner}</h1>
+  <p>seen {count} — doubled {doubled}</p>
+  <p>{html`<em>latest:</em> ${latest?.text ?? '—'}`}</p>
+
+  <form onsubmit={send}>
+    <input bind:value={draft} attach={focus} placeholder="message" />
+    <label><input type="checkbox" bind:checked={muted} /> mute</label>
+    <label><input type="radio" bind:group={topic} value="all" /> all</label>
+    <label><input type="radio" bind:group={topic} value="mine" /> mine</label>
+    <input type="range" min="0" max="50" bind:value={{ get, set }} />
+    <button>send</button>
+  </form>
+
+  {#snippet row(message)}
+    <li>{html`<strong>${message.author}</strong>`}: {message.text}</li>
+  {/snippet}
+
+  {#if recent.length === 0}
+    <p>No messages yet.</p>
+  {:else if muted}
+    <p>Muted — {recent.length} hidden.</p>
+    <script>
+      // a nested script scoped to this branch — its own scope(), no imports
+      const { computed } = scope()
+      const note = computed(() => `${recent.length} while muted`)
+    </script>
+    <small>{note}</small>
+    <style>
+      small { color: gray; }
+    </style>
+  {:else}
     <ul>
-        {#for msg of messages by msg.at}{row({ msg })}{/for}
+      {#for message, i of recent by message.id}
+        <Card title={`#${i}`}>{row(message)}</Card>
+      {/for}
     </ul>
-{:catch error}
-    <p class="error">{error.message}</p>
-{/await}
+  {/if}
+
+  <h2>filter</h2>
+  {#switch topic}
+    {:case 'all'}<p>showing everything</p>
+    {:case 'mine'}<p>showing mine</p>
+    {:default}<p>unknown filter</p>
+  {/switch}
+
+  <h2>history</h2>
+  {#await cache(getMessages)({ channel })}
+    <p>loading…</p>
+  {:then list}
+    <ul>
+      {#for entry of list by entry.id}
+        <Message {...entry} />
+      {/for}
+    </ul>
+  {:catch error}
+    <p>failed: {error.message}</p>
+  {:finally}
+    <hr />
+  {/await}
+
+  <h2>live</h2>
+  <ul>
+    {#for await frame of chat}
+      <li>{frame.text}</li>
+    {/for}
+  </ul>
+
+  {#try}
+    <Risky />
+  {:catch error}
+    <p>widget crashed: {error.message}</p>
+  {:finally}
+    <span>boundary settled</span>
+  {/try}
+</main>
+
+<style>
+  main { font-family: system-ui; }
+  .muted { text-decoration: line-through; }
+</style>
+```
+
+A capitalised tag is a child component; the content nested inside it renders
+where the child calls `{children()}` (the `<slot>` element was removed — there
+are no named slots). `{#if children}…{:else}…{/if}` is the fallback form:
+
+```html
+<script>
+  const { title = 'Card' } = props()
+</script>
+
+<section class="card">
+  <h3>{title}</h3>
+  {#if children}{children()}{:else}<p>empty</p>{/if}
+</section>
 
 <style>
-    .muted { color: #64748b; }
-    .error { color: #b91c1c; }
+  .card { border: 1px solid #ddd; }
 </style>
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.43.1",
+    "version": "0.44.1",
     "type": "module",
     "sideEffects": false,
     "description": "Isomorphic multimodal HTTP framework built for humans and machines in a single Bun runtime",
@@ -63,7 +63,6 @@
         "./shared/refreshing": "./src/lib/shared/refreshing.ts",
         "./shared/HttpError": "./src/lib/shared/HttpError.ts",
         "./shared/ValidationErrorData": "./src/lib/shared/types/ValidationErrorData.ts",
-        "./shared/html": "./src/lib/shared/html.ts",
         "./shared/snippet": "./src/lib/shared/snippet.ts",
         "./shared/withJsonSchema": "./src/lib/shared/withJsonSchema.ts",
         "./shared/health": "./src/lib/shared/health.ts",
@@ -73,6 +72,7 @@
         "./shared/trace": "./src/lib/shared/trace.ts",
         "./shared/url": "./src/lib/shared/url.ts",
         "./shared/createSubscriber": "./src/lib/shared/createSubscriber.ts",
+        "./ui/html": "./src/lib/ui/html.ts",
         "./ui/effect": "./src/lib/ui/effect.ts",
         "./ui/scope": "./src/lib/ui/scope.ts",
         "./ui/enterScope": "./src/lib/ui/enterScope.ts",

package/src/abideLsp.ts

@@ -7,6 +7,7 @@ import type {
 } from './lib/ui/compile/createShadowLanguageService.ts'
 import { createShadowLanguageService } from './lib/ui/compile/createShadowLanguageService.ts'
 import { encodeSemanticTokens } from './lib/ui/compile/encodeSemanticTokens.ts'
+import { markupTokens } from './lib/ui/compile/markupTokens.ts'
 import { nearestProjectRoot } from './lib/ui/compile/nearestProjectRoot.ts'
 import { offsetToPosition } from './lib/ui/compile/offsetToPosition.ts'
 import { structuralBlockTokens } from './lib/ui/compile/structuralBlockTokens.ts'
@@ -24,10 +25,12 @@ nearest tsconfig, so files in a monorepo opened at its root are checked against
 their own project — matching `abide check` run from that package.
 */
 /*
-The semantic-tokens `data` array for one component: the structural `{#…}` framing
-merged with the shadow's type-aware expression tokens, encoded to the LSP wire
-format. Never throws — on any internal failure it yields an empty stream so the
-editor falls back to tree-sitter highlighting.
+The semantic-tokens `data` array for one component: the HTML markup structure and
+the structural `{#…}` framing merged with the shadow's type-aware expression
+tokens, encoded to the LSP wire format. The markup tokens make the LSP own the
+element/attribute coloring too, so a tree-sitter parse desynced by an `attr={expr}`
+value can't bleed miscoloring below it. Never throws — on any internal failure it
+yields an empty stream so the editor falls back to tree-sitter highlighting.
 */
 export function componentSemanticTokens(
     service: ShadowLanguageService,
@@ -36,6 +39,7 @@ export function componentSemanticTokens(
 ): number[] {
     try {
         const tokens = [
+            ...markupTokens(text),
             ...structuralBlockTokens(text),
             ...service.semanticClassifications(abidePath),
         ]

package/src/abideResolverPlugin.ts

@@ -84,12 +84,22 @@ Bun plugin that wires every virtual import abide produces at build time:
 - `abide:rpc`     — { rpcUrl: () => import(rpc-module) } HTTP-method manifest
 - `abide:sockets` — { socketName: () => import(socket-module) } socket manifest
 - `abide:pages`   — { pageUrl: () => import(page.abide) } manifest
+- `abide:layouts` — { layoutUrl: () => import(layout.abide) } layout manifest
 - `abide:prompts` — { promptName: () => import(prompt-module) } manifest
-- `abide:app`     — { init?, handle?, handleError? } from src/app.ts
+- `abide:app`     — { init?, handle?, handleError?, health?, forwardHeaders? } from src/app.ts
+- `abide:config`  — re-exports src/server/config.ts for boot-time env validation
 - `abide:assets`  — gzip-compressed chunk bytes embedded for standalone compile
 - `abide:public-assets`  — gzip-embedded src/ui/public files
 - `abide:mcp-resources`  — gzip-embedded src/mcp/resources files
+- `abide:mcp`     — generated MCP server (createMcpServer)
 - `abide:shell`   — app.html content (custom or default)
+- `abide:app-info`    — { name, version } from package.json for OpenAPI info
+- `abide:cli-manifest` — baked per-rpc manifest for the CLI binary
+- `abide:cli-name`     — program name from package.json
+- `abide:cli-chrome`   — banner/footer text from src/cli/
+- `abide:bundle-window`               — optional bundle window config
+- `abide:bundle-disconnected`         — baked connect-screen HTML
+- `abide:bundle-disconnected-component` — connect-screen abide-ui component
 
 Also rewrites modules under src/server/rpc and src/server/sockets:
 - src/server/rpc/<file>.ts: each HTTP-method export is bound to a runtime
@@ -247,10 +257,15 @@ export function abideResolverPlugin({
     return {
         name: 'abide-resolver',
         setup(build) {
-            /* Fresh edge graph each build (dev watch reuses the plugin instance).
+            /* Fresh edge graph + resolution cache each build (dev watch reuses the
+               plugin instance). The resolution cache memoises (path → resolved file)
+               within a build; clearing it per build keeps the memo but stops a stale
+               miss — a path resolved before its file existed — surviving into the next
+               build, so a freshly-created file resolves instead of staying "not found".
                onStart is build-time only — absent in the runtime/preload plugin context. */
             build.onStart?.(() => {
                 importerOf.clear()
+                resolveExtensionCache.clear()
             })
 
             /*

package/src/build.ts

@@ -40,12 +40,14 @@ export async function build({
     compress = true,
     clean = true,
     exitOnFailure = true,
+    dev = false,
 }: {
     cwd?: string
     minify?: boolean
     compress?: boolean
     clean?: boolean
     exitOnFailure?: boolean
+    dev?: boolean
 } = {}): Promise<boolean> {
     const distDir = `${cwd}/dist`
     const outDir = `${distDir}/_app`
@@ -84,6 +86,13 @@ export async function build({
                 chunk: '[name]-[hash].[ext]',
                 asset: '[name].[ext]',
             },
+            /* Build-time flag the client reads to fold away dev-only machinery: production
+               (`dev: false`) defines it false so the hot-reload subtree — mountChild's
+               record path, hotReplace, captureModelDoc — dead-code-eliminates instead of
+               shipping behind a runtime flag the minifier can't prove. Dev defines it true
+               to keep HMR. Under `bun test` no define applies; the source falls back to true
+               so `hotReloadEnabled` alone governs (see startClient/mountChild). */
+            define: { __ABIDE_DEV__: dev ? 'true' : 'false' },
             plugins,
         })
 

package/src/buildDisconnected.ts

@@ -51,6 +51,8 @@ export async function buildDisconnected({
         entrypoints: [ENTRY, CSS_ENTRY],
         target: 'browser',
         minify: true,
+        // Connect screen ships in production bundles only — fold dev-only machinery out.
+        define: { __ABIDE_DEV__: 'false' },
         plugins,
     })
     exitOnBuildFailure(result)

package/src/devEntry.ts

@@ -6,6 +6,7 @@ import { DEV_READY_MESSAGE } from './lib/server/runtime/DEV_READY_MESSAGE.ts'
 import { DEV_REBUILD_MESSAGE } from './lib/server/runtime/DEV_REBUILD_MESSAGE.ts'
 import { findOpenPort } from './lib/server/runtime/findOpenPort.ts'
 import { abideLog } from './lib/shared/abideLog.ts'
+import { changeAffectsClient } from './lib/shared/changeAffectsClient.ts'
 
 /*
 Dev orchestrator. Replaces `bun --watch` (which only watches the import graph,
@@ -63,6 +64,7 @@ const buildOptions = {
     compress: false,
     clean: false,
     exitOnFailure: false,
+    dev: true,
 } as const
 
 // The worker currently meant to be serving; undefined while crashed or replaced.
@@ -173,30 +175,51 @@ async function replaceServer(port: number): Promise<void> {
 
 let building = false
 let queued = false
+// True once any change collapsed into the queued run needs the client rebuilt;
+// a client-affecting change can never be downgraded to a server-only restart.
+let queuedNeedsClient = false
 
 /*
-Rebuild the client, then (on success) swap in a fresh server child. Serialized:
-a change arriving mid-build sets `queued` so exactly one more rebuild runs
-after, collapsing any further changes in between. A failed build leaves the
-current child untouched — the error is logged and the last-good server keeps
-serving.
+Apply a change: rebuild the client (unless `skipClientBuild` — a server/MCP-only
+change leaves the client bundle byte-identical), then on success swap in a fresh
+server child. The worker restart always runs: SSR renders through Bun's module
+cache, so a new process is the only reliable way to reflect any source edit,
+client-affecting or not.
+
+Serialized: a change arriving mid-build sets `queued` so exactly one more run
+follows, collapsing further changes in between; `queuedNeedsClient` records
+whether any of them needs the client, so the collapsed run never skips a client
+rebuild a queued change required. A failed build leaves the current child
+untouched — the error is logged and the last-good server keeps serving.
 */
-async function rebuild(port: number): Promise<void> {
+async function rebuild(port: number, skipClientBuild = false): Promise<void> {
     if (building) {
         queued = true
+        queuedNeedsClient ||= !skipClientBuild
         return
     }
     building = true
     try {
-        const succeeded = await build(buildOptions)
+        const succeeded = skipClientBuild ? true : await build(buildOptions)
         if (succeeded) {
             await replaceServer(port)
         }
+        /* A server/MCP-only change reuses the existing client bundle. That's correct for
+           an rpc/socket handler BODY edit, but changing an rpc's method, its export name,
+           or `outbox: true` changes the client proxy stub too — the stale bundle then
+           calls with the old shape (e.g. a 405). Flag the skip so that case isn't silent. */
+        if (skipClientBuild) {
+            abideLog.info(
+                'server-only change — kept the existing client bundle; if you changed an rpc method, export name, or outbox, save a client file (or restart dev) for a full rebuild',
+            )
+        }
     } finally {
         building = false
         if (queued) {
             queued = false
-            void rebuild(port)
+            const needsClient = queuedNeedsClient
+            queuedNeedsClient = false
+            void rebuild(port, !needsClient)
         }
     }
 }
@@ -222,14 +245,26 @@ an agent editing the app's own source — isn't yanked mid-run by a save.
 const manualRebuild = Bun.env.ABIDE_DEV_NO_WATCH === '1'
 
 let debounce: ReturnType<typeof setTimeout> | undefined
+/*
+True only while every change collapsed into the pending debounce is server/MCP-
+only; one client-affecting change in the burst flips it false (latches until the
+debounce fires), so a multi-file save that touches the client never skips the
+client rebuild.
+*/
+let pendingSkipClientBuild = true
 const watcher = manualRebuild
     ? undefined
     : watch(SOURCE_DIR, { recursive: true }, (_event, filename) => {
           if (!filename || isGenerated(filename)) {
               return
           }
+          pendingSkipClientBuild &&= !changeAffectsClient(filename)
           clearTimeout(debounce)
-          debounce = setTimeout(() => void rebuild(port), REBUILD_DEBOUNCE_MS)
+          debounce = setTimeout(() => {
+              const skipClientBuild = pendingSkipClientBuild
+              pendingSkipClientBuild = true
+              void rebuild(port, skipClientBuild)
+          }, REBUILD_DEBOUNCE_MS)
       })
 if (manualRebuild) {
     abideLog.info(