@abide/abide 0.41.1 → 0.43.0

package/CHANGELOG.md

@@ -1,5 +1,87 @@
 # abide
 
+## 0.43.0
+
+### Minor Changes
+
+- 6453cf9: repurpose the bare outbox() export to the global reactive aggregate ([`003713d`](https://github.com/briancray/abide/commit/003713dab125b3df72d6cf832ec18ea546922c79))
+- 6453cf9: typed navigate params, scope-destructured primitives, precise prop diagnostics ([`0769896`](https://github.com/briancray/abide/commit/07698966147e96970c27e0278e2152a23e48b219))
+- 6453cf9: OutboxEntry type + status ([`08d9b03`](https://github.com/briancray/abide/commit/08d9b036501110ab24c18258cc79364f9ac71ea8))
+- 6453cf9: migrate kitchen-sink to rpc-native outbox; AGENTS.md surface ([`1b8aa3f`](https://github.com/briancray/abide/commit/1b8aa3fe631181e7798d0703eb09a0f22dba0f88))
+- 6453cf9: persist request body + content-type, replay on reload ([`26c309f`](https://github.com/briancray/abide/commit/26c309f20bf573e512b74477ba2319c22218f7d9))
+- 6453cf9: client registry of durable rpc queues ([`2b89c20`](https://github.com/briancray/abide/commit/2b89c20b1f1f1794f90152f46958ee760333bab5))
+- 6453cf9: reject server-only imports in the client bundle with an evidence chain ([`2de1730`](https://github.com/briancray/abide/commit/2de1730872898d320c240a89b570dfaa9acace7a))
+- 6453cf9: name-keyed typed errors via a handler errors ctx ([`62f75a8`](https://github.com/briancray/abide/commit/62f75a8341d61ac9cfd1e7cbeccc66ddec991643))
+- 6453cf9: createOutboxQueue enqueue + reactive/persisted entries ([`88560c9`](https://github.com/briancray/abide/commit/88560c942d0f28623a68ed1315bb2341ad66a9c3))
+- 6453cf9: bundler threads outbox:true into the client proxy emission ([`b279960`](https://github.com/briancray/abide/commit/b27996089f4a3c8786fcd1ade530057a34f086fc))
+- 6453cf9: pending() reflects the durable queue (in-flight or queued) ([`bfa505d`](https://github.com/briancray/abide/commit/bfa505d8d5326f0464be35568ac8ae6fc4bd1901))
+- 6453cf9: class: and style: directives for surgical reactive class/style writes ([`c5ee6d1`](https://github.com/briancray/abide/commit/c5ee6d13faad82ac45c6c1627c6e9435c9c59c5f))
+- 6453cf9: durable return type — outbox:true overload on mutating rpc helpers ([`d916c6b`](https://github.com/briancray/abide/commit/d916c6b5b563ddc4dee07a015cde08d32e6dd750))
+- 6453cf9: outbox:true rpc option, gated to mutating methods ([`e37f2a3`](https://github.com/briancray/abide/commit/e37f2a333e201ef40303dd25bafb9f0ca82dd220))
+- 6453cf9: drain loop — deliver/retry/error/cancel under the entry signal ([`ec32868`](https://github.com/briancray/abide/commit/ec32868eb860b6185f21c196b18f03c7b3605ba8))
+- 6453cf9: durable client invoke path + rpc.outbox face ([`f96a0c0`](https://github.com/briancray/abide/commit/f96a0c025cfda5f6daf713f4d69857854b8f3459))
+
+### Patch Changes
+
+- 6453cf9: notify() forEach callback must not return a value ([`1c7f20f`](https://github.com/briancray/abide/commit/1c7f20fa5b6a24f3a5e90ab20521f7d24ba55d57))
+- 6453cf9: Breaking: rename defineVerb export to defineRpc ([`29fe778`](https://github.com/briancray/abide/commit/29fe7782844e0de15c53fad711d6616cc90a27e0))
+- 6453cf9: rename VERB*\* constants to RPC*\* ([`391687a`](https://github.com/briancray/abide/commit/391687a252a33ba355ba929944cd1a2cef83c1ef))
+- 6453cf9: rename verb-named rpc helpers to rpc ([`4ebdd8f`](https://github.com/briancray/abide/commit/4ebdd8ff862121a48a39fbdb7b2893a14fd52022))
+- 6453cf9: rename verbRegistry to rpcRegistry ([`507adf5`](https://github.com/briancray/abide/commit/507adf5d5ae3a1b66ef85fc495ba1a974a530abf))
+- 6453cf9: rename Verb-named types/helpers/files to Rpc ([`8342e96`](https://github.com/briancray/abide/commit/8342e963babbddcb9a87dcc99fc2e4958dbc5750))
+- 6453cf9: refresh AGENTS surface map ({#…} blocks, scaffold flags, migration error) ([`88cc4d9`](https://github.com/briancray/abide/commit/88cc4d97205bd3de74a08a6dbae3f2221f0275fe))
+- 6453cf9: commit working tree — outbox, rpc errors, compile plans, cache refactor ([`c673dc7`](https://github.com/briancray/abide/commit/c673dc71522e33ad4f9b48f41ac73fa6c4f03a02))
+- 6453cf9: rename HttpVerb type to HttpMethod ([`d64a59a`](https://github.com/briancray/abide/commit/d64a59a045f77c627b98dbb1b3a12b545f3d3c60))
+- 6453cf9: scrub verb from comments, AGENTS.md, and inspector surface (rpc/method) ([`d9356ce`](https://github.com/briancray/abide/commit/d9356ce9eeba6b03d43ef67fc500cf697e34d39c))
+
+## 0.42.0
+
+### Minor Changes
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - reject stray {:…}/{/…} tokens outside a block ([`1b5d54e`](https://github.com/briancray/abide/commit/1b5d54e7798acfa7c9b15ce6b65b0c2b6a8c2c07))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - parse {#switch}/{:case}/{:default} blocks to the switch AST ([`448da38`](https://github.com/briancray/abide/commit/448da3840c120ac3b15d239c090f123c25527fec))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - parse {#for … of … by …} blocks to the each AST ([`7bb2ac8`](https://github.com/briancray/abide/commit/7bb2ac8f3012e3d40cfcbe8ddf277d6a8732ee93))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - LSP semantic-token encoder + extract offsetToPosition ([`7daeb92`](https://github.com/briancray/abide/commit/7daeb926f045058aa452b5f539ddd75b0d8efa67))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - semantic-token legend + TS-classification mapping for abide lsp ([`892f97b`](https://github.com/briancray/abide/commit/892f97bbc6dfd8af9301297276995f7060fe3f9a))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - type-aware semanticClassifications on the shadow language service ([`9377dd2`](https://github.com/briancray/abide/commit/9377dd24d855cde790d960fceef00255904ee926))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - block control-flow grammar formatting + shared helpers ([`b39c0a7`](https://github.com/briancray/abide/commit/b39c0a70696b031b63ef157c67360c2da0fd60b0))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - zed onboarding — auto-install extension + enable semantic tokens ([`b47acc7`](https://github.com/briancray/abide/commit/b47acc7cc106956f115c70b110c29ce017a71cd0))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - parse {#if}/{:else if}/{:else} blocks to the if AST ([`b662397`](https://github.com/briancray/abide/commit/b66239765bae2ec7a24d70bc7b2edbcbe400614c))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - parse {#try}/{:catch}/{:finally} blocks to the try AST ([`b82c3dd`](https://github.com/briancray/abide/commit/b82c3ddaaec3db3941639df952e568f017d6c767))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - Breaking: remove <template> control-flow directives in favor of {#…} blocks ([`bf5cf89`](https://github.com/briancray/abide/commit/bf5cf89813a8dcbc967e1303bd2509e18e701761))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - color of/by connectors in {#for} block heads ([`c958614`](https://github.com/briancray/abide/commit/c9586147f8196e9e6301b14cdb08986b36da2751))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - parse {#await} streaming + blocking blocks to the await AST ([`cfd7ff0`](https://github.com/briancray/abide/commit/cfd7ff0102b2be2ac241a6c0b1965949aa6621bf))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - serve textDocument/semanticTokens/full for .abide ([`e152663`](https://github.com/briancray/abide/commit/e152663dae9e60e13d16f0edf4b0a140a99b1bfb))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - structural {#…} block framing tokenizer ([`e1e85e8`](https://github.com/briancray/abide/commit/e1e85e847e9442f8c6140df5346b1d37f8cfad54))
+
+### Patch Changes
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - point block-construct loc at its primary expression (shadow source-map fidelity) ([`0fb0efa`](https://github.com/briancray/abide/commit/0fb0efab43639331c856969fdb6a7b83bd7ab604))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - unify block/branch child-scan loops behind a shared helper ([`4683098`](https://github.com/briancray/abide/commit/4683098df96edd0321dc66d200372e0fbedce2e2))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - document {#…} control-flow blocks in the AGENTS surface map ([`68fe96f`](https://github.com/briancray/abide/commit/68fe96f3294a228b91eef5cde37c0300673eb88a))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - map {#for}/{:then}/{:catch} bindings + by-key to source so hover & semantic tokens land on them ([`e8447e8`](https://github.com/briancray/abide/commit/e8447e8d54934737b80c2f49d4f4d1b134786531))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - map <template args> snippet param + await/try {:catch} bindings (+ index/catch/snippet tests) ([`f724d10`](https://github.com/briancray/abide/commit/f724d101f5baed79de2d39a1ab9598eb9d1eb818))
+
+- [`568956c`](https://github.com/briancray/abide/commit/568956c88ff1d32ca79a2aa8a1a0ffffeb25afe3) - satisfy noUncheckedIndexedAccess in block-token + shadow paths ([`fbb6e44`](https://github.com/briancray/abide/commit/fbb6e4443932e92277fb332b639c746663c7759b))
+
 ## 0.41.1
 
 ### Patch Changes

package/README.md

@@ -1,171 +1,127 @@
 # abide
 
-**One typed declaration fans out to HTTP, a CLI, an MCP tool, and an
-OpenAPI spec — the bundler swaps the runtime per side.**
+**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.**
 
-abide is an isomorphic framework on Bun where you write a function once and
-it serves every consumer: a browser fetch, an in-process SSR call, a CLI
-subcommand, an MCP tool, an OpenAPI operation. The same callable keeps its
-name and behaviour on both sides — the bundler decides whether it runs the
-real handler or a network proxy. Built for humans _and_ machines.
+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.
 
-- One direct dependency (`typescript`); `tailwindcss` + `bun-plugin-tailwind`
-  are optional peers. Single runtime: Bun ≥ 1.3.0.
+- One direct dependency (TypeScript). Bun is the only runtime — no Node, no separate bundler, no dev server to wire up.
 
 ## Quick start
 
 ```sh
-bunx abide scaffold my-app   # scaffolds, installs deps, and starts dev
+bunx abide scaffold my-app   # scaffolds the project, installs it, and starts dev
 ```
 
-Or read the full feature tour in the kitchen-sink example:
+Or read the runnable tour — every primitive below, live:
 
 ```sh
-git clone https://github.com/briancray/abide
+git clone git@github.com:briancray/abide.git
 cd abide/examples/kitchen-sink
 bun install
-bun run dev
+bun dev
 ```
 
 ## RPCs
 
-An RPC is one export per file under `src/server/rpc/`. The file path is the
-URL; the export name is the verb. A Standard Schema (zod / valibot / arktype,
-unadapted) validates the args and projects the same shape into the MCP tool,
-the CLI flags, and the OpenAPI operation.
+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.
 
 ```ts
 // src/server/rpc/getMessages.ts
 import { GET } from '@abide/abide/server/GET'
 import { json } from '@abide/abide/server/json'
 import { z } from 'zod'
-import { recent } from '../../chatState.ts'
 
-const inputSchema = z.object({ room: z.string(), limit: z.coerce.number().default(20) })
+const inputSchema = z.object({ room: z.string() })
 
-export const getMessages = GET(({ room, limit }) => json(recent(room).slice(-limit)), {
-    inputSchema,
-})
+export const getMessages = GET(({ room }) => json(db.messages(room)), { inputSchema })
 ```
 
-One declaration, every surface:
+That single declaration fans out:
 
 ```text
-              getMessages = GET(fn, { inputSchema })
-                              │
-      ┌─────────────┬─────────┼──────────┬──────────────┐
-      ▼             ▼         ▼          ▼              ▼
-  SSR call      browser    MCP tool   CLI sub-      OpenAPI
-  cache(fn)()   fetch       (read)    command       operation
-                proxy
+      export const getMessages = GET(fn, { inputSchema })
+                            │
+  ┌────────────┬────────────┬────────────┬────────────┐
+  ▼            ▼            ▼            ▼            ▼
+  SSR call     browser      MCP tool     CLI cmd      OpenAPI
+  cache(fn)()  fetch proxy  (read-only)  abide cli    /openapi.json
 ```
 
-A schema unlocks the CLI for every verb and MCP for read-only verbs (`GET` /
-`HEAD`); a mutating verb never auto-exposes to MCP — it needs an explicit
-`clients: { mcp: true }`. Consume the verb four ways: `cache(getMessages)(args)`
-in-process (warm SSR hydration), the swapped `fetch` proxy in the browser,
-`getMessages.raw(args)` for the untouched `Response`, and
-`getMessages.stream(args)` to iterate a `jsonl`/`sse` body.
+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.
 
-> Query args arrive as strings — wrap numeric/boolean fields in `z.coerce.*`.
-> The per-verb `timeout` (504 on every surface) is distinct from the
-> client-side `ABIDE_CLIENT_TIMEOUT`.
+> 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`.
 
 ## Sockets
 
-A socket is one broadcast topic per file under `src/server/sockets/`. A
-`Socket<T>` is an isomorphic `AsyncIterable<T>`; 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({ id: z.string(), from: z.string(), text: z.string(), at: z.number() })
+const schema = z.object({ from: z.string(), text: z.string(), at: z.number() })
 
-// retain the last 100 frames; evict any older than an hour
+// 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>
 ```
 
-It also has an HTTP face for clients that can't speak the multiplex (the CLI
-and MCP): `GET /__abide/sockets/chat` returns the retained tail, and
-`POST /__abide/sockets/chat` publishes — gated by `clientPublish` (default off,
-so browsers publish through a validating verb instead).
+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.
 
-## Components — the full template
+## Components
 
-A `.abide` component pulls the verb and the socket above into one page and
-exercises the template grammar. `scope`, `props`, `effect`, `html`, and
-`snippet` are ambient — no import needed.
+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.
 
-<!-- prettier-ignore -->
 ```html
 <script>
 import { cache } from '@abide/abide/shared/cache'
 import { tail } from '@abide/abide/ui/tail'
 import { getMessages } from '$server/rpc/getMessages.ts'
-import { publishChat } from '$server/rpc/publishChat.ts'
+import { createMessage } from '$server/rpc/createMessage.ts'
 import { chat } from '$server/sockets/chat.ts'
 import Avatar from '$ui/Avatar.abide'
 
-const { room } = props()
+const { room = 'lobby' } = props()
+const { state, computed } = scope()
 
-// warm on the server, live on the client
-const history = scope().computed(() => cache(getMessages)({ room }))
-const latest = scope().computed(() => tail(chat))
+let draft = state('')
+let notify = state(true)
+const live = computed(() => tail(chat))            // read-only derived
+const ready = computed(() => draft.trim().length > 0)
 
-let from = scope().state('alice')
-let text = scope().state('')
-let pinned = scope().state(false)
-let view = scope().state('all')
-
-async function send() {
-    await publishChat({ from, text })
-    text = ''
+async function send(event: SubmitEvent) {
+    event.preventDefault()
+    await createMessage({ room, text: draft, notify })
+    draft = ''
 }
 </script>
 
-<template name="line" args={message}>
-    <li><Avatar name={message.from} /> <b>{message.from}</b>: {message.text}</li>
+<template name="row" args={{ msg }}>
+    <li><Avatar name={msg.from} /> {msg.text}</li>
 </template>
 
 <form onsubmit={send}>
-    <input bind:value={from} placeholder="name" />
-    <input bind:value={text} placeholder="message" />
-    <label><input type="checkbox" bind:checked={pinned} /> pin</label>
-    <label><input type="radio" bind:group={view} value="all" /> all</label>
-    <label><input type="radio" bind:group={view} value="mine" /> mine</label>
-    <button disabled={!text}>send</button>
+    <input bind:value={draft} placeholder="message" />
+    <label><input type="checkbox" bind:checked={notify} /> notify</label>
+    <button disabled={!ready()}>Send</button>
 </form>
 
-<template if={latest}>
-    <p>latest from {latest.from}</p>
-<template else>
-    <p>no messages yet</p>
-</template>
-
-<template switch={view}>
-<template case="mine"><p>showing your messages</p></template>
-<template default><p>showing every message</p></template>
-</template>
+{#if live()}<p class="muted">latest: {live().text}</p>{/if}
 
-<template await={history}>
-    <p>loading…</p>
-<template then="data">
+{#await cache(getMessages)({ room })}
+    <p>Loading…</p>
+{:then messages}
     <ul>
-        <template each={data} as="message" key="message.id" index="i">
-            {i}. {line(message)}
-        </template>
+        {#for msg of messages by msg.at}{row({ msg })}{/for}
     </ul>
-<template catch="reason">
-    <p>failed: {reason.message}</p>
-</template>
-</template>
+{:catch error}
+    <p class="error">{error.message}</p>
+{/await}
 
 <style>
-form { display: flex; gap: 0.5rem; }
+    .muted { color: #64748b; }
+    .error { color: #b91c1c; }
 </style>
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.41.1",
+    "version": "0.43.0",
     "type": "module",
     "sideEffects": false,
     "description": "Isomorphic multimodal HTTP framework built for humans and machines in a single Bun runtime",
@@ -54,7 +54,7 @@
         "./server/AppModule": "./src/lib/server/AppModule.ts",
         "./server/InspectorContext": "./src/lib/server/runtime/types/InspectorContext.ts",
         "./server/agent": "./src/lib/server/agent.ts",
-        "./server/rpc/defineVerb": "./src/lib/server/rpc/defineVerb.ts",
+        "./server/rpc/defineRpc": "./src/lib/server/rpc/defineRpc.ts",
         "./server/sockets/defineSocket": "./src/lib/server/sockets/defineSocket.ts",
         "./server/prompts/definePrompt": "./src/lib/server/prompts/definePrompt.ts",
         "./ui/tail": "./src/lib/ui/tail.ts",
@@ -62,6 +62,7 @@
         "./shared/pending": "./src/lib/shared/pending.ts",
         "./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",

package/src/abideLsp.ts

@@ -1,11 +1,15 @@
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import ts from 'typescript'
+import { ABIDE_SEMANTIC_TOKENS_LEGEND } from './lib/ui/compile/ABIDE_SEMANTIC_TOKENS_LEGEND.ts'
 import type {
     ShadowLanguageService,
     ShadowQuickInfo,
 } from './lib/ui/compile/createShadowLanguageService.ts'
 import { createShadowLanguageService } from './lib/ui/compile/createShadowLanguageService.ts'
+import { encodeSemanticTokens } from './lib/ui/compile/encodeSemanticTokens.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'
 import type { AbideDiagnostic } from './lib/ui/compile/types/AbideDiagnostic.ts'
 
 /*
@@ -19,6 +23,28 @@ unsaved text as overlays. Each document routes to a shadow service for its
 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.
+*/
+export function componentSemanticTokens(
+    service: ShadowLanguageService,
+    abidePath: string,
+    text: string,
+): number[] {
+    try {
+        const tokens = [
+            ...structuralBlockTokens(text),
+            ...service.semanticClassifications(abidePath),
+        ]
+        return encodeSemanticTokens(text, tokens)
+    } catch {
+        return []
+    }
+}
+
 export async function abideLsp({ cwd }: { cwd: string }): Promise<void> {
     const documentText = new Map<string, string>()
 
@@ -64,7 +90,14 @@ export async function abideLsp({ cwd }: { cwd: string }): Promise<void> {
                     jsonrpc: '2.0',
                     id: message.id,
                     result: {
-                        capabilities: { textDocumentSync: 1, hoverProvider: true },
+                        capabilities: {
+                            textDocumentSync: 1,
+                            hoverProvider: true,
+                            semanticTokensProvider: {
+                                legend: ABIDE_SEMANTIC_TOKENS_LEGEND,
+                                full: true,
+                            },
+                        },
                         serverInfo: { name: 'abide-lsp' },
                     },
                 })
@@ -115,6 +148,18 @@ export async function abideLsp({ cwd }: { cwd: string }): Promise<void> {
                 })
                 return
             }
+            case 'textDocument/semanticTokens/full': {
+                const { uri } = message.params.textDocument
+                const data = isAbide(uri)
+                    ? componentSemanticTokens(
+                          serviceFor(fileURLToPath(uri)),
+                          fileURLToPath(uri),
+                          documentText.get(fileURLToPath(uri)) ?? '',
+                      )
+                    : []
+                send({ jsonrpc: '2.0', id: message.id, result: { data } })
+                return
+            }
             case 'textDocument/didClose': {
                 const { uri } = message.params.textDocument
                 if (isAbide(uri)) {
@@ -194,13 +239,6 @@ function toLspHover(text: string, info: ShadowQuickInfo): object {
     }
 }
 
-/* An absolute offset → LSP `{ line, character }` (0-based, UTF-16 code units). */
-function offsetToPosition(text: string, offset: number): { line: number; character: number } {
-    const before = text.slice(0, offset)
-    const line = before.split('\n').length - 1
-    return { line, character: offset - (before.lastIndexOf('\n') + 1) }
-}
-
 /* An LSP `{ line, character }` (0-based) → absolute offset in `text`. */
 function positionToOffset(text: string, position: { line: number; character: number }): number {
     const lineStart = text