@abide/abide 0.28.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brian Cray
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,154 @@
+# abide
+
+**A type-safe isomorphic framework built on web standards and Bun. Zero runtime dependencies, single runtime.**
+
+abide is not just a web framework. Strongly-typed RPCs surface through HTTP, a CLI, and an MCP, with a full OpenAPI spec. Everything is generated for you with zero additional work - but you control surface exposure. Its a framework built for humans *and* machines.
+
+## Quick start
+
+```sh
+bunx abide scaffold my-app   # scaffolds, installs, and starts the dev server
+```
+
+To see a full demo, clone the repo and run the kitchen-sink example — every surface is a runnable, documented page:
+
+```sh
+git clone https://github.com/briancray/abide
+cd abide && bun install
+cd examples/kitchen-sink && bun run dev
+```
+
+## Three foundational primitives
+
+### RPCs
+
+An RPC is a handler wrapped by its HTTP method — one export per file under `src/server/rpc/`. The file path is the URL; the schema validates args and projects the MCP tool, CLI flags, and OpenAPI operation. Standard Schema is the contract: zod, valibot, and arktype work unadapted.
+
+```ts
+// src/server/rpc/getMessages.ts
+import { GET } from '@abide/abide/server/GET'
+import { json } from '@abide/abide/server/json'
+import { z } from 'zod'
+
+// query args arrive as strings — coerce in the schema
+const inputSchema = z.object({ room: z.string(), limit: z.coerce.number().default(50) })
+
+export const getMessages = GET(
+    async ({ room, limit }) => json(await db.recentMessages(room, limit)),
+    { inputSchema },
+)
+```
+
+One declared verb fans out to every surface — this is the whole premise:
+
+```text
+       export const getMessages = GET(fn, { inputSchema })
+                                 │
+   ┌───────────────┬────────────┼──────────────┬────────────────┐
+ SSR call      browser fetch    MCP tool      CLI subcommand   OpenAPI op
+cache(fn)()   fetch /rpc/...   getMessages   app get-messages  /openapi.json
+(in-process)  (typed proxy)  (read-only+schema) (schema→flags)   (described)
+```
+
+The same callable is consumed differently per side — `cache(getMessages)({ room })` in-process, the swapped `fetch` in the browser, `.raw(args)` for a `Response`, `.stream(args)` for `tail()`. A schema gates the machine surfaces: it unlocks CLI and (for read-only verbs) MCP; a mutating verb never auto-exposes to MCP — it needs an explicit `clients: { mcp: true }`. Per-verb `timeout` (504, on every surface) is distinct from the client-side `ABIDE_CLIENT_TIMEOUT`.
+
+> Query args travel as strings — use `z.coerce.*` so numbers and booleans validate.
+
+### Sockets
+
+One broadcast topic per file under `src/server/sockets/`. A `Socket<T>` is an isomorphic `AsyncIterable<T>` — every socket multiplexes onto one ws 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() })
+
+// 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>
+```
+
+For clients that can't speak the ws multiplex, each socket has an HTTP face at `/__abide/sockets/<name>` — `GET` returns the retained tail, `POST` publishes (gated by `clientPublish`).
+
+### Components
+
+Components are `.abide` files — valid HTML with `<script>`, native `<template>` control flow, `{expr}` bindings, and a component-scoped `<style>`. The reactive primitives (`state`, `derived`, `effect`, `prop`) are in scope without import. This page reads the verb above through `cache()`, tails the socket live, and exercises most of the template grammar:
+
+```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 { chat } from '$server/sockets/chat.ts'
+import Avatar from '$ui/Avatar.abide'
+
+let room = prop('room')                                  // typed via src/.abide/routes.d.ts
+const history = derived(() => cache(getMessages)({ room })) // SSR snapshot + reactive refetch
+const latest = derived(() => tail(chat))                 // re-renders on every new frame
+
+let from = state('alice')
+let text = state('')
+let filter = state('all')        // all | mine | others
+let onlyUnread = state(false)
+
+async function send(event: SubmitEvent) {
+    event.preventDefault()
+    if (text.trim() === '') return
+    await publishChat({ room, from, text })              // server validates, then broadcasts
+    text = ''
+}
+</script>
+
+<template name="message" args={m}>                       <!-- snippet: a reusable builder -->
+    <li class="row"><Avatar name={m.from} /> <strong>{m.from}</strong>: {m.text}</li>
+</template>
+
+<form onsubmit={send}>
+    <input bind:value={from} placeholder="you" />
+    <input bind:value={text} placeholder="say something…" />
+    <label><input type="checkbox" bind:checked={onlyUnread} /> unread only</label>
+    <fieldset>
+        <label><input type="radio" bind:group={filter} value="all" /> all</label>
+        <label><input type="radio" bind:group={filter} value="mine" /> mine</label>
+    </fieldset>
+    <button type="submit" disabled={text.trim() === ''}>send</button>
+</form>
+
+<template if={latest}>
+    <p class="ping">latest from <strong>{latest.from}</strong></p>
+    <template else>
+        <p class="ping muted">no live messages yet</p>
+    </template>
+</template>
+
+<template switch={filter}>
+    <template case={'mine'}><p>showing your messages</p></template>
+    <template default><p>showing every message</p></template>
+</template>
+
+<template await={history}>
+    <p>loading history…</p>
+    <template then="messages">
+        <ul>
+            <template each={messages} as="m" key="m.id">
+                {message(m)}                              <!-- render the snippet -->
+            </template>
+        </ul>
+    </template>
+    <template catch="err">
+        <p class="error">{err.message}</p>
+    </template>
+</template>
+
+<style>
+    .row { display: flex; gap: 0.5rem; }
+    .muted { color: #94a3b8; }
+    .error { color: #dc2626; }
+</style>
+```
+
+
+MIT

package/bin/abide.ts

@@ -0,0 +1,212 @@
+#!/usr/bin/env bun
+import { abideLsp } from '../src/abideLsp.ts'
+import { build } from '../src/build.ts'
+import { buildCli } from '../src/buildCli.ts'
+import { bundleApp } from '../src/bundleApp.ts'
+import { checkAbide } from '../src/checkAbide.ts'
+import { compile } from '../src/compile.ts'
+import { normalizeTarget } from '../src/lib/shared/normalizeTarget.ts'
+import { scaffold } from '../src/scaffold.ts'
+
+const PRELOAD = new URL('../src/preload.ts', import.meta.url).pathname
+const SERVER_ENTRY = new URL('../src/serverEntry.ts', import.meta.url).pathname
+const DEV_ENTRY = new URL('../src/devEntry.ts', import.meta.url).pathname
+const cwd = process.cwd()
+const [, , command, ...rest] = process.argv
+
+// Reads `--name=value` or `--name value` from the trailing argv tail.
+function parseFlag(name: string): string | undefined {
+    const prefix = `--${name}=`
+    const match = rest.find((arg) => arg.startsWith(prefix))
+    if (match) {
+        return match.slice(prefix.length)
+    }
+    const index = rest.indexOf(`--${name}`)
+    if (index !== -1 && index + 1 < rest.length) {
+        return rest[index + 1]
+    }
+    return undefined
+}
+
+/*
+Runs a long-lived child (server, job, script) and owns its shutdown. Ctrl+C
+delivers SIGINT to the whole foreground process group, so without a parent
+handler the parent's default action kills it instantly — abandoning the
+`await child.exited` and orphaning the child, which (for a server) can then
+linger holding the port. Forwarding the signal and awaiting the child's exit
+(with a SIGKILL watchdog for a wedged child) guarantees the child is reaped
+before the parent leaves. Mirrors the child's exit code so callers and CI see
+the real result.
+*/
+async function runChild(cmd: string[]): Promise<never> {
+    const child = Bun.spawn({ cmd, cwd, stdio: ['inherit', 'inherit', 'inherit'] })
+    const forward = (signal: NodeJS.Signals) => {
+        child.kill(signal)
+        setTimeout(() => child.kill('SIGKILL'), 3000).unref()
+    }
+    process.on('SIGINT', () => forward('SIGINT'))
+    process.on('SIGTERM', () => forward('SIGTERM'))
+    process.exit(await child.exited)
+}
+
+/*
+Runs the dev orchestrator (devEntry) — not `bun --watch`. The orchestrator owns
+the loop: it builds the client, spawns the server as a child on a fixed dev
+port, watches src/ recursively, and on any change rebuilds + restarts the child.
+The server mounts a live-reload channel under dev, so the browser reloads itself
+when the restarted server comes back. runChild forwards Ctrl+C so the
+orchestrator (and its server child) shut down cleanly.
+*/
+async function dev(): Promise<void> {
+    await runChild(['bun', '--preload', PRELOAD, DEV_ENTRY])
+}
+
+// Performs a single client build with no server attached (for CI / static deploys).
+async function buildOnce(): Promise<void> {
+    await build({ cwd })
+}
+
+// Starts the production server against an already-built dist directory.
+async function start(): Promise<void> {
+    await runChild(['bun', '--preload', PRELOAD, SERVER_ENTRY])
+}
+
+/*
+Runs an arbitrary script under the abide preload — same runtime as the server,
+so jobs/scripts get .abide compilation, abide/* + $server/$shared resolution,
+and the .css no-op loader for free. Everything after `run` is forwarded
+verbatim: the first token is the script, the rest are its argv (bun stops
+parsing its own flags at the script path).
+*/
+async function runCmd(): Promise<void> {
+    if (rest.length === 0) {
+        console.error('usage: abide run <file> [args...]')
+        process.exit(1)
+    }
+    await runChild(['bun', '--preload', PRELOAD, ...rest])
+}
+
+// Parses the --target and --out flags and produces a standalone executable.
+async function compileCmd(): Promise<void> {
+    const targetFlag = parseFlag('target')
+    const outFlag = parseFlag('out')
+    await compile({
+        cwd,
+        target: targetFlag ? normalizeTarget(targetFlag) : undefined,
+        outfile: outFlag,
+    })
+}
+
+// Builds the standalone CLI binary — a thin remote client (manifest baked in)
+// that ships the compiled server beside it, so it can talk to a remote server
+// or spawn a local instance (`<name> start`). Discovery walks the rpc registry
+// to bake the manifest in. `--platforms a,b,c` cross-compiles per target into
+// dist/cli-thin/<platform>/ (cli + server) — the layout the /__abide/cli
+// download endpoint streams. For just the server, use `abide compile`.
+async function cliCmd(): Promise<void> {
+    const targetFlag = parseFlag('target')
+    const outFlag = parseFlag('out')
+    const platformsFlag = parseFlag('platforms')
+    const platforms = platformsFlag
+        ? platformsFlag.split(',').map((value) => normalizeTarget(value.trim()))
+        : undefined
+    await buildCli({
+        cwd,
+        target: targetFlag ? normalizeTarget(targetFlag) : undefined,
+        outfile: outFlag,
+        platforms,
+    })
+}
+
+// Type-checks every .abide component's template + props through its shadow and
+// exits non-zero if any errors are found.
+async function checkCmd(): Promise<void> {
+    const errors = await checkAbide({ cwd })
+    process.exit(errors === 0 ? 0 : 1)
+}
+
+// Runs the .abide language server over stdio (JSON-RPC) — an editor spawns this
+// to get live template + prop type-check diagnostics. Runs until the client exits.
+async function lspCmd(): Promise<void> {
+    await abideLsp({ cwd })
+}
+
+// Assembles a movable, self-contained app bundle for the host platform —
+// the server binary, the launcher, and the webview lib together (a .app on
+// macOS, a flat directory elsewhere). Unsigned; for distribution to other
+// users the bundle still needs platform signing/notarization.
+async function bundleCmd(): Promise<void> {
+    await bundleApp({ cwd })
+}
+
+/*
+Scaffolds the bundled template, installs it, and — interactively — starts the
+dev server so the one command ends in a running app. Non-TTY runs (CI,
+scripts) never auto-start; `--no-dev` opts out explicitly.
+*/
+async function scaffoldCmd(): Promise<void> {
+    const name = rest.find((arg) => !arg.startsWith('--'))
+    if (!name) {
+        console.error('usage: bunx abide scaffold <project-name> [--no-install] [--no-dev]')
+        process.exit(1)
+    }
+    const install = !rest.includes('--no-install')
+    // scaffold gates dev on a successful install, so only the TTY/flag policy lives here.
+    const dev = !rest.includes('--no-dev') && Boolean(process.stdout.isTTY)
+    await scaffold({ cwd, name, install, dev })
+}
+
+// Prints the CLI synopsis to stderr and exits non-zero. Marked `never` because the process is gone.
+function usage(): never {
+    console.error(
+        'usage:\n' +
+            '  bunx abide scaffold <project-name>   scaffold a new abide project, install\n' +
+            '                                       it, and start its dev server\n' +
+            '                                       (--no-install / --no-dev to skip)\n' +
+            '  abide dev                            build + run with hot reload\n' +
+            '  abide build                          build the client into dist/_app/\n' +
+            '  abide check                          type-check .abide templates + props\n' +
+            '  abide start                          run the production server against dist/\n' +
+            '  abide run <file> [args...]           run a script under the abide preload\n' +
+            '                                       (jobs, one-off scripts — same runtime as\n' +
+            '                                       the server). For tests, add\n' +
+            '                                       preload = ["@abide/abide/preload"] under\n' +
+            '                                       [test] in bunfig.toml and use `bun test`\n' +
+            '  abide compile [--target=<bun-...>] [--out=<path>]\n' +
+            '                                       build a standalone server executable\n' +
+            '  abide cli [--target=<bun-...>] [--out=<path>] [--platforms=<a,b,c>]\n' +
+            '                                       build the cli binary — a thin remote client that\n' +
+            '                                       ships the server beside it (connect to a remote\n' +
+            '                                       server or `start` a local instance; --platforms\n' +
+            '                                       cross-compiles per platform)\n' +
+            '  abide bundle                         build a movable, self-contained app\n' +
+            '                                       bundle for this platform (unsigned). Boots\n' +
+            '                                       into a connect screen — start the embedded\n' +
+            '                                       server or connect to a remote one',
+    )
+    process.exit(1)
+}
+
+if (command === 'scaffold') {
+    await scaffoldCmd()
+} else if (command === 'dev') {
+    await dev()
+} else if (command === 'build') {
+    await buildOnce()
+} else if (command === 'start') {
+    await start()
+} else if (command === 'run') {
+    await runCmd()
+} else if (command === 'compile') {
+    await compileCmd()
+} else if (command === 'cli') {
+    await cliCmd()
+} else if (command === 'bundle') {
+    await bundleCmd()
+} else if (command === 'check') {
+    await checkCmd()
+} else if (command === 'lsp') {
+    await lspCmd()
+} else {
+    usage()
+}

package/package.json

@@ -0,0 +1,155 @@
+{
+    "name": "@abide/abide",
+    "version": "0.28.0",
+    "type": "module",
+    "sideEffects": false,
+    "description": "Isomorphic multimodal HTTP framework built for humans and machines in a single Bun runtime",
+    "license": "MIT",
+    "author": "Brian Cray",
+    "homepage": "https://github.com/briancray/abide#readme",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/briancray/abide.git",
+        "directory": "packages/abide"
+    },
+    "bugs": {
+        "url": "https://github.com/briancray/abide/issues"
+    },
+    "keywords": [
+        "bun",
+        "ssr",
+        "spa",
+        "framework",
+        "isomorphic",
+        "rpc",
+        "mcp",
+        "cli"
+    ],
+    "engines": {
+        "bun": ">=1.3.0"
+    },
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "exports": {
+        "./server/GET": "./src/lib/server/GET.ts",
+        "./server/POST": "./src/lib/server/POST.ts",
+        "./server/PUT": "./src/lib/server/PUT.ts",
+        "./server/PATCH": "./src/lib/server/PATCH.ts",
+        "./server/DELETE": "./src/lib/server/DELETE.ts",
+        "./server/HEAD": "./src/lib/server/HEAD.ts",
+        "./server/socket": "./src/lib/server/socket.ts",
+        "./server/json": "./src/lib/server/json.ts",
+        "./server/jsonl": "./src/lib/server/jsonl.ts",
+        "./server/sse": "./src/lib/server/sse.ts",
+        "./server/error": "./src/lib/server/error.ts",
+        "./server/redirect": "./src/lib/server/redirect.ts",
+        "./server/request": "./src/lib/server/request.ts",
+        "./server/reachable": "./src/lib/server/reachable.ts",
+        "./server/cookies": "./src/lib/server/cookies.ts",
+        "./server/env": "./src/lib/server/env.ts",
+        "./server/appDataDir": "./src/lib/server/appDataDir.ts",
+        "./server/server": "./src/lib/server/server.ts",
+        "./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/sockets/defineSocket": "./src/lib/server/sockets/defineSocket.ts",
+        "./server/prompts/definePrompt": "./src/lib/server/prompts/definePrompt.ts",
+        "./ui/tail": "./src/lib/ui/tail.ts",
+        "./shared/cache": "./src/lib/shared/cache.ts",
+        "./shared/pending": "./src/lib/shared/pending.ts",
+        "./shared/refreshing": "./src/lib/shared/refreshing.ts",
+        "./shared/HttpError": "./src/lib/shared/HttpError.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",
+        "./shared/log": "./src/lib/shared/log.ts",
+        "./shared/online": "./src/lib/shared/online.ts",
+        "./shared/page": "./src/lib/shared/page.ts",
+        "./shared/trace": "./src/lib/shared/trace.ts",
+        "./shared/url": "./src/lib/shared/url.ts",
+        "./shared/createSubscriber": "./src/lib/shared/createSubscriber.ts",
+        "./ui/state": "./src/lib/ui/state.ts",
+        "./ui/derived": "./src/lib/ui/derived.ts",
+        "./ui/effect": "./src/lib/ui/effect.ts",
+        "./ui/doc": "./src/lib/ui/doc.ts",
+        "./ui/dom/mount": "./src/lib/ui/dom/mount.ts",
+        "./ui/dom/mountChild": "./src/lib/ui/dom/mountChild.ts",
+        "./ui/dom/hydrate": "./src/lib/ui/dom/hydrate.ts",
+        "./ui/dom/text": "./src/lib/ui/dom/text.ts",
+        "./ui/dom/openChild": "./src/lib/ui/dom/openChild.ts",
+        "./ui/dom/openRoot": "./src/lib/ui/dom/openRoot.ts",
+        "./ui/dom/appendText": "./src/lib/ui/dom/appendText.ts",
+        "./ui/dom/appendSnippet": "./src/lib/ui/dom/appendSnippet.ts",
+        "./ui/dom/appendStatic": "./src/lib/ui/dom/appendStatic.ts",
+        "./ui/dom/cloneStatic": "./src/lib/ui/dom/cloneStatic.ts",
+        "./ui/dom/attr": "./src/lib/ui/dom/attr.ts",
+        "./ui/dom/on": "./src/lib/ui/dom/on.ts",
+        "./ui/dom/attach": "./src/lib/ui/dom/attach.ts",
+        "./ui/dom/each": "./src/lib/ui/dom/each.ts",
+        "./ui/dom/eachAsync": "./src/lib/ui/dom/eachAsync.ts",
+        "./ui/dom/when": "./src/lib/ui/dom/when.ts",
+        "./ui/dom/awaitBlock": "./src/lib/ui/dom/awaitBlock.ts",
+        "./ui/dom/tryBlock": "./src/lib/ui/dom/tryBlock.ts",
+        "./ui/dom/switchBlock": "./src/lib/ui/dom/switchBlock.ts",
+        "./ui/dom/applyResolved": "./src/lib/ui/dom/applyResolved.ts",
+        "./ui/runtime/nextBlockId": "./src/lib/ui/runtime/nextBlockId.ts",
+        "./ui/runtime/enterRenderPass": "./src/lib/ui/runtime/enterRenderPass.ts",
+        "./ui/runtime/exitRenderPass": "./src/lib/ui/runtime/exitRenderPass.ts",
+        "./ui/router": "./src/lib/ui/router.ts",
+        "./ui/startClient": "./src/lib/ui/startClient.ts",
+        "./ui/navigate": "./src/lib/ui/navigate.ts",
+        "./ui/renderToStream": "./src/lib/ui/renderToStream.ts",
+        "./ui-plugin": "./src/lib/ui/compile/abideUiPlugin.ts",
+        "./mcp/createMcpServer": "./src/lib/mcp/createMcpServer.ts",
+        "./bundle/BundleWindow": "./src/lib/bundle/BundleWindow.ts",
+        "./bundle/BundleMenu": "./src/lib/bundle/BundleMenu.ts",
+        "./bundle/BundleMenuItem": "./src/lib/bundle/BundleMenuItem.ts",
+        "./bundle/onMenu": "./src/lib/bundle/onMenu.ts",
+        "./bundle/bundled": "./src/lib/bundle/bundled.ts",
+        "./test/createTestApp": "./src/lib/test/createTestApp.ts",
+        "./test/createScriptedSurface": "./src/lib/test/createScriptedSurface.ts",
+        "./test/assertAgentFrameConformance": "./src/lib/test/assertAgentFrameConformance.ts",
+        "./tsconfig": "./tsconfig.app.json",
+        "./build": "./src/build.ts",
+        "./compile": "./src/compile.ts",
+        "./preload": "./src/preload.ts",
+        "./resolver-plugin": "./src/abideResolverPlugin.ts",
+        "./ui/remoteProxy": "./src/lib/ui/remoteProxy.ts",
+        "./ui/socketProxy": "./src/lib/ui/socketProxy.ts",
+        "./server/prompts/renderPromptTemplate": "./src/lib/server/prompts/renderPromptTemplate.ts"
+    },
+    "bin": {
+        "abide": "./bin/abide.ts"
+    },
+    "files": [
+        "src",
+        "bin",
+        "template",
+        "tsconfig.app.json",
+        "CHANGELOG.md"
+    ],
+    "dependencies": {
+        "typescript": "^6.0.3"
+    },
+    "peerDependencies": {
+        "bun-plugin-tailwind": "*",
+        "tailwindcss": "^4.0.0"
+    },
+    "peerDependenciesMeta": {
+        "bun-plugin-tailwind": {
+            "optional": true
+        },
+        "tailwindcss": {
+            "optional": true
+        }
+    },
+    "devDependencies": {
+        "@abide/inspector": "workspace:*",
+        "bun-plugin-tailwind": "^0.1.2",
+        "tailwindcss": "^4.0.0"
+    }
+}