@decohere/http 0.0.1-dev.116

package/types/src/routing/anvil.types.d.ts

@@ -0,0 +1,119 @@
+import type { Constructable, Type } from "@decohere/core/reflection";
+import type { HTTPMethod } from "../const.js";
+import type { SseOptions } from "../sse/sse.types.js";
+import type { Pipe } from "./pipes/pipes.js";
+export type Metadata = "controller" | "route" | "parameter" | "fieldMap" | "authorize" | "allowAnonymous" | "httpCode" | "headers" | "catch";
+export type CorsOptions = {
+    origin?: boolean | string | string[];
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+};
+export declare const RequestParts: {
+    query: "query";
+    params: "params";
+    body: "body";
+    principal: "principal";
+    signal: "signal";
+    lastEventId: "lastEventId";
+};
+export interface HttpProvider {
+    start<T extends StartOptions>(options: T): Promise<StartResponse>;
+    stop(): Promise<StopResponse>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export type RequestPart = "query" | "params" | "body" | "principal" | "signal" | "lastEventId";
+/** Argument locations filled by the HTTP package itself rather than read from the request payload. */
+export declare const InjectedParts: readonly RequestPart[];
+export type MappedRoute = {
+    key: string;
+    controller: Constructable;
+    handler: string;
+    routeArgs?: RouteArg[];
+    httpCode?: number;
+    headers?: Record<string, string>;
+    /** Set by `@Sse()`: the handler returns a stream of events instead of a single response. */
+    sse?: SseOptions;
+} & RouteMetadata;
+export type RouteArg = {
+    argumentType: Constructable;
+    fieldMap?: Map<string, FieldMeta>;
+    pipes?: Constructable<Pipe>[];
+} & ArgumentMeta;
+export declare class HttpRequest {
+    constructor(data?: Partial<HttpRequest>);
+    requestId: string;
+    url: string;
+    method: string;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    body: unknown;
+    headers: Record<string, string>;
+    /** Aborts when the client disconnects or the app stops. Never aborts if the provider cannot tell. */
+    signal: AbortSignal;
+    /** Outbound headers set by middleware; applied by the HTTP provider. */
+    responseHeaders: Record<string, string>;
+}
+export type StartResponse = {
+    addresses: string[];
+};
+export type StopResponse = {
+    message: string;
+};
+export type StartOptions = {
+    port: number;
+    host?: string;
+};
+export type ArgumentMeta = {
+    argumentIndex: number;
+    mappingKey?: string;
+    argumentLocation?: RequestPart;
+    pipes: Constructable<Pipe>[];
+};
+export type ControllerMetadata = {
+    prefix: string;
+    /**
+     * `false` leaves this controller's routes out of the global prefix (`withGlobalPrefix`), for
+     * paths something outside the app expects at a fixed place: probes, webhooks, metrics. Default
+     * `true`.
+     */
+    globalPrefix?: boolean;
+};
+export type FieldMeta = {
+    fieldKey: string;
+    fieldType: Type;
+    mappingKey: string;
+    fieldLocation?: RequestPart;
+    pipes?: Constructable<Pipe>[];
+};
+export type RouteMetadata = {
+    path: string;
+    method: HTTPMethod;
+};
+export declare class RouteConfigurationError extends Error {
+}
+export declare class RoutingError extends Error {
+}
+export declare class TransformError extends Error {
+}
+export declare class HttpError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+export declare class UnauthorizedError extends HttpError {
+    constructor(message?: string);
+}
+export declare class ForbiddenError extends HttpError {
+    constructor(message?: string);
+}
+export type ValidationIssue = {
+    path: string;
+    message: string;
+    keyword?: string;
+};
+export declare class ValidationError extends HttpError {
+    readonly errors: ValidationIssue[];
+    constructor(message?: string, errors?: ValidationIssue[]);
+}

package/types/src/routing/decorators/argument.decorator.d.ts

@@ -0,0 +1,11 @@
+import type { Constructable } from "@decohere/core/reflection";
+import { type RequestPart } from "../anvil.types.js";
+import type { Pipe } from "../pipes/pipes.js";
+export type ArgumentOptions = {
+    mappingKey?: string;
+    argumentLocation?: RequestPart;
+    pipes?: Constructable<Pipe>[];
+};
+export declare function Query(key: string): (target: object, functionName: string, argumentIndex: number) => void;
+export declare function Param(key: string): (target: object, functionName: string, argumentIndex: number) => void;
+export declare function Argument(options: ArgumentOptions): (target: object, functionName: string, argumentIndex: number) => void;

package/types/src/routing/decorators/auth.decorator.d.ts

@@ -0,0 +1,30 @@
+import type { Constructable } from "@decohere/core/reflection";
+export type AuthorizeOptions = {
+    action: string;
+    subject: string;
+};
+/**
+ * Require the principal to be able to perform `action` on `subject`.
+ * Uses an IAuthorizationService (e.g. CaslAuthorizationService) registered in DI.
+ * When applied to a class, all methods inherit the constraint.
+ * When applied to a method, it takes precedence over the class-level decorator.
+ *
+ * @example
+ * \@Authorize("delete", "Article")
+ * \@Authorize("manage", "all")
+ */
+export declare function Authorize(action: string, subject?: string): (target: object | Constructable, methodName?: string, _descriptor?: PropertyDescriptor) => void;
+/**
+ * Opt a specific route method out of authentication, even when the controller
+ * class is decorated with @Authorize.
+ */
+export declare function AllowAnonymous(): (target: object, methodName: string, _descriptor?: PropertyDescriptor) => void;
+/** Read the effective @Authorize options for a handler function. */
+export declare function getAuthorizeOptions(controllerPrototype: object, handlerFn: object): AuthorizeOptions | undefined;
+/** Returns true only when the handler is explicitly marked @AllowAnonymous. */
+export declare function isAllowAnonymous(_controllerPrototype: object, handlerFn: object): boolean;
+/**
+ * Parameter decorator — injects the authenticated Principal into this argument.
+ * The argument resolver will supply the principal verified during the auth step.
+ */
+export declare function CurrentUser(): (target: object, propertyKey: string, parameterIndex: number) => void;

package/types/src/routing/decorators/controller.decorator.d.ts

@@ -0,0 +1,3 @@
+import type { Constructable } from "@decohere/core/reflection";
+import type { ControllerMetadata } from "../anvil.types.js";
+export declare function Controller(options?: ControllerMetadata): (target: Constructable) => void;

package/types/src/routing/decorators/field.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { RequestPart } from "../anvil.types.js";
+export declare function Field(fieldLocation?: RequestPart, mappingKey?: string): (target: object, fieldName: string) => void;

package/types/src/routing/decorators/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./argument.decorator.js";
+export * from "./auth.decorator.js";
+export * from "./controller.decorator.js";
+export * from "./field.decorator.js";
+export * from "./request.decorator.js";
+export * from "./response.decorator.js";
+export * from "./route.decorator.js";

package/types/src/routing/decorators/request.decorator.d.ts

@@ -0,0 +1,8 @@
+import type { Constructable } from "@decohere/core/reflection";
+import type { RequestPart } from "../anvil.types.js";
+/**
+ * Used to map a request object to route params
+ * @param mappingKey
+ * @returns
+ */
+export declare function Request(mappingKey?: RequestPart): (target: Constructable) => void;

package/types/src/routing/decorators/response.decorator.d.ts

@@ -0,0 +1,4 @@
+/** Set the HTTP status code returned on a successful handler response. */
+export declare function HttpCode(statusCode: number): (_target: object, _methodName: string, descriptor: PropertyDescriptor) => void;
+/** Set a response header on a successful handler response. Stackable. */
+export declare function Header(name: string, value: string): (_target: object, _methodName: string, descriptor: PropertyDescriptor) => void;

package/types/src/routing/decorators/route.decorator.d.ts

@@ -0,0 +1,7 @@
+import { type HTTPMethod } from "../../const.js";
+export declare function Get(path?: string): (targetClass: object, functionName: string, descriptor?: TypedPropertyDescriptor<(...args: any[]) => any>) => void;
+export declare function Post(path?: string): (targetClass: object, functionName: string, descriptor?: TypedPropertyDescriptor<(...args: any[]) => any>) => void;
+export declare function Put(path?: string): (targetClass: object, functionName: string, descriptor?: TypedPropertyDescriptor<(...args: any[]) => any>) => void;
+export declare function Patch(path?: string): (targetClass: object, functionName: string, descriptor?: TypedPropertyDescriptor<(...args: any[]) => any>) => void;
+export declare function Delete(path?: string): (targetClass: object, functionName: string, descriptor?: TypedPropertyDescriptor<(...args: any[]) => any>) => void;
+export declare function Route(method: HTTPMethod, path?: string): (targetClass: object, functionName: string, descriptor?: TypedPropertyDescriptor<(...args: any[]) => any>) => void;

package/types/src/routing/filters/exception-filter-host.d.ts

@@ -0,0 +1,19 @@
+import { type LifetimeScope } from "@decohere/crucible";
+import type { HttpOptions } from "../../http/http.options.js";
+import { type ExceptionContext, type ExceptionFilter, type ExceptionResult } from "./exception-filter.js";
+export declare class DefaultHttpExceptionFilter implements ExceptionFilter {
+    private readonly logger;
+    catch(error: unknown, _ctx: ExceptionContext): ExceptionResult;
+}
+/**
+ * Resolves the first matching filter for an error.
+ * Custom filters (registered via builder) are tried first; default is last.
+ */
+export declare class ExceptionFilterHost {
+    private readonly options?;
+    private readonly scope?;
+    private filters?;
+    constructor(options?: HttpOptions, scope?: LifetimeScope);
+    handle(error: unknown, ctx: ExceptionContext): Promise<ExceptionResult>;
+    private getFilters;
+}

package/types/src/routing/filters/exception-filter.d.ts

@@ -0,0 +1,16 @@
+import type { Constructable } from "@decohere/core/reflection";
+import type { HttpRequest } from "../anvil.types.js";
+export type ExceptionResult = {
+    status: number;
+    body: unknown;
+    headers?: Record<string, string>;
+};
+export type ExceptionContext = {
+    request: HttpRequest;
+};
+export interface ExceptionFilter {
+    catch(error: unknown, ctx: ExceptionContext): ExceptionResult | Promise<ExceptionResult>;
+}
+/** Declare which error types this filter handles. Empty = catch-all. */
+export declare function Catch(...types: Constructable[]): (target: Constructable) => void;
+export declare function getCatchTypes(filterType: Constructable): Constructable[];

package/types/src/routing/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./anvil.types.js";
+export * from "./decorators/index.js";
+export * from "./filters/exception-filter.js";
+export * from "./filters/exception-filter-host.js";
+export * from "./middleware/http-access-log.middleware.js";
+export * from "./middleware/middleware.js";
+export * from "./middleware/request-id.js";
+export * from "./pipes/index.js";

package/types/src/routing/middleware/http-access-log.middleware.d.ts

@@ -0,0 +1,8 @@
+import type { Middleware, MiddlewareContext } from "./middleware.js";
+/**
+ * Echoes `x-request-id` on the response and writes an HTTP access line via Scribe
+ * (method, path, status, durationMs, requestId). Enabled by default through `withHttp`.
+ */
+export declare class HttpAccessLogMiddleware implements Middleware {
+    use(ctx: MiddlewareContext, next: () => Promise<unknown>): Promise<unknown>;
+}

package/types/src/routing/middleware/middleware.d.ts

@@ -0,0 +1,10 @@
+import type { HttpRequest, MappedRoute } from "../anvil.types.js";
+export type MiddlewareContext = {
+    request: HttpRequest;
+    route: MappedRoute;
+};
+export interface Middleware {
+    use(ctx: MiddlewareContext, next: () => Promise<unknown>): Promise<unknown>;
+}
+/** Compose middleware around a terminal handler; returns the handler result. */
+export declare function composeMiddleware(middlewares: Middleware[], handler: () => Promise<unknown>, ctx: MiddlewareContext): Promise<unknown>;

package/types/src/routing/middleware/request-id.d.ts

@@ -0,0 +1,6 @@
+/** Canonical inbound/outbound request id header (lowercase). */
+export declare const REQUEST_ID_HEADER = "x-request-id";
+/**
+ * Prefer an inbound `x-request-id`, then an existing id, otherwise generate one.
+ */
+export declare function resolveRequestId(headers: Record<string, string>, fallback?: string): string;

package/types/src/routing/path.util.d.ts

@@ -0,0 +1,9 @@
+/** Normalize a prefix to `/foo` form with no trailing slash. Empty → `""`. */
+export declare function normalizePrefix(prefix: string | undefined | null): string;
+/**
+ * Join a controller prefix with a method-relative route path.
+ * Preserves `@Get("/")` trailing-slash semantics (`/hello` + `/` → `/hello/`).
+ */
+export declare function joinRoutePath(prefix: string, routePath: string): string;
+/** Prepend a global prefix onto an already-joined controller route path. */
+export declare function applyGlobalPrefix(globalPrefix: string, path: string): string;

package/types/src/routing/pipes/index.d.ts

@@ -0,0 +1 @@
+export * from "./pipes.js";

package/types/src/routing/pipes/pipes.d.ts

@@ -0,0 +1,21 @@
+import type { Type } from "@decohere/core/reflection";
+export type PipeContext = {
+    fieldTypes: Record<string, Type>;
+};
+export declare abstract class Pipe<T = unknown> {
+    abstract transform(value: unknown, context?: PipeContext): T;
+}
+export declare class BooleanPipe extends Pipe<boolean> {
+    transform(value: unknown, _context?: unknown): boolean;
+}
+export declare class DatePipe extends Pipe<Date> {
+    transform(value: unknown, _context?: unknown): Date;
+}
+export declare class JsonPipe extends Pipe<object> {
+    transform(value: string, context?: PipeContext): object;
+    private reviver;
+}
+export declare class NumberPipe extends Pipe<number> {
+    /** Finite numbers only. Blank or non-numeric input is a 400, not `undefined` (#503). */
+    transform(value: unknown, _context?: unknown): number;
+}

package/types/src/routing/services/index.d.ts

@@ -0,0 +1 @@
+export * from "./router.js";

package/types/src/routing/services/route-argument-resolver.d.ts

@@ -0,0 +1,10 @@
+import type { IPrincipalProvider } from "../../auth/principal-provider.js";
+import type { HttpRequest, RouteArg } from "../anvil.types.js";
+export declare class RouteArgumentResolve {
+    resolveArguments(httpRequest: HttpRequest, routeArgs: RouteArg[], principalProvider?: IPrincipalProvider): any[];
+    private getValue;
+    private mapPrimitive;
+    private mapObject;
+    private transform;
+    private pipeContext;
+}

package/types/src/routing/services/route-registry.d.ts

@@ -0,0 +1,20 @@
+import type { Constructable } from "@decohere/core/reflection";
+import type { HttpOptions } from "../../http/http.options.js";
+import type { MappedRoute } from "../anvil.types.js";
+export declare class RouteRegistry {
+    private readonly routeMap;
+    private readonly httpOptions?;
+    constructor(httpOptions?: HttpOptions);
+    addController(controller: Constructable): void;
+    get routes(): MapIterator<MappedRoute>;
+    getRoute(key: string): MappedRoute;
+    private addControllerRoute;
+    /** `@Controller({ globalPrefix: false })` opts out, unless the app put it back under. */
+    private takesGlobalPrefix;
+    private getControllerPrefix;
+    private getRouteArguments;
+    private getRouteArgument;
+    private getFields;
+    private enrichField;
+    private getDefaultPipes;
+}

package/types/src/routing/services/router.d.ts

@@ -0,0 +1,22 @@
+import { type LifetimeScope } from "@decohere/crucible";
+import type { IAuthorizationService } from "../../auth/auth.types.js";
+import type { HttpOptions } from "../../http/http.options.js";
+import type { HttpRequest } from "../anvil.types.js";
+import { RouteRegistry } from "./route-registry.js";
+export declare class Router {
+    private readonly argResolver;
+    private readonly lifetimeScope;
+    private readonly routeRegistry;
+    private readonly authService?;
+    private readonly httpOptions?;
+    private readonly logger;
+    constructor(routeRegistry: RouteRegistry, lifetimeScope: LifetimeScope, authService?: IAuthorizationService, httpOptions?: HttpOptions);
+    /**
+     * Without an authorization service nothing checks tokens, so a route marked @Authorize
+     * would be served to anyone. Refuse to start instead of failing open (#500).
+     */
+    private assertAuthConfiguredForProtectedRoutes;
+    route(routeKey: string, httpRequest: HttpRequest): Promise<any>;
+    private resolveMiddlewares;
+    private authorize;
+}

package/types/src/sse/index.d.ts

@@ -0,0 +1,3 @@
+export { LastEventId, Signal, Sse } from "./sse.decorator.js";
+export type { SseMessage, SseOptions, SseStream } from "./sse.types.js";
+export { SseResponse } from "./sse.types.js";

package/types/src/sse/sse.decorator.d.ts

@@ -0,0 +1,17 @@
+import type { SseOptions } from "./sse.types.js";
+/**
+ * Mark a route as a server-sent event stream. The method returns an `AsyncIterable` of
+ * {@link SseMessage}s (an `async *` method is the usual shape) and the HTTP package writes it as
+ * `text/event-stream`. Auth, validation and middleware run first, exactly as on any route,
+ * so an unauthorised caller gets a normal 401/403 and no event is ever sent.
+ *
+ * Combine with `@Get()` (EventSource only issues GET).
+ */
+export declare function Sse(options?: SseOptions): (_target: object, _methodName: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Inject an `AbortSignal` that aborts when the client disconnects or the app stops. Pass it to
+ * whatever the producer waits on (timers, subscriptions, queries) so it stops promptly.
+ */
+export declare const Signal: () => (target: object, propertyKey: string, parameterIndex: number) => void;
+/** Inject the `Last-Event-ID` header the browser sends when it reconnects, or `undefined`. */
+export declare const LastEventId: () => (target: object, propertyKey: string, parameterIndex: number) => void;

package/types/src/sse/sse.encoder.d.ts

@@ -0,0 +1,16 @@
+export type SseEncodeOptions = {
+    /** Aborted when the client disconnects or the app stops. */
+    signal: AbortSignal;
+    heartbeatMs: number;
+    /**
+     * Called once, as the stream ends, with a promise that settles when the producer has
+     * actually stopped (its `finally` blocks have run).
+     */
+    onProducerStopped: (stopped: Promise<void>) => void;
+};
+/**
+ * Turn the handler's events into SSE text. Writes an opening comment so the browser sees the
+ * response headers at once, a heartbeat whenever the producer is quiet, and stops as soon as the
+ * signal aborts, without waiting for a producer that is stuck.
+ */
+export declare function encodeSse(source: AsyncIterable<unknown>, options: SseEncodeOptions): AsyncGenerator<string>;

package/types/src/sse/sse.types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * One server-sent event. A bare `string` yielded by a handler is shorthand for `{ data }`.
+ *
+ * `data` is written as-is when it is a string and as JSON otherwise.
+ */
+export type SseMessage<T = unknown> = {
+    data: T;
+    /** Becomes the `event:` field; the browser dispatches it to `addEventListener(event, ...)`. */
+    event?: string;
+    /** Becomes the `id:` field; the browser sends the last one back as `Last-Event-ID` on reconnect. */
+    id?: string;
+    /** Tells the browser how many milliseconds to wait before reconnecting. */
+    retry?: number;
+};
+/** What a `@Sse()` handler returns: any async iterable of messages (an `async *` method is the usual shape). */
+export type SseStream<T = unknown> = AsyncIterable<SseMessage<T> | string>;
+export type SseOptions = {
+    /**
+     * Milliseconds of silence before the HTTP package writes a `: heartbeat` comment, which keeps proxies
+     * and load balancers from closing an idle connection. Default 15000. `0` turns heartbeats off.
+     */
+    heartbeatMs?: number;
+};
+export declare const DEFAULT_SSE_HEARTBEAT_MS = 15000;
+/**
+ * What the router hands the HTTP provider for an `@Sse()` route. The request-scoped services the
+ * handler uses must stay alive for as long as the stream runs, so the provider calls `release()`
+ * once the stream is over, instead of the router disposing them as soon as the handler returns.
+ */
+export declare class SseResponse {
+    readonly events: AsyncIterable<unknown>;
+    private readonly onRelease;
+    private released;
+    constructor(events: AsyncIterable<unknown>, onRelease: () => Promise<void>);
+    /** Safe to call more than once. */
+    release(): Promise<void>;
+}

package/types/src/sse/sse.wire.d.ts

@@ -0,0 +1,9 @@
+/** Encode one event as the text a browser's `EventSource` parses. */
+declare function formatMessage(item: unknown): string;
+/** A comment line: ignored by `EventSource`, but it is traffic on the wire. */
+declare function formatComment(text: string): string;
+export declare const sseWire: {
+    formatMessage: typeof formatMessage;
+    formatComment: typeof formatComment;
+};
+export {};

package/types/src/testing/boot-module.d.ts

@@ -0,0 +1,34 @@
+import type { ContainerBuilder } from "@decohere/crucible";
+import type { Constructable } from "@decohere/core/reflection";
+import type { App } from "../app/app.js";
+import { Builder } from "../builder/builder.js";
+import "../http/http.extensions.js";
+import type { HttpProvider } from "../routing/anvil.types.js";
+import { type EventStreamRead, type ReadEventsOptions } from "./sse-reader.js";
+export type BootModuleOptions = {
+    controllers: Constructable[];
+    /** Register services the controllers need. */
+    services?: (containerBuilder: ContainerBuilder) => void;
+    /** Add anything else to the builder (`withAuth()`, `withOpenApi()`, ...) before the app is built. */
+    configure?: (builder: Builder) => unknown;
+    /** Defaults to the Fastify provider. */
+    provider?: Constructable<HttpProvider>;
+};
+export type BootedModule = AsyncDisposable & {
+    app: App;
+    /** Origin of the listening app, e.g. `http://127.0.0.1:41233`. */
+    baseUrl: string;
+    /** `GET path` as an `EventSource` would, and collect the first `count` events. */
+    readEvents(path: string, options?: ReadEventsOptions): Promise<EventStreamRead>;
+    /** Stop the app (closing any open streams). Same as `await using`. */
+    stop(): Promise<void>;
+};
+/**
+ * Boot the given controllers as a real app on a free loopback port, so a test can call it over
+ * HTTP. The app runs the full pipeline: routing, auth, middleware, and the real provider.
+ *
+ * @example
+ * await using api = await bootModule({ controllers: [PriceController] });
+ * const { events } = await api.readEvents("/prices/stream", { count: 3 });
+ */
+export declare function bootModule(options: BootModuleOptions): Promise<BootedModule>;

package/types/src/testing/index.d.ts

@@ -0,0 +1,4 @@
+export type { BootedModule, BootModuleOptions } from "./boot-module.js";
+export { bootModule } from "./boot-module.js";
+export type { EventStreamRead, ReadEventsOptions, ReceivedEvent } from "./sse-reader.js";
+export { readEventStream } from "./sse-reader.js";

package/types/src/testing/sse-reader.d.ts

@@ -0,0 +1,29 @@
+export type ReceivedEvent = {
+    /** The `data:` lines joined with `\n`, as `EventSource` would give them. */
+    data: string;
+    event?: string;
+    id?: string;
+    retry?: number;
+};
+export type EventStreamRead = {
+    status: number;
+    headers: Headers;
+    /** The events received, at most the requested count. */
+    events: ReceivedEvent[];
+    /** Comment lines (`: heartbeat` and the like) seen before the read ended. */
+    comments: string[];
+    /** True when the server ended the stream (as opposed to the reader stopping at the count). */
+    ended: boolean;
+};
+export type ReadEventsOptions = {
+    /** Stop and close the connection after this many events. Default 1. `Infinity` reads until the server ends the stream. */
+    count?: number;
+    headers?: Record<string, string>;
+    /** Give up (and fail) if the read has not finished after this many milliseconds. Default 5000. */
+    timeoutMs?: number;
+};
+/**
+ * GET `url` as an `EventSource` would and collect events until `count` have arrived or the
+ * server ends the stream. A non-200 answer (401, 403, ...) returns at once with no events.
+ */
+export declare function readEventStream(url: string, options?: ReadEventsOptions): Promise<EventStreamRead>;