@abide/abide 0.41.0 → 0.42.0

package/CHANGELOG.md

@@ -1,5 +1,97 @@
 # abide
 
+## 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
+
+- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - shared replaceRange region-update seam ([`184cf41`](https://github.com/briancray/abide/commit/184cf41157ef0a5340a4a916d6cfc4f4e09b6c71))
+
+- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - single-source the marker-depth and isElement helpers ([`188c6ff`](https://github.com/briancray/abide/commit/188c6ff29fcaff2c9c206b971a2f04daf9a18cb3))
+
+- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - guard against double-dispose on reentrant branch swap ([`40600c7`](https://github.com/briancray/abide/commit/40600c7921c9fee9b6be947472c770af795f60c6))
+
+- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - await block on marker ranges, not a node array ([`5d12e83`](https://github.com/briancray/abide/commit/5d12e83b7313a04a925df3464ef5c7669bcbc1e6))
+
+- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - refresh AGENTS surface map, README, and kitchen-sink example ([`6cd7a3f`](https://github.com/briancray/abide/commit/6cd7a3f5686a69f4dd5faf87026d7f1ab0362bdb))
+
+- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - single client warm-seed intake (seedResolved) ([`8c3c19e`](https://github.com/briancray/abide/commit/8c3c19ed0a4d4244cb2634c025ef9ff88b7c9670))
+
+- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - centralize comment-marker sentinels and detached-range builder ([`99d4499`](https://github.com/briancray/abide/commit/99d44991c499b96fc016c3d204cb4dafa340cbe1))
+
+- [`74f5312`](https://github.com/briancray/abide/commit/74f531260e17f48162397142fb19b3df9e081b2c) - unify skeleton positional model on shared walks ([`cbb9daa`](https://github.com/briancray/abide/commit/cbb9daaa6f31532331df44136dd029f3e32cdfd7))
+
+- [`f3e0a13`](https://github.com/briancray/abide/commit/f3e0a132f9f9fbb020a8c783a0b54d3b37457e39) - Coalesce reactive writes inside event handlers
+
+    Event handlers now batch their writes: a handler that sets several signals re-runs
+    each dependent effect/computed/DOM-binding once on the handler's exit instead of once
+    per write (the previous default flushed eagerly per write). The change stays fully
+    synchronous — the flush runs at handler-end before it returns — so the causal stack
+    (`dispatch → handler → effects`) is intact and server/client scheduling stays identical.
+
+    Factored the batch idiom `createDoc`/`clientPage` inlined into a shared, nesting-safe
+    `batch()` (flushes only on the depth-0 exit) and migrated both onto it, so a handler
+    that triggers a doc patch now coalesces end-to-end rather than flushing mid-handler.
+
+    A handler writing N fields cuts dependent re-runs N× (bench: an 8-field form handler
+    drops aggregate re-runs 8× and runs ~4.8× faster). Single-write handlers and navigation
+    (already batched) are unchanged. New contract, pinned by tests: a handler that writes
+    then synchronously reads the bound DOM sees the pre-write value until it returns; signal
+    reads stay current.
+
+- [`f26cba2`](https://github.com/briancray/abide/commit/f26cba22b92683f7316cc7212c5fe10500bdad13) - `abide check`: declare the `each` `index` binding in the type-check shadow
+
+    `index="i"` (0.41.0) was bound in the build and SSR passes but not in the shadow the
+    type-checker reads, so `{i}` in a row body false-positived "Cannot find name 'i'". The
+    shadow now declares the index as a `number` inside the loop body, matching the runtime.
+
 ## 0.41.0
 
 ### Minor Changes

package/README.md

@@ -1,24 +1,24 @@
 # abide
 
-**One typed declaration fans out to HTTP, a CLI, an MCP tool, and an OpenAPI
-spec — and the bundler swaps the runtime per side.**
+**One typed declaration fans out to HTTP, a CLI, an MCP tool, and an
+OpenAPI spec — the bundler swaps the runtime per side.**
 
-abide is an isomorphic framework on Bun and web standards: you declare a verb,
-a socket, or a component once, and the same callable runs server-side, in the
-browser, from the terminal, and from an agent — the bundler decides which
-runtime each side gets. Built for humans *and* machines.
+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.
 
-- One direct dependency — the TypeScript compiler, used by `abide check`.
-  Tailwind is an optional peer. Everything runs on a single Bun runtime
-  (≥ 1.3.0); no second toolchain.
+- One direct dependency (`typescript`); `tailwindcss` + `bun-plugin-tailwind`
+  are optional peers. Single runtime: Bun ≥ 1.3.0.
 
 ## Quick start
 
 ```sh
-bunx abide scaffold my-app   # copies the template, installs, starts dev
+bunx abide scaffold my-app   # scaffolds, installs deps, and starts dev
 ```
 
-Or clone the kitchen-sink and run it:
+Or read the full feature tour in the kitchen-sink example:
 
 ```sh
 git clone https://github.com/briancray/abide
@@ -29,134 +29,142 @@ bun run dev
 
 ## RPCs
 
-An RPC is one export per file under `src/server/rpc/`. **The file path is the
-URL.** The schema validates arguments and projects the MCP tool, the CLI flags,
-and the OpenAPI operation. The contract is Standard Schema — zod, valibot, or
-arktype, unadapted.
+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.
 
 ```ts
-// src/server/rpc/getMessages.ts — file path is the route: GET /getMessages
+// 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() })
+const inputSchema = z.object({ room: z.string(), limit: z.coerce.number().default(20) })
 
-export const getMessages = GET(({ room }) => json(board(room)), { inputSchema })
+export const getMessages = GET(({ room, limit }) => json(recent(room).slice(-limit)), {
+    inputSchema,
+})
 ```
 
-One declaration, five surfaces:
+One declaration, every surface:
 
 ```text
               getMessages = GET(fn, { inputSchema })
                               │
-   ┌───────────┬─────────────┼────────────┬──────────────┐
- SSR call   browser fetch   MCP tool    CLI command    OpenAPI op
-cache(fn)() typed proxy()  (read-only)  abide ... cli  /openapi.json
+      ┌─────────────┬─────────┼──────────┬──────────────┐
+      ▼             ▼         ▼          ▼              ▼
+  SSR call      browser    MCP tool   CLI sub-      OpenAPI
+  cache(fn)()   fetch       (read)    command       operation
+                proxy
 ```
 
-A schema unlocks the CLI everywhere and MCP for read-only verbs; a mutating
-verb never auto-exposes to MCP — it needs explicit `clients: { mcp: true }`.
-Consume the verb four ways: `cache(getMessages)({ room })` resolves in-process
-during SSR, the same call hits a swapped `fetch` in the browser,
-`getMessages.raw(args)` returns the undecoded `Response`, and
-`getMessages.stream(args)` is an iterable view of the body.
+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.
 
-> Query args travel as strings — validate with `z.coerce.*`. The per-verb
-> `timeout` (504 on every surface) is distinct from `ABIDE_CLIENT_TIMEOUT`.
+> 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`.
 
 ## Sockets
 
 A socket is one broadcast topic per file under `src/server/sockets/`. A
-`Socket<T>` is an isomorphic `AsyncIterable<T>`, and every socket multiplexes
-onto one websocket at `/__abide/sockets`.
+`Socket<T>` is an isomorphic `AsyncIterable<T>`; every socket multiplexes onto
+one WebSocket at `/__abide/sockets`.
 
 ```ts
-// src/server/sockets/messages.ts — topic name = file name: `messages`
+// src/server/sockets/chat.ts
 import { socket } from '@abide/abide/server/socket'
 import { z } from 'zod'
 
-const schema = z.object({ id: z.string(), room: z.string(), from: z.string(), text: z.string() })
+const schema = z.object({ id: z.string(), from: z.string(), text: z.string(), at: z.number() })
 
-// retain the last 50 frames; evict any older than an hour
-export const messages = socket({ schema, tail: 50, ttl: 3_600_000 })
-export type Message = z.infer<typeof schema>
+// retain the last 100 frames; evict any older than an hour
+export const chat = socket({ schema, tail: 100, ttl: 3_600_000 })
+export type ChatMessage = z.infer<typeof schema>
 ```
 
-The socket also has an HTTP face at `/__abide/sockets/messages`, for clients
-that can't speak the ws multiplex: `GET` returns the retained tail, `POST`
-publishes — gated by `clientPublish` (off by default, so the POST 403s).
+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).
 
-## Components
+## Components — the full template
 
-A `.abide` component is the payoff: it imports the verb and the socket above
-and ties them together with the native `<template>` grammar. Reactive state is
-reached only through `scope()` — `scope().state()` is writable,
-`scope().computed()` is read-only. `props()` and `effect()` are in-scope, no
-import.
+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.
 
+<!-- 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 { postMessage } from '$server/rpc/postMessage.ts'
-import { messages } from '$server/sockets/messages.ts'
+import { publishChat } from '$server/rpc/publishChat.ts'
+import { chat } from '$server/sockets/chat.ts'
 import Avatar from '$ui/Avatar.abide'
 
-const { room = 'lobby' } = props<{ room?: string }>()
+const { room } = props()
 
-// SSR-warm history; live frames then stream over the ws
-const seed = cache(getMessages)({ room })
-const live = scope().computed(() => tail(messages, { last: 50 }))
+// warm on the server, live on the client
+const history = scope().computed(() => cache(getMessages)({ room }))
+const latest = scope().computed(() => tail(chat))
 
 let from = scope().state('alice')
 let text = scope().state('')
 let pinned = scope().state(false)
-let sort = scope().state('newest')
+let view = scope().state('all')
 
 async function send() {
-    await postMessage({ room, from, text })
+    await publishChat({ from, text })
     text = ''
 }
 </script>
 
-<template name="bubble" args={msg}>
-    <li class="flex gap-2"><Avatar name={msg.from} /> <b>{msg.from}</b> {msg.text}</li>
+<template name="line" args={message}>
+    <li><Avatar name={message.from} /> <b>{message.from}</b>: {message.text}</li>
 </template>
 
-<form onsubmit={send} class="flex gap-2">
-    <input bind:value={from} class="border px-2" />
-    <input bind:value={text} placeholder="message" class="flex-1 border px-2" />
+<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={sort} value="newest" /> newest</label>
-    <button disabled={!text} class="border px-3">send</button>
+    <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>
 </form>
 
-<template if={pinned}>
-    <p class="text-xs text-amber-700">room pinned</p>
-    <template else><p class="text-xs text-slate-400">not pinned</p></template>
-</template>
-
-<template switch={sort}>
-    <template case={'newest'}><p class="text-xs">newest first</p></template>
-    <template default><p class="text-xs">oldest first</p></template>
-</template>
-
-<template await={seed}>
-    <p class="text-xs text-slate-500">loading…</p>
-    <template then="history">
-        <ul class="mt-3 space-y-1">
-            <template each={live ?? history} as="msg" key="msg.id">
-                {bubble(msg)}
-            </template>
-        </ul>
-    </template>
-    <template catch="err"><p class="text-rose-700">{err.message}</p></template>
-</template>
+{#if latest}
+    <p>latest from {latest.from}</p>
+{:else}
+    <p>no messages yet</p>
+{/if}
+
+{#switch view}
+{:case 'mine'}<p>showing your messages</p>
+{:default}<p>showing every message</p>
+{/switch}
+
+{#await history}
+    <p>loading…</p>
+{:then data}
+    <ul>
+        {#for message, i of data by message.id}
+            {i}. {line(message)}
+        {/for}
+    </ul>
+{:catch reason}
+    <p>failed: {reason.message}</p>
+{/await}
 
 <style>
-    li { font-size: 0.875rem; }
+form { display: flex; gap: 0.5rem; }
 </style>
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.41.0",
+    "version": "0.42.0",
     "type": "module",
     "sideEffects": false,
     "description": "Isomorphic multimodal HTTP framework built for humans and machines in a single Bun runtime",

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

package/src/abideResolverPlugin.ts

@@ -4,6 +4,8 @@ import type { BunPlugin } from 'bun'
 import { Glob } from 'bun'
 import { abideImportName } from './lib/shared/abideImportName.ts'
 import { abideLog } from './lib/shared/abideLog.ts'
+import { escapeRegex } from './lib/shared/escapeRegex.ts'
+import { fileName } from './lib/shared/fileName.ts'
 import { fileStem } from './lib/shared/fileStem.ts'
 import { jsonSchemaForPromptArguments } from './lib/shared/jsonSchemaForPromptArguments.ts'
 import { manifestModule } from './lib/shared/manifestModule.ts'
@@ -65,10 +67,6 @@ function resolveExtensionUncached(path: string): string {
 
 const NS = 'abide-virtual'
 
-function escapeRegex(value: string): string {
-    return value.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
-}
-
 /* Memoises a zero-arg async producer so repeat calls reuse the first in-flight promise. */
 function once<T>(produce: () => Promise<T>): () => Promise<T> {
     let promise: Promise<T> | undefined
@@ -791,7 +789,7 @@ async function scanPages(pagesDir: string): Promise<PagesScan> {
         return { pageFiles: [], layoutFiles: [] }
     }
     const allFiles = await Array.fromAsync(new Glob('**/*.abide').scan({ cwd: pagesDir }))
-    const leafIs = (name: string) => (file: string) => (file.split('/').pop() ?? '') === name
+    const leafIs = (name: string) => (file: string) => fileName(file) === name
     return {
         pageFiles: allFiles.filter(leafIs('page.abide')),
         layoutFiles: allFiles.filter(leafIs('layout.abide')),

package/src/lib/server/runtime/devClientFingerprint.ts

@@ -1,4 +1,5 @@
 import { relative } from 'node:path'
+import { fileName } from '../../shared/fileName.ts'
 import { analyzeComponent } from '../../ui/compile/analyzeComponent.ts'
 import { compileComponent } from '../../ui/compile/compileComponent.ts'
 import { nearestProjectRoot } from '../../ui/compile/nearestProjectRoot.ts'
@@ -19,7 +20,7 @@ const GENERATED = /(^|\/)\.abide\//
 // page.abide / layout.abide are router-mounted, not `mountChild`-tracked, so they
 // can't hot-swap — they fold into `structure` (a reload) instead.
 function isPageOrLayout(moduleId: string): boolean {
-    const file = moduleId.split('/').pop() ?? ''
+    const file = fileName(moduleId)
     return file === 'page.abide' || file === 'layout.abide'
 }
 

package/src/lib/shared/escapeRegex.ts

@@ -0,0 +1,9 @@
+/*
+Escapes the regex metacharacters in `value` so it can be embedded literally
+inside a `new RegExp(...)` pattern. Shared by the $rpc/$sockets import stripper,
+the resolver plugin's virtual-namespace matcher, and the SSR snippet-call
+rewriter so the same escaping is applied one way everywhere.
+*/
+export function escapeRegex(value: string): string {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}

package/src/lib/shared/fileName.ts

@@ -0,0 +1,9 @@
+/*
+The bare leaf filename of a path — directory stripped, extension kept —
+e.g. `users/list.ts` → `list.ts`. The extension-stripping `fileStem` builds on
+this; call sites that match a full filename (`layout.abide`, `page.abide`) use
+it directly so the leaf-grab is written one way.
+*/
+export function fileName(path: string): string {
+    return path.split('/').pop() ?? ''
+}

package/src/lib/shared/fileStem.ts

@@ -1,3 +1,5 @@
+import { fileName } from './fileName.ts'
+
 /*
 The bare filename of a path, with directory and trailing extension stripped —
 e.g. `users/list.ts` → `list`, `/_virtual/mcp-resources.ts` → `mcp-resources`.
@@ -5,5 +7,5 @@ Used to derive a virtual-module name from its path and to check an $rpc /
 $sockets module's single export name against its file stem.
 */
 export function fileStem(path: string): string {
-    return (path.split('/').pop() ?? '').replace(/\.[^.]+$/, '')
+    return fileName(path).replace(/\.[^.]+$/, '')
 }

package/src/lib/shared/programNameForPackage.ts

@@ -1,3 +1,5 @@
+import { fileName } from './fileName.ts'
+
 /*
 Derives the CLI program/binary name from a package.json `name` field.
 Scoped names (`@scope/tool`) keep only the final segment so the value is
@@ -10,5 +12,5 @@ export function programNameForPackage(name: string | undefined): string {
     if (name === undefined || name === '') {
         return 'app'
     }
-    return name.split('/').pop() || 'app'
+    return fileName(name) || 'app'
 }

package/src/lib/shared/stripImport.ts

@@ -1,3 +1,5 @@
+import { escapeRegex } from './escapeRegex.ts'
+
 /*
 Strips the user's `import { … } from '<moduleName>'` declaration from a
 module source. Used by the $rpc / $sockets rewriters to remove the
@@ -18,7 +20,7 @@ includes newlines, so multi-line braced imports like
 still match — the body just can't contain another `}` to bound it.
 */
 export function stripImport(source: string, moduleName: string): string {
-    const escaped = moduleName.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
+    const escaped = escapeRegex(moduleName)
     const pattern = new RegExp(
         `^\\s*import\\s*\\{[^}]*\\}\\s*from\\s*['"]${escaped}['"]\\s*;?\\s*$`,
         'gm',

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

@@ -0,0 +1,45 @@
+/*
+The LSP semantic-tokens legend abide lsp advertises, and the decoder from
+TypeScript's encoded classifications to legend names. TypeScript encodes a
+classification as `((tokenType + 1) << 8) + modifierBitset`; its TokenType and
+TokenModifier enums fix the orders below. `keyword`/`operator` carry the `{#…}`
+block framing the structural tokenizer emits.
+*/
+
+/* TS TokenType order (class=0 … member=11) → LSP token-type name. */
+const TS_TYPE_TO_LSP = [
+    'class',
+    'enum',
+    'interface',
+    'namespace',
+    'typeParameter',
+    'type',
+    'parameter',
+    'variable',
+    'enumMember',
+    'property',
+    'function',
+    'method',
+]
+
+/* TS TokenModifier order (declaration=bit 0 … local=bit 5). */
+const TS_MODIFIERS = ['declaration', 'static', 'async', 'readonly', 'defaultLibrary', 'local']
+
+export const ABIDE_SEMANTIC_TOKENS_LEGEND = {
+    tokenTypes: [...TS_TYPE_TO_LSP, 'keyword', 'operator'],
+    tokenModifiers: TS_MODIFIERS,
+}
+
+/* Decodes one TypeScript encoded classification into legend names. */
+export function mapTsClassification(
+    classification: number,
+): { type: string; modifiers: string[] } | undefined {
+    const tokenType = (classification >> 8) - 1
+    const type = TS_TYPE_TO_LSP[tokenType]
+    if (type === undefined) {
+        return undefined
+    }
+    const modifierSet = classification & 255
+    const modifiers = TS_MODIFIERS.filter((_, bit) => (modifierSet & (1 << bit)) !== 0)
+    return { type, modifiers }
+}

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

@@ -1,3 +1,5 @@
+import { SNIPPET_CLOSE, SNIPPET_OPEN } from '../runtime/RANGE_MARKER.ts'
+
 /*
 Source text for the `$esc` / `$attr` / `$spread` / `$text` / `$snip` helpers injected
 into every SSR render body. `$esc` escapes the five HTML-significant characters. `$attr`
@@ -30,6 +32,6 @@ export const SSR_ESCAPE =
     "const $SNIP = Symbol.for('abide.snippet');\n" +
     'const $snip = (s) => ({ [$SNIP]: s });\n' +
     'const $text = (v) => (v !== null && typeof v === "object" && $SNIP in v) ' +
-    "? ('<!--abide:snippet-->' + v[$SNIP] + '<!--/abide:snippet-->') " +
+    `? ('<!--${SNIPPET_OPEN}-->' + v[$SNIP] + '<!--${SNIPPET_CLOSE}-->') ` +
     ': (v !== null && typeof v === "object" && $RAW in v) ' +
     "? ('<!--abide:html-->' + v[$RAW] + '<!--/abide:html-->') : $esc(v);"