@abide/abide 0.58.0 → 0.100.0

package/src/lib/shared/emitLogRecord.ts

@@ -1,217 +0,0 @@
-import { logTapSlot } from './logTapSlot.ts'
-import { requestScopeSlot } from './requestScopeSlot.ts'
-import type { LogRecord } from './types/LogRecord.ts'
-import type { LogVoice } from './types/LogVoice.ts'
-
-const hasBun = typeof Bun !== 'undefined'
-const useColor = hasBun && Bun.enableANSIColors
-const RESET = '\x1b[0m'
-const DIM = '\x1b[2m'
-
-/* The finite color set the log fragments paint with. Resolve each ANSI-256
-   escape once at module load — `Bun.color` was otherwise called per colored
-   fragment per line. Empty when colors are off so `paint` short-circuits. */
-const COLOR_NAMES = ['red', 'yellow', 'cyan', 'green', 'blue', 'white'] as const
-const COLOR_ESCAPES: Record<string, string> = useColor
-    ? Object.fromEntries(COLOR_NAMES.map((name) => [name, Bun.color(name, 'ansi-256') ?? '']))
-    : {}
-
-// Wraps `text` in a precomputed ANSI color escape; no-op when colors are disabled or unavailable (browser).
-function paint(color: string, text: string): string {
-    const ansiEscape = COLOR_ESCAPES[color]
-    if (ansiEscape === undefined) {
-        return text
-    }
-    return `${ansiEscape}${text}${RESET}`
-}
-
-// Applies the ANSI dim attribute; no-op when colors are disabled.
-function dim(text: string): string {
-    if (!useColor) {
-        return text
-    }
-    return `${DIM}${text}${RESET}`
-}
-
-// Maps an HTTP status code to a color that matches the usual server-log convention.
-function colorStatus(status: number): string {
-    if (status >= 500) {
-        return paint('red', String(status))
-    }
-    if (status >= 400) {
-        return paint('yellow', String(status))
-    }
-    if (status >= 300) {
-        return paint('cyan', String(status))
-    }
-    return paint('green', String(status))
-}
-
-// Maps an HTTP method to a color so the request log line is easy to scan.
-function colorMethod(method: string): string {
-    const upper = method.toUpperCase()
-    if (upper === 'GET') {
-        return paint('green', upper)
-    }
-    if (upper === 'POST') {
-        return paint('blue', upper)
-    }
-    if (upper === 'PUT' || upper === 'PATCH') {
-        return paint('yellow', upper)
-    }
-    if (upper === 'DELETE') {
-        return paint('red', upper)
-    }
-    return paint('white', upper)
-}
-
-/* json emission is a server concern (stdout ingestion); the browser console always gets tsv. Read per call — log volume never makes this hot. */
-function useJson(): boolean {
-    return typeof process !== 'undefined' && process.env.ABIDE_LOG_FORMAT === 'json'
-}
-
-/* `+12.30ms` — unpadded: the timing trails the line, so no width keeps columns aligned. */
-function formatElapsed(ms: number): string {
-    return `+${ms.toFixed(2)}ms`
-}
-
-/* Left-pads a clock component to a fixed width. Module-scoped so it isn't
-   re-allocated per log line. */
-function pad(value: number, width = 2): string {
-    return String(value).padStart(width, '0')
-}
-
-/* `14:23:01.072` — local wall-clock to the ms. Every record carries `ts`, so the
-   tsv line always leads with one; `+elapsedMs` still trails as the request-relative
-   timing — the two are different axes (when it happened vs how long it took). */
-function formatClock(ts: number): string {
-    const date = new Date(ts)
-    return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}`
-}
-
-/*
-Builds the record from the emission's own fields plus the ambient request
-scope (trace, elapsed, method+path), then renders it through the active
-formatter. The scope is read at emission time so a record emitted from a
-stream-flush callback re-entered into the scope still carries its context.
-Internal seam shared by the public logger and the framework's closing-record
-emitter; console.* is the side effect — logging is intentionally impure.
-*/
-export function emitLogRecord(fields: Omit<LogRecord, 'ts'>, voice?: LogVoice): void {
-    const scope = requestScopeSlot.resolver?.()
-    const record: LogRecord = { ts: Date.now(), ...fields }
-    if (scope) {
-        record.trace = scope.trace.traceId
-        record.requestSpan = scope.trace.spanId
-        record.parentSpan = scope.trace.parentSpanId
-        record.elapsedMs = scope.elapsedMs
-        record.method = fields.method ?? scope.method
-        record.path = fields.path ?? scope.path
-    }
-    // Hand the finished record to the inspector tap (when installed) before
-    // formatting — it observes the same structure the console receives.
-    logTapSlot.tap?.(record)
-    if (useJson()) {
-        printJson(record)
-        return
-    }
-    printTsv(record, voice)
-}
-
-/*
-One JSON object per line on the level-matched console stream. Undefined
-fields drop out of JSON.stringify; non-serialisable `data` degrades to its
-String form rather than killing the record.
-*/
-function printJson(record: LogRecord): void {
-    const payload = { ...record, ts: new Date(record.ts).toISOString() }
-    let line: string
-    try {
-        line = JSON.stringify(payload)
-    } catch {
-        line = JSON.stringify({ ...payload, data: String(record.data) })
-    }
-    consoleFor(record.level)(line)
-}
-
-function consoleFor(level: LogRecord['level']): (...args: unknown[]) => void {
-    if (level === 'error') {
-        return console.error
-    }
-    if (level === 'warn') {
-        return console.warn
-    }
-    return console.log
-}
-
-/*
-The unified tsv line (the default format): tab-separated
-`<clock>	<trace8>	<rpc path>	[channel] <message>	+0.00ms`. The
-wall-clock leads every line (each record carries `ts`); inside a request scope
-the trace column follows and the elapsed-at-emission timing trails; a closing
-record emitted outside one (asset hits sidestep the scope) pads a blank trace
-column and trails its serve duration instead, so request lines stay aligned
-whatever produced them. Every record speaks on a channel
-(the app name, 'abide', or a diagnostic channel), shown as a dim `[name]`
-tag opening the message field. The method+path pair is one field — it's the
-line's anchor unit — and the tag folds into the message field so field
-positions stay stable for cut/awk consumers.
-*/
-function printTsv(record: LogRecord, voice?: LogVoice): void {
-    const fields: string[] = []
-    const closing = record.status !== undefined
-    /* Wall-clock leads every line — a stable first column, unlike the conditional
-       trace field, and the axis `+elapsedMs` can't give (when, not how-long). */
-    fields.push(dim(formatClock(record.ts)))
-    if (record.trace) {
-        fields.push(dim(record.trace.slice(0, 8)))
-    } else if (closing) {
-        fields.push(' '.repeat(8))
-    }
-    if (record.method && record.path) {
-        fields.push(`${colorMethod(record.method)} ${record.path}`)
-    }
-    const message: string[] = []
-    if (record.channel) {
-        message.push(dim(`[${record.channel}]`))
-    }
-    message.push(tsvBody(record, voice))
-    fields.push(message.join(' '))
-    if (record.elapsedMs !== undefined) {
-        fields.push(dim(formatElapsed(record.elapsedMs)))
-    } else if (closing && record.durationMs !== undefined) {
-        fields.push(dim(formatElapsed(record.durationMs)))
-    }
-    const writer = consoleFor(record.level)
-    if (record.data !== undefined) {
-        writer(fields.join('\t'), record.data)
-        return
-    }
-    writer(fields.join('\t'))
-}
-
-// The message field after the context fields, styled by level/kind/voice.
-function tsvBody(record: LogRecord, voice?: LogVoice): string {
-    /* Closing request record: status is the message; the duration rides the elapsed column. */
-    if (record.status !== undefined) {
-        return colorStatus(record.status)
-    }
-    /* log.trace operation record: name + settled duration. */
-    if (record.name !== undefined && record.durationMs !== undefined) {
-        const failure = record.level === 'error' ? ` ${paint('red', record.msg)}` : ''
-        return `${record.name} ${dim(`${record.durationMs.toFixed(2)}ms`)}${failure}`
-    }
-    if (record.level === 'error') {
-        return paint('red', record.stack ?? record.msg)
-    }
-    if (record.level === 'warn') {
-        return paint('yellow', record.msg)
-    }
-    if (voice === 'success') {
-        return paint('green', record.msg)
-    }
-    if (voice === 'detail') {
-        return dim(record.msg)
-    }
-    return record.msg
-}

package/src/lib/shared/encodeRefJson.ts

@@ -1,108 +0,0 @@
-/*
-Serialise an arbitrary value graph to a JSON string that survives cycles and shared
-references — the gap JSON.stringify can't cross. Only mutable CONTAINERS (objects,
-arrays, Maps, Sets) are hoisted into a flat `slots` array and referenced by index, so
-a cycle becomes a back-reference instead of infinite recursion, and two paths to the
-same container decode back to the same object. Primitives are encoded INLINE at their
-position (not hoisted), so a primitive-heavy payload stays near plain-JSON size and
-speed. Beyond plain objects/arrays it round-trips the types JSON drops or coerces:
-undefined, bigint, NaN, ±Infinity, -0, Date, RegExp, Map and Set. Functions and
-symbols can't be serialised and encode as undefined, matching JSON.stringify. Output
-shape is `[rootValue, slots]`. Decode with decodeRefJson. Not streaming — the whole
-graph is walked up front.
-*/
-import { REF_JSON_NUMBER_TOKENS, REF_JSON_TAGS } from './REF_JSON_TAGS.ts'
-import { setOwnProperty } from './setOwnProperty.ts'
-
-export function encodeRefJson(value: unknown): string {
-    // Hoisted containers only; slots[i] is addressed by ['~r', i]. Primitives stay inline.
-    const slots: unknown[] = []
-    // Container identity → slot index: a revisited container emits a back-reference instead of recursing.
-    const ids = new Map<object, number>()
-
-    // Hoist a container to a slot (once) and return its index. Reserve the index BEFORE encoding
-    // children so a cyclic child resolves back to this slot.
-    function intern(container: object): number {
-        const seen = ids.get(container)
-        if (seen !== undefined) {
-            return seen
-        }
-        const index = slots.length
-        slots.push(0)
-        ids.set(container, index)
-        slots[index] = encodeContainer(container)
-        return index
-    }
-
-    // Inline encoding of a value at its position: bare primitive, leaf-special tag, or a container reference.
-    function encodeValue(input: unknown): unknown {
-        if (input === null) {
-            return null
-        }
-        const type = typeof input
-        if (type === 'string' || type === 'boolean') {
-            return input
-        }
-        if (type === 'number') {
-            const numeric = input as number
-            // -0, NaN, ±Infinity can't round-trip as bare JSON; tag them.
-            if (!Number.isFinite(numeric) || Object.is(numeric, -0)) {
-                return [REF_JSON_TAGS.NUMBER, numberToken(numeric)]
-            }
-            return numeric
-        }
-        if (type === 'bigint') {
-            return [REF_JSON_TAGS.BIGINT, (input as bigint).toString()]
-        }
-        // undefined | function | symbol — not representable; fold to undefined as JSON drops them.
-        if (type !== 'object') {
-            return [REF_JSON_TAGS.UNDEFINED]
-        }
-        if (input instanceof Date) {
-            return [REF_JSON_TAGS.DATE, input.getTime()]
-        }
-        if (input instanceof RegExp) {
-            return [REF_JSON_TAGS.REGEXP, input.source, input.flags]
-        }
-        // Mutable container: hoist for identity and reference it — primitives above never reach here.
-        return [REF_JSON_TAGS.REF, intern(input as object)]
-    }
-
-    // A hoisted container's slot: a tagged array (or plain object) whose nested values are encoded inline.
-    function encodeContainer(container: object): unknown {
-        if (Array.isArray(container)) {
-            return [REF_JSON_TAGS.ARRAY, ...container.map(encodeValue)]
-        }
-        if (container instanceof Map) {
-            return [
-                REF_JSON_TAGS.MAP,
-                Array.from(container, ([key, val]) => [encodeValue(key), encodeValue(val)]),
-            ]
-        }
-        if (container instanceof Set) {
-            return [REF_JSON_TAGS.SET, Array.from(container, encodeValue)]
-        }
-        const record = container as Record<string, unknown>
-        // Own enumerable keys, built in one loop — ~2× cheaper than Object.fromEntries(keys.map(...))
-        // (no intermediate pairs array / closures) on this per-object always-hot path.
-        const encoded: Record<string, unknown> = {}
-        for (const key of Object.keys(record)) {
-            // setOwnProperty: an own `__proto__` key must reach the wire, not the accessor.
-            setOwnProperty(encoded, key, encodeValue(record[key]))
-        }
-        return encoded
-    }
-
-    return JSON.stringify([encodeValue(value), slots])
-}
-
-// Stable token for the numbers JSON can't carry.
-function numberToken(value: number): string {
-    if (Object.is(value, -0)) {
-        return REF_JSON_NUMBER_TOKENS.NEG_ZERO
-    }
-    if (Number.isNaN(value)) {
-        return REF_JSON_NUMBER_TOKENS.NAN
-    }
-    return value > 0 ? REF_JSON_NUMBER_TOKENS.INFINITY : REF_JSON_NUMBER_TOKENS.NEG_INFINITY
-}

package/src/lib/shared/encodeSeedValue.ts

@@ -1,24 +0,0 @@
-import { encodeRefJson } from './encodeRefJson.ts'
-
-/*
-The ONE degradation site for every server→client hydration seed (ADR-0048): ref-json-encode
-a value bound for a warm-seed channel (await resume, cell value, doc snapshot, socket frame,
-streamed-cell chunk), or drop JUST that entry with a warn naming what was dropped and what
-the client does instead. encodeRefJson is total for ordinary graphs (cycles become
-back-references, functions fold to undefined), so a throw is pathological — but it must
-never blank the surrounding payload/stream. Funnelling every channel through here keeps the
-serialize-or-degrade policy, the warn shape, and the per-kind consequence in one place
-instead of seven independently-worded (or silent) drop sites.
-*/
-export function encodeSeedValue(
-    value: unknown,
-    label: string,
-    consequence: string,
-): string | undefined {
-    try {
-        return encodeRefJson(value)
-    } catch (cause) {
-        console.warn(`[abide] ${label} is not serializable — ${consequence}.`, cause)
-        return undefined
-    }
-}

package/src/lib/shared/encodeWireBody.ts

@@ -1,18 +0,0 @@
-/*
-The single honest-JSON ENCODE point for the REST response faces (`json()` and the
-per-frame `sse()` body). JSON.stringify driven by wireJsonReplacer so a structured
-runtime value crosses as honest JSON — a `Set` → array, a `Map` → `[K,V]` entries, a
-`bigint` → digit string — instead of the silent `{}` a bare Set stringifies to or the
-throw a bare bigint triggers. Value-directed (not type-directed), so every consumer
-reads the same honest JSON the projected schema (jsonSchemaForType) describes: abide's
-own client and a foreign EventSource/curl alike.
-
-This is the REST counterpart to the ws path's encodeRefJson: it preserves the
-structured values losslessly the way ref-json does, but without the `[rootValue, slots]`
-envelope a foreign REST consumer (a naive EventSource + JSON.parse) can't read.
-*/
-import { wireJsonReplacer } from './wireJsonReplacer.ts'
-
-export function encodeWireBody(value: unknown): string {
-    return JSON.stringify(value, wireJsonReplacer)
-}

package/src/lib/shared/escapeHtml.ts

@@ -1,15 +0,0 @@
-/*
-HTML-escapes the five HTML-significant characters — the same set the runtime
-`$esc` handles. Isomorphic: shared by the build-time SSR/static-clone generators
-(so server markup and the client clone template can't diverge on escaping) and
-the server runtime's dev error page. Static text reaches the compile callers
-already entity-decoded (see parseTemplate), so escaping round-trips it through
-the HTML parser to the same plain text the client would build directly.
-*/
-export function escapeHtml(value: string): string {
-    return value.replace(
-        /[&<>"']/g,
-        (char) =>
-            ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[char] ?? char,
-    )
-}

package/src/lib/shared/escapeRegex.ts

@@ -1,9 +0,0 @@
-/*
-Escapes the regex metacharacters in `value` so it can be embedded literally
-inside a `new RegExp(...)` pattern. Shared by the $rpc/$sockets import stripper,
-the resolver plugin's virtual-namespace matcher, and the SSR snippet-call
-rewriter so the same escaping is applied one way everywhere.
-*/
-export function escapeRegex(value: string): string {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}

package/src/lib/shared/exeSuffix.ts

@@ -1,9 +0,0 @@
-import type { CompileTarget } from './types/CompileTarget.ts'
-
-/*
-Executable filename suffix for a compile target — `.exe` on Windows targets,
-empty elsewhere. Single source so every cross-compile output path agrees.
-*/
-export function exeSuffix(target: CompileTarget): string {
-    return target.includes('windows') ? '.exe' : ''
-}

package/src/lib/shared/exitOnBuildFailure.ts

@@ -1,18 +0,0 @@
-import type { BuildOutput } from 'bun'
-import { abideLog } from './abideLog.ts'
-
-/*
-On a failed Bun.build(), logs each diagnostic and exits non-zero. The one-shot
-build entrypoints reach it through `buildArtifact` (build-or-die); the
-incremental client build (build.ts) calls it directly on its conditional-exit
-path. One reporter so build failure can't drift between them.
-*/
-export function exitOnBuildFailure(result: BuildOutput): void {
-    if (result.success) {
-        return
-    }
-    result.logs.forEach((entry) => {
-        abideLog.error(entry)
-    })
-    process.exit(1)
-}

package/src/lib/shared/extraForwardHeaders.ts

@@ -1,16 +0,0 @@
-/*
-App-configured inbound header names to forward onto in-process rpc Requests,
-on top of the built-in FORWARDED_HEADERS. Set once at boot from
-app.forwardHeaders so the SSR in-process path (defineRpc) and the MCP
-dispatcher honour the same list without re-reading app config per call. A
-module-level slot rather than threaded config because both call sites are deep
-in the request path and the value is fixed for the process lifetime.
-*/
-let names: readonly string[] = []
-
-export const extraForwardHeaders = {
-    get: (): readonly string[] => names,
-    set: (configured: readonly string[]): void => {
-        names = configured
-    },
-}

package/src/lib/shared/fieldErrorsFromIssues.ts

@@ -1,27 +0,0 @@
-import type { StandardSchemaV1 } from './types/StandardSchemaV1.ts'
-
-/*
-Flattens Standard Schema issues into a top-level-field → first-message map, the
-form-friendly companion to the raw `issues` on a 422. A path segment is either a
-bare `PropertyKey` or a `{ key }` wrapper (the spec allows both), so normalize
-before reading. First message wins per field (a form shows one per input); the
-raw `issues` keep every message and the full path. Issues with no string field
-(root-level refinements) are omitted — they live only in `issues`.
-
-Isomorphic (only the type-only StandardSchemaV1 import): the server 422 path
-(validationError.ts) and the client pre-flight (validationHttpError.ts, ADR-0026)
-both build the identical `fields` map from the same issue list.
-*/
-export function fieldErrorsFromIssues(
-    issues: readonly StandardSchemaV1.Issue[],
-): Record<string, string> {
-    const fields: Record<string, string> = {}
-    for (const issue of issues) {
-        const segment = issue.path?.[0]
-        const key = typeof segment === 'object' ? segment.key : segment
-        if (typeof key === 'string' && !(key in fields)) {
-            fields[key] = issue.message
-        }
-    }
-    return fields
-}

package/src/lib/shared/fileName.ts

@@ -1,9 +0,0 @@
-/*
-The bare leaf filename of a path — directory stripped, extension kept —
-e.g. `users/list.ts` → `list.ts`. The extension-stripping `fileStem` builds on
-this; call sites that match a full filename (`layout.abide`, `page.abide`) use
-it directly so the leaf-grab is written one way.
-*/
-export function fileName(path: string): string {
-    return path.split('/').pop() ?? ''
-}

package/src/lib/shared/fileStem.ts

@@ -1,11 +0,0 @@
-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`.
-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 fileName(path).replace(/\.[^.]+$/, '')
-}