@abide/abide 0.57.1 → 0.100.0

package/src/lib/server/runtime/snapshotEntryFromCache.ts

@@ -1,121 +0,0 @@
-import { contentBodyKind } from '../../shared/contentBodyKind.ts'
-import { contentTypeOf } from '../../shared/contentTypeOf.ts'
-import { hasSeedableRequest } from '../../shared/hasSeedableRequest.ts'
-import { isStreamingResponse } from '../../shared/isStreamingResponse.ts'
-import type { CacheEntry } from '../../shared/types/CacheEntry.ts'
-import type { CacheSnapshotEntry } from '../../shared/types/CacheSnapshotEntry.ts'
-import type { CacheStore } from '../../shared/types/CacheStore.ts'
-import type { HttpMethod } from '../../shared/types/HttpMethod.ts'
-
-/*
-Awaits one cache entry and turns it into a wire-safe snapshot, or undefined
-when it can't ship. Shared by the inline snapshot path (settled entries,
-resolves immediately) and the streaming drain (pending {#await} entries,
-resolves whenever the underlying fetch lands). Any entry carrying a wire request
-(any method — an inline POST seeds too, so it hydrates warm rather than re-firing
-after render) with a textual Content-Type survives; producers/stream cells (no
-request) and binary bodies (don't round-trip through JSON) drop out. Seeding is
-not replay: the seeded value is read warm once, never auto-re-fired (that stays
-GET-only — see REPLAYABLE_METHODS).
-
-Reads the body once and replaces the entry's promise with a string-bodied
-Response so later `shareable()` clones operate on a buffered body instead of
-teeing the original stream. Returns undefined on a rejected fetch (the client
-falls back to a live re-fetch on cache miss) or when the entry was evicted /
-replaced between resolution and read (a concurrent invalidate) so the snapshot
-never ships a key that no longer matches the live store.
-*/
-export async function snapshotEntryFromCache(
-    store: CacheStore,
-    entry: CacheEntry,
-): Promise<CacheSnapshotEntry | undefined> {
-    /* The request half of the shared shippability gate: a seedable wire request (any method).
-       Producer entries and stream cells (no request) never snapshot — the streaming-drain
-       caller hands still-pending entries here, so `settled` is NOT gated (the caller's
-       snapshotShippable filter already required it for the entries it picks). */
-    if (!hasSeedableRequest(entry) || !entry.request) {
-        return undefined
-    }
-    const method = entry.request.method.toUpperCase() as HttpMethod
-    const response = await readSettled(entry.promise as Promise<Response>)
-    if (!response) {
-        return undefined
-    }
-    /* A failed load never seeds the client: negative caching (errorTtl) can leave an
-       error-status entry in the store at snapshot time, but shipping it would warm-hydrate
-       a poisoned entry. Skip it — the client live-fetches on the miss and runs its own
-       negative cache. (Before errorTtl, errors evicted at settle and never reached here.) */
-    if (!response.ok) {
-        return undefined
-    }
-    if (store.entries.get(entry.key) !== entry) {
-        return undefined
-    }
-    /* A streaming body (SSE / JSONL / NDJSON) can't ship: `response.text()` below would
-       hang buffering a never-ending stream, and `decodeResponse` refuses it on the client
-       anyway — so a snapshot value would diverge from a live read. Skip it (the same guard
-       `decodeResponse` applies), letting the client live-fetch and get the proper streaming
-       error. */
-    if (isStreamingResponse(response)) {
-        return undefined
-    }
-    /* Ship only a body the client's WARM read can consume — `json`/`text` per the single
-       `contentBodyKind` classification the live decoder uses. Gating on the same table (not a
-       private textual list) keeps warm read ≡ live read (ADR-0011): the private list shipped
-       `application/xml`, which `contentBodyKind` buckets as `binary` and the warm read defers
-       on, so that snapshot could never be consumed warm — a silent divergence. */
-    const kind = contentBodyKind(contentTypeOf(response.headers))
-    if (kind !== 'json' && kind !== 'text') {
-        return undefined
-    }
-    /* Read a CLONE, not the original: a reader that captured this same `entry.promise`
-       before the replacement below still holds `response` and may `.clone()` it — reading
-       the original here would lock its body and throw "Body already used" for that reader.
-       The body stream can still error mid-read (reset/truncated upstream) after headers
-       resolved — degrade that to undefined (matching the fetch-rejection path) so one flaky
-       entry doesn't reject the whole snapshot batch and 500 / abort the page stream. */
-    let body: string
-    try {
-        body = await response.clone().text()
-    } catch {
-        return undefined
-    }
-    entry.promise = Promise.resolve(
-        new Response(body, {
-            status: response.status,
-            statusText: response.statusText,
-            headers: response.headers,
-        }),
-    )
-    const wire: CacheSnapshotEntry = {
-        key: entry.key,
-        url: entry.request.url,
-        method,
-        status: response.status,
-        statusText: response.statusText,
-        headers: Array.from(response.headers.entries()),
-    }
-    /* Ship a json body PARSED so it single-encodes in the payload rather than nesting a
-       re-escaped JSON string (ADR-0051 — the double-encoding that ~2.35×'d the wire). On a
-       parse failure ship the raw string under `body`: the client decodes it async exactly as
-       before (warmValueFromSnapshot's own try/catch), so a malformed-but-json-typed body still
-       round-trips rather than throwing here. A text body always ships raw. */
-    if (kind === 'json') {
-        try {
-            wire.data = JSON.parse(body)
-            return wire
-        } catch {
-            /* fall through to the raw-string form */
-        }
-    }
-    wire.body = body
-    return wire
-}
-
-async function readSettled(promise: Promise<Response>): Promise<Response | undefined> {
-    try {
-        return await promise
-    } catch {
-        return undefined
-    }
-}

package/src/lib/server/runtime/streamCacheResolutions.ts

@@ -1,44 +0,0 @@
-import type { CacheEntry } from '../../shared/types/CacheEntry.ts'
-import type { CacheSnapshotEntry } from '../../shared/types/CacheSnapshotEntry.ts'
-import type { CacheStore } from '../../shared/types/CacheStore.ts'
-import type { CacheResolution } from '../../shared/types/StreamedResolution.ts'
-import { snapshotEntryFromCache } from './snapshotEntryFromCache.ts'
-
-/*
-Drains the pending ({#await}) cache entries in resolution order — whichever
-fetch lands next is yielded next, so a slow entry never blocks a fast one
-behind it. Yields exactly one CacheResolution per entry: the snapshot when
-serialization succeeds, or a `{ key, miss }` marker when the body can't ship so
-the client placeholder re-fetches instead of hanging on a deferred that never
-settles. (Never the cell arm of StreamedResolution — that is emitted separately.)
-*/
-export async function* streamCacheResolutions(
-    store: CacheStore,
-    pending: CacheEntry[],
-): AsyncIterable<CacheResolution> {
-    /*
-    Tag each pending serialization with its key so the loop can drop exactly
-    the one that just settled. Deleting inside the `.then` instead would race
-    the loop — already-resolved promises empty the map before the first
-    Promise.race runs — so removal happens here, after the await.
-    */
-    const inflight = new Map<string, Promise<{ key: string; snapshot?: CacheSnapshotEntry }>>()
-    for (const entry of pending) {
-        inflight.set(
-            entry.key,
-            snapshotEntryFromCache(store, entry).then((snapshot) => ({ key: entry.key, snapshot })),
-        )
-    }
-    /*
-    Drain in settle order. A pending BARE read (ADR-0024 auto-streaming) is bounded by its OWN
-    endpoint `timeout` — which 504s the in-process handler during SSR, settling the entry into an
-    error that snapshots as a `{ key, miss }` (the client refetches on hydrate). So there is no
-    separate SSR-stream deadline (ADR-0024 option a): a read with a declared timeout self-settles;
-    a read that declares none is unbounded — the author bounds it with a `timeout`.
-    */
-    while (inflight.size > 0) {
-        const settled = await Promise.race(inflight.values())
-        inflight.delete(settled.key)
-        yield settled.snapshot ?? { key: settled.key, miss: true }
-    }
-}

package/src/lib/server/runtime/streamFromIterator.ts

@@ -1,124 +0,0 @@
-import { abideLog } from '../../shared/abideLog.ts'
-import { messageFromError } from '../../shared/messageFromError.ts'
-
-/*
-Shared body builder for the streaming respond helpers (`jsonl`, `sse`).
-Both flow the same shape — pull from an AsyncIterator, encode each frame
-to bytes, emit a sentinel `error` frame on a generator throw, and route
-ReadableStream's `cancel` into `iterator.return()` so the handler's
-`for await` exits via its normal control path. Only the per-frame
-encoding and the optional keepalive payload differ between the two.
-
-Keepalive is opt-in: SSE uses `: keepalive\n\n` every 15s so proxies
-don't drop an idle connection; jsonl has no spec-defined comment, so it
-omits keepalive entirely.
-*/
-
-export type StreamEncoder<T> = {
-    encodeFrame: (value: T) => string
-    encodeError: (message: string) => string
-    keepaliveMs?: number
-    keepalivePayload?: string
-}
-
-export function streamFromIterator<T>(
-    iterable: AsyncIterable<T>,
-    encoder: StreamEncoder<T>,
-): ReadableStream<Uint8Array> {
-    const textEncoder = new TextEncoder()
-    const iterator = iterable[Symbol.asyncIterator]()
-    let keepalive: ReturnType<typeof setInterval> | undefined
-    /* Set once the stream closes or is cancelled. A `pull` parked on `iterator.next()`
-       resolves AFTER a client-disconnect `cancel()` has already closed the controller;
-       without this guard it would touch the dead controller and throw "Controller is
-       already closed" — noise on every mid-frame disconnect. */
-    let closed = false
-
-    function stopKeepalive(): void {
-        if (keepalive !== undefined) {
-            clearInterval(keepalive)
-            keepalive = undefined
-        }
-    }
-
-    return new ReadableStream<Uint8Array>({
-        start(controller) {
-            if (encoder.keepaliveMs !== undefined && encoder.keepalivePayload !== undefined) {
-                const payload = textEncoder.encode(encoder.keepalivePayload)
-                keepalive = setInterval(() => {
-                    /*
-                    Every close/cancel path clears this interval synchronously,
-                    so a tick can't normally hit a closed controller — but
-                    enqueue throws on a closed/errored stream, and an uncaught
-                    throw in a timer crashes the process. Guard + self-stop.
-                    */
-                    /*
-                    Skip the tick under backpressure: a stalled consumer leaves
-                    desiredSize <= 0, and enqueuing anyway grows the internal
-                    queue unbounded. null = no HWM set, > 0 = consumer keeping up.
-                    */
-                    if (controller.desiredSize !== null && controller.desiredSize <= 0) {
-                        return
-                    }
-                    try {
-                        controller.enqueue(payload)
-                    } catch {
-                        stopKeepalive()
-                    }
-                }, encoder.keepaliveMs)
-            }
-        },
-        async pull(controller) {
-            try {
-                const next = await iterator.next()
-                /* Cancelled during the awaited next() — the controller is already closed,
-                   so any close/enqueue here would throw. Nothing left to do. */
-                if (closed) {
-                    return
-                }
-                if (next.done) {
-                    closed = true
-                    stopKeepalive()
-                    controller.close()
-                    return
-                }
-                controller.enqueue(textEncoder.encode(encoder.encodeFrame(next.value)))
-            } catch (error) {
-                /* A throw during cancellation unwinding (the generator's `finally` rejecting
-                   as `.return()` runs) is not a real stream error — the controller is gone. */
-                if (closed) {
-                    return
-                }
-                /* Log the FULL error server-side (host/credentials/stack an operator needs) — the
-                   unary rpc path does the same, and the jsonl/sse docs promise it. Only the
-                   sanitized message crosses the wire in the sentinel error frame. */
-                abideLog.error(error)
-                const message = messageFromError(error)
-                closed = true
-                stopKeepalive()
-                try {
-                    controller.enqueue(textEncoder.encode(encoder.encodeError(message)))
-                    controller.close()
-                } catch {
-                    /* Consumer vanished between the throw and the sentinel frame — the error
-                       frame never lands, but the connection is already closing regardless. */
-                }
-            }
-        },
-        cancel(reason) {
-            closed = true
-            stopKeepalive()
-            /*
-            Route cancel into the generator's normal exit, but swallow a
-            rejection from its cleanup: a `finally` that throws on `.return()`
-            would otherwise surface as an unhandled rejection (process-fatal
-            under Bun's default) on a client disconnect — a path every
-            sse/jsonl stream hits routinely.
-            */
-            return iterator.return?.(reason)?.then(
-                () => undefined,
-                () => undefined,
-            )
-        },
-    })
-}

package/src/lib/server/runtime/textResponse.ts

@@ -1,23 +0,0 @@
-import { NO_STORE } from '../../shared/CACHE_CONTROL_VALUES.ts'
-import { TEXT_PLAIN } from '../../shared/TEXT_PLAIN.ts'
-import { STATUS_TEXT } from './STATUS_TEXT.ts'
-
-/*
-The framework's plain-text status response — a `text/plain`, `no-store` body at
-`status`, shared by the 404/405 dispatch branches, the asset servers' miss, and
-the failed-upgrade reply so those literals can't drift. `body` defaults to the
-status reason phrase (STATUS_TEXT, e.g. 'Not Found'), falling back to `HTTP
-<status>` for an unlisted code. `extraHeaders` overlays the defaults per-key —
-the 405 passes `Allow` this way. A fresh Response per call: a body is
-single-use, so it can't be hoisted to a shared const.
-*/
-export function textResponse(
-    status: number,
-    body?: string,
-    extraHeaders?: Record<string, string>,
-): Response {
-    return new Response(body ?? STATUS_TEXT[status] ?? `HTTP ${status}`, {
-        status,
-        headers: { 'Content-Type': TEXT_PLAIN, 'Cache-Control': NO_STORE, ...extraHeaders },
-    })
-}

package/src/lib/server/runtime/typedErrorResponse.ts

@@ -1,26 +0,0 @@
-import { NO_STORE } from '../../shared/CACHE_CONTROL_VALUES.ts'
-import type { TypedResponse } from '../rpc/types/TypedResponse.ts'
-import { STATUS_TEXT } from './STATUS_TEXT.ts'
-import { withResponseDefaults } from './withResponseDefaults.ts'
-
-/*
-Serializes a typed error as a `{ $abideError, data }` JSON body at `status`, with
-the status reason phrase as statusText so it reaches `HttpError.statusText` on the
-client (which parses the body back onto `HttpError.kind` / `.data`). `data` of
-`undefined` drops the key (nullary errors). The single serializer shared by the
-`error.typed(...)` constructors and the framework-reserved `validation` error.
-*/
-export function typedErrorResponse(
-    name: string,
-    status: number,
-    data: unknown,
-): TypedResponse<never> {
-    return new Response(
-        JSON.stringify({ $abideError: name, data }),
-        withResponseDefaults(
-            { statusText: STATUS_TEXT[status] ?? `HTTP ${status}` },
-            { 'Content-Type': 'application/json', 'Cache-Control': NO_STORE },
-            status,
-        ),
-    ) as TypedResponse<never>
-}

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

@@ -1,6 +0,0 @@
-/*
-Embedded asset bytes keyed by request path (compile-time gzip embed). Pinned
-to a plain-ArrayBuffer backing so values feed `new Response(...)` directly —
-BodyInit rejects views over a possibly-shared buffer.
-*/
-export type Assets = Record<string, Uint8Array<ArrayBuffer>>

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

@@ -1,14 +0,0 @@
-/*
-The dev live-reload stamp the worker announces on the channel, split so the
-browser keeps its page across edits that don't need a reload:
-  - `structure` fingerprints every source signal a reload must react to — each
-    `.abide`'s client build hash (no CSS), the component-id set, non-`.abide`
-    source, public assets, and the shell (with the stylesheet href normalised out).
-    Any change here reloads.
-  - `cssHref` is the entry stylesheet's current content-hashed URL; a change here
-    alone swaps the `<link>` in place. Undefined when no stylesheet is built.
-*/
-export type DevReloadStamp = {
-    structure: string
-    cssHref: string | undefined
-}

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

@@ -1,24 +0,0 @@
-/*
-One shared cache entry projected for the inspector — the serializable facts the
-Cache tab renders. The stored promise/Request/timer aren't included; what an
-operator wants is the entry's identity, lifecycle state, retention, and a peek
-at the held value.
-*/
-export type InspectorCacheEntry = {
-    /* The cache key (remote: method+url+args; producer: reference+args). */
-    key: string
-    /* Lifecycle: 'settled' | 'in-flight' | 'refreshing'. */
-    status: string
-    /* True when the entry stores a wire Response (a remote rpc), false for a plain producer value. */
-    remote: boolean
-    /* Retention ttl in ms; undefined = forever, 0 = dedupe-only. */
-    ttl: number | undefined
-    /* Ms until expiry from snapshot time; undefined = no expiry armed. */
-    expiresInMs: number | undefined
-    /* The call's tags (cache.invalidate({ tags }) targets). */
-    tags: string[]
-    /* A short JSON preview of the decoded warm value, when the entry holds one. */
-    value: string | undefined
-    /* An armed refetch policy (`refetch`, optionally + throttle/debounce + ms), if declared. */
-    policy: string | undefined
-}

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

@@ -1,11 +0,0 @@
-import type { InspectorCacheEntry } from './InspectorCacheEntry.ts'
-
-/*
-The inspector's view of the cache: the process-level (`shared: true, ttl:
-Infinity`) store's current entries. That's the persistent store —
-request-scoped caches live and die with their request, so they surface as
-per-request tallies in the feed and traces rather than here.
-*/
-export type InspectorCacheSnapshot = {
-    entries: InspectorCacheEntry[]
-}

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

@@ -1,34 +0,0 @@
-import type { LogRecord } from '../../../shared/types/LogRecord.ts'
-import type { InspectorCacheSnapshot } from './InspectorCacheSnapshot.ts'
-import type { InspectorInFlightSnapshot } from './InspectorInFlightSnapshot.ts'
-import type { InspectorSurface } from './InspectorSurface.ts'
-
-/*
-The capabilities core injects into `@abide/inspector` when
-ABIDE_ENABLE_INSPECTOR=true. The package consumes this and imports no abide
-internals — so the inspector stays a pure consumer and core grows no public
-surface for it (mirrors how AppModule / AgentEngine are the documented seams).
-Everything here is already produced by the runtime: the registries behind
-loadSurface(), the log chokepoint behind onRecord().
-*/
-// @documentation plumbing
-export type InspectorContext = {
-    /* App identity for the UI header — the same name/version the health probe reports. */
-    app: { name: string; version: string }
-    /* Eager-loads the registries, then projects the current RPC + socket catalog. */
-    loadSurface: () => Promise<InspectorSurface>
-    /* Snapshots the persistent (shared) cache store — current entries with their
-       lifecycle state, retention, tags, and a value preview. */
-    cacheSnapshot: () => InspectorCacheSnapshot
-    /* Snapshots the requests whose handler is executing right now — the live
-       counterpart to the closing records onRecord emits once a request settles. */
-    inFlightSnapshot: () => InspectorInFlightSnapshot
-    /*
-    Subscribes to the unified event stream: every emitted log record (the log's
-    structured form, trace context and all) plus published socket frames shaped
-    as `socket`-channel records — one feed, so the inspector treats sockets,
-    cache diagnostics, and request logs uniformly. Returns an unsubscribe; the
-    underlying taps are process-wide, owned by the inspector for its lifetime.
-    */
-    onRecord: (listener: (record: LogRecord) => void) => () => void
-}

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

@@ -1,20 +0,0 @@
-/*
-One in-flight request projected for the inspector — the serializable facts the
-In-flight tab renders for a handler that's currently executing. The held Request
-and CacheStore aren't included; what an operator wants is which request it is,
-how long it's been running, and where it landed in routing.
-*/
-export type InspectorInFlightRequest = {
-    /* The W3C trace id, so the row links to the same trace the Logs/Traces tabs group by. */
-    trace: string
-    /* HTTP method of the inbound request. */
-    method: string
-    /* Request path with query string (app-space, as logged). */
-    path: string
-    /* Ms the handler has been running, measured from scope entry to snapshot time. */
-    elapsedMs: number
-    /* The matched page route pattern, once routing has landed; undefined on rpc/socket requests or before a match. */
-    route: string | undefined
-    /* The matched route's decoded params, when a page route landed. */
-    params: Record<string, string> | undefined
-}

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

@@ -1,10 +0,0 @@
-import type { InspectorInFlightRequest } from './InspectorInFlightRequest.ts'
-
-/*
-The requests executing their handler at snapshot time — a point-in-time read of
-the in-flight set, the live counterpart to the closing records the Logs tab
-shows once a request settles. Empty when the server is idle.
-*/
-export type InspectorInFlightSnapshot = {
-    requests: InspectorInFlightRequest[]
-}

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

@@ -1,15 +0,0 @@
-/*
-One declared MCP prompt projected for the inspector: the serializable facts the
-Surface tab renders. The render closure isn't included — what an operator wants
-is the prompt's name, what it's for, and the arguments it interpolates, the same
-trio `prompts/list` advertises. Prompts are MCP-only, so there are no client
-surface flags to show.
-*/
-export type InspectorPrompt = {
-    /* The prompt's name (stamped from its file path under src/mcp/prompts/). */
-    name: string
-    /* The frontmatter description, when the prompt declared one. */
-    description: string | undefined
-    /* The argument shape as JSON Schema (from the frontmatter `arguments` list); undefined when it takes none. */
-    inputSchema: Record<string, unknown> | undefined
-}

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

@@ -1,27 +0,0 @@
-/*
-One declared RPC 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 rpc whose library can't render a schema still lists with an opaque shape.
-*/
-export type InspectorRpc = {
-    /* Registry key — the rpc URL the rpc mounts at (e.g. /rpc/users/create). */
-    url: string
-    /* HTTP method bound to the rpc. */
-    method: string
-    /* Which surfaces advertise it (browser/mcp/cli), from the rpc's ClientFlags. */
-    clients: Record<string, boolean>
-    /* Argument-bag shape as JSON Schema; undefined when the rpc declares none. */
-    inputSchema: Record<string, unknown> | undefined
-    /* Success-body shape as JSON Schema; undefined when the rpc declares none. */
-    outputSchema: Record<string, unknown> | undefined
-    /* True when the rpc declares a filesSchema — it accepts multipart File parts. */
-    files: boolean
-    /* Per-rpc handler deadline in ms; undefined = no deadline. */
-    timeout: number | undefined
-    /* Per-rpc received-body cap in bytes; undefined = Bun's server-wide ceiling. */
-    maxBodySize: number | undefined
-    /* True when the rpc opts out of the same-origin CSRF gate. */
-    crossOrigin: boolean | undefined
-}

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

@@ -1,17 +0,0 @@
-/*
-One declared socket projected for the inspector: its name plus the operations
-it exposes (tail always; publish only when it allows client publishing),
-mirroring the CLI/MCP projection from socketOperations so the inspector can't
-disagree with them about a socket's faces.
-*/
-export type InspectorSocket = {
-    /* The socket's file-path name (may contain `/` for nested files). */
-    name: string
-    /* The operations exposed, named as the CLI/MCP advertise them. */
-    operations: Array<{
-        kind: string
-        name: string
-        method: string
-        restUrl: string
-    }>
-}

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

@@ -1,16 +0,0 @@
-import type { InspectorPrompt } from './InspectorPrompt.ts'
-import type { InspectorRpc } from './InspectorRpc.ts'
-import type { InspectorSocket } from './InspectorSocket.ts'
-
-/*
-The app's machine surface projected for the inspector — the static catalog the
-UI renders. Built by reading the rpc, socket, and prompt registries after
-they're eager-loaded, so a freshly-booted server lists its whole surface, not
-just the rpcs hit so far. Pages stay out: they're the human surface, already
-navigable.
-*/
-export type InspectorSurface = {
-    rpcs: InspectorRpc[]
-    sockets: InspectorSocket[]
-    prompts: InspectorPrompt[]
-}