@abide/abide 0.58.0 → 0.101.0

package/src/serverBuildPlugins.ts

@@ -1,25 +0,0 @@
-import type { BunPlugin } from 'bun'
-import { abideResolverPlugin } from './abideResolverPlugin.ts'
-import { abideUiPlugin } from './lib/ui/compile/abideUiPlugin.ts'
-import { zodCjsPlugin } from './zodCjsPlugin.ts'
-
-/*
-The server-target Bun.build plugin set shared by compile / buildCli / bundleApp:
-the abide-ui `.abide` loader (so SSR `render()` resolves), abide's virtual-module
-resolver, and the zod→CommonJS shim that works around bun's broken ESM-cycle
-bundling (see zodCjsPlugin). `embedAssets` flips on the gzip asset embed used by
-the standalone server binary; the CLI + launcher builds leave it off.
-*/
-export function serverBuildPlugins({
-    cwd,
-    embedAssets = false,
-}: {
-    cwd: string
-    embedAssets?: boolean
-}): BunPlugin[] {
-    return [
-        zodCjsPlugin(cwd),
-        abideUiPlugin,
-        abideResolverPlugin({ cwd, embedAssets, target: 'server' }),
-    ]
-}

package/src/serverEntry.ts

@@ -1,138 +0,0 @@
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-import * as appMod from './_virtual/app.ts'
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-import { appInfo } from './_virtual/app-info.ts'
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-import { assets } from './_virtual/assets.ts'
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-import cliProgramName from './_virtual/cli-name.ts'
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-import { layouts } from './_virtual/layouts.ts'
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-import mcp from './_virtual/mcp.ts'
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-import { mcpResources } from './_virtual/mcp-resources.ts'
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-import { pages } from './_virtual/pages.ts'
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-import { prompts } from './_virtual/prompts.ts'
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-import { publicAssets } from './_virtual/public-assets.ts'
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-import { rpc } from './_virtual/rpc.ts'
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-import { shell } from './_virtual/shell.ts'
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-import { sockets } from './_virtual/sockets.ts'
-import { exitWithParent } from './lib/bundle/exitWithParent.ts'
-import { loadEnvFromBinaryDir } from './lib/cli/loadEnvFromBinaryDir.ts'
-import { broadcastAmend } from './lib/server/runtime/amendBroadcaster.ts'
-import { broadcastCacheStaleness } from './lib/server/runtime/cacheStalenessBroadcaster.ts'
-import { createServer } from './lib/server/runtime/createServer.ts'
-import { requestContext } from './lib/server/runtime/requestContext.ts'
-import { resolvePageSnapshot } from './lib/server/runtime/resolvePageSnapshot.ts'
-import { amendBroadcastSlot } from './lib/shared/amendBroadcastSlot.ts'
-import { cacheStalenessSlot } from './lib/shared/cacheStalenessSlot.ts'
-import { cacheStoreSlot } from './lib/shared/cacheStoreSlot.ts'
-import { createCacheStore } from './lib/shared/createCacheStore.ts'
-import { docSnapshotsSlot } from './lib/shared/docSnapshotsSlot.ts'
-import { loadEnvFromDataDir } from './lib/shared/loadEnvFromDataDir.ts'
-import { pageSlot } from './lib/shared/pageSlot.ts'
-import { pendingAsyncCellsSlot } from './lib/shared/pendingAsyncCellsSlot.ts'
-import { resolvedCellsSlot } from './lib/shared/resolvedCellsSlot.ts'
-import { runningAsStandaloneBinary } from './lib/shared/runningAsStandaloneBinary.ts'
-import { sharedCacheStoreSlot } from './lib/shared/sharedCacheStoreSlot.ts'
-import { socketTailsSlot } from './lib/shared/socketTailsSlot.ts'
-import { streamedCellsSlot } from './lib/shared/streamedCellsSlot.ts'
-
-/*
-Resolve config into process.env before anything reads it (createServer reads
-PORT, app code reads Bun.env.*). Standalone-only: data-dir first so the user's
-saved config wins over the binary-dir shipped default; both back-fill only what
-the shell didn't already set. A bundle launched via `open` has cwd `/`, so the
-data-dir `.env` is how it gets its config at all. Under `bun dev`/`bun start`
-these bundle layers don't apply — the project's own CWD `.env` (Bun-autoloaded)
-is the config — so loading them would let a stray data-dir `PORT` defeat dev's
-port scan.
-*/
-if (runningAsStandaloneBinary()) {
-    await loadEnvFromDataDir(cliProgramName)
-    await loadEnvFromBinaryDir()
-}
-
-/*
-Eager-import src/server/config.ts (via abide:config) now that every .env layer
-is merged into process.env — its top-level `env(schema)` validates the
-environment and fails the boot loudly here, before the server starts, rather
-than lazily on the first handler that imports `$server/config`. A dynamic
-import (not a static top-level one) so it runs after the merge above, not at
-module-eval time. No-op when the file is absent.
-*/
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-await import('./_virtual/config.ts')
-
-// In a bundle, tie this server's life to the launcher's (no-op standalone).
-exitWithParent()
-
-/*
-Process-level ("shared") store for cache(fn, { shared: true }) — one per server
-process, outlives every request so memoised external calls are shared across them.
-It is also the store a read with no request in flight resolves to, so boot/cron/
-socket-handler reads coalesce into a real store instead of an orphan fallback.
-*/
-const sharedCacheStore = createCacheStore()
-sharedCacheStoreSlot.resolver = () => sharedCacheStore
-
-cacheStoreSlot.resolver = () => requestContext.getStore()?.cache ?? sharedCacheStore
-
-/*
-Server-side invalidate()/refresh() broadcast to every connected client instead of
-mutating a throwaway request store (ADR-0041). The broadcaster is imported ONLY here
-so its server socket code never enters the client reachability graph.
-*/
-cacheStalenessSlot.resolver = () => broadcastCacheStaleness
-
-/*
-Server-side amend(args, value) broadcasts the keyed value to every authorized reader
-instead of mutating a throwaway request store (ADR-0043). Imported ONLY here so the
-broadcaster's socket code never enters the client reachability graph — the same import
-discipline as the staleness broadcaster above.
-*/
-amendBroadcastSlot.resolver = () => broadcastAmend
-
-/* One process-wide fallback list for reads with no request in flight (boot/cron/socket) —
-   real requests each carry their own `pendingAsyncCells`, so the SSR barrier drains a
-   per-request list and concurrent renders never cross-contaminate. */
-const sharedPendingAsyncCells = { promises: [] }
-pendingAsyncCellsSlot.resolver = () =>
-    requestContext.getStore()?.pendingAsyncCells ?? sharedPendingAsyncCells
-const sharedResolvedCells = { entries: [] }
-resolvedCellsSlot.resolver = () => requestContext.getStore()?.resolvedCells ?? sharedResolvedCells
-const sharedStreamedCells = { entries: [] }
-streamedCellsSlot.resolver = () => requestContext.getStore()?.streamedCells ?? sharedStreamedCells
-/* No shared fallback: `defineSocket.peek` records into this on every retained-frame read, including
-   reads outside any request (ws handlers, boot) — a fallback list would accumulate entries no render
-   ever drains. Off-request this resolves undefined and the record is skipped (see socketTailsSlot). */
-socketTailsSlot.resolver = () => requestContext.getStore()?.socketTails
-const sharedDocSnapshots = { entries: [] }
-docSnapshotsSlot.resolver = () => requestContext.getStore()?.docSnapshots ?? sharedDocSnapshots
-
-pageSlot.resolver = resolvePageSnapshot
-
-await createServer({
-    pages,
-    layouts,
-    rpc,
-    sockets,
-    prompts,
-    shell,
-    app: appMod,
-    assets,
-    publicAssets,
-    mcpResources,
-    mcp,
-    cliProgramName,
-    appInfo,
-    // Set by the dev orchestrator (devEntry); mounts the live-reload channel.
-    dev: Bun.env.ABIDE_DEV === '1',
-})

package/src/zodCjsPlugin.ts

@@ -1,51 +0,0 @@
-import { existsSync } from 'node:fs'
-import { dirname } from 'node:path'
-import type { BunPlugin } from 'bun'
-
-/*
-Routes every `zod` import in a server bundle to zod's CommonJS build.
-
-zod v4's ESM is reached through two subpaths (`zod` and `zod/v4/core`) whose
-modules form an initialization cycle. Bun's bundler emits a broken init order
-for that cycle (oven-sh/bun#31586, closed as not-planned), so a bundled binary
-crashes (`<helper> is not defined`) or — for a lazily imported module — silently
-fails to evaluate, which drops every rpc whose module imports zod from the
-registry. It only bites bundled output; `abide dev` runs unbundled and is fine.
-
-zod ships a parallel CommonJS build (`index.cjs`, `v4/core/index.cjs`, …), and
-CommonJS resolves circular requires through a mutating `module.exports` with no
-temporal-dead-zone, so the cycle initializes correctly. Resolving each zod
-specifier to its `.cjs` sibling makes bun bundle zod as CommonJS and sidesteps
-the bug while keeping zod v4. Server-only: the client bundle strips zod from rpc
-modules (they become remote proxies), and dev never bundles.
-*/
-export function zodCjsPlugin(cwd: string): BunPlugin {
-    /*
-    The (specifier, importer-dir) → cjs path mapping is deterministic per build —
-    zod's location doesn't move mid-build, and the filter fires for every zod
-    import in every module. Memoise on a `${path}\0${from}` key (mirrors the
-    resolver's resolveExtension cache) so the fs round-trips (resolveSync +
-    existsSync) run once per unique pair instead of once per import.
-    */
-    const cjsPathCache = new Map<string, string>()
-    return {
-        name: 'abide-zod-cjs',
-        setup(build) {
-            build.onResolve({ filter: /^zod($|\/)/ }, (args) => {
-                /* Resolve from the importer (or cwd for the entry) to zod's ESM
-                   target, then swap to its `.cjs` sibling when one exists. */
-                const from = args.importer ? dirname(args.importer) : cwd
-                const key = `${args.path}\0${from}`
-                const cached = cjsPathCache.get(key)
-                if (cached !== undefined) {
-                    return { path: cached }
-                }
-                const resolved = Bun.resolveSync(args.path, from)
-                const cjs = resolved.replace(/\.js$/, '.cjs')
-                const path = existsSync(cjs) ? cjs : resolved
-                cjsPathCache.set(key, path)
-                return { path }
-            })
-        },
-    }
-}

package/template/.zed/settings.json

@@ -1,10 +0,0 @@
-{
-  "auto_install_extensions": { "abide": true },
-  "semantic_tokens": "combined",
-  "global_lsp_settings": {
-    "semantic_token_rules": [
-      { "token_type": "tag", "style": ["tag"] },
-      { "token_type": "attribute", "style": ["attribute"] }
-    ]
-  }
-}

package/template/CLAUDE.md

@@ -1,22 +0,0 @@
-# Project guide for Claude
-
-This app is built with **abide** — a type-safe isomorphic framework on Bun.
-
-**Before working with any abide API, read the complete surface map:**
-`node_modules/@abide/abide/AGENTS.md` — every export (with import path + signature),
-the file-based conventions, the CLI, env vars, and the `.abide` component grammar.
-Open the source under `node_modules/@abide/abide/src/lib/` for depth; the README is
-at `node_modules/@abide/abide/README.md`.
-
-> Tip: to keep that map permanently in context instead of reading it on demand,
-> replace the line above with an import: `@node_modules/@abide/abide/AGENTS.md`
-
-## Conventions (see AGENTS.md for the full list)
-
-- One export per file, named after the file. No barrels — import each name by its
-  own path (`@abide/abide/server/GET`, `@abide/abide/shared/refresh`, …).
-- RPCs live in `src/server/rpc/<name>.ts`; sockets in `src/server/sockets/`;
-  pages are `**/page.abide`, layouts `**/layout.abide`.
-- Generated types land in `src/.abide/` — do not hand-edit them; run `abide dev`/
-  `abide check` to regenerate.
-- Prefer Bun and web-standard APIs over Node APIs.

package/template/bunfig.toml

@@ -1,4 +0,0 @@
-[test]
-# Register the abide preload so `.abide` components compile under `bun test`
-# (same runtime as the server).
-preload = ["@abide/abide/preload"]

package/template/package.json

@@ -1,21 +0,0 @@
-{
-    "name": "abide-app",
-    "version": "0.0.1",
-    "private": true,
-    "type": "module",
-    "scripts": {
-        "dev": "abide dev",
-        "build": "abide build",
-        "start": "abide start",
-        "compile": "abide compile",
-        "cli": "abide cli",
-        "bundle": "abide bundle",
-        "test": "bun test"
-    },
-    "dependencies": {
-        "@abide/abide": "^0.46.0"
-    },
-    "devDependencies": {
-        "@types/bun": "^1.3.14"
-    }
-}

package/template/src/app.ts

@@ -1,28 +0,0 @@
-/*
-Optional application hooks. Every export is optional; delete the ones you
-don't need. Abide resolves this file at build time via the abide:app virtual
-module — no import is needed from your own code.
-
-  forwardHeaders extra inbound header names forwarded onto in-process rpc
-                 Requests (SSR / MCP), on top of abide's cookie/authorization/
-                 traceparent/tracestate/x-forwarded-* allowlist
-  init           runs once after Bun.serve is up; return a cleanup for SIGINT/SIGTERM
-  handle         middleware wrapping the default request pipeline
-  handleError    custom 500 fallback
-  health         app fields merged into the /__abide/health payload the
-                 client health() polls — public, never put secrets in it
-*/
-import type { AppModule } from '@abide/abide/server/AppModule'
-
-export const init: AppModule['init'] = () => {
-    // one-time setup; optionally return a cleanup to run on SIGINT/SIGTERM
-}
-
-export const handle: AppModule['handle'] = async (request, next) => {
-    return next(request)
-}
-
-export const handleError: AppModule['handleError'] = (error) => {
-    console.error(error)
-    return new Response('something went wrong', { status: 500 })
-}

package/template/src/cli/banner.txt

@@ -1,3 +0,0 @@
-┌───────────────┐
-│   abide app   │
-└───────────────┘

package/template/src/cli/footer.txt

@@ -1 +0,0 @@
-Run `<command> --help` for command-specific flags.

package/template/src/server/config.ts

@@ -1,17 +0,0 @@
-/*
-Typed environment. `env(schema)` validates Bun.env against a Standard Schema at
-boot — a missing or malformed variable fails the boot with every issue listed,
-instead of surfacing as `undefined` inside a handler. Import `config` from
-`$server/config` anywhere server-side; it's typed from the schema.
-
-Abide eager-imports this file at boot (the abide:config virtual) — no import is
-needed from your own code. The floor below re-exports Bun.env untyped; swap it
-for a schema once you have required variables:
-
-  import { env } from '@abide/abide/server/env'
-  import { z } from 'zod'
-  export const config = env(z.object({ DATABASE_URL: z.string() }))
-
-Optional — delete this file to read Bun.env directly instead.
-*/
-export const config = Bun.env

package/template/src/server/rpc/getHello.ts

@@ -1,38 +0,0 @@
-/*
-RPC module — every file under src/server/rpc/ exposes exactly one RPC: a remote
-function. The filename is the export name and the URL path (under `/rpc/`),
-and the imported method helper (GET / POST / PUT / PATCH / DELETE / HEAD) picks
-the HTTP method. The bundler swaps the runtime per build target: direct call on
-the server, fetch over the network on the client.
-
-Args (what the caller passes in) come from the handler's parameter type —
-annotate the parameter and the body infers; a typed generic on the helper is a
-compile error. Return (what the caller receives after Content-Type-driven
-decoding) is inferred from the handler's return type via the `TypedResponse<T>`
-brand on `json`/`error`/`redirect`/`jsonl`/`sse`, so plain
-`GET(() => json({...}))` already types end-to-end.
-
-For inbound validation pass a Standard Schema under `schemas.input` in the
-second argument: `GET(fn, { schemas: { input } })`. Args then infers from the
-schema's output type and the server replies with 422 on validation failure. An
-optional `schemas.output` describes the success body for the OpenAPI 200
-response and the MCP tool output; without one the handler's return type is
-projected to JSON Schema.
-
-`json(...)` from `abide/server/json` is a thin wrapper over `Response.json`
-that defaults `Cache-Control: no-store`, since intermediary caches shouldn't
-memoise rpc replies (the framework's per-request cache handles in-process
-dedupe). Other helpers are siblings, one per file: `abide/server/error`,
-`abide/server/redirect`, `abide/server/sse`, `abide/server/jsonl`.
-
-Every rpc value also exposes `.raw(args?, init?)` (returns the underlying
-`Response`) for callers that need headers or status. A streaming rpc — a
-jsonl/sse handler — returns a `NamedAsyncIterable` over the frames from its bare
-call (`fn(args)`); iterate it with `for await` or react to it with
-`watch(fn(args), frame => …)`.
-*/
-
-import { GET } from '@abide/abide/server/GET'
-import { json } from '@abide/abide/server/json'
-
-export const getHello = GET(() => json({ message: 'Hello from abide' }))

package/template/src/ui/app.css

@@ -1,21 +0,0 @@
-/*
-Global stylesheet. Imported once from src/ui/Layout.abide so it ships
-with every page that wraps it. To enable Tailwind v4, add `bun-plugin-tailwind` and
-`tailwindcss` as devDependencies and replace this file with:
-
-    @import "tailwindcss";
-*/
-
-:root {
-    font-family: system-ui, sans-serif;
-    color: #1f2937;
-    background: #f8fafc;
-}
-
-body {
-    margin: 0;
-}
-
-a {
-    color: inherit;
-}

package/template/src/ui/app.html

@@ -1,24 +0,0 @@
-<!--
-Optional HTML shell. If present at src/ui/app.html, abide uses this as the SSR
-template; otherwise an identical default shell is used. abide has no component
-<head>, so static tags like <title> live here. abide injects its client entry
-(the /_app/client.css <link> and /_app/client.js <script>) automatically, so the
-shell only needs page structure and the three markers, replaced at render time:
-  ssr:head     abide's hydration bootstrap
-  ssr:body     rendered page body
-  ssr:state    cache snapshot + route info for hydration
-Delete this file to use the default shell.
--->
-<!doctype html>
-<html lang="en">
-<head>
-<meta charset="UTF-8" />
-<meta name="viewport" content="width=device-width, initial-scale=1.0" />
-<title>abide app</title>
-<!--ssr:head-->
-</head>
-<body>
-<div id="app"><!--ssr:body--></div>
-<!--ssr:state-->
-</body>
-</html>

package/template/src/ui/pages/about/page.abide

@@ -1,7 +0,0 @@
-<script>
-/* A second page — served at GET /about. Folder name becomes the URL segment; the
-   root layout.abide wraps it, same as the home page. */
-</script>
-
-<h1>About</h1>
-<p>This is a barebones abide app.</p>

package/template/src/ui/pages/layout.abide

@@ -1,19 +0,0 @@
-<script>
-/*
-Root layout. A layout.abide wraps every page at or below its folder — here
-src/ui/pages/, so it wraps the whole app. The page renders where this layout
-calls {children()}; the resolver finds it by filename (no per-page import), and the client router
-keeps it mounted across navigation, so this chrome never re-mounts. A nested
-layout.abide (in a subfolder) wraps inside this one. Runs on the server during
-SSR and on the client after hydration.
-*/
-import '../app.css'
-</script>
-
-<header>
-    <nav>
-        <a href="/">Home</a>
-        <a href="/about">About</a>
-    </nav>
-</header>
-<main>{children()}</main>

package/template/src/ui/pages/page.abide

@@ -1,19 +0,0 @@
-<script>
-/*
-Root page — served at GET /. Every folder under src/ui/pages/ that contains a
-page.abide mounts at that folder's URL; the root layout.abide wraps it.
-
-The blocking await-block below (the `then` clause sits in the `{#await}` head)
-resolves on the server during SSR and renders inline — no pending placeholder. The
-bare rpc call IS the smart read: cached, coalesced, and reactive by default. The
-decoded body is captured into the per-request cache, serialized into the HTML, and
-replayed on the client during hydration with no second fetch. A `{:then}` *branch*
-instead would stream the resolution in out of order.
-*/
-import { getHello } from '$server/rpc/getHello.ts'
-</script>
-
-{#await getHello() then hello}
-    <h1>{hello.message}</h1>
-{/await}
-<p>Edit <code>src/ui/pages/page.abide</code> and the page hot-reloads.</p>

package/template/test/app.test.ts

@@ -1,30 +0,0 @@
-/*
-Test module — `createTestApp()` boots your real app on an ephemeral port (the
-same wiring as `abide start`, no fixtures) and hands back the whole surface:
-
-  app.fetch(path)        — pages and raw HTTP, origin + mount base resolved
-  app.rpc.<name>(args)   — RPCs over the real pipeline (CSRF, cookies, base),
-                           typed and decoded; .raw(args) for the Response
-  app.sockets.<name>     — a live Socket: iterate it (for await), .peek(), .publish(m)
-  app.health()           — the /__abide/health payload
-
-`app.rpc` / `app.sockets` are typed from your own RPCs and sockets — generated
-into src/.abide during a build, so the keys exist with no imports. The abide
-preload (see bunfig.toml) makes the project's routes resolvable under bun test.
-
-`await using` disposes the app (server + restored slots) when the block ends,
-so a thrown assertion still releases the port.
-*/
-import { expect, test } from 'bun:test'
-import { createTestApp } from '@abide/abide/test/createTestApp'
-
-test('serves the home page', async () => {
-    await using app = await createTestApp()
-    const html = await (await app.fetch('/')).text()
-    expect(html).toContain('Hello from abide')
-})
-
-test('getHello returns the greeting', async () => {
-    await using app = await createTestApp()
-    expect(await app.rpc.getHello()).toEqual({ message: 'Hello from abide' })
-})

package/template/tsconfig.json

@@ -1,18 +0,0 @@
-{
-    "extends": "@abide/abide/tsconfig",
-    "include": ["src/**/*.ts", "src/.abide/**/*.ts", "src/**/*.abide"],
-    "compilerOptions": {
-        "paths": {
-            "$server": ["./src/server"],
-            "$server/*": ["./src/server/*"],
-            "$ui": ["./src/ui"],
-            "$ui/*": ["./src/ui/*"],
-            "$shared": ["./src/shared"],
-            "$shared/*": ["./src/shared/*"],
-            "$mcp": ["./src/mcp"],
-            "$mcp/*": ["./src/mcp/*"],
-            "$cli": ["./src/cli"],
-            "$cli/*": ["./src/cli/*"]
-        }
-    }
-}

package/tsconfig.app.json

@@ -1,17 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ESNext",
-        "module": "ESNext",
-        "moduleResolution": "bundler",
-        "lib": ["ESNext", "DOM", "DOM.Iterable"],
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "allowImportingTsExtensions": true,
-        "verbatimModuleSyntax": true,
-        "noEmit": true,
-        "isolatedModules": true,
-        "erasableSyntaxOnly": true,
-        "types": ["bun"]
-    }
-}