@elysra/tungsten-runtime 0.0.0-bootstrap.0

package/dist/serialize.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Parameter serialization (OpenAPI 3 `style`/`explode` for path, query,
+ * header and cookie parameters) and request body encoding.
+ */
+import type { BodyDescriptor, OperationDescriptor, ParamDescriptor } from "./types.js";
+/** Problem found while serializing an argument; becomes VALIDATION_FAILED. */
+export declare class SerializationError extends Error {
+    readonly parameter: string;
+    readonly expected: string;
+    readonly value: unknown;
+    constructor(parameter: string, expected: string, value: unknown);
+}
+/** One path parameter value, already percent-encoded (`simple`, `label`, `matrix`). */
+export declare function serializePathParam(p: ParamDescriptor, value: unknown): string;
+/** Query string parts (`name=value`, encoded) for one query parameter. */
+export declare function serializeQueryParam(p: ParamDescriptor, value: unknown): string[];
+/** Header value for one header parameter (`simple` style, not encoded). */
+export declare function serializeHeaderParam(p: ParamDescriptor, value: unknown): string;
+/** `name=value` for one cookie parameter (`form` style, values encoded). */
+export declare function serializeCookieParam(p: ParamDescriptor, value: unknown): string;
+/** An encoded request body. */
+export interface EncodedBody {
+    /** What fetch sends; null for no body. */
+    body: BodyInit | null;
+    /** Content-Type to set, or null (multipart: fetch sets the boundary). */
+    contentType: string | null;
+    /** JSON-friendly rendering for previews (binary summarised), redacted. */
+    display: unknown;
+    /** The same rendering before redaction (never shown). */
+    raw: unknown;
+    /** Bytes or text whose SHA-256 is the `content_hash` key. */
+    hashMaterial: string | Uint8Array | null;
+}
+/** The body value before encoding: merged fields picked from the args, or
+ * the whole `args[arg]`; wrapped in the rpc envelope when the operation
+ * has one. `undefined` means no body. */
+export declare function bodyValue(op: OperationDescriptor, args: Record<string, unknown>, paramNames: ReadonlySet<string>): unknown;
+/** Encode `value` per the body descriptor. Throws `SerializationError` for
+ * values the encoding cannot carry. */
+export declare function encodeBody(descriptor: BodyDescriptor | null, value: unknown, redactDisplay: (display: unknown) => unknown): Promise<EncodedBody>;
+export declare function validHeaderName(name: string): boolean;
+export declare function validHeaderValue(value: string): boolean;
+/** Case-insensitive header collection that remembers which values are
+ * secrets, so previews and middleware see them redacted. */
+export declare class HeaderBag {
+    #private;
+    set(name: string, value: string, secret?: boolean): void;
+    get(name: string): string | undefined;
+    has(name: string): boolean;
+    isSecret(name: string): boolean;
+    /** Plain record; secret values replaced by `<redacted>` when `redact`. */
+    toRecord(redact: boolean): Record<string, string>;
+    /** Secret values, for scrubbing diagnostics. */
+    secrets(): string[];
+}

package/dist/serialize.js

@@ -0,0 +1,323 @@
+import { binarySize, canonicalJson, isBinary, isBlob, isNamedBinary, isRecord, REDACTED, utf8 } from "./util.js";
+/** Problem found while serializing an argument; becomes VALIDATION_FAILED. */
+export class SerializationError extends Error {
+    parameter;
+    expected;
+    value;
+    constructor(parameter, expected, value) {
+        super(`${parameter}: expected ${expected}`);
+        this.parameter = parameter;
+        this.expected = expected;
+        this.value = value;
+    }
+}
+function scalar(value) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint")
+        return String(value);
+    if (value instanceof Date)
+        return value.toISOString();
+    return JSON.stringify(value) ?? "";
+}
+function enc(text) {
+    return encodeURIComponent(text);
+}
+function entries(value) {
+    return Object.entries(value).filter(([, v]) => v !== undefined && v !== null);
+}
+function present(value) {
+    return value !== undefined && value !== null;
+}
+/** One path parameter value, already percent-encoded (`simple`, `label`, `matrix`). */
+export function serializePathParam(p, value) {
+    const name = enc(p.wire);
+    const style = p.style === "label" || p.style === "matrix" ? p.style : "simple";
+    if (Array.isArray(value)) {
+        const items = value.filter(present).map((v) => enc(scalar(v)));
+        if (style === "label")
+            return `.${items.join(p.explode ? "." : ",")}`;
+        if (style === "matrix")
+            return p.explode ? items.map((i) => `;${name}=${i}`).join("") : `;${name}=${items.join(",")}`;
+        return items.join(",");
+    }
+    if (isRecord(value) && !(value instanceof Date)) {
+        const pairs = entries(value).map(([k, v]) => [enc(k), enc(scalar(v))]);
+        const exploded = pairs.map(([k, v]) => `${k}=${v}`);
+        const flat = pairs.flat();
+        if (style === "label")
+            return p.explode ? `.${exploded.join(".")}` : `.${flat.join(",")}`;
+        if (style === "matrix")
+            return p.explode ? exploded.map((e) => `;${e}`).join("") : `;${name}=${flat.join(",")}`;
+        return p.explode ? exploded.join(",") : flat.join(",");
+    }
+    const v = enc(scalar(value));
+    if (style === "label")
+        return `.${v}`;
+    if (style === "matrix")
+        return `;${name}=${v}`;
+    return v;
+}
+function deepObjectPairs(prefix, value, out, depth) {
+    if (depth > 16 || !present(value))
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value)
+            deepObjectPairs(prefix, item, out, depth + 1);
+    }
+    else if (isRecord(value) && !(value instanceof Date)) {
+        for (const [k, v] of entries(value))
+            deepObjectPairs(`${prefix}[${enc(k)}]`, v, out, depth + 1);
+    }
+    else {
+        out.push(`${prefix}=${enc(scalar(value))}`);
+    }
+}
+/** Query string parts (`name=value`, encoded) for one query parameter. */
+export function serializeQueryParam(p, value) {
+    if (!present(value))
+        return [];
+    const name = enc(p.wire);
+    const delimiter = p.style === "space_delimited" ? "%20" : p.style === "pipe_delimited" ? "|" : ",";
+    if (p.style === "deep_object" && isRecord(value) && !(value instanceof Date)) {
+        const out = [];
+        deepObjectPairs(name, value, out, 0);
+        return out;
+    }
+    if (Array.isArray(value)) {
+        const items = value.filter(present).map((v) => enc(scalar(v)));
+        if (items.length === 0)
+            return [];
+        if (p.explode || p.style === "deep_object")
+            return items.map((i) => `${name}=${i}`);
+        return [`${name}=${items.join(delimiter)}`];
+    }
+    if (isRecord(value) && !(value instanceof Date)) {
+        const pairs = entries(value).map(([k, v]) => [enc(k), enc(scalar(v))]);
+        if (p.explode)
+            return pairs.map(([k, v]) => `${k}=${v}`);
+        return [`${name}=${pairs.flat().join(delimiter)}`];
+    }
+    return [`${name}=${enc(scalar(value))}`];
+}
+/** Header value for one header parameter (`simple` style, not encoded). */
+export function serializeHeaderParam(p, value) {
+    if (Array.isArray(value))
+        return value.filter(present).map(scalar).join(",");
+    if (isRecord(value) && !(value instanceof Date)) {
+        const pairs = entries(value).map(([k, v]) => [k, scalar(v)]);
+        return p.explode ? pairs.map(([k, v]) => `${k}=${v}`).join(",") : pairs.flat().join(",");
+    }
+    return scalar(value);
+}
+/** `name=value` for one cookie parameter (`form` style, values encoded). */
+export function serializeCookieParam(p, value) {
+    if (Array.isArray(value))
+        return `${p.wire}=${value.filter(present).map((v) => enc(scalar(v))).join(",")}`;
+    if (isRecord(value) && !(value instanceof Date)) {
+        return `${p.wire}=${entries(value)
+            .flatMap(([k, v]) => [enc(k), enc(scalar(v))])
+            .join(",")}`;
+    }
+    return `${p.wire}=${enc(scalar(value))}`;
+}
+const NO_BODY = { body: null, contentType: null, display: null, raw: null, hashMaterial: null };
+/** The body value before encoding: merged fields picked from the args, or
+ * the whole `args[arg]`; wrapped in the rpc envelope when the operation
+ * has one. `undefined` means no body. */
+export function bodyValue(op, args, paramNames) {
+    let value;
+    const body = op.body;
+    if (body) {
+        if (body.shape.kind === "merged") {
+            const picked = {};
+            for (const field of body.shape.fields) {
+                if (args[field] !== undefined)
+                    picked[field] = args[field];
+            }
+            value = Object.keys(picked).length > 0 || body.required || op.rpc ? picked : undefined;
+        }
+        else {
+            value = args[body.shape.arg];
+        }
+    }
+    if (op.rpc) {
+        let params = value;
+        if (!body) {
+            const rest = {};
+            for (const [k, v] of Object.entries(args)) {
+                if (!paramNames.has(k) && v !== undefined)
+                    rest[k] = v;
+            }
+            params = rest;
+        }
+        const envelope = { ...(op.rpc.constants ?? {}) };
+        envelope[op.rpc.field] = op.rpc.value;
+        envelope[op.rpc.paramsField] = params ?? {};
+        return envelope;
+    }
+    return value;
+}
+function formPairs(value, parameter) {
+    if (!isRecord(value))
+        throw new SerializationError(parameter, "an object of form fields", value);
+    const out = [];
+    for (const [k, v] of entries(value)) {
+        if (Array.isArray(v)) {
+            for (const item of v)
+                if (present(item))
+                    out.push([k, scalar(item)]);
+        }
+        else {
+            out.push([k, scalar(v)]);
+        }
+    }
+    return out;
+}
+function toBlob(value, type) {
+    if (isBlob(value))
+        return type !== "" && value.type !== type ? value.slice(0, value.size, type) : value;
+    const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : value;
+    const copy = new Uint8Array(new ArrayBuffer(bytes.byteLength));
+    copy.set(bytes);
+    return new Blob([copy], type ? { type } : {});
+}
+function binaryDisplay(value, mediaType) {
+    return `<${binarySize(value)} bytes${mediaType ? ` of ${mediaType}` : ""}>`;
+}
+/** Encode `value` per the body descriptor. Throws `SerializationError` for
+ * values the encoding cannot carry. */
+export async function encodeBody(descriptor, value, redactDisplay) {
+    if (value === undefined)
+        return NO_BODY;
+    const encoding = descriptor?.encoding ?? "json";
+    const mediaType = descriptor?.mediaType ?? "application/json";
+    const parameter = "body";
+    switch (encoding) {
+        case "json": {
+            let text;
+            try {
+                text = JSON.stringify(value);
+            }
+            catch {
+                throw new SerializationError(parameter, "a JSON-serializable value", value);
+            }
+            if (text === undefined)
+                throw new SerializationError(parameter, "a JSON-serializable value", value);
+            const raw = JSON.parse(text);
+            return {
+                body: text,
+                contentType: mediaType,
+                display: redactDisplay(raw),
+                raw,
+                hashMaterial: canonicalJson(JSON.parse(text)),
+            };
+        }
+        case "form": {
+            const params = new URLSearchParams(formPairs(value, parameter));
+            const text = params.toString();
+            const raw = Object.fromEntries(params.entries());
+            return {
+                body: text,
+                contentType: mediaType,
+                display: redactDisplay(raw),
+                raw,
+                hashMaterial: text,
+            };
+        }
+        case "multipart": {
+            if (!isRecord(value))
+                throw new SerializationError(parameter, "an object of multipart fields", value);
+            const form = new FormData();
+            const display = {};
+            for (const [k, v] of entries(value)) {
+                const items = Array.isArray(v) ? v.filter(present) : [v];
+                const shown = [];
+                for (const item of items) {
+                    if (isBinary(item) || isNamedBinary(item)) {
+                        const { data, filename, contentType } = isNamedBinary(item) ? item : { data: item, filename: undefined, contentType: undefined };
+                        const blob = toBlob(data, contentType ?? "");
+                        const name = filename ?? (typeof File !== "undefined" && data instanceof File ? data.name : k);
+                        form.append(k, blob, name);
+                        shown.push(binaryDisplay(data, blob.type));
+                    }
+                    else if (isRecord(item) && !(item instanceof Date)) {
+                        form.append(k, new Blob([JSON.stringify(item)], { type: "application/json" }));
+                        shown.push(item);
+                    }
+                    else {
+                        form.append(k, scalar(item));
+                        shown.push(scalar(item));
+                    }
+                }
+                display[k] = Array.isArray(v) ? shown : shown[0];
+            }
+            return { body: form, contentType: null, display: redactDisplay(display), raw: display, hashMaterial: canonicalJson(value) };
+        }
+        case "bytes": {
+            let bytes;
+            if (value instanceof Uint8Array)
+                bytes = value;
+            else if (value instanceof ArrayBuffer)
+                bytes = new Uint8Array(value);
+            else if (isBlob(value))
+                bytes = value;
+            else if (typeof value === "string")
+                bytes = utf8(value);
+            else
+                throw new SerializationError(parameter, "binary data (Uint8Array, ArrayBuffer or Blob)", value);
+            const material = isBlob(bytes) ? new Uint8Array(await bytes.arrayBuffer()) : bytes;
+            return {
+                body: toBlob(material, mediaType),
+                contentType: mediaType,
+                display: binaryDisplay(material, mediaType),
+                raw: binaryDisplay(material, mediaType),
+                hashMaterial: material,
+            };
+        }
+        case "text": {
+            if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+                throw new SerializationError(parameter, "a string", value);
+            }
+            const text = String(value);
+            return { body: text, contentType: mediaType, display: text, raw: text, hashMaterial: text };
+        }
+    }
+}
+/** Header names and values that `fetch` accepts, checked before sending. */
+const TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const HEADER_VALUE = /^[\t\x20-\x7e\x80-\xff]*$/;
+export function validHeaderName(name) {
+    return TOKEN.test(name);
+}
+export function validHeaderValue(value) {
+    return HEADER_VALUE.test(value);
+}
+/** Case-insensitive header collection that remembers which values are
+ * secrets, so previews and middleware see them redacted. */
+export class HeaderBag {
+    #entries = new Map();
+    set(name, value, secret = false) {
+        this.#entries.set(name.toLowerCase(), { name, value, secret });
+    }
+    get(name) {
+        return this.#entries.get(name.toLowerCase())?.value;
+    }
+    has(name) {
+        return this.#entries.has(name.toLowerCase());
+    }
+    isSecret(name) {
+        return this.#entries.get(name.toLowerCase())?.secret ?? false;
+    }
+    /** Plain record; secret values replaced by `<redacted>` when `redact`. */
+    toRecord(redact) {
+        const out = {};
+        for (const { name, value, secret } of this.#entries.values())
+            out[name] = redact && secret ? REDACTED : value;
+        return out;
+    }
+    /** Secret values, for scrubbing diagnostics. */
+    secrets() {
+        return [...this.#entries.values()].filter((e) => e.secret).map((e) => e.value);
+    }
+}

package/dist/sse.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A server-sent events parser (WHATWG HTML 9.2 "Server-sent events"):
+ * lines end with CRLF, LF or CR; a line is a comment (`:`), a field
+ * (`event`, `data`, `id`, `retry`; the value loses one leading space) or
+ * the blank line that dispatches the event. Several `data` lines are
+ * joined with LF; an event without `data` lines is not dispatched; an
+ * event still open when the stream ends is discarded.
+ *
+ * An event may hold at most `maxEventBytes` (default {@link DEFAULT_MAX_EVENT_BYTES},
+ * 1 MiB): the UTF-8 bytes of its field lines (each counted with a one-byte
+ * terminator; a finished comment line is not kept and does not count) plus
+ * the line being read, whatever it turns out to be, so a comment longer than
+ * the limit with no line end also stops the parser. A parser that sees more stops: {@link SseParser.exceeded}
+ * becomes true, the events completed before the oversize one are still
+ * returned, and later input is ignored, so nothing is buffered without bound.
+ */
+/** The default size limit of one event, in UTF-8 bytes. */
+export declare const DEFAULT_MAX_EVENT_BYTES: number;
+/** The number of bytes of `text` in UTF-8. */
+export declare function utf8Length(text: string): number;
+export interface SseEvent {
+    /** The `event` field, `message` when the event has none. */
+    event: string;
+    data: string;
+    /** The last event id seen so far (it survives across events), or null. */
+    id: string | null;
+    /** The last valid `retry` value seen so far, in milliseconds, or null. */
+    retry: number | null;
+}
+export declare class SseParser {
+    #private;
+    constructor(maxEventBytes?: number);
+    /** The event being read is larger than the limit: the parser has stopped. */
+    get exceeded(): boolean;
+    /** Feed decoded text; returns the events it completes. A CR at the end
+     * of the text is held back until the next text shows whether an LF
+     * follows. */
+    push(chunk: string): SseEvent[];
+    /** The stream ended: a CR held back ends its line. Whatever is still
+     * open is discarded. */
+    end(): SseEvent[];
+}

package/dist/sse.js

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * A server-sent events parser (WHATWG HTML 9.2 "Server-sent events"):
+ * lines end with CRLF, LF or CR; a line is a comment (`:`), a field
+ * (`event`, `data`, `id`, `retry`; the value loses one leading space) or
+ * the blank line that dispatches the event. Several `data` lines are
+ * joined with LF; an event without `data` lines is not dispatched; an
+ * event still open when the stream ends is discarded.
+ *
+ * An event may hold at most `maxEventBytes` (default {@link DEFAULT_MAX_EVENT_BYTES},
+ * 1 MiB): the UTF-8 bytes of its field lines (each counted with a one-byte
+ * terminator; a finished comment line is not kept and does not count) plus
+ * the line being read, whatever it turns out to be, so a comment longer than
+ * the limit with no line end also stops the parser. A parser that sees more stops: {@link SseParser.exceeded}
+ * becomes true, the events completed before the oversize one are still
+ * returned, and later input is ignored, so nothing is buffered without bound.
+ */
+/** The default size limit of one event, in UTF-8 bytes. */
+export const DEFAULT_MAX_EVENT_BYTES = 1024 * 1024;
+/** The number of bytes of `text` in UTF-8. */
+export function utf8Length(text) {
+    let bytes = 0;
+    for (let i = 0; i < text.length; i += 1) {
+        const c = text.charCodeAt(i);
+        if (c < 0x80)
+            bytes += 1;
+        else if (c < 0x800)
+            bytes += 2;
+        else if (c >= 0xd800 && c <= 0xdbff && i + 1 < text.length) {
+            bytes += 4;
+            i += 1;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
+export class SseParser {
+    #buffer = "";
+    #started = false;
+    #event = "";
+    #data = "";
+    #hasData = false;
+    #id = null;
+    #retry = null;
+    #eventBytes = 0;
+    #bufferBytes = 0;
+    #exceeded = false;
+    #max;
+    constructor(maxEventBytes = DEFAULT_MAX_EVENT_BYTES) {
+        this.#max = maxEventBytes;
+    }
+    /** The event being read is larger than the limit: the parser has stopped. */
+    get exceeded() {
+        return this.#exceeded;
+    }
+    /** Feed decoded text; returns the events it completes. A CR at the end
+     * of the text is held back until the next text shows whether an LF
+     * follows. */
+    push(chunk) {
+        if (this.#exceeded)
+            return [];
+        let text = this.#buffer + chunk;
+        this.#buffer = "";
+        let chunkBytes = utf8Length(chunk);
+        if (!this.#started && text.length > 0) {
+            this.#started = true;
+            if (text.charCodeAt(0) === 0xfeff) {
+                text = text.slice(1);
+                chunkBytes -= 3;
+            }
+        }
+        const out = [];
+        let start = 0;
+        let completed = false;
+        for (let i = 0; i < text.length; i += 1) {
+            const c = text.charCodeAt(i);
+            if (c !== 10 && c !== 13)
+                continue;
+            if (c === 13 && i + 1 === text.length) {
+                this.#hold(text, start, completed, chunkBytes);
+                return out;
+            }
+            const line = text.slice(start, i);
+            if (c === 13 && text.charCodeAt(i + 1) === 10)
+                i += 1;
+            start = i + 1;
+            completed = true;
+            this.#line(line, out);
+            if (this.#exceeded)
+                return out;
+        }
+        this.#hold(text, start, completed, chunkBytes);
+        return out;
+    }
+    /** Keep the unfinished line `text[start..]`; its bytes are counted from
+     * the chunk alone unless a line ended in this push. Too much ends the parser. */
+    #hold(text, start, completed, chunkBytes) {
+        this.#buffer = text.slice(start);
+        this.#bufferBytes = completed ? utf8Length(this.#buffer) : this.#bufferBytes + chunkBytes;
+        if (this.#eventBytes + this.#bufferBytes > this.#max) {
+            this.#exceeded = true;
+            this.#buffer = "";
+            this.#bufferBytes = 0;
+        }
+    }
+    /** The stream ended: a CR held back ends its line. Whatever is still
+     * open is discarded. */
+    end() {
+        const out = [];
+        if (!this.#exceeded && this.#buffer.endsWith("\r"))
+            this.#line(this.#buffer.slice(0, -1), out);
+        this.#buffer = "";
+        this.#bufferBytes = 0;
+        this.#event = "";
+        this.#data = "";
+        this.#hasData = false;
+        return out;
+    }
+    #line(line, out) {
+        if (line === "") {
+            if (this.#hasData) {
+                out.push({ event: this.#event === "" ? "message" : this.#event, data: this.#data.slice(0, -1), id: this.#id, retry: this.#retry });
+            }
+            this.#event = "";
+            this.#data = "";
+            this.#hasData = false;
+            this.#eventBytes = 0;
+            return;
+        }
+        if (line.startsWith(":"))
+            return;
+        this.#eventBytes += utf8Length(line) + 1;
+        if (this.#eventBytes > this.#max) {
+            this.#exceeded = true;
+            return;
+        }
+        const colon = line.indexOf(":");
+        const field = colon < 0 ? line : line.slice(0, colon);
+        let value = colon < 0 ? "" : line.slice(colon + 1);
+        if (value.startsWith(" "))
+            value = value.slice(1);
+        switch (field) {
+            case "event":
+                this.#event = value;
+                break;
+            case "data":
+                this.#data += `${value}\n`;
+                this.#hasData = true;
+                break;
+            case "id":
+                if (!value.includes("\0"))
+                    this.#id = value;
+                break;
+            case "retry":
+                if (/^[0-9]+$/.test(value)) {
+                    const ms = Number(value);
+                    if (Number.isSafeInteger(ms))
+                        this.#retry = ms;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+}

package/dist/streams.d.ts

@@ -0,0 +1,65 @@
+/**
+ * `EventStream`: what `ClientCore.stream` returns. It is the async iterable
+ * of {@link StreamItem}s it always was, plus helpers that consume it:
+ * {@link EventStream.on} (dispatch by event name), {@link EventStream.collect},
+ * {@link EventStream.reduce}, {@link EventStream.first} and
+ * {@link EventStream.cancel}. A stream is read once; every helper closes the
+ * connection when it returns.
+ */
+import type { Diagnostic, StreamItem } from "./types.js";
+/** One delivered event. */
+export interface StreamEvent<T> {
+    value: T;
+    /** The `event` field, `message` when the server named none. */
+    event: string;
+    /** The last event id the stream has set so far, or null. */
+    id: string | null;
+    /** The last `retry` value (milliseconds) the stream has set so far, or null. */
+    retry: number | null;
+}
+/** What a helper resolves to: the result and the number of reconnects the
+ * stream made, or the failure that ended the stream with what was gathered
+ * before it as `partial`. */
+export type StreamResult<R, P = R> = {
+    ok: true;
+    value: R;
+    reconnects: number;
+} | {
+    ok: false;
+    error: Diagnostic;
+    partial: P;
+    reconnects: number;
+};
+/** A handler of {@link EventStream.on}: receives the decoded `data` and the event. */
+export type EventHandler<T> = (value: T, event: StreamEvent<T>) => void | Promise<void>;
+/** The key of {@link EventStream.on} handlers that receives every event no
+ * other handler took. */
+export declare const ANY_EVENT = "*";
+export declare class EventStream<T> implements AsyncIterable<StreamItem<T>> {
+    #private;
+    /** @param source the items of the stream
+     * @param abort aborts the request the source reads (closes the connection) */
+    constructor(source: AsyncGenerator<StreamItem<T>>, abort: () => void);
+    /** Whether {@link cancel} was called. */
+    get cancelled(): boolean;
+    /** Close the connection and end the stream: a pending or later read ends
+     * without a failure item. Safe to call more than once. */
+    cancel(): void;
+    [Symbol.asyncIterator](): AsyncGenerator<StreamItem<T>>;
+    /** Read the stream to its end and call the handler named like each event
+     * (`handlers.message_delta` for `event: message_delta`; events without a
+     * name are `message`), else `handlers["*"]`. A handler that throws or
+     * rejects ends the stream (the connection is closed) and the error
+     * propagates. Resolves to the number of events delivered. */
+    on(handlers: Record<string, EventHandler<T> | undefined>): Promise<StreamResult<number, number>>;
+    /** Read the stream to its end and fold the events into one value
+     * (concatenating text deltas, say). `partial` of a failure is the value
+     * folded so far. */
+    reduce<A>(fold: (accumulator: A, value: T, event: StreamEvent<T>) => A, initial: A): Promise<StreamResult<A>>;
+    /** Read the stream to its end into a list of the events' `data`. */
+    collect(): Promise<StreamResult<T[]>>;
+    /** The first event for which `predicate` holds (any event without one),
+     * then close the stream; `value` is null when the stream ends without
+     * one. */
+    first(predicate?: (value: T, event: StreamEvent<T>) => boolean): Promise<StreamResult<StreamEvent<T> | null, null>>;
+}