@abide/abide 0.41.1 → 0.43.0

package/src/lib/shared/fileStem.ts

@@ -1,3 +1,5 @@
+import { fileName } from './fileName.ts'
+
 /*
 The bare filename of a path, with directory and trailing extension stripped —
 e.g. `users/list.ts` → `list`, `/_virtual/mcp-resources.ts` → `mcp-resources`.
@@ -5,5 +7,5 @@ Used to derive a virtual-module name from its path and to check an $rpc /
 $sockets module's single export name against its file stem.
 */
 export function fileStem(path: string): string {
-    return (path.split('/').pop() ?? '').replace(/\.[^.]+$/, '')
+    return fileName(path).replace(/\.[^.]+$/, '')
 }

package/src/lib/shared/findExportCallSite.ts

@@ -1,9 +1,14 @@
+import { isAsciiWhitespace } from './isAsciiWhitespace.ts'
+import { isIdentPart } from './isIdentPart.ts'
+import { isIdentStart } from './isIdentStart.ts'
+import { skipNonCode } from './skipNonCode.ts'
+
 /*
 Scans a module source character-by-character — skipping strings,
-templates, comments, and TypeScript generics — for an
-`export const <name> = <IDENT>(...)` binding the caller cares about.
-On a match returns the identifier text, the export name, and the byte
-ranges of the call's open and close parens; the $rpc and $sockets
+templates, comments, regex literals (via skipNonCode), and TypeScript
+generics — for an `export const <name> = <IDENT>(...)` binding the caller
+cares about. On a match returns the identifier text, the export name, and
+the byte ranges of the call's open and close parens; the $rpc and $sockets
 rewriters splice their runtime bindings into those ranges.
 
 The scanner enforces a single matching export per module: a second match
@@ -32,20 +37,12 @@ export function findExportCallSite(
     const len = source.length
     let i = 0
     while (i < len) {
-        const c = source[i]
-        const afterSlash = skipSlashConstruct(source, i)
-        if (afterSlash !== undefined) {
-            i = afterSlash
-            continue
-        }
-        if (c === '"' || c === "'") {
-            i = skipString(source, i + 1, c)
-            continue
-        }
-        if (c === '`') {
-            i = skipTemplate(source, i + 1)
+        const skipped = skipNonCode(source, i)
+        if (skipped !== undefined) {
+            i = skipped
             continue
         }
+        const c = source[i]
         if (isIdentStart(c) && !isIdentPart(source[i - 1])) {
             let j = i + 1
             while (j < len && isIdentPart(source[j])) {
@@ -84,106 +81,9 @@ export function findExportCallSite(
     return found
 }
 
-function skipString(source: string, start: number, quote: string): number {
-    let i = start
-    while (i < source.length) {
-        const c = source[i]
-        if (c === '\\') {
-            i += 2
-            continue
-        }
-        if (c === quote) {
-            return i + 1
-        }
-        if (c === '\n') {
-            return i
-        }
-        i++
-    }
-    return source.length
-}
-
-function skipTemplate(source: string, start: number): number {
-    let i = start
-    while (i < source.length) {
-        const c = source[i]
-        if (c === '\\') {
-            i += 2
-            continue
-        }
-        if (c === '`') {
-            return i + 1
-        }
-        if (c === '$' && source[i + 1] === '{') {
-            i = skipTemplateExpression(source, i + 2)
-            continue
-        }
-        i++
-    }
-    return source.length
-}
-
-function skipTemplateExpression(source: string, start: number): number {
-    let depth = 1
-    let i = start
-    while (i < source.length && depth > 0) {
-        const c = source[i]
-        if (c === '{') {
-            depth++
-            i++
-            continue
-        }
-        if (c === '}') {
-            depth--
-            i++
-            continue
-        }
-        if (c === '"' || c === "'") {
-            i = skipString(source, i + 1, c)
-            continue
-        }
-        if (c === '`') {
-            i = skipTemplate(source, i + 1)
-            continue
-        }
-        const afterSlash = skipSlashConstruct(source, i)
-        if (afterSlash !== undefined) {
-            i = afterSlash
-            continue
-        }
-        i++
-    }
-    return i
-}
-
-/*
-When `i` sits on a `/` introducing a line comment, block comment, or regex
-literal, returns the index immediately after the construct; undefined when
-the `/` is division (or `i` isn't a `/`). One statement of the skip rules
-shared by every scanner loop so they can't drift.
-*/
-function skipSlashConstruct(source: string, i: number): number | undefined {
-    if (source[i] !== '/') {
-        return undefined
-    }
-    const next = source[i + 1]
-    if (next === '/') {
-        const newline = source.indexOf('\n', i + 2)
-        return newline === -1 ? source.length : newline + 1
-    }
-    if (next === '*') {
-        const end = source.indexOf('*/', i + 2)
-        return end === -1 ? source.length : end + 2
-    }
-    if (isRegexContext(source, i)) {
-        return skipRegex(source, i + 1)
-    }
-    return undefined
-}
-
 function matchCallTail(source: string, after: number): number | undefined {
     let j = after
-    while (j < source.length && isWhitespace(source[j])) {
+    while (j < source.length && isAsciiWhitespace(source[j])) {
         j++
     }
     if (source[j] === '<') {
@@ -192,7 +92,7 @@ function matchCallTail(source: string, after: number): number | undefined {
             return undefined
         }
         j = closed
-        while (j < source.length && isWhitespace(source[j])) {
+        while (j < source.length && isAsciiWhitespace(source[j])) {
             j++
         }
     }
@@ -216,15 +116,12 @@ function skipGenerics(source: string, start: number): number | undefined {
     let bracketDepth = 0
     let i = start
     while (i < source.length) {
-        const c = source[i]
-        if (c === '"' || c === "'") {
-            i = skipString(source, i + 1, c)
-            continue
-        }
-        if (c === '`') {
-            i = skipTemplate(source, i + 1)
+        const skipped = skipNonCode(source, i)
+        if (skipped !== undefined) {
+            i = skipped
             continue
         }
+        const c = source[i]
         if (c === '<') {
             angleDepth++
         } else if (c === '>') {
@@ -254,28 +151,20 @@ function skipGenerics(source: string, start: number): number | undefined {
 }
 
 /*
-Walks the call body, skipping strings/templates/comments and respecting
-nested `()` so brackets inside object literals or nested calls don't
-throw the depth count.
+Walks the call body, skipping strings/templates/comments/regex and
+respecting nested `()` so brackets inside object literals or nested calls
+don't throw the depth count.
 */
 function findCallEnd(source: string, parenStart: number): number | undefined {
     let depth = 1
     let i = parenStart + 1
     while (i < source.length) {
-        const c = source[i]
-        if (c === '"' || c === "'") {
-            i = skipString(source, i + 1, c)
-            continue
-        }
-        if (c === '`') {
-            i = skipTemplate(source, i + 1)
-            continue
-        }
-        const afterSlash = skipSlashConstruct(source, i)
-        if (afterSlash !== undefined) {
-            i = afterSlash
+        const skipped = skipNonCode(source, i)
+        if (skipped !== undefined) {
+            i = skipped
             continue
         }
+        const c = source[i]
         if (c === '(') {
             depth++
         } else if (c === ')') {
@@ -297,14 +186,14 @@ isn't the module's declared export.
 */
 function detectExportName(source: string, callStart: number): string | undefined {
     let i = callStart - 1
-    while (i >= 0 && isWhitespace(source[i])) {
+    while (i >= 0 && isAsciiWhitespace(source[i])) {
         i--
     }
     if (source[i] !== '=') {
         return undefined
     }
     i--
-    while (i >= 0 && isWhitespace(source[i])) {
+    while (i >= 0 && isAsciiWhitespace(source[i])) {
         i--
     }
     const nameEnd = i + 1
@@ -316,14 +205,14 @@ function detectExportName(source: string, callStart: number): string | undefined
         return undefined
     }
     const name = source.slice(nameStart, nameEnd)
-    while (i >= 0 && isWhitespace(source[i])) {
+    while (i >= 0 && isAsciiWhitespace(source[i])) {
         i--
     }
     if (!matchesBackwards(source, i, 'const')) {
         return undefined
     }
     i -= 'const'.length
-    while (i >= 0 && isWhitespace(source[i])) {
+    while (i >= 0 && isAsciiWhitespace(source[i])) {
         i--
     }
     if (!matchesBackwards(source, i, 'export')) {
@@ -342,135 +231,3 @@ function matchesBackwards(source: string, end: number, keyword: string): boolean
     }
     return start === 0 || !isIdentPart(source[start - 1])
 }
-
-function isIdentStart(c: string | undefined): boolean {
-    if (c === undefined) {
-        return false
-    }
-    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c === '_' || c === '$'
-}
-
-function isIdentPart(c: string | undefined): boolean {
-    if (c === undefined) {
-        return false
-    }
-    return isIdentStart(c) || (c >= '0' && c <= '9')
-}
-
-function isWhitespace(c: string | undefined): boolean {
-    return c === ' ' || c === '\t' || c === '\n' || c === '\r'
-}
-
-/*
-A `/` starts a regex literal when the prior expression context expects an
-expression rather than a value — after an open delimiter, operator, or
-expression-prefix keyword (return, typeof, instanceof, in, of, delete,
-void, await, yield, new, throw, case, do). Otherwise `/` is division.
-Without this disambiguation a regex like `/^\//` reads as `/` (division),
-then `^`, `\`, `/`, `/` — and the final `//` pair fakes a line comment
-that swallows the rest of the line, eating any `)` that closes the
-enclosing call.
-*/
-const REGEX_PREFIX_KEYWORDS = new Set([
-    'return',
-    'typeof',
-    'instanceof',
-    'in',
-    'of',
-    'delete',
-    'void',
-    'await',
-    'yield',
-    'new',
-    'throw',
-    'case',
-    'do',
-])
-
-const REGEX_PUNCTUATION = new Set([
-    '(',
-    '[',
-    '{',
-    ',',
-    ';',
-    ':',
-    '?',
-    '!',
-    '&',
-    '|',
-    '^',
-    '~',
-    '+',
-    '-',
-    '*',
-    '%',
-    '<',
-    '>',
-    '=',
-    '/',
-])
-
-function isRegexContext(source: string, slashIndex: number): boolean {
-    let i = slashIndex - 1
-    while (i >= 0 && isWhitespace(source[i])) {
-        i--
-    }
-    if (i < 0) {
-        return true
-    }
-    const prev = source[i] as string
-    if (REGEX_PUNCTUATION.has(prev)) {
-        return true
-    }
-    if (isIdentPart(prev)) {
-        let start = i
-        while (start > 0 && isIdentPart(source[start - 1])) {
-            start--
-        }
-        return REGEX_PREFIX_KEYWORDS.has(source.slice(start, i + 1))
-    }
-    return false
-}
-
-/*
-Walks past a regex literal body, respecting character classes (`[...]`
-where `/` is literal) and backslash escapes, then consumes trailing
-flag identifiers. Returns the index immediately after the regex. An
-unterminated regex (newline before closing `/`) returns the newline
-position so the outer scanner can resume normally on the next line.
-*/
-function skipRegex(source: string, start: number): number {
-    let i = start
-    let inClass = false
-    while (i < source.length) {
-        const c = source[i]
-        if (c === '\\') {
-            i += 2
-            continue
-        }
-        if (c === '\n') {
-            return i
-        }
-        if (inClass) {
-            if (c === ']') {
-                inClass = false
-            }
-            i++
-            continue
-        }
-        if (c === '[') {
-            inClass = true
-            i++
-            continue
-        }
-        if (c === '/') {
-            let j = i + 1
-            while (j < source.length && isIdentPart(source[j])) {
-                j++
-            }
-            return j
-        }
-        i++
-    }
-    return source.length
-}

package/src/lib/shared/forwardHeaders.ts

@@ -4,8 +4,8 @@ import { extraForwardHeaders } from './extraForwardHeaders.ts'
 Headers abide forwards from an inbound HTTP/MCP request onto every
 synthesized in-process rpc Request — cookies + bearer auth + the four
 forwarding hints proxies set when terminating TLS in front of the app.
-defineVerb uses this when an SSR pass calls a verb in-process; the MCP
-dispatcher uses it when piping a tool invocation through verb.fetch.
+defineRpc uses this when an SSR pass calls a rpc in-process; the MCP
+dispatcher uses it when piping a tool invocation through rpc.fetch.
 
 WARNING — this is an allowlist: every inbound header NOT named here (and
 not added via app.forwardHeaders) is DROPPED on the in-process path. A

package/src/lib/shared/httpErrorFor.ts

@@ -0,0 +1,26 @@
+import { contentBodyKind } from './contentBodyKind.ts'
+import { contentTypeOf } from './contentTypeOf.ts'
+import { HttpError } from './HttpError.ts'
+
+/*
+Builds the HttpError for a non-2xx response, parsing a typed-error body
+(`{ $abideError, data }`, emitted by `error(errors.x(...))` and validation 422)
+onto `.kind` / `.data`. Reads a clone so the original `response.body` stays
+unread for callers that inspect it. A non-JSON or malformed body leaves
+`.kind` / `.data` undefined (a plain `error(status, text)`). Shared by the
+plain decode path (decodeResponse) and the streaming path (streamResponse) so
+both surface the same typed error on a non-2xx.
+*/
+export async function httpErrorFor(response: Response): Promise<HttpError> {
+    if (contentBodyKind(contentTypeOf(response.headers)) === 'json') {
+        try {
+            const body = await response.clone().json()
+            if (body !== null && typeof body === 'object' && '$abideError' in body) {
+                return new HttpError(response, body.$abideError, body.data)
+            }
+        } catch {
+            /* malformed JSON error body — fall through to a plain HttpError */
+        }
+    }
+    return new HttpError(response)
+}

package/src/lib/shared/isAsciiWhitespace.ts

@@ -0,0 +1,5 @@
+/* True for the source-scanner whitespace set (space, tab, CR, LF). Distinct from
+   isWhitespaceText, which classifies template text nodes. */
+export function isAsciiWhitespace(c: string | undefined): boolean {
+    return c === ' ' || c === '\t' || c === '\n' || c === '\r'
+}

package/src/lib/shared/isIdentPart.ts

@@ -0,0 +1,9 @@
+import { isIdentStart } from './isIdentStart.ts'
+
+/* True when `c` can continue a JavaScript identifier — an identifier-start char or a digit. */
+export function isIdentPart(c: string | undefined): boolean {
+    if (c === undefined) {
+        return false
+    }
+    return isIdentStart(c) || (c >= '0' && c <= '9')
+}

package/src/lib/shared/isIdentStart.ts

@@ -0,0 +1,8 @@
+/* True when `c` can begin a JavaScript identifier (ASCII letters, `_`, `$`). Shared by the
+   source scanners (findExportCallSite, skipNonCode) to find identifiers and regex flags. */
+export function isIdentStart(c: string | undefined): boolean {
+    if (c === undefined) {
+        return false
+    }
+    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c === '_' || c === '$'
+}

package/src/lib/shared/isReadOnlyMethod.ts

@@ -1,14 +1,14 @@
-import type { HttpVerb } from './types/HttpVerb.ts'
+import type { HttpMethod } from './types/HttpMethod.ts'
 
 /*
 Read-only (safe) HTTP methods — they don't mutate server state. Abide
-uses this to decide which verbs auto-expose to MCP: reads flip MCP on
+uses this to decide which rpcs auto-expose to MCP: reads flip MCP on
 when a schema is present, mutations require an explicit `clients.mcp`
 opt-in so a model can't delete/overwrite data just because the handler
 carries a schema. Also feeds the MCP tool `readOnlyHint` annotation.
 */
-const READ_ONLY_METHODS = new Set<HttpVerb>(['GET', 'HEAD'])
+const READ_ONLY_METHODS = new Set<HttpMethod>(['GET', 'HEAD'])
 
-export function isReadOnlyMethod(method: HttpVerb): boolean {
+export function isReadOnlyMethod(method: HttpMethod): boolean {
     return READ_ONLY_METHODS.has(method)
 }

package/src/lib/shared/keyForRemoteCall.ts

@@ -1,17 +1,17 @@
 import { canonicalJson } from './canonicalJson.ts'
 import { carriesBodyArgs } from './carriesBodyArgs.ts'
 import { queryStringFromArgs } from './queryStringFromArgs.ts'
-import type { HttpVerb } from './types/HttpVerb.ts'
+import type { HttpMethod } from './types/HttpMethod.ts'
 
 /*
-Derives a cache key from a verb-defined remote function and its args. The
+Derives a cache key from a rpc-defined remote function and its args. The
 prefix is `${method} ${url}` where `url` is the route template. GET/DELETE/HEAD
 serialise args onto the URL as `?key=value` (sorted, via queryStringFromArgs —
 the same encoder buildRpcRequest builds its query with, so the key and the
 synthesized Request can't disagree); POST/PUT/PATCH join args after a space as
-canonical JSON. The verb split mirrors buildRpcRequest exactly.
+canonical JSON. The rpc split mirrors buildRpcRequest exactly.
 */
-export function keyForRemoteCall(method: HttpVerb, url: string, args: unknown): string {
+export function keyForRemoteCall(method: HttpMethod, url: string, args: unknown): string {
     const prefix = `${method} ${url}`
     if (!carriesBodyArgs(method)) {
         if (args && typeof args === 'object' && !Array.isArray(args)) {

package/src/lib/shared/log.ts

@@ -5,7 +5,7 @@ import type { Log } from './types/Log.ts'
 
 /*
 The unified logger: every record carries the request-scope context (short
-trace id, +elapsed, verb+path) when one is active, plus a channel — the
+trace id, +elapsed, method+path) when one is active, plus a channel — the
 line's speaker. `log(...)`/`warn`/`error`/`trace` speak on the app's own
 always-on channel (the app name, resolved per emission so boot order doesn't
 matter); `log.channel(name)` returns the same shape on a DEBUG-gated

package/src/lib/shared/outboxProbeSlot.ts

@@ -0,0 +1,20 @@
+/*
+Internal slot the browser outbox registry registers its prober into, so the
+shared pending() probe can count parked durable-rpc writes without shared/
+importing browser/. Mirrors tailProbeSlot. The prober reads the doc-backed
+queue entries (reactive inside $derived / $effect) and reports whether any
+undelivered entry matches the selector: a durable rpc selector (carries a
+`url`) narrows to its own queue, the bare form spans every registered queue,
+optional args narrow to one parked call by structural compare. Outbox state is
+pending-only — a parked write has no value, so it never contributes to
+refreshing(); probeRegistries reads this slot only on its `field === 'pending'`
+branch, which is why the slot mirrors tailProbeSlot but reports a bare boolean
+rather than a { pending, refreshing } pair. When no prober is registered (server
+render, or no durable rpc was ever used) pending() sees no parked writes,
+exactly as on the server where there are no client queues.
+*/
+export const outboxProbeSlot: {
+    probe: ((selector: unknown, args: unknown) => boolean) | undefined
+} = {
+    probe: undefined,
+}

package/src/lib/shared/pending.ts

@@ -15,9 +15,12 @@ tail registry (streams). Pending means "no value yet":
   pending(subscribable)  → that stream awaiting its first frame
                            (tail.status === 'pending'; true when nothing
                            is reading yet — there is no value either way)
+  pending(durableRpc)    → that durable rpc's parked writes (a parked write
+                           has no value yet); the bare form counts them too
 Probes report, never act: reading one opens no fetch and no stream. SSR
 loading state is driven by {#await}, not this. Scan semantics (tap order,
-selector grammar, registry spans) live in probeRegistries.
+selector grammar, registry spans, the parked-write term) live in
+probeRegistries.
 */
 // @documentation probes
 export function pending<Args, Return>(