@abide/abide 0.57.1 → 0.100.0

package/src/lib/ui/state.ts

@@ -1,77 +0,0 @@
-import { computed } from './computed.ts'
-import { linked } from './linked.ts'
-import { createSignalNode } from './runtime/createSignalNode.ts'
-import { readNode } from './runtime/readNode.ts'
-import type { State } from './runtime/types/State.ts'
-import { writeNode } from './runtime/writeNode.ts'
-import { scope } from './scope.ts'
-
-/* The imported reactive surface: the `state` callable plus its attached members.
-   `state`/`state.linked`/`state.computed` are the reactive primitives an author
-   imports (`import { state } from '@abide/abide/ui/state'`); the compiler resolves
-   the import binding (alias-safe) and lowers each onto the ambient scope. `.share`/
-   `.shared` are the context seam — the reference store the runtime scope exposes,
-   reached ambiently so a component can pass a named value down its subtree. */
-type StateFn = {
-    /* No-arg form for an undefined initial with a declared type: `state<Foo>()` is
-       `State<Foo | undefined>`. Without it `state(undefined)` infers `T = undefined`
-       (every `.value` access then narrows to `never`). */
-    <T>(): State<T | undefined>
-    <T>(initial: T, transform?: (next: T, previous: T) => T): State<T>
-    /* The no-arg form spelled out: `state<Foo>(undefined)` is `State<Foo | undefined>`
-       too. Kept a distinct overload (not `initial?: T`) BELOW the general form — a real
-       initial still binds `T` from the value; only an explicit `undefined` (which the
-       general form rejects as "not assignable to T") falls through to here. A bare
-       `state(undefined)` still resolves against the general form (`T = undefined`), so
-       this overload changes nothing for it. */
-    <T>(initial: undefined): State<T | undefined>
-    /* A writable cell reseeded from a reactive thunk (`state.linked(() => src())`). */
-    linked: typeof linked
-    /* A read-only cell computed from other cells (`state.computed(() => a() + b())`). */
-    computed: typeof computed
-    /* Puts a named value on the ambient scope, read down the tree by `state.shared`. */
-    share: (key: string, value: unknown) => void
-    /* Reads the closest ancestor scope that shared `key`; undefined if none provided. */
-    shared: <T>(key: string) => T | undefined
-}
-
-/*
-A writable reactive cell — abide's from-scratch reactive primitive, with no
-compiler sigil and no external reactivity-library import. `.value` is a
-plain getter/setter over a signal node, so a read/write shows up as exactly that
-in a stack trace. Imported and called bare (`let count = state(0)`); the compiler
-resolves the `state` import binding (alias-safe), desugars plain `state(initial)` to
-a serializable `model` doc slot, and keeps `state(initial, transform)` as a `.value`
-cell routed onto the ambient scope; the runtime needs no magic.
-
-`transform` is an optional coercion gate on the write path: every `.value =`
-runs it and stores what it returns, with `previous` for clamp-relative writes or
-rejection (`return previous` is an `Object.is` no-op). It is the local-truth
-mirror of `computed`'s write-through `set` — here the value lives in this cell, so
-the gate *returns* what to store rather than writing an external target. The
-construction `initial` is taken verbatim; the gate runs on writes only.
-*/
-function stateCell<T>(initial?: T, transform?: (next: T, previous: T) => T): State<T | undefined> {
-    const node = createSignalNode(initial)
-    return {
-        get value(): T | undefined {
-            return readNode(node) as T | undefined
-        },
-        set value(next: T | undefined) {
-            writeNode(node, transform === undefined ? next : transform(next as T, node.value as T))
-        },
-    }
-}
-
-const stateFn = stateCell as StateFn
-stateFn.linked = linked
-stateFn.computed = computed
-/* `.share`/`.shared` route onto the ambient scope, read/written at call time so the
-   state ↔ scope module cycle resolves. */
-stateFn.share = (key: string, value: unknown): void => {
-    scope().share(key, value)
-}
-stateFn.shared = <T>(key: string): T | undefined => scope().shared<T>(key)
-
-// @documentation reactive-state
-export const state = stateFn

package/src/lib/ui/subscribeCacheStaleness.ts

@@ -1,85 +0,0 @@
-import { abideLog } from '../shared/abideLog.ts'
-import { CACHE_STALENESS_SOCKET } from '../shared/CACHE_STALENESS_SOCKET.ts'
-import { cache } from '../shared/cache.ts'
-import { matcherFromEnvelope } from '../shared/matcherFromEnvelope.ts'
-import { SocketDisconnectedError } from '../shared/SocketDisconnectedError.ts'
-import type { CacheStalenessFrame } from '../shared/types/CacheStalenessFrame.ts'
-import type { Socket } from '../shared/types/Socket.ts'
-import { socketProxy } from './socketProxy.ts'
-
-/*
-The client half of the cross-client staleness broadcast (ADR-0041): every tab
-subscribes to the reserved __abide/cache socket at boot and applies each frame to
-its own cache. A frame rebuilds the entry predicate via matcherFromEnvelope and
-drives the SAME store loop a local invalidate()/refresh() does
-(cache.invalidateMatching / cache.refreshMatching), so wire-driven and local applies
-can't diverge.
-
-LIVE-ONLY, never replay: bare iteration (replay 0) on both boot and reconnect — a
-client applies only frames published while it is connected. The reserved topic keeps
-no tail, so there is nothing to catch up on; a client offline when a frame was
-published misses it and falls back to SWR staleness. Applies are idempotent, so
-correctness has no dependency on frame ordering.
-
-No-op on the server (no window): the broadcast is the server's job, not something it
-consumes. Returns a disposer that stops the loop and closes the subscription.
-*/
-export function subscribeCacheStaleness(injectedSocket?: Socket<CacheStalenessFrame>): () => void {
-    if (typeof window === 'undefined') {
-        return () => undefined
-    }
-    /* Default to the browser channel proxy; tests inject a socket over their own channel. */
-    const socket = injectedSocket ?? socketProxy<CacheStalenessFrame>(CACHE_STALENESS_SOCKET)
-    const controller = new AbortController()
-    /* `let`: a reconnect swaps in a fresh live iterator after a transport loss. */
-    let iterator = socket[Symbol.asyncIterator]()
-    ;(async () => {
-        while (!controller.signal.aborted) {
-            let next: IteratorResult<CacheStalenessFrame>
-            try {
-                next = await iterator.next()
-            } catch (error) {
-                if (controller.signal.aborted) {
-                    return
-                }
-                /* Transport loss: re-open a fresh LIVE subscription (no replay) and keep going. */
-                if (error instanceof SocketDisconnectedError) {
-                    iterator = socket[Symbol.asyncIterator]()
-                    continue
-                }
-                abideLog.error(error)
-                return
-            }
-            if (controller.signal.aborted || next.done === true) {
-                return
-            }
-            /* One malformed frame must not tear down the live pipe: a throw from decode/apply
-               is logged and swallowed so every subsequent frame still delivers. Frames come
-               only from the trusted server (clientPublish is false), so this is defense in
-               depth, not an expected path. */
-            try {
-                applyFrame(next.value)
-            } catch (error) {
-                abideLog.error(error)
-            }
-        }
-    })()
-    return () => {
-        controller.abort()
-        iterator.return?.(undefined)?.catch(() => undefined)
-    }
-}
-
-/* Applies one decoded frame to this tab's cache via the shared apply-by-matcher seam. */
-function applyFrame(frame: CacheStalenessFrame): void {
-    const matches = matcherFromEnvelope(frame)
-    /* The tripwire label + the rpc-error-registry prefix, mirroring what a local selector
-       derives: a tag frame has no key prefix to clear. */
-    const label = frame.mode === 'tags' ? `tags: ${frame.tags.join(', ')}` : frame.match
-    const prefix = frame.mode === 'tags' ? undefined : frame.match
-    if (frame.op === 'invalidate') {
-        cache.invalidateMatching(matches, label, prefix)
-    } else {
-        cache.refreshMatching(matches, label, prefix)
-    }
-}

package/src/lib/ui/trackedComputed.ts

@@ -1,68 +0,0 @@
-import { isAsyncIterable } from '../shared/isAsyncIterable.ts'
-import type { AsyncComputed } from '../shared/types/AsyncComputed.ts'
-import type { NamedAsyncIterable } from '../shared/types/NamedAsyncIterable.ts'
-import { createAsyncCell } from './runtime/createAsyncCell.ts'
-import { createComputedNode } from './runtime/createComputedNode.ts'
-import { isAsyncFunction } from './runtime/isAsyncFunction.ts'
-import { OWNER } from './runtime/OWNER.ts'
-import { readNode } from './runtime/readNode.ts'
-import type { Computed } from './runtime/types/Computed.ts'
-import { unlinkDeps } from './runtime/unlinkDeps.ts'
-import { untrack } from './runtime/untrack.ts'
-
-/*
-The eager, stream-classifying read-only computed the compiler routes a bare-call /
-identifier seed to — `computed(getStream())` / `computed(ref)` (ADR-0019 D1). Unlike the
-lazy `computed` primitive it PROBES its seed once to self-identify the source: a
-`NamedAsyncIterable` (socket / streaming rpc) auto-tracks its frames as an `AsyncComputed`,
-an `async () => await …` seed unwraps its promise, and anything else — a sync value, a bare
-opaque promise — falls back to the lazy `Computed`, so laziness is preserved on the miss and
-only a real stream/promise producer becomes a cell. It lives apart from the `computed`
-primitive so a DIRECT `computed(() => …)` call stays lazy (the primitive never probes); the
-eager probe is reached only through this compiler-emitted entry, matching how `linked`
-already classifies its seed. The probe runs untracked — a throwaway read must not subscribe
-the enclosing build.
-*/
-export function trackedComputed<T>(
-    compute: () => T | Promise<T> | NamedAsyncIterable<T>,
-    /* ADR-0032: when the compiler lifts a no-`await` async (sub)expression to a cell, it passes
-       `streaming: true` so the resolved promise does not join the SSR blocking barrier (the shell
-       ships pending, the client resolves). Default false = today's blocking registration; a stream
-       seed never registers regardless, so it only matters for a promise-unwrapping seed. */
-    streaming = false,
-): Computed<T> | AsyncComputed<T> {
-    /* `await` marker: an async-function seed unwraps its promise into a read-only async cell. */
-    if (isAsyncFunction(compute)) {
-        return createAsyncCell(compute as () => unknown, {
-            writable: false,
-            streaming,
-        }) as AsyncComputed<T>
-    }
-    /* Probe the seed once (untracked) to detect a self-identifying stream. A discarded stream
-       iterable costs nothing — a streaming rpc defers its fetch to the first pull, which never
-       happens here; a throw means a plain reactive compute, so fall through to the lazy path
-       (it throws at read, unchanged). */
-    let probe: unknown
-    let threw = false
-    try {
-        probe = untrack(compute)
-    } catch {
-        threw = true
-    }
-    if (!threw && isAsyncIterable(probe)) {
-        return createAsyncCell(compute as () => unknown, {
-            writable: false,
-            streaming,
-        }) as AsyncComputed<T>
-    }
-    /* Sync value or a bare (opaque) promise: the lazy computed, identical to the primitive. */
-    const node = createComputedNode(compute as () => unknown)
-    if (OWNER.current !== undefined) {
-        OWNER.current.push(() => unlinkDeps(node))
-    }
-    return {
-        get value(): T {
-            return readNode(node) as T
-        },
-    }
-}

package/src/lib/ui/tryEncodeResume.ts

@@ -1,11 +0,0 @@
-import { encodeSeedValue } from '../shared/encodeSeedValue.ts'
-import type { ResumeEntry } from './runtime/RESUME.ts'
-
-/* ref-json-encode an await-resume entry, or `undefined` if it can't be serialized — the
-   await-resume arm of the shared serialize-or-degrade policy (`encodeSeedValue`): drop
-   just this entry, so the client re-runs that one branch's promise while every other
-   branch stays seeded. Shared by the streaming (`renderToStream`) and buffered/seed
-   (`resumeSeedScript`) paths. */
-export function tryEncodeResume(entry: ResumeEntry, id: number | string): string | undefined {
-    return encodeSeedValue(entry, `resume for await ${id}`, 'the client will refetch it')
-}

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

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

@@ -1,8 +0,0 @@
-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/lib/ui/types/Scope.ts

@@ -1,68 +0,0 @@
-import type { computed } from '../computed.ts'
-import type { effect } from '../effect.ts'
-import type { linked } from '../linked.ts'
-import type { Patch } from '../runtime/types/Patch.ts'
-import type { state } from '../state.ts'
-import type { trackedComputed } from '../trackedComputed.ts'
-
-/*
-A lexical scope: the unit that owns a region's reactive data, its lifetime, and
-the capabilities applied to it. This is the INTERNAL shape — the compiler's lowering
-host and the runtime object; it is no longer the author surface. The author reactive
-surface is the imported `state`/`state.linked`/`state.computed`/`effect` (see
-`state.ts`); the compiler resolves those import bindings and lowers each onto this
-scope (`$$scope().derive`/`.linked`/`.effect`, `state.share`/`.shared` → `share`/
-`shared`). The data surface MIRRORS `Doc` (read/replace/add/remove/derive/apply/
-snapshot) so the compiler can target a scope as a component's data binding directly;
-it passes values down the tree as context (`share`/`shared`).
-
-The reactive primitives remain on this internal shape because the lowered runtime calls
-them (`$$scope().linked(...)`) — they are withdrawn from the AUTHOR-facing public surface
-(docs/examples), not the runtime object.
-*/
-export type Scope = {
-    readonly id: string
-    readonly parent: Scope | undefined
-    /* data — mirrors Doc */
-    read: <T>(path: string) => T
-    replace: (path: string, value: unknown) => unknown
-    add: (path: string, value: unknown) => void
-    remove: (path: string) => void
-    apply: (patch: Patch) => void
-    derive: <T>(path: string, compute: () => T) => () => T
-    snapshot: () => unknown
-    /* The reactive primitives — namespaced under the scope, but AMBIENT-bound, not
-       receiver-bound (unlike the data methods above, which act on THIS scope's doc).
-       `state`/`linked`/`computed`/`effect` create their cell in whatever scope is currently
-       rendering and own their teardown to the finest ambient BUILD WINDOW — a control-flow
-       branch or list row, not the whole component. So `someScope.computed(fn)` does NOT
-       create state in someScope; the receiver is namespacing only, the cells bind the
-       ambient window. Binding them to the receiver instead would leak a branch-local cell
-       past a branch flip (the build window is finer-grained than the lexical scope — see
-       ADR-0012). Forms: a writable `state(x, transform)` gate, a reseeding `linked`, the
-       read-only `computed(compute)` (a writable computed does not exist — that write is
-       expressed at the binding `bind:value={{ get, set }}`; the serializable computed doc
-       slot is `derive` above), and `effect`, the reaction re-run on dep change (the SSR
-       back-end strips it — effects are client lifecycle). */
-    state: typeof state
-    linked: typeof linked
-    computed: typeof computed
-    /* The eager stream-classifying read-only computed a bare-call `computed(getStream())`
-       lowers to — auto-tracks a stream/promise producer, falls back to a lazy computed. */
-    trackedComputed: typeof trackedComputed
-    effect: typeof effect
-    /* Adopts a teardown into this scope's lifetime — the build's reactivity stopper
-       (effects/listeners), run first on `dispose` (before children, before capabilities).
-       Internal: the mount core registers the build's disposer here so a component has ONE
-       teardown (`dispose`) rather than a separate stop + dispose composed at every site. */
-    own: (dispose: () => void) => void
-    /* context — values shared DOWN the tree (not in the reactive doc, which doesn't
-       inherit): `share` puts a named value on this scope; `shared` reads the closest
-       ancestor (self included) that has the key, undefined if none. The value is held
-       by reference, so reactive context = share a scope (its doc is reactive), not a
-       plain object snapshot. */
-    share: (key: string, value: unknown) => void
-    shared: <T>(key: string) => T | undefined
-    /* lifetime */
-    dispose: () => void
-}

package/src/lib/ui/watch.ts

@@ -1,150 +0,0 @@
-import { cache } from '../shared/cache.ts'
-import { isAsyncIterable } from '../shared/isAsyncIterable.ts'
-import { REMOTE_FUNCTION } from '../shared/REMOTE_FUNCTION.ts'
-import type { CacheOnContext } from '../shared/types/CacheOnContext.ts'
-import type { NamedAsyncIterable } from '../shared/types/NamedAsyncIterable.ts'
-import type { RemoteFunction } from '../shared/types/RemoteFunction.ts'
-import { withSuspense } from './dom/withSuspense.ts'
-import { effect } from './effect.ts'
-import { generationGuard } from './runtime/generationGuard.ts'
-import type { EffectResult } from './runtime/types/EffectResult.ts'
-import type { State } from './runtime/types/State.ts'
-import { untrack } from './runtime/untrack.ts'
-
-/*
-The single reaction primitive: `watch(source, handler)` names its trigger and runs
-`handler` with the source's new value whenever it changes. It unifies three
-previously-separate things — the author `effect`, `socket.on`, and `cache.on` —
-and it is also the compiler's binding primitive (emitted as `$$watch(thunk)` for
-`{expr}` / `class:` / `bind:*`). Client-only: SSR-inert here and stripped by the
-compiler. Returns a scope-tied disposer.
-
-Instance sugar mirrors the global for the two subscribable/rpc sources (the other
-sources have no instance home): `socket.watch(handler)` ≡ `watch(socket, handler)`, and
-`getUser.watch(handler)` / `getUser.watch(args, handler)` ≡ `watch(getUser, …)`. The
-method is client-attached (socketProxy / remoteProxy) so this ui primitive never rides
-into a server bundle; server-side it is an inert no-op. Unlike bare `watch(…)` — which
-the SSR back-end strips — a `.watch(…)` member call survives to the server and relies on
-that inert stub.
-
-Tracking contract (ADR-0044): the named source(s) are the sole triggers — the handler
-is a sink, run untracked, so a reactive read in its body never becomes an accidental
-extra trigger. Only the bare `watch(thunk)` form auto-tracks everything it reads (that
-IS its job — it is the compiler binding). This makes all explicit-source forms uniform:
-the subscribable (cache.on, per-frame) and rpc (handler in a .then microtask) branches
-already ran their handlers out of the tracking window; the two synchronous cell branches
-now match by wrapping the handler in `untrack`.
-
-Sources (discriminated at runtime, monomorphic per branch):
-  watch(thunk)                       // compiler binding form — auto-tracked, == effect(thunk)
-  watch(count, n => …)               // a state cell → handler(newValue)
-  watch([a, b], vals => …)           // multiple cells → fires on any change
-  watch(socket, frame => …)          // a subscribable → handler per frame (cache.on loop)
-  watch(getUser, user => …)          // an rpc → runs the smart read, handler(resolved value)
-  watch(getUser, args, user => …)    // an rpc with args
-*/
-// @documentation reactive-state
-export function watch(thunk: () => EffectResult): () => void
-export function watch<T>(source: State<T>, handler: (value: T) => void): () => void
-export function watch(
-    sources: ReadonlyArray<State<unknown>>,
-    handler: (values: unknown[]) => void,
-): () => void
-export function watch<Frame>(
-    source: NamedAsyncIterable<Frame>,
-    handler: (frame: Frame, context: CacheOnContext) => void | Promise<void>,
-): () => void
-export function watch<Args, Return>(
-    fn: RemoteFunction<Args, Return>,
-    handler: (value: Return) => void,
-): () => void
-export function watch<Args, Return>(
-    fn: RemoteFunction<Args, Return>,
-    args: Args,
-    handler: (value: Return) => void,
-): () => void
-export function watch(
-    source: unknown,
-    argsOrHandler?: unknown,
-    maybeHandler?: unknown,
-): () => void {
-    /* Client lifecycle, exactly like the effect it wraps: no runtime window guard (that would
-       also silence the compiler's generated bindings, which build on the client where the test
-       DOM sets no global `window`). SSR-safety comes from the compiler stripping author
-       `watch(...)` calls, and the subscribable branch's own server guard (cache.on). */
-    /* Compiler binding form watch(thunk): a bare auto-tracked effect (== today's $$effect). A
-       pending blocking `await` read throws a `SuspenseSignal` (ADR-0042) — withhold this reaction
-       (e.g. leave a `class:`/`style:` binding untouched) until the value resolves; the read tracked
-       its cell, so the effect re-runs on settle. Rethrows any real error. */
-    if (argsOrHandler === undefined) {
-        const thunk = source as () => EffectResult
-        return effect(() => withSuspense<EffectResult>(thunk, undefined))
-    }
-    /* watch(fn, args, handler): an rpc selector with explicit args. */
-    if (maybeHandler !== undefined) {
-        return reactToRpc(source, argsOrHandler, maybeHandler as (value: unknown) => void)
-    }
-    const handler = argsOrHandler as (value: unknown, context?: CacheOnContext) => void
-    /* A subscribable (socket / stream): per-frame delivery with reconnect-replay — the
-       existing cache.on loop is the single implementation this branch delegates to. */
-    if (isAsyncIterable(source)) {
-        return cache.on(
-            source as NamedAsyncIterable<unknown>,
-            handler as (frame: unknown, context: CacheOnContext) => void | Promise<void>,
-        )
-    }
-    /* An rpc without args → run the smart read reactively, pipe its value to the handler. A
-       RemoteFunction is a callable, so accept `function` too — a state cell is a branded-free
-       object and never matches, and a streaming rpc was already caught by isAsyncIterable above. */
-    if (
-        source !== null &&
-        (typeof source === 'object' || typeof source === 'function') &&
-        REMOTE_FUNCTION in source
-    ) {
-        return reactToRpc(source, undefined, handler)
-    }
-    /* Multiple cells → fire on any change; hand the handler the current values. Read every
-       cell (the tracked triggers), then run the handler untracked so a reactive read in its
-       body is not captured as an extra trigger (ADR-0044). */
-    if (Array.isArray(source)) {
-        const cells = source as ReadonlyArray<State<unknown>>
-        return effect(() => {
-            const values = cells.map((cell) => cell.value)
-            untrack(() => handler(values))
-        })
-    }
-    /* A single state cell → handler(newValue) on change. The cell read is the tracked
-       trigger; the handler is a sink, run untracked (ADR-0044). */
-    const cell = source as State<unknown>
-    return effect(() => {
-        const value = cell.value
-        untrack(() => handler(value))
-    })
-}
-
-/*
-Reacts to an rpc's cached value: an effect that runs the smart read (subscribing
-its key synchronously, so the effect re-runs when the value changes — a refresh,
-an amend, an invalidate) and pipes the resolved value to the handler. Triggers the
-read, unlike peek: `watch` observes a live query, so it keeps it flowing.
-*/
-function reactToRpc(fn: unknown, args: unknown, handler: (value: unknown) => void): () => void {
-    const call = fn as (args: unknown) => Promise<unknown>
-    /* The bare call routes through cache.read (cache-managed flight, not scope-abortable), so
-       a slow flight can settle AFTER a faster re-run's flight OR after the owner tears down.
-       Guard the handler on the generation so only the current flight's value lands and a
-       post-teardown settle is dropped — a re-run renews, teardown bumps (both via the shared
-       generationGuard). */
-    const guard = generationGuard()
-    return effect(() => {
-        const generation = guard.renew()
-        void Promise.resolve(call(args)).then(
-            (value) => {
-                if (guard.live(generation)) {
-                    handler(value)
-                }
-            },
-            () => undefined,
-        )
-    })
-}

package/src/preload.ts

@@ -1,19 +0,0 @@
-// @documentation 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

@@ -1,153 +0,0 @@
-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
-}