@abide/abide 0.43.0 → 0.44.0

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # abide
 
+## 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
+
+- 943402b: restore reload scroll flash-free via native restoration ([`876b99c`](https://github.com/briancray/abide/commit/876b99cd6e285b6a41afe87ca053cf0631099c03))
+- ed96096: abide check: quote hyphenated component prop keys (`aria-label`, `data-*`) so the props shim parses, and treat `on*` callbacks as ordinary declared props (not DOM passthrough) so a passed required `onsave`/`oncancel` no longer reads as missing while an undeclared handler is still caught
+
 ## 0.43.0
 
 ### Minor 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.0",
+    "version": "0.44.0",
     "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

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

@@ -63,6 +63,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.

package/src/lib/bundle/probeAbideServer.ts

@@ -10,7 +10,7 @@ Confirms a URL points at a abide server before the launcher navigates the app
 window there, by fetching its unauthenticated health endpoint. Returns the
 server's identity on success, or undefined when nothing abide answers — a network
 error, the wrong port, or a non-abide page (a bare 403/404, a different app, a
-captive portal's 200 — hence the `abide: true` body check, never response.ok
+captive portal's 200 — hence the `abide: true` (or version string) body check, never response.ok
 alone). The endpoint bypasses the app's own middleware, so an auth-guarded abide
 app still verifies here even though its pages would later redirect to a login.
 Probes HEALTH_PATH first, falling back to the IDENTITY_PATH alias so a newer

package/src/lib/cli/parseArgvForRpc.ts

@@ -9,8 +9,10 @@ on the manifest entry (when present) drives flag typing:
 
 For complex shapes (nested objects, unions, anyOf) the CLI exposes
 `--json <stringified-args>` as an escape hatch that supplies the whole
-args bag verbatim. Stdin: if a JSON object arrives piped in, it's used
-as the full args bag (flags layer on top).
+args bag verbatim. Stdin: if a JSON object arrives piped in with no argv flags, it is used
+as the full args bag. Stdin and flags are mutually exclusive — stdin is
+skipped when argv is non-empty to avoid hanging on a pipe that never
+sends EOF.
 
 Unrecognised flags throw — early loud feedback is more useful than
 silent drops.

package/src/lib/cli/types/CliManifest.ts

@@ -1,9 +1,11 @@
 import type { CliManifestEntry } from './CliManifestEntry.ts'
 
 /*
-Map from rpc export-name (e.g. "getReport") to its manifest entry. Built
-by the bundler from the same rpcRegistry MCP consumes; entries are
-emitted only for rpcs with `clients.cli: true`. The CLI binary and any
-programmatic createClient caller read this to dispatch calls.
+Map from command name (URL-derived via commandNameForUrl, e.g. "getReport"
+or "users-list") to its manifest entry. Built by the bundler from
+rpcRegistry and socketRegistry; entries are emitted for rpcs and sockets
+with `clients.cli: true`. Sockets produce `<base>-tail` (and `-publish`
+when `allowClientPublish` is set). The CLI binary and any programmatic
+createClient caller read this to dispatch calls.
 */
 export type CliManifest = Record<string, CliManifestEntry>

package/src/lib/mcp/annotationsForMethod.ts

@@ -2,7 +2,7 @@ import type { HttpMethod } from '../shared/types/HttpMethod.ts'
 
 /*
 Maps an HTTP method to MCP tool annotations so a model can tell a read from
-a write before calling. Abide derives these from the rpc the RPC was
+a write before calling. Abide derives these from the HTTP method the RPC was
 declared with rather than asking the author to repeat the intent:
   - GET / HEAD  → read-only, non-destructive
   - POST        → creates; not idempotent, not (necessarily) destructive

package/src/lib/mcp/toolResultFromResponse.ts

@@ -15,7 +15,7 @@ function asText(value: unknown): string {
 }
 
 /*
-Turns an rpc/socket Response into an MCP `tools/call` result. Always
+Turns an RPC Response into an MCP `tools/call` result. Always
 carries a `text` content block for backward compatibility; adds
 `structuredContent` (an object, per the MCP spec) so models that
 understand structured output get the typed value instead of a stringified

package/src/lib/mcp/types/JsonRpcRequest.ts

@@ -1,8 +1,8 @@
 /*
 JSON-RPC 2.0 request frame as MCP delivers it over Streamable HTTP. The
-`id` is absent for notifications (which we don't currently receive from
-clients but accept silently). `method` is a string like "tools/list" or
-"resources/read".
+`id` is absent for notifications; they are dispatched for their side effect
+and acknowledged with a 202 (JSON-RPC forbids replying with an envelope).
+`method` is a string like "tools/list" or "resources/read".
 */
 export type JsonRpcRequest = {
     jsonrpc: '2.0'

package/src/lib/server/AppModule.ts

@@ -10,7 +10,7 @@ WebSockets are not exposed here — abide's only native WebSocket
 surface is the sockets hub (see `abide/server/socket`), multiplexed onto a
 single framework-owned connection per client at `/__abide/sockets`.
 Inside request scopes, the live Bun.Server is reachable via the
-exported `server()` function from `abide/server`; `init` receives it
+exported `server()` function from `abide/server/server`; `init` receives it
 explicitly because it runs outside a request.
 */
 // @documentation plumbing

package/src/lib/server/cli/handleCliDownload.ts

@@ -92,12 +92,14 @@ async function computeBinary(
 }
 
 /*
-Handles GET /__abide/cli/<platform> — streams a gzipped tarball
-containing the platform-specific thin binary + a `.env` carrying
-ABIDE_APP_URL (and ABIDE_APP_TOKEN if the inbound request was authenticated).
+Handles GET /__abide/cli/<platform> — streams a gzipped tarball containing
+the platform-specific thin binary, the sibling server binary, and a `.env`
+carrying ABIDE_APP_URL (and ABIDE_APP_TOKEN if the inbound request was
+authenticated).
 
-Thin binaries live at `dist/cli-thin/<platform>/<programName>`
-(produced by `abide cli` with ABIDE_APP_URL set). Missing platforms produce
+Thin binaries live at `dist/cli-thin/<platform>/<programName>` (produced
+lazily by `buildCli` on first request). The `.env` baking `ABIDE_APP_URL`
+is generated at download time, not build time. Missing platforms produce
 404 — the install script reports it, doesn't try to fall back.
 */
 export async function handleCliDownload(

package/src/lib/server/cli/installScript.ts

@@ -7,9 +7,9 @@ platform-specific tarball and extracts it into `$ABIDE_INSTALL_DIR`
 (default `~/.local/bin`). The tarball already contains the `.env` next
 to the binary — no separate config write step in the script.
 
-The script is rendered server-side so `<ABIDE_APP_URL>` is the request's own
-origin and the embedded curl URL needs no escaping or quoting beyond
-basic shell hygiene.
+The script is rendered server-side so the request origin is baked into the
+`URL` variable at generation time and the embedded curl URL needs no escaping
+or quoting beyond basic shell hygiene.
 */
 export function installScript(appUrl: string, programName: string): string {
     return `#!/usr/bin/env sh