@abide/abide 0.42.0 → 0.43.1

package/src/lib/ui/socketChannel.ts

@@ -80,7 +80,13 @@ export function getSocketChannel(): SocketChannel {
         if (document.hidden) {
             return
         }
-        if (ws && (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING)) {
+        /* A socket reference in ANY non-closed state means one is already in play — bail.
+           CONNECTING/OPEN are healthy; CLOSING means a close event is still pending and the
+           close handler (which alone nulls `ws` and re-arms the backoff) hasn't run yet.
+           Spawning here would orphan that socket: its deferred close fires against the shared
+           `ws`, draining the fresh connection's subs and nulling it. The close handler always
+           clears `ws`, so reconnection is never stranded — it just sequences after the close. */
+        if (ws) {
             return
         }
         const scheme = window.location.protocol === 'https:' ? 'wss:' : 'ws:'

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

@@ -1,4 +1,5 @@
 import type { computed } from '../computed.ts'
+import type { effect } from '../effect.ts'
 import type { linked } from '../linked.ts'
 import type { Cell } from '../runtime/types/Cell.ts'
 import type { Patch } from '../runtime/types/Patch.ts'
@@ -35,14 +36,28 @@ export type Scope = {
     cell: <T>(path: string) => Cell<T>
     derive: <T>(path: string, compute: () => T) => () => T
     snapshot: () => unknown
-    /* the `.value`-cell signal forms, reachable only through a scope (the standalone
-       `state`/`linked`/`computed` are no longer exported): a writable `state(x, transform)`
-       gate, a reseeding `linked`, and 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. */
+    /* 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
+    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
     /* tree */
     child: (initial?: unknown) => Scope
     root: () => Scope

package/template/CLAUDE.md

@@ -15,7 +15,7 @@ at `node_modules/@abide/abide/README.md`.
 
 - One export per file, named after the file. No barrels — import each name by its
   own path (`@abide/abide/server/GET`, `@abide/abide/shared/cache`, …).
-- RPC verbs live in `src/server/rpc/<name>.ts`; sockets in `src/server/sockets/`;
+- 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.

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

@@ -1,8 +1,8 @@
 /*
-RPC module — every file under src/server/rpc/ exposes exactly one verb-bound remote
+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 verb (GET / POST / PUT / PATCH / DELETE / HEAD) picks the
-HTTP method. The bundler swaps the runtime per build target: direct call on
+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 —

package/template/test/app.test.ts

@@ -3,12 +3,12 @@ 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.<verb>(args)   — verbs over the real pipeline (CSRF, cookies, base),
+  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, .tail(n), .publish(m)
   app.health()           — the /__abide/health payload
 
-`app.rpc` / `app.sockets` are typed from your own verbs and sockets — generated
+`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.
 

package/src/lib/server/rpc/registerVerb.ts

@@ -1,6 +0,0 @@
-import type { VerbRegistryEntry } from './types/VerbRegistryEntry.ts'
-import { verbRegistry } from './verbRegistry.ts'
-
-export function registerVerb(entry: VerbRegistryEntry): void {
-    verbRegistry.set(entry.remote.url, entry)
-}

package/src/lib/server/runtime/types/InspectorVerb.ts

@@ -1,27 +0,0 @@
-/*
-One RPC verb projected for the inspector: the registry entry reduced to the
-serializable facts the UI renders — where it mounts, its method, which
-non-browser surfaces advertise it, and its argument/result shapes as JSON
-Schema. Schemas project through jsonSchemaForSchema (same as MCP/OpenAPI), so
-a verb whose library can't render a schema still lists with an opaque shape.
-*/
-export type InspectorVerb = {
-    /* Registry key — the rpc URL the verb mounts at (e.g. /rpc/users/create). */
-    url: string
-    /* HTTP method bound to the verb. */
-    method: string
-    /* Which surfaces advertise it (browser/mcp/cli), from the verb's ClientFlags. */
-    clients: Record<string, boolean>
-    /* Argument-bag shape as JSON Schema; undefined when the verb declares none. */
-    inputSchema: Record<string, unknown> | undefined
-    /* Success-body shape as JSON Schema; undefined when the verb declares none. */
-    outputSchema: Record<string, unknown> | undefined
-    /* True when the verb declares a filesSchema — it accepts multipart File parts. */
-    files: boolean
-    /* Per-verb handler deadline in ms; undefined = no deadline. */
-    timeout: number | undefined
-    /* Per-verb received-body cap in bytes; undefined = Bun's server-wide ceiling. */
-    maxBodySize: number | undefined
-    /* True when the verb opts out of the same-origin CSRF gate. */
-    crossOrigin: boolean | undefined
-}

package/src/lib/shared/detectVerbMethod.ts

@@ -1,17 +0,0 @@
-import type { HttpVerb } from './types/HttpVerb.ts'
-
-/*
-Reads the HTTP verb of an $rpc module from its source. Every file under
-src/server/rpc/ follows the convention `export const <name> = GET(fn)` (the
-verb helper picks the method, possibly with an explicit generic
-`GET<{…}>(fn)`), so the helper name at the export is the method. Returns
-undefined when no verb export matches — the caller skips the file rather
-than guessing. Used by the rpc.d.ts codegen to type url() against
-query-carrying verbs; matching the same convention the bundler rewrites
-keeps the two from drifting.
-*/
-const VERB_EXPORT = /export\s+const\s+\w+\s*=\s*(GET|POST|PUT|PATCH|DELETE|HEAD)\s*[<(]/
-
-export function detectVerbMethod(source: string): HttpVerb | undefined {
-    return (source.match(VERB_EXPORT)?.[1] as HttpVerb | undefined) ?? undefined
-}

package/src/lib/shared/types/HttpVerb.ts

@@ -1 +0,0 @@
-export type HttpVerb = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD'

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

@@ -1,14 +0,0 @@
-/*
-A durable, FIFO queue of pending mutations that drains when the client is online —
-the local-first half of "act now, sync later". `enqueue` records a serializable
-payload (persisted, so it survives a reload) and tries to drain; `pending` is a
-reactive read of the payloads still in flight (for a "3 unsynced" indicator);
-`flush` drains on demand (and is what the reconnect effect calls); `dispose` stops
-draining and detaches persistence.
-*/
-export type Outbox<T> = {
-    enqueue: (payload: T) => void
-    pending: () => T[]
-    flush: () => Promise<void>
-    dispose: () => void
-}