@abide/abide 0.58.0 → 0.100.0

package/src/lib/shared/hydrationWindow.ts

@@ -1,53 +0,0 @@
-import { cacheStores } from './cacheStores.ts'
-
-/*
-The one owner of the hydration pass lifecycle — the timing window during which the
-client adopts the server-rendered DOM (the router's hydrate branch and `hydrate`).
-
-Why it exists: the server materializes no cache value (materializeRetained/
-cacheEntryFromSnapshot are client-only), so server-side peek is uniformly undefined
-and the SSR render always shows the fallback. A snapshot-seeded warm value surfacing
-DURING hydration would diverge from that server text and corrupt the claimed text
-node (assertClaimedText desync), so `peek` withholds it while `active` is true and
-`wake()` re-runs the withheld scopes once the pass ends.
-
-`active` is a plain boolean — false on the server (no hydration) and after boot —
-readable by the withhold check. `enter`/`exit` bracket a pass with save/restore
-nesting (a `depth` counter) so a child hydrate can't clear an outer pass early;
-`active` stays true until the OUTERMOST `exit`, which then fires `wake`.
-
-`wake` marks every live cache entry's key: a peek scope taps the exact call key's
-lifecycle channel (peek's trackLifecycle), so marking every live entry's key wakes
-the scopes that withheld — cheap, one-time, and harmless for non-peek lifecycle
-readers (they recompute the same value). Marks by key, not the bare store-wide
-channel, because a peek(fn, args) scope taps the per-key prefix channel, which a
-keyless mark misses.
-*/
-export const hydrationWindow = {
-    active: false,
-    depth: 0,
-    /* Open a pass. Nested enters raise the depth without re-firing anything. */
-    enter(): void {
-        hydrationWindow.depth += 1
-        hydrationWindow.active = true
-    },
-    /* Close a pass. Only the OUTERMOST unwind (depth back to zero) clears `active`
-       and wakes the scopes the pass withheld — a nested child exit must not. */
-    exit(): void {
-        hydrationWindow.depth -= 1
-        if (hydrationWindow.depth === 0) {
-            hydrationWindow.active = false
-            hydrationWindow.wake()
-        }
-    },
-    /* Re-run the peeks the pass withheld, now that the retained value is congruent
-       to show. Mark every live entry's key across both cache stores. */
-    wake(): void {
-        const stores = cacheStores()
-        for (const store of stores) {
-            for (const key of store.entries.keys()) {
-                store.markLifecycle(key)
-            }
-        }
-    },
-}

package/src/lib/shared/importNamesToStrip.ts

@@ -1,13 +0,0 @@
-import { ABIDE_PACKAGE_NAME } from './ABIDE_PACKAGE_NAME.ts'
-
-/*
-The names a user may import a abide server helper under: the project's chosen
-alias plus the canonical package name. The resolver strips the dead import
-under both so it can't side-effect-load the server stub into the client
-bundle. When the alias already is the canonical name, there's only one.
-*/
-export function importNamesToStrip(importName: string): string[] {
-    return importName === ABIDE_PACKAGE_NAME
-        ? [ABIDE_PACKAGE_NAME]
-        : [importName, ABIDE_PACKAGE_NAME]
-}

package/src/lib/shared/invalidate.ts

@@ -1,39 +0,0 @@
-import { cacheStalenessSlot } from './cacheStalenessSlot.ts'
-import { isAsyncCell } from './isAsyncCell.ts'
-import type { AsyncComputed } from './types/AsyncComputed.ts'
-import type { CacheSelector } from './types/CacheSelector.ts'
-
-/*
-Drop every cached read matching the selector so the next read reloads it lazily —
-the drop verb, distinct from refresh (which refetches now, keeping the stale value
-visible). A mounted RETAINED reader revalidates stale-in-place under invalidate too
-(its retain+invalidation policy keeps the value and refetches); a background /
-non-retained entry (an explicit `cache()`, a producer, a reader-less entry) is
-dropped and refetches only when re-read. Follows the shared selector grammar:
-
-  invalidate(getFoo, args)   → that exact call
-  invalidate(getFoo)         → every args-variant of that rpc
-  invalidate({ tags })       → every entry sharing a tag
-  invalidate()               → every entry
-
-Instance sugar `getFoo.invalidate(args?)` ≡ `invalidate(getFoo, args?)`.
-
-Isomorphic (ADR-0041): applied LOCALLY on the client, and on the SERVER it
-broadcasts to every connected client (each applies the local drop). The side-swap
-rides the cacheStalenessSlot resolver — this source is byte-identical on both
-sides. `invalidate(asyncCell)` aliases `cell.refresh()` (a cell has no droppable
-entry; its staleness is re-running its seed), matching `refresh(cell)`.
-*/
-// @documentation cache
-export function invalidate<Args, Return>(
-    arg?: CacheSelector<Args, Return> | AsyncComputed<unknown>,
-    args?: Args,
-): void {
-    /* An async cell re-invokes its own seed (`invalidate(cell)` ≡ `cell.refresh()`). */
-    if (isAsyncCell(arg)) {
-        arg.refresh()
-        return
-    }
-    /* Side-swap: the client entry applies locally; the server entry broadcasts. */
-    cacheStalenessSlot.get()?.('invalidate', arg as CacheSelector<Args, Return>, args)
-}

package/src/lib/shared/invalidateEvent.ts

@@ -1,11 +0,0 @@
-import type { CacheInvalidation } from './types/CacheInvalidation.ts'
-
-/*
-Constructs the cache store's 'invalidate' event from the keys an
-invalidation touched. The single definition of the event name + detail
-shape, so the two dispatch sites (cache.invalidate and the streamed-
-resolution placeholder settle) can't drift from the cache store's listener.
-*/
-export function invalidateEvent(keys: Iterable<string>): CustomEvent<CacheInvalidation> {
-    return new CustomEvent('invalidate', { detail: new Set(keys) })
-}

package/src/lib/shared/invalidateTripwire.ts

@@ -1,40 +0,0 @@
-import { abideLog } from './abideLog.ts'
-
-/*
-Same-selector invalidations within one macrotask before the warning fires. A
-reactive loop spins on microtasks (lifecycle mark → effect flush →
-invalidate), starving macrotasks — so the reset timer below never runs while
-one is live, and legitimate repeats (socket frames, user events) arriving
-across macrotasks clear the count instead.
-*/
-const LOOP_THRESHOLD = 25
-
-const invalidationCounts = new Map<string, number>()
-let resetTimer: ReturnType<typeof setTimeout> | undefined
-
-/*
-Cycle tripwire for cache.invalidate. A synchronous re-run counter (an
-effect-update-depth limit) counts synchronous re-runs, but the probes' lifecycle marks defer a microtask
-(createLifecycleChannel), so a self-feeding effect — one that reads a probe or
-cached value and invalidates a selector that re-wakes its own scope — spins
-forever without tripping it, pinning the CPU. Many invalidations of one
-selector inside a single macrotask is that signature. Warns once per episode
-(the starved reset timer can't fire mid-loop, so the count only crosses the
-threshold once); reporting only — invalidation proceeds.
-*/
-export function invalidateTripwire(selectorLabel: string): void {
-    const count = (invalidationCounts.get(selectorLabel) ?? 0) + 1
-    invalidationCounts.set(selectorLabel, count)
-    if (resetTimer === undefined) {
-        resetTimer = setTimeout(() => {
-            resetTimer = undefined
-            invalidationCounts.clear()
-        }, 0)
-        resetTimer.unref?.()
-    }
-    if (count === LOOP_THRESHOLD) {
-        abideLog.warn(
-            `cache.invalidate(${selectorLabel}) fired ${LOOP_THRESHOLD}× within one task — likely a reactive loop: an effect that reads pending()/refreshing() or a cached value and invalidates a selector waking its own scope re-triggers itself across microtasks, invisible to synchronous loop detection. Find the effect invalidating ${selectorLabel}.`,
-        )
-    }
-}

package/src/lib/shared/isAbideHealthPayload.ts

@@ -1,11 +0,0 @@
-/*
-Whether a health/identity response body identifies a abide server. The
-`abide` field carries the framework version (a non-empty string) on current
-servers and `true` on older ones — both accepted, so a newer prober still
-recognises an older server. The body check (never response.ok alone) is the
-captive-portal defense shared by every prober: a portal answers any GET with
-a 200, but it doesn't answer with this.
-*/
-export function isAbideHealthPayload(body: { abide?: unknown }): boolean {
-    return body.abide === true || (typeof body.abide === 'string' && body.abide !== '')
-}

package/src/lib/shared/isAsciiWhitespace.ts

@@ -1,5 +0,0 @@
-/* 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/isAsyncCell.ts

@@ -1,11 +0,0 @@
-import { ASYNC_CELL } from './ASYNC_CELL.ts'
-import type { AsyncComputed } from './types/AsyncComputed.ts'
-
-/*
-True for an async cell's facet — the brand the probe family tests to route a cell
-(`AsyncComputed`/`AsyncState`) to its own `peek`/`pending`/`refreshing`/`refresh`
-methods instead of the cache/stream registries.
-*/
-export function isAsyncCell(value: unknown): value is AsyncComputed<unknown> {
-    return typeof value === 'object' && value !== null && ASYNC_CELL in value
-}

package/src/lib/shared/isAsyncIterable.ts

@@ -1,8 +0,0 @@
-/*
-Any async iterable — a stream cell auto-tracks by consuming `Symbol.asyncIterator` alone, so
-it needs no `name` (unlike `isSubscribable`, which the probe registry keys on the name). A
-plain `async function*` generator qualifies here where the named check would reject it.
-*/
-export function isAsyncIterable(value: unknown): value is AsyncIterable<unknown> {
-    return value != null && typeof (value as any)[Symbol.asyncIterator] === 'function'
-}

package/src/lib/shared/isCompileTarget.ts

@@ -1,21 +0,0 @@
-import type { CompileTarget } from './types/CompileTarget.ts'
-
-/* The canonical cross-compile targets, as a runtime set for validation. Kept
-   separate from `detectTarget`'s `HOST_TO_TARGET` on purpose, though the two lists
-   coincide today: this is "every target `--target` accepts" (all cross-targets),
-   while that map is "targets auto-detectable from a host". A future Bun target that
-   no host maps to (a new arch/libc we cross-compile to but don't run on) belongs
-   here and not there — deriving one from the other would couple distinct concerns.
-   Both stay aligned to `CompileTarget`, the single source of truth. */
-const COMPILE_TARGETS: readonly CompileTarget[] = [
-    'bun-darwin-arm64',
-    'bun-darwin-x64',
-    'bun-linux-arm64',
-    'bun-linux-x64',
-    'bun-windows-x64',
-]
-
-/* Narrows an arbitrary string to a known CompileTarget. */
-export function isCompileTarget(value: string): value is CompileTarget {
-    return (COMPILE_TARGETS as readonly string[]).includes(value)
-}

package/src/lib/shared/isDebugEnabled.ts

@@ -1,19 +0,0 @@
-import { debugGate } from './debugGate.ts'
-
-/*
-Whether a DEBUG-gated channel is enabled, npm-debug conventions:
-DEBUG="abide"           → enables "abide"
-DEBUG="abide:*"         → enables "abide" and "abide:anything"
-DEBUG="*"               → enables everything
-DEBUG="a,abide"         → comma-separated list
-DEBUG="abide:*,-abide:cache" → negation: exclusions win over inclusions
-Always-on channels don't consult this — they check isDebugNegated only.
-The default is guarded: this runs in the browser bundle, where `process`
-doesn't exist. Decision routed through debugGate, memoized per DEBUG value.
-*/
-export function isDebugEnabled(
-    name: string,
-    env: string | undefined = typeof process === 'undefined' ? undefined : process.env.DEBUG,
-): boolean {
-    return debugGate(env).enabled(name)
-}

package/src/lib/shared/isDebugNegated.ts

@@ -1,17 +0,0 @@
-import { debugGate } from './debugGate.ts'
-
-/*
-Whether a `-` pattern in DEBUG explicitly shuts a channel off — the off
-switch for the always-on channels (the app's name, 'abide'): DEBUG="-abide"
-silences framework lines including the per-request closing records,
-DEBUG="-myapp" the app's own. Silencing a channel silences all its levels —
-levels never gate, in either direction. The default is guarded: this runs in
-the browser bundle, where `process` doesn't exist. Decision routed through
-debugGate, memoized per DEBUG value.
-*/
-export function isDebugNegated(
-    name: string,
-    env: string | undefined = typeof process === 'undefined' ? undefined : process.env.DEBUG,
-): boolean {
-    return debugGate(env).negated(name)
-}

package/src/lib/shared/isIdentPart.ts

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

@@ -1,8 +0,0 @@
-/* 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/isLayoutFile.ts

@@ -1,12 +0,0 @@
-import { fileName } from './fileName.ts'
-
-/*
-Whether a module path is a router `layout.abide` — an EXACT leaf-filename match, the
-one predicate every site shares. `endsWith('layout.abide')` is wrong: it also matches
-`cardlayout.abide`, which the bundler's loader (exact match) compiles as a plain
-component, so an `endsWith` site would hot-compile / fingerprint it as a layout and
-diverge from the shipped bundle. Mirrors the loader so classification can't drift.
-*/
-export function isLayoutFile(path: string): boolean {
-    return fileName(path) === 'layout.abide'
-}

package/src/lib/shared/isModuleNotFound.ts

@@ -1,18 +0,0 @@
-import { messageFromError } from './messageFromError.ts'
-
-/*
-True when an error from a dynamic `import(...)` is a module-resolution
-failure (the package isn't installed) rather than an error thrown while
-the module's own code ran. Lets optional-peer loads swallow "not installed"
-while letting a genuine load-time failure surface. Bun surfaces the former
-as a ResolveMessage / ERR_MODULE_NOT_FOUND; the message check is the
-cross-runtime fallback.
-*/
-export function isModuleNotFound(error: unknown): boolean {
-    const code = (error as { code?: string })?.code
-    if (code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') {
-        return true
-    }
-    const message = messageFromError(error)
-    return /cannot find (module|package)|failed to resolve/i.test(message)
-}

package/src/lib/shared/isReadOnlyMethod.ts

@@ -1,14 +0,0 @@
-import type { HttpMethod } from './types/HttpMethod.ts'
-
-/*
-Read-only (safe) HTTP methods — they don't mutate server state. Abide
-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<HttpMethod>(['GET', 'HEAD'])
-
-export function isReadOnlyMethod(method: HttpMethod): boolean {
-    return READ_ONLY_METHODS.has(method)
-}

package/src/lib/shared/isReplayableMethod.ts

@@ -1,7 +0,0 @@
-import { REPLAYABLE_METHODS } from './REPLAYABLE_METHODS.ts'
-import type { ReplayableMethod } from './types/ReplayableMethod.ts'
-
-/* Narrowing gate over REPLAYABLE_METHODS so callers get the typed method without a cast. */
-export function isReplayableMethod(method: string): method is ReplayableMethod {
-    return REPLAYABLE_METHODS.has(method)
-}

package/src/lib/shared/isStreamingResponse.ts

@@ -1,12 +0,0 @@
-import { contentBodyKind } from './contentBodyKind.ts'
-import { contentTypeOf } from './contentTypeOf.ts'
-
-/*
-Whether a Response carries a streaming body (SSE / JSONL / NDJSON) by its
-Content-Type, so callers drain it frame-by-frame instead of buffering. The
-streaming bucket of the shared `contentBodyKind` classification. Shared by the
-CLI print path and the MCP tool dispatcher.
-*/
-export function isStreamingResponse(response: Response): boolean {
-    return contentBodyKind(contentTypeOf(response.headers)) === 'streaming'
-}

package/src/lib/shared/isSubscribable.ts

@@ -1,15 +0,0 @@
-import type { NamedAsyncIterable } from './types/NamedAsyncIterable.ts'
-
-/*
-A NamedAsyncIterable is an AsyncIterable carrying a `name` — distinguishes a stream argument from
-the other probe selector shapes (callables and `{ tags }` objects, neither of
-which carries Symbol.asyncIterator).
-*/
-export function isSubscribable(value: unknown): value is NamedAsyncIterable<unknown> {
-    return (
-        typeof value === 'object' &&
-        value !== null &&
-        Symbol.asyncIterator in value &&
-        'name' in value
-    )
-}

package/src/lib/shared/isThenable.ts

@@ -1,9 +0,0 @@
-/* True for a Promise-like value — anything carrying a callable `then`. Used to tell an
-   async cell's unwrap path (a promise to await) from a synchronously-produced value. */
-export function isThenable(value: unknown): value is PromiseLike<unknown> {
-    return (
-        value !== null &&
-        (typeof value === 'object' || typeof value === 'function') &&
-        typeof (value as { then?: unknown }).then === 'function'
-    )
-}

package/src/lib/shared/jsonSchemaForPromptArguments.ts

@@ -1,29 +0,0 @@
-import type { PromptArgument } from './types/PromptArgument.ts'
-
-/*
-Turns a markdown prompt's frontmatter `arguments` list into the JSON
-Schema the MCP dispatcher advertises in `prompts/list` (top-level string
-properties + a `required` array). Prompt arguments are always strings —
-MCP fills them from model output — so every property is `{ type: 'string' }`.
-Returns undefined for an argument-less prompt so the generated module
-omits the field entirely.
-*/
-export function jsonSchemaForPromptArguments(
-    args: PromptArgument[],
-): Record<string, unknown> | undefined {
-    if (args.length === 0) {
-        return undefined
-    }
-    const properties = Object.fromEntries(
-        args.map((arg) => [
-            arg.name,
-            { type: 'string', ...(arg.description ? { description: arg.description } : {}) },
-        ]),
-    )
-    const required = args.filter((arg) => arg.required).map((arg) => arg.name)
-    return {
-        type: 'object',
-        properties,
-        ...(required.length > 0 ? { required } : {}),
-    }
-}

package/src/lib/shared/jsonSchemaForSchema.ts

@@ -1,39 +0,0 @@
-import type { StandardSchemaV1 } from './types/StandardSchemaV1.ts'
-
-const OPAQUE = { type: 'object', additionalProperties: true } as const
-
-/*
-Resolves a JSON Schema for an MCP tool's `inputSchema`, an OpenAPI body, a CLI
-flag set, or the bundle setup form. Probes the schema's own projection:
-
-  1. `schema.toJsonSchema()` (Arktype 2+)
-  2. `schema.toJSONSchema()` (Zod 4, Effect Schema, or a withJsonSchema wrap)
-  3. Opaque object — the surface still works, the consumer just gets no shape hint
-
-A projection that exists but throws (e.g. Zod 4 can't render `z.custom()`)
-degrades to the same opaque fallback rather than escaping — one un-serializable
-schema must not take down the whole list its caller is building (an MCP
-tools/list, an OpenAPI doc). Wrap with withJsonSchema to supply a shape.
-
-Schemas whose library exposes neither carry one via withJsonSchema. Returns a
-fresh object each call; callers can mutate (e.g. add a description) without
-aliasing the schema's own.
-*/
-export function jsonSchemaForSchema(schema: StandardSchemaV1 | undefined): Record<string, unknown> {
-    if (!schema) {
-        return { ...OPAQUE }
-    }
-    const candidate = schema as unknown as {
-        toJsonSchema?: () => Record<string, unknown>
-        toJSONSchema?: () => Record<string, unknown>
-    }
-    const project = candidate.toJsonSchema ?? candidate.toJSONSchema
-    if (typeof project !== 'function') {
-        return { ...OPAQUE }
-    }
-    try {
-        return { ...project.call(candidate) }
-    } catch {
-        return { ...OPAQUE }
-    }
-}