@abide/abide 0.28.0

package/src/lib/shared/loadEnvFromDataDir.ts

@@ -0,0 +1,14 @@
+import { dataDirEnvPath } from './dataDirEnvPath.ts'
+import { loadEnvFile } from './loadEnvFile.ts'
+
+/*
+Loads the user's `.env` from the program's per-user data dir into `process.env`.
+This is the cwd-independent config layer — where the connect-screen form writes
+the user's answers, and where a bundle launched via `open` (cwd `/`, so Bun's
+CWD `.env` autoload finds nothing) actually picks up its config. Loaded before
+the binary-dir `.env`, so a user's saved config overrides the shipped default;
+still loses to a shell export or a CWD `.env` (fill-when-unset, see loadEnvFile).
+*/
+export async function loadEnvFromDataDir(programName: string): Promise<void> {
+    await loadEnvFile(dataDirEnvPath(programName))
+}

package/src/lib/shared/log.ts

@@ -0,0 +1,24 @@
+import { appNameSlot } from './appNameSlot.ts'
+import { createChannelLog } from './createChannelLog.ts'
+import type { ChannelLog } from './types/ChannelLog.ts'
+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
+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
+diagnostic channel (browser: the `abide-debug` localStorage key). Renders as
+the tab-separated tsv format (default) or one JSON object per line under
+ABIDE_LOG_FORMAT=json.
+*/
+// @readme observability
+export const log: Log = Object.assign(
+    createChannelLog(() => appNameSlot.name ?? 'app', true),
+    {
+        channel(name: string): ChannelLog {
+            return createChannelLog(() => name, false)
+        },
+    },
+)

package/src/lib/shared/logClosingRecord.ts

@@ -0,0 +1,28 @@
+import { emitLogRecord } from './emitLogRecord.ts'
+import type { CacheStats } from './types/CacheStats.ts'
+
+/*
+Emits the request's closing record — the line that ends a trace: status as
+the message, total duration at settle, cache read tallies frozen at that
+moment. Framework-internal (runWithRequestScope at settle, the asset paths
+directly); not part of the public log surface because its structured fields
+only make sense at the request boundary the framework owns.
+*/
+export function logClosingRecord(
+    method: string,
+    path: string,
+    status: number,
+    durationMs: number,
+    cache?: CacheStats,
+): void {
+    emitLogRecord({
+        level: 'info',
+        msg: '',
+        channel: 'abide',
+        method,
+        path,
+        status,
+        durationMs,
+        cache,
+    })
+}

package/src/lib/shared/logTapSlot.ts

@@ -0,0 +1,13 @@
+import type { LogRecord } from './types/LogRecord.ts'
+
+/*
+Passive observation seam for the unified log. emitLogRecord calls the tap (when
+set) with every fully-built record, before formatting — so an observer sees the
+exact structured record stdout/console would, trace context and all. The
+inspector installs one to feed its live event buffer; unset everywhere else, so
+the call no-ops with zero allocation. One slot, not a listener set: the single
+in-process observer fans out to its own readers. Mirrors requestScopeSlot.
+*/
+export const logTapSlot: { tap: ((record: LogRecord) => void) | undefined } = {
+    tap: undefined,
+}

package/src/lib/shared/manifestModule.ts

@@ -0,0 +1,39 @@
+import { abideLog } from './abideLog.ts'
+
+/*
+Builds one of abide's virtual manifest modules — the `{ key: () => import(...) }`
+map the bundler emits for rpc / sockets / prompts / pages / layouts. They differ
+only in their files, the key derived per file, the import dir, the export name,
+and the log label; this is the single shape they share.
+*/
+export function manifestModule(options: {
+    files: string[]
+    keyForFile: (file: string) => string
+    importDir: string
+    exportName: string
+    /*
+    A plain `resolved N <label>: keys` line at build time, when set. Omitted for
+    manifests whose contents are enumerated once at boot as an aligned table (see
+    logExposedSurfaces) — rpc/sockets/pages/layouts — which both avoids the
+    redundant list and the double-log of manifests (pages/layouts) loaded by both
+    the server and client bundles. prompts/errors have no table, so they pass a
+    label to keep their build-time line.
+    */
+    label?: string
+}): { contents: string; loader: 'js' } {
+    const entries = options.files
+        .toSorted()
+        .map((file) => ({ key: options.keyForFile(file), file }))
+    const lines = entries
+        .map(
+            ({ key, file }) =>
+                `    ${JSON.stringify(key)}: () => import(${JSON.stringify(`${options.importDir}/${file}`)}),`,
+        )
+        .join('\n')
+    if (options.label && entries.length > 0) {
+        abideLog.info(
+            `resolved ${entries.length} ${options.label}: ${entries.map((entry) => entry.key).join(', ')}`,
+        )
+    }
+    return { contents: `export const ${options.exportName} = {\n${lines}\n}\n`, loader: 'js' }
+}

package/src/lib/shared/matchesDebugPattern.ts

@@ -0,0 +1,16 @@
+/*
+One DEBUG pattern against one channel name, npm-debug conventions:
+`*` matches everything, `abide:*` matches 'abide' and every 'abide:…'
+sub-channel, anything else matches exactly. Negation (`-` prefix) is the
+caller's concern — patterns arrive here already stripped.
+*/
+export function matchesDebugPattern(name: string, pattern: string): boolean {
+    if (pattern === '*') {
+        return true
+    }
+    if (pattern.endsWith(':*')) {
+        const prefix = pattern.slice(0, -2)
+        return name === prefix || name.startsWith(`${prefix}:`)
+    }
+    return pattern === name
+}

package/src/lib/shared/memoizeByKey.ts

@@ -0,0 +1,32 @@
+/*
+Memoises an async loader keyed by string: the first call for a key starts the
+load and caches its promise; later calls reuse it. `load` returns undefined when
+the key has no loader, which is passed through (and not cached) so the caller can
+treat "unknown key" distinctly from "loaded value". Used by the rpc-module and
+socket-module load caches, which share this exact shape.
+*/
+export function memoizeByKey<T>(
+    load: (key: string) => Promise<T> | undefined,
+): (key: string) => Promise<T> | undefined {
+    const cache = new Map<string, Promise<T>>()
+    return (key) => {
+        const existing = cache.get(key)
+        if (existing) {
+            return existing
+        }
+        const started = load(key)
+        if (!started) {
+            return undefined
+        }
+        cache.set(key, started)
+        // Evict on rejection so a transient load failure doesn't poison the key
+        // forever; the next call retries. The separate handle doesn't swallow the
+        // rejection seen by the returned promise.
+        void started.catch(() => {
+            if (cache.get(key) === started) {
+                cache.delete(key)
+            }
+        })
+        return started
+    }
+}

package/src/lib/shared/normalizeTarget.ts

@@ -0,0 +1,10 @@
+import type { CompileTarget } from './types/CompileTarget.ts'
+
+/*
+Prepends the `bun-` prefix if missing so CLI users can pass either
+`darwin-arm64` or the canonical `bun-darwin-arm64` form to `--target`.
+*/
+export function normalizeTarget(input: string): CompileTarget {
+    const normalized = input.startsWith('bun-') ? input : `bun-${input}`
+    return normalized as CompileTarget
+}

package/src/lib/shared/online.ts

@@ -0,0 +1,51 @@
+import { createSubscriber } from './createSubscriber.ts'
+import { requestScopeSlot } from './requestScopeSlot.ts'
+
+/*
+Reactive network-connectivity probe in the pending()/refreshing() family:
+reading it from a $derived/$effect re-runs that scope when the browser's
+online/offline events fire. navigator.onLine's *offline* signal is reliable
+(a true network loss always reports); its online value can false-positive
+behind captive portals — verified backend reachability is a separate,
+opt-in concern (the bundle launcher's liveness watch owns it for bundles).
+
+On the server it reflects the *calling client's* reported connectivity — the
+OFFLINE_HEADER a abide RPC fetch stamps while offline (read off the request
+scope). In a bundle the client and embedded server share a machine, so this is
+exactly the outbound reachability a handler reaching external sites needs:
+`if (!online()) return error(503)` skips a doomed fetch. True outside any
+request scope (boot, cron) and for non-abide-client requests (no header).
+
+It answers "did the calling client report itself offline," NOT "can this
+server reach the internet." So during SSR it is always true: the initial
+render is a browser document navigation abide didn't issue, carrying no
+header — there's been no client round-trip to report connectivity yet. Gate
+external fetches on online() in the RPC/handler path (a real client called),
+not in SSR; in SSR bound the fetch with AbortSignal.timeout instead, or defer
+the read to the hydrated client where navigator.onLine is live. Bundles feel
+this most — localhost serves the SSR even with the machine offline.
+
+Reports, never acts — reading this opens no fetch and no stream.
+*/
+const subscribeOnline =
+    typeof window === 'undefined'
+        ? undefined
+        : createSubscriber((update) => {
+              const changed = () => update()
+              window.addEventListener('online', changed)
+              window.addEventListener('offline', changed)
+              return () => {
+                  window.removeEventListener('online', changed)
+                  window.removeEventListener('offline', changed)
+              }
+          })
+
+// @readme probes
+export function online(): boolean {
+    /* window, not navigator: Bun defines a partial navigator with no onLine. */
+    if (typeof window === 'undefined') {
+        return requestScopeSlot.resolver?.()?.online ?? true
+    }
+    subscribeOnline?.()
+    return navigator.onLine
+}

package/src/lib/shared/page.ts

@@ -0,0 +1,30 @@
+import { activePage } from './activePage.ts'
+import type { PageSnapshot } from './types/PageSnapshot.ts'
+
+/*
+The reactive page proxy: the matched route, decoded params, browser-space URL,
+and `navigating` flag for the active page. Isomorphic — the server resolver reads
+the per-request store, the client resolver the router-updated snapshot — so
+`{page.url.pathname}` and `page.params.id` work the same during SSR and after
+hydration. Read inside a abide-ui effect/derived, a field re-runs its reader when
+navigation updates the snapshot (the client resolver reads a abide-ui signal).
+
+`url` is browser-space on both sides: under a mount base the pathname carries the
+prefix (the server re-applies it to the proxy-stripped request URL), so compare
+active state against url() output, e.g. `page.url.pathname.startsWith(url('/x'))`.
+*/
+// @readme page
+export const page: PageSnapshot = {
+    get route(): string {
+        return activePage().route
+    },
+    get params(): Record<string, string> {
+        return activePage().params
+    },
+    get url(): URL {
+        return activePage().url
+    },
+    get navigating(): boolean {
+        return activePage().navigating
+    },
+}

package/src/lib/shared/pageSlot.ts

@@ -0,0 +1,17 @@
+import type { PageSnapshot } from './types/PageSnapshot.ts'
+
+/*
+Internal slot the runtime entries register their page resolver into. The
+server entry installs an ALS-backed resolver (request-scoped, so concurrent
+and streaming renders never share state); the client entry installs a
+module-singleton resolver. `fallback` is a single lazy snapshot used only
+when no resolver is registered — keeps isolated tests working without forcing
+them to spin up the runtime. Mirrors cacheStoreSlot.
+*/
+export const pageSlot: {
+    resolver: (() => PageSnapshot | undefined) | undefined
+    fallback: PageSnapshot | undefined
+} = {
+    resolver: undefined,
+    fallback: undefined,
+}

package/src/lib/shared/pageUrlForFile.ts

@@ -0,0 +1,14 @@
+/*
+Maps a page-relative path (under `src/ui/pages/`) to its URL route. Pages are
+folder-based: every leaf is `page.abide` or `layout.abide`, and the URL
+is the directory path. Pages mount at the directory path; layouts mount at
+the directory prefix. Dynamic segments keep their `[name]` / `[...rest]`
+shape — translation to Bun's `:name` / `*` happens at server registration
+via toBunRoutePattern; consumers see the readable form in `nav.route`.
+*/
+export function pageUrlForFile(relPath: string): string {
+    const segments = relPath.split('/')
+    segments.pop()
+    const path = segments.filter(Boolean).join('/')
+    return path === '' ? '/' : `/${path}`
+}

package/src/lib/shared/parseBoundedEnvInt.ts

@@ -0,0 +1,20 @@
+/*
+Parses an env string into an integer within [min, max], returning undefined for
+missing, empty, or out-of-range/non-integer input so the caller can fall back to
+a default. A bare Number() turns '' into 0 and 'abc' into NaN, both silently
+wrong; this rejects them instead.
+*/
+export function parseBoundedEnvInt(
+    value: string | undefined,
+    min: number,
+    max: number,
+): number | undefined {
+    if (value === undefined || value.trim() === '') {
+        return undefined
+    }
+    const parsed = Number(value)
+    if (!Number.isInteger(parsed) || parsed < min || parsed > max) {
+        return undefined
+    }
+    return parsed
+}

package/src/lib/shared/parseDebugPatterns.ts

@@ -0,0 +1,21 @@
+/*
+DEBUG's comma list, parsed once per distinct string — the gate runs on every
+log emission, and the env never changes server-side. A single-slot memo
+suffices: the browser's abide-debug localStorage toggle produces a new string
+that misses the memo and reparses.
+*/
+let lastEnv: string | undefined
+let lastPatterns: string[] = []
+
+export function parseDebugPatterns(env: string | undefined): string[] {
+    if (env !== lastEnv) {
+        lastEnv = env
+        lastPatterns = env
+            ? env
+                  .split(',')
+                  .map((raw) => raw.trim())
+                  .filter((pattern) => pattern !== '')
+            : []
+    }
+    return lastPatterns
+}

package/src/lib/shared/parseEnv.ts

@@ -0,0 +1,30 @@
+const ENV_LINE = /^\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.*)$/
+
+/*
+Parses `.env` text into a key→value record. Skips blanks, comments, and
+malformed lines; strips a single layer of surrounding single or double quotes.
+Intentionally minimal — no variable expansion, escapes, or multi-line. The pure
+counterpart to loadEnvFile (which merges into process.env) and serializeEnv
+(which writes records back), so all three round-trip the same shape.
+*/
+export function parseEnv(text: string): Record<string, string> {
+    const result: Record<string, string> = {}
+    for (const line of text.split('\n')) {
+        if (!line || line.startsWith('#')) {
+            continue
+        }
+        const match = ENV_LINE.exec(line)
+        if (!match) {
+            continue
+        }
+        const [, key, rawValue] = match
+        const trimmed = rawValue?.trim() ?? ''
+        const unquoted =
+            (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+            (trimmed.startsWith("'") && trimmed.endsWith("'"))
+                ? trimmed.slice(1, -1)
+                : trimmed
+        result[key as string] = unquoted
+    }
+    return result
+}

package/src/lib/shared/parsePromptMarkdown.ts

@@ -0,0 +1,35 @@
+import type { PromptArgument } from './types/PromptArgument.ts'
+
+export type ParsedPromptMarkdown = {
+    description: string | undefined
+    arguments: PromptArgument[]
+    body: string
+}
+
+// Leading YAML frontmatter block fenced by `---` lines (CRLF tolerant).
+const FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/
+
+/*
+Splits a `src/mcp/prompts/**.md` file into its frontmatter metadata and
+template body. The frontmatter (optional) carries `description` and an
+`arguments` list; everything after the closing `---` is the prompt body,
+interpolated at render time via `{{name}}` placeholders. A file with no
+frontmatter is all body. Parsed with Bun.YAML — the resolver plugin runs
+under Bun, so the native parser is always available at build time.
+*/
+export function parsePromptMarkdown(source: string): ParsedPromptMarkdown {
+    const match = FRONTMATTER.exec(source)
+    if (!match) {
+        return { description: undefined, arguments: [], body: source.trim() }
+    }
+    // The pattern makes group 1 mandatory; the '' default exists for noUncheckedIndexedAccess in consumer tsconfigs.
+    const frontmatter = (Bun.YAML.parse(match[1] ?? '') ?? {}) as {
+        description?: string
+        arguments?: PromptArgument[]
+    }
+    return {
+        description: frontmatter.description,
+        arguments: Array.isArray(frontmatter.arguments) ? frontmatter.arguments : [],
+        body: source.slice(match[0].length).trim(),
+    }
+}

package/src/lib/shared/parseRouteSegments.ts

@@ -0,0 +1,22 @@
+export type RouteSegment =
+    | { kind: 'literal'; value: string }
+    | { kind: 'param'; name: string; catchAll: boolean }
+
+/*
+Splits a abide route URL into typed segments. `[name]` becomes a param,
+`[...rest]` becomes a catch-all param, anything else is a literal. Used
+by toBunRoutePattern (server-side Bun pattern emission) and writeRoutesDts
+(client-side `Routes` type augmentation) so the two consumers can't drift
+on what counts as a param.
+*/
+export function parseRouteSegments(routeUrl: string): RouteSegment[] {
+    return routeUrl.split('/').map((segment) => {
+        if (segment.startsWith('[...') && segment.endsWith(']')) {
+            return { kind: 'param', name: segment.slice(4, -1), catchAll: true }
+        }
+        if (segment.startsWith('[') && segment.endsWith(']')) {
+            return { kind: 'param', name: segment.slice(1, -1), catchAll: false }
+        }
+        return { kind: 'literal', value: segment }
+    })
+}

package/src/lib/shared/parseTraceparent.ts

@@ -0,0 +1,26 @@
+import type { TraceContext } from './types/TraceContext.ts'
+
+const TRACEPARENT_PATTERN = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/
+
+/*
+Parses a W3C `traceparent` header into a TraceContext, or undefined when the
+value is malformed (per spec, an unreadable header is ignored and the receiver
+starts a fresh trace). Rejects the all-zero trace/span ids and the reserved
+version 'ff'. The header's span id lands in `spanId`: from the wire's point of
+view that field is "the id of the step that sent this" — callers minting their
+own step id move it to `parentSpanId` (createTraceContext does).
+*/
+export function parseTraceparent(header: string): TraceContext | undefined {
+    const match = TRACEPARENT_PATTERN.exec(header.trim().toLowerCase())
+    if (!match) {
+        return undefined
+    }
+    /* The pattern makes all four groups mandatory, but consumer tsconfigs with
+       noUncheckedIndexedAccess type-check this shipped source and see them as
+       possibly undefined — default to '' so the zero-id guards reject that path. */
+    const [, version = '', traceId = '', spanId = '', flags = ''] = match
+    if (version === 'ff' || /^0*$/.test(traceId) || /^0*$/.test(spanId)) {
+        return undefined
+    }
+    return { traceId, spanId, flags }
+}

package/src/lib/shared/pending.ts

@@ -0,0 +1,30 @@
+import { probeRegistries } from './probeRegistries.ts'
+import type { CacheEntry } from './types/CacheEntry.ts'
+import type { CacheSelector } from './types/CacheSelector.ts'
+import type { Subscribable } from './types/Subscribable.ts'
+
+/*
+Reactive in-flight probe over both registries — the cache (calls) and the
+tail registry (streams). Pending means "no value yet":
+  pending()              → any call in flight, or any registered stream
+                           awaiting its first frame (global activity bar)
+  pending(fn)            → that function's calls (per-route spinner; remote or
+                           producer, same selector grammar as cache.invalidate)
+  pending(fn, args)      → exactly that call (per-row spinner)
+  pending({ scope })     → a tagged group
+  pending(subscribable)  → that stream awaiting its first frame
+                           (tail.status === 'pending'; true when nothing
+                           is reading yet — there is no value either way)
+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.
+*/
+// @readme probes
+export function pending<Args, Return>(
+    arg?: CacheSelector<Args, Return> | Subscribable<unknown>,
+    args?: Args,
+): boolean {
+    return probeRegistries(arg, args, 'pending', unsettled, true)
+}
+
+const unsettled = (entry: CacheEntry) => entry.settled !== true

package/src/lib/shared/prepareRpcModule.ts

@@ -0,0 +1,59 @@
+import { findExportCallSite } from './findExportCallSite.ts'
+import { importNamesToStrip } from './importNamesToStrip.ts'
+import { stripImport } from './stripImport.ts'
+import type { HttpVerb } from './types/HttpVerb.ts'
+
+const VERB_NAMES = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD'] as const
+const VERB_SET = new Set<string>(VERB_NAMES)
+
+const SINGLE_EXPORT_ERROR =
+    '[abide] $rpc module contains more than one `<VERB>(...)` export — each file must declare exactly one remote function'
+
+export type PreparedRpcModule = {
+    verb: HttpVerb
+    exportName: string
+    rewriteForServer: (url: string) => string
+}
+
+/*
+Scans an `$rpc/**` module once and returns its declared verb + export
+name plus a closure that, given the route URL, emits the server-side
+rewrite (`__abideDefineVerb__("VERB", "<url>", … )` spliced into the
+original source). The single scan replaces the prior separate
+extract + rewrite passes, so the resolver plugin only walks each source
+character-by-character once.
+
+A regex pass would be tidier but it can't tell a `GET` mention inside a
+docstring or template literal from the real call, and it can't follow
+nested generics like `GET<Map<K, V>>(`.
+*/
+export function prepareRpcModule(
+    source: string,
+    importName: string,
+): PreparedRpcModule | undefined {
+    /*
+    The "no barrels" surface places each verb at its own path
+    (`abide/server/GET`, `abide/server/POST`, …) — strip every one so
+    the user's verb import doesn't linger and side-effect-load the
+    stub module into the server bundle. The user may import under the
+    project's chosen name or the canonical package name, so strip both.
+    */
+    const stripped = importNamesToStrip(importName).reduce(
+        (current, name) =>
+            VERB_NAMES.reduce((acc, verb) => stripImport(acc, `${name}/server/${verb}`), current),
+        source,
+    )
+    const site = findExportCallSite(stripped, (ident) => VERB_SET.has(ident), SINGLE_EXPORT_ERROR)
+    if (!site) {
+        return undefined
+    }
+    const verb = site.ident as HttpVerb
+    return {
+        verb,
+        exportName: site.exportName,
+        rewriteForServer(url: string): string {
+            const binding = `__abideDefineVerb__(${JSON.stringify(verb)}, ${JSON.stringify(url)}, `
+            return stripped.slice(0, site.callStart) + binding + stripped.slice(site.parenStart + 1)
+        },
+    }
+}

package/src/lib/shared/prepareSocketModule.ts

@@ -0,0 +1,49 @@
+import { findExportCallSite } from './findExportCallSite.ts'
+import { importNamesToStrip } from './importNamesToStrip.ts'
+import { stripImport } from './stripImport.ts'
+
+const SINGLE_EXPORT_ERROR =
+    '[abide] $sockets module contains more than one `socket(...)` export — each file must declare exactly one socket'
+
+export type PreparedSocketModule = {
+    exportName: string
+    rewriteForServer: (name: string) => string
+}
+
+/*
+Scans a `$sockets/**` module once and returns its declared export name
+plus a closure that, given the socket name, emits the server-side
+rewrite (`__abideDefineSocket__("<name>"[, opts])` spliced into the
+original source). The single scan replaces the prior separate
+extract + rewrite passes, so the resolver plugin only walks each source
+character-by-character once.
+*/
+export function prepareSocketModule(
+    source: string,
+    importName: string,
+): PreparedSocketModule | undefined {
+    /*
+    Strip the user's `socket` import under the project's chosen name and the
+    canonical package name so the dead import can't side-effect-load the
+    socket helper into the server bundle.
+    */
+    const stripped = importNamesToStrip(importName).reduce(
+        (current, name) => stripImport(current, `${name}/server/socket`),
+        source,
+    )
+    const site = findExportCallSite(stripped, (ident) => ident === 'socket', SINGLE_EXPORT_ERROR)
+    if (!site) {
+        return undefined
+    }
+    return {
+        exportName: site.exportName,
+        rewriteForServer(name: string): string {
+            const inner = stripped.slice(site.parenStart + 1, site.parenEnd).trim()
+            const binding =
+                inner.length === 0
+                    ? `__abideDefineSocket__(${JSON.stringify(name)})`
+                    : `__abideDefineSocket__(${JSON.stringify(name)}, ${stripped.slice(site.parenStart + 1, site.parenEnd)})`
+            return stripped.slice(0, site.callStart) + binding + stripped.slice(site.parenEnd + 1)
+        },
+    }
+}