@abide/abide 0.28.0

package/src/lib/ui/tail.ts

@@ -0,0 +1,324 @@
+import { createLifecycleChannel } from '../shared/createLifecycleChannel.ts'
+import { createSubscriber } from '../shared/createSubscriber.ts'
+import { SocketDisconnectedError } from '../shared/SocketDisconnectedError.ts'
+import { tailProbeSlot } from '../shared/tailProbeSlot.ts'
+import type { Subscribable } from '../shared/types/Subscribable.ts'
+import type { TailOptions } from '../shared/types/TailOptions.ts'
+
+type TailStatus = 'pending' | 'open' | 'done' | 'error'
+
+/*
+One entry shape for both read forms: the bare latest-wins read is a window of
+1 projected to its single frame, so the frame loop, reconnect handling, and
+probes have exactly one path. The bare form keys by name alone (so `tail(x)`
+and `tail(x, { last: 1 })` stay independent subscriptions); probes match on
+`source`.
+*/
+type Entry<T> = {
+    source: string
+    key: string
+    /* window cap; 1 for the bare latest-wins form */
+    last: number
+    window: T[]
+    error: Error | undefined
+    status: TailStatus
+    refreshing: boolean
+    /* true while the createSubscriber connect callback holds the iterator open */
+    live: boolean
+    tap: () => void
+}
+
+const registry = new Map<string, Entry<unknown>>()
+
+/*
+Registry-wide lifecycle channel for the pending()/refreshing() probes — the
+tail-side counterpart of the cache store's. Probes match entries by source
+name (or all) without creating them, so they tap one "membership or state
+changed" signal instead of opening a stream the way a tail() read would.
+*/
+const lifecycle = createLifecycleChannel()
+
+/*
+Prober for the shared pending()/refreshing() probes. Probes report, never
+act: an absent entry is read as "no value yet" (pending) without opening a
+stream. A name spans every entry on that source — latest-wins and window
+forms alike; the bare form spans every registered stream.
+*/
+tailProbeSlot.probe = (name) => {
+    lifecycle.track()
+    const entries = [...registry.values()].filter(
+        (entry) => name === undefined || entry.source === name,
+    )
+    return {
+        pending:
+            (name !== undefined && entries.length === 0) ||
+            entries.some((entry) => entry.status === 'pending'),
+        refreshing: entries.some((entry) => entry.refreshing),
+    }
+}
+
+/*
+Reactive consumer for streaming sources. Takes a Subscribable<T> — the shape
+both `Socket<T>` (declared under src/server/sockets/) and the result of
+`fn.stream(args)` satisfy:
+
+  const latest = $derived(tail(chat))                      // socket, latest frame
+  const recent = $derived(tail(chat, { last: 20 }))        // live window of the last ≤20
+  const tick   = $derived(tail(tickFeed.stream()))         // rpc stream
+
+The bare form is latest-wins: T | undefined, pending until the first frame.
+The window form returns T[] — `[]` while pending, never undefined — holding
+the last ≤`last` frames however they arrived. Seeding rides the source's
+optional retention capability (`Subscribable.tail(count)`): a socket declared
+`{ tail: n }` replays up to `last` retained frames (1 for the bare form — a
+latest-wins reader only needs the newest); a source without the capability
+(rpc stream, undeclared socket) starts live-only. tail() never requires
+retention — the window semantics are identical either way, only how much
+past it can show differs.
+
+Lifecycle mirrors cache(): the entry's tracker is a createSubscriber,
+so the first derived read in a tracking scope opens the underlying iterator
+and the last derived to stop reading closes it. Many deriveds reading the
+same source share one underlying subscription — the registry dedupes by
+`subscribable.name`, with `last` folded into the key, so the bare form and
+each window size are independent subscriptions. Passing fresh `fn.stream(args)`
+Subscribables across re-renders is safe: same args → same key → shared
+subscription. tail.error / tail.status take the same options to address the
+same entry.
+
+Reconnect-with-retained-value: a transport loss (the typed
+SocketDisconnectedError, raised only by the ws channel — an rpc stream is a
+one-shot Response and never disconnects) does not surface as an error. The
+entry keeps its window, flags `refreshing` (the probe contract: value held,
+fresher source in flight — never merely `open`), and re-invokes the source;
+the channel's backoff owns the retry. The reopened source's replay commits
+over the window atomically at the `replayed` boundary (TailHooks) — appended
+it would duplicate, rebuilt frame-by-frame it would flash — and an empty
+replay keeps the held window, with live frames appending after. For the
+bare form the commit is exactly latest-wins convergence. Initial opens seed
+the same way, so a window's first paint is the full seed, not a staircase.
+
+tail is a no-op on the server (returns undefined / []) — SSR can't keep a
+stream open across the request boundary. Pages that want a seeded value in
+the initial HTML should fetch via cache() against an HTTP rpc handler and
+layer tail() on top for live updates after hydration.
+
+Errors are surfaced through tail.error(x) rather than thrown, so reading
+from a $derived can't crash the component. Status distinguishes "haven't
+received the first frame" (pending) from "stream ended cleanly" (done) and
+"wire layer surfaced an error" (error).
+*/
+// @readme tail
+export function tail<T>(subscribable: Subscribable<T>): T | undefined
+export function tail<T>(subscribable: Subscribable<T>, options: TailOptions): T[]
+export function tail<T>(subscribable: Subscribable<T>, options?: TailOptions): T | T[] | undefined {
+    if (options) {
+        return readField(subscribable, options, 'window') ?? []
+    }
+    return readField(subscribable, undefined, 'window')?.[0]
+}
+
+tail.error = function tailError<T>(
+    subscribable: Subscribable<T>,
+    options?: TailOptions,
+): Error | undefined {
+    return readField(subscribable, options, 'error')
+}
+
+tail.status = function tailStatus<T>(
+    subscribable: Subscribable<T>,
+    options?: TailOptions,
+): TailStatus {
+    return readField(subscribable, options, 'status') ?? 'pending'
+}
+
+function readField<T, K extends keyof Entry<T>>(
+    subscribable: Subscribable<T>,
+    options: TailOptions | undefined,
+    field: K,
+): Entry<T>[K] | undefined {
+    if (options && (!Number.isInteger(options.last) || options.last < 1)) {
+        throw new RangeError(`[abide] tail() \`last\` must be an integer ≥ 1, got ${options.last}`)
+    }
+    if (typeof window === 'undefined') {
+        return undefined
+    }
+    const entry = getOrCreateEntry(subscribable, options)
+    entry.tap()
+    const value = entry[field]
+    /*
+    Untracked read (outside $derived/$effect): tap() never connects, so no
+    teardown will ever evict the entry — drop it now or it sits in the
+    registry as a permanently-pending zombie the bare probes keep seeing.
+    */
+    if (!entry.live) {
+        evictIfCurrent(entry as Entry<unknown>)
+    }
+    return value
+}
+
+/* Delete only if this entry still owns its key — a fresh Subscribable with the
+   same name may have replaced it, and a stale cleanup must not nuke the new entry. */
+function evictIfCurrent(entry: Entry<unknown>): boolean {
+    if (registry.get(entry.key) === entry) {
+        registry.delete(entry.key)
+        return true
+    }
+    return false
+}
+
+function getOrCreateEntry<T>(
+    subscribable: Subscribable<T>,
+    options: TailOptions | undefined,
+): Entry<T> {
+    const key = options ? `${subscribable.name}#${options.last}` : subscribable.name
+    const cached = registry.get(key)
+    if (cached) {
+        return cached as Entry<T>
+    }
+    const last = options?.last ?? 1
+    const entry: Entry<T> = {
+        source: subscribable.name,
+        key,
+        last,
+        window: [],
+        error: undefined,
+        status: 'pending',
+        refreshing: false,
+        live: false,
+        tap: () => undefined,
+    }
+    entry.tap = createSubscriber((update) => {
+        entry.window = []
+        entry.error = undefined
+        entry.status = 'pending'
+        entry.refreshing = false
+        entry.live = true
+        let cancelled = false
+        const notify = () => {
+            update()
+            lifecycle.mark()
+        }
+        /*
+        Seed-and-commit: frames from a retaining source accumulate silently
+        until its in-band `replayed` boundary, then commit to the window in
+        one update — readers never see the window rebuild frame-by-frame.
+        An empty seed keeps the held window across a gap: nothing was
+        replayed, so nothing can duplicate, and the live frames that follow
+        append. Sources without the capability have no replay; their frames
+        append directly.
+        */
+        let seeding = false
+        let seed: T[] = []
+        const commit = () => {
+            if (cancelled || !seeding) {
+                return
+            }
+            seeding = false
+            if (seed.length > 0) {
+                entry.window = seed
+                seed = []
+            }
+            if (entry.window.length > 0) {
+                entry.status = 'open'
+            }
+            entry.refreshing = false
+            notify()
+        }
+        /*
+        A retaining source bounds replay to what the reader keeps: 1 frame
+        seeds the bare form, `last` seeds a window.
+        */
+        const open = () => {
+            if (!subscribable.tail) {
+                return subscribable[Symbol.asyncIterator]()
+            }
+            seeding = true
+            seed = []
+            return subscribable.tail(last, { replayed: commit })[Symbol.asyncIterator]()
+        }
+        /* `let`: the reconnect path swaps in a fresh iterator; teardown closes the current one. */
+        let iterator = open()
+        ;(async () => {
+            while (!cancelled) {
+                try {
+                    const next = await iterator.next()
+                    if (cancelled) {
+                        return
+                    }
+                    if (next.done) {
+                        /* a retaining source that ends without signalling still commits its seed */
+                        commit()
+                        if (entry.status !== 'error') {
+                            entry.status = 'done'
+                        }
+                        entry.refreshing = false
+                        notify()
+                        return
+                    }
+                    if (seeding) {
+                        seed.push(next.value)
+                        if (seed.length > last) {
+                            seed.shift()
+                        }
+                        continue
+                    }
+                    /*
+                    Probes read only status/refreshing, so the registry
+                    channel pings on transitions, not per frame — a chatty
+                    stream must not re-derive every bare pending()/refreshing()
+                    reader on each value. (A frame after a reconnect is the
+                    seed landing — current again, hence a transition.)
+                    */
+                    const transitioned = entry.status !== 'open' || entry.refreshing
+                    /* One copy per frame: take the surviving suffix, then append. */
+                    const base = entry.window
+                    const frames =
+                        base.length < last ? base.slice() : base.slice(base.length - last + 1)
+                    frames.push(next.value)
+                    entry.window = frames
+                    entry.status = 'open'
+                    entry.refreshing = false
+                    update()
+                    if (transitioned) {
+                        lifecycle.mark()
+                    }
+                } catch (error) {
+                    if (cancelled) {
+                        return
+                    }
+                    if (error instanceof SocketDisconnectedError) {
+                        /*
+                        Recoverable transport loss: retain the window, flag the
+                        gap, reopen — open() re-arms seeding so the reopened
+                        source's replay commits atomically over the held
+                        window. The fresh sub frame queues on the channel and
+                        flushes when its backoff attempt reconnects, so this
+                        loop just awaits the next push — no spin.
+                        */
+                        entry.refreshing = entry.window.length > 0
+                        notify()
+                        iterator = open()
+                        continue
+                    }
+                    entry.error = error instanceof Error ? error : new Error(String(error))
+                    entry.status = 'error'
+                    entry.refreshing = false
+                    notify()
+                    return
+                }
+            }
+        })()
+        lifecycle.mark()
+        return () => {
+            cancelled = true
+            entry.live = false
+            iterator.return?.(undefined)?.catch(() => undefined)
+            if (evictIfCurrent(entry as Entry<unknown>)) {
+                lifecycle.mark()
+            }
+        }
+    })
+    registry.set(key, entry as Entry<unknown>)
+    return entry
+}

package/src/lib/ui/types/Layouts.ts

@@ -0,0 +1,9 @@
+import type { UiComponent } from '../runtime/types/UiComponent.ts'
+
+/*
+Manifest of directory URL → layout.abide module loader. Produced by the resolver
+plugin from `layout.abide` files anywhere under src/ui/pages. A layout's key is its
+folder path, so it wraps every page at or below that folder; the renderer and router
+resolve a route's chain (outermost first) via layoutChainForRoute.
+*/
+export type Layouts = Record<string, () => Promise<{ default: UiComponent }>>

package/src/lib/ui/types/Pages.ts

@@ -0,0 +1,8 @@
+import type { UiComponent } from '../runtime/types/UiComponent.ts'
+
+/*
+Manifest of route URL → page.abide module loader. Produced by the resolver plugin
+from `page.abide` files anywhere under src/ui/pages. `layout.abide` files form a
+parallel manifest (see Layouts); there is no error manifest.
+*/
+export type Pages = Record<string, () => Promise<{ default: UiComponent }>>

package/src/preload.ts

@@ -0,0 +1,19 @@
+// @readme plumbing
+import { plugin } from 'bun'
+import { abideResolverPlugin } from './abideResolverPlugin.ts'
+import { abideUiPlugin } from './lib/ui/compile/abideUiPlugin.ts'
+
+const mode = (process.env.ABIDE_TARGET ?? 'server') as 'server' | 'client'
+
+await plugin(abideUiPlugin)
+await plugin(abideResolverPlugin({ target: mode }))
+
+await plugin({
+    name: 'css-noop',
+    setup(build) {
+        build.onLoad({ filter: /\.css$/ }, () => ({
+            contents: 'export default {};',
+            loader: 'js',
+        }))
+    },
+})

package/src/scaffold.ts

@@ -0,0 +1,153 @@
+import { Glob } from 'bun'
+import { abideLog } from './lib/shared/abideLog.ts'
+
+const TEMPLATE_DIR = new URL('../template', import.meta.url).pathname
+const OWN_PACKAGE_JSON = new URL('../package.json', import.meta.url).pathname
+
+/*
+Copies the bundled template directory into `${cwd}/${name}`, installs its
+dependencies, and — when `dev` is set — starts the dev server in the new
+project, so one command ends in a running app. A process can't change its
+parent shell's cwd, so `cd` is printed as the step for when editing starts.
+Refuses to write into a non-empty directory so an accidental run doesn't
+overwrite real work. `install: false` (the `--no-install` flag) skips the
+install — for CI flows that swap the dependency for a packed tarball before
+installing, and offline scaffolds. An install *failure* doesn't fail the
+scaffold: the tree is intact, so print `bun install` as a next step instead.
+`dev` only fires after a successful install and holds until the server exits.
+*/
+export async function scaffold({
+    cwd = process.cwd(),
+    name,
+    install = true,
+    dev = false,
+}: {
+    cwd?: string
+    name: string
+    install?: boolean
+    dev?: boolean
+}): Promise<string> {
+    const trimmed = name.trim()
+    if (trimmed === '') {
+        throw new Error('[abide] project name is required: bunx abide scaffold <name>')
+    }
+    const target = resolveTarget(cwd, trimmed)
+    if (await targetIsNonEmpty(target)) {
+        throw new Error(`[abide] target directory is not empty: ${target}`)
+    }
+    if (!(await Bun.file(`${TEMPLATE_DIR}/package.json`).exists())) {
+        throw new Error(`[abide] template missing at ${TEMPLATE_DIR}`)
+    }
+    await copyTree(TEMPLATE_DIR, target)
+    await pinAbideToOwnVersion(target)
+    const installed = install ? await installDependencies(target) : false
+    abideLog.success(`scaffolded abide project at ${target}`)
+    if (target !== cwd) {
+        abideLog.detail(`  to start editing: cd ${trimmed}`)
+    }
+    if (dev && installed) {
+        await runDevServer(target)
+        return target
+    }
+    abideLog.detail('  to run it:')
+    if (!installed) {
+        abideLog.detail('    bun install')
+    }
+    abideLog.detail('    bun run dev')
+    return target
+}
+
+/* Runs `bun install` in the scaffolded project, streaming its output. */
+async function installDependencies(target: string): Promise<boolean> {
+    const proc = Bun.spawn(['bun', 'install'], {
+        cwd: target,
+        stdout: 'inherit',
+        stderr: 'inherit',
+    })
+    if ((await proc.exited) === 0) {
+        return true
+    }
+    abideLog.warn('bun install failed — run it yourself once the cause is fixed')
+    return false
+}
+
+/* Starts the project's dev server (Ctrl-C stops it) and waits for it to exit. */
+async function runDevServer(target: string): Promise<void> {
+    abideLog.detail('  starting the dev server (Ctrl-C to stop)…')
+    const proc = Bun.spawn(['bun', 'run', 'dev'], {
+        cwd: target,
+        stdin: 'inherit',
+        stdout: 'inherit',
+        stderr: 'inherit',
+    })
+    await proc.exited
+}
+
+/*
+Rewrites the scaffolded package.json so `abide` is pinned to the
+version of the CLI that ran the scaffold. The template's static pin is only a
+fallback — deriving the range at scaffold time means a stale template can
+never install a framework version the docs don't describe.
+*/
+async function pinAbideToOwnVersion(target: string): Promise<void> {
+    const { name, version } = await Bun.file(OWN_PACKAGE_JSON).json()
+    const manifestFile = Bun.file(`${target}/package.json`)
+    const manifest = await manifestFile.json()
+    manifest.dependencies[name] = `^${version}`
+    await Bun.write(manifestFile, `${JSON.stringify(manifest, undefined, 4)}\n`)
+}
+
+/*
+Copies every file under `from` into `to`, preserving relative paths. Uses
+Bun.Glob to enumerate (dotfiles included) and Bun.write to materialize each
+file — Bun.write auto-creates parent directories.
+*/
+async function copyTree(from: string, to: string): Promise<void> {
+    const files = await Array.fromAsync(
+        new Glob('**/*').scan({ cwd: from, onlyFiles: true, dot: true }),
+    )
+    await Promise.all(
+        files.map(async (relativePath) => {
+            const source = Bun.file(`${from}/${relativePath}`)
+            await Bun.write(`${to}/${relativePath}`, source)
+        }),
+    )
+}
+
+/*
+Resolves the user-supplied name against the working directory. Absolute
+paths (`/tmp/foo`) and `~`-prefixed paths are used as-is; relative names
+are joined onto `cwd`.
+*/
+function resolveTarget(cwd: string, name: string): string {
+    if (name === '.' || name === './') {
+        return cwd
+    }
+    if (name.startsWith('/')) {
+        return name
+    }
+    if (name.startsWith('~/')) {
+        const home = process.env.HOME ?? ''
+        return `${home}${name.slice(1)}`
+    }
+    return `${cwd}/${name}`
+}
+
+/*
+True when the target exists and contains at least one entry. Uses Bun.Glob
+rather than fs.readdir to honor the project's "Bun-first" rule. A missing
+directory is reported as empty so first-time scaffolds proceed.
+*/
+async function targetIsNonEmpty(target: string): Promise<boolean> {
+    try {
+        for await (const _ of new Glob('*').scan({ cwd: target, onlyFiles: false, dot: true })) {
+            return true
+        }
+    } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+            return false
+        }
+        throw error
+    }
+    return false
+}

package/src/serverBuildPlugins.ts

@@ -0,0 +1,19 @@
+import type { BunPlugin } from 'bun'
+import { abideResolverPlugin } from './abideResolverPlugin.ts'
+import { abideUiPlugin } from './lib/ui/compile/abideUiPlugin.ts'
+
+/*
+The server-target Bun.build plugin pair shared by compile / buildCli / bundleApp:
+the abide-ui `.abide` loader (so SSR `render()` resolves) plus abide's virtual-
+module resolver. `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 [abideUiPlugin, abideResolverPlugin({ cwd, embedAssets, target: 'server' })]
+}

package/src/serverEntry.ts

@@ -0,0 +1,95 @@
+// @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 { createServer } from './lib/server/runtime/createServer.ts'
+import { requestContext } from './lib/server/runtime/requestContext.ts'
+import { resolvePageSnapshot } from './lib/server/runtime/resolvePageSnapshot.ts'
+import { createCacheStore } from './lib/shared/createCacheStore.ts'
+import { loadEnvFromDataDir } from './lib/shared/loadEnvFromDataDir.ts'
+import { runningAsStandaloneBinary } from './lib/shared/runningAsStandaloneBinary.ts'
+import { setCacheStoreResolver } from './lib/shared/setCacheStoreResolver.ts'
+import { setGlobalCacheStoreResolver } from './lib/shared/setGlobalCacheStoreResolver.ts'
+import { setPageResolver } from './lib/shared/setPageResolver.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()
+
+setCacheStoreResolver(() => requestContext.getStore()?.cache)
+
+setPageResolver(resolvePageSnapshot)
+
+/*
+Process-level store for cache(fn, { global: true }) — one per server process,
+outlives every request so memoised external calls are shared across them.
+*/
+const globalCacheStore = createCacheStore()
+setGlobalCacheStoreResolver(() => globalCacheStore)
+
+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/template/bunfig.toml

@@ -0,0 +1,4 @@
+[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

@@ -0,0 +1,18 @@
+{
+    "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.27.0"
+    }
+}