@decohere/http 0.0.1-dev.126 → 0.0.1-dev.5

package/es6/src/routing/services/route-registry.js

@@ -1,184 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { inject, injectable } from "@decohere/crucible/decorators";
-import { getArgumentMeta, getFields, getFunctionArgs, getFunctions, getMeta, isConstructable, isPrimitiveOrDateType } from "@decohere/core/reflection";
-import { HttpOptionsToken, MetadataKeys } from "../../const.js";
-import { InjectedParts, RouteConfigurationError } from "../anvil.types.js";
-import { applyGlobalPrefix, joinRoutePath, normalizePrefix } from "../path.util.js";
-import { BooleanPipe, DatePipe, JsonPipe, NumberPipe } from "../pipes/pipes.js";
-export class RouteRegistry {
-    routeMap = new Map();
-    httpOptions;
-    constructor(httpOptions){
-        this.httpOptions = httpOptions;
-    }
-    addController(controller) {
-        const funcs = getFunctions(controller);
-        for (const func of funcs){
-            this.addControllerRoute(controller, func);
-        }
-    }
-    get routes() {
-        return this.routeMap.values();
-    }
-    getRoute(key) {
-        return this.routeMap.get(key);
-    }
-    addControllerRoute(controller, prop) {
-        const func = prop.value;
-        const handler = func.name;
-        const route = getMeta(MetadataKeys.route, func);
-        if (route == null) {
-            return;
-        }
-        const globalPrefix = this.takesGlobalPrefix(controller) ? normalizePrefix(this.httpOptions?.globalPrefix) : "";
-        const controllerPrefix = this.getControllerPrefix(controller);
-        const path = applyGlobalPrefix(globalPrefix, joinRoutePath(controllerPrefix, route.path));
-        const { method } = route;
-        const key = `${method}|${path}`;
-        const existing = this.routeMap.get(key);
-        if (existing != null) {
-            // Last one used to win silently, leaving the other handler unreachable.
-            throw new RouteConfigurationError(`Duplicate route ${method.toUpperCase()} ${path}: ${existing.controller.name}.${existing.handler} and ${controller.name}.${handler}`);
-        }
-        const routeArgs = this.getRouteArguments(controller, func);
-        const httpCode = getMeta(MetadataKeys.httpCode, func);
-        const headers = getMeta(MetadataKeys.headers, func);
-        const sse = getMeta(MetadataKeys.sse, func);
-        this.routeMap.set(key, {
-            key,
-            controller,
-            handler,
-            path,
-            method,
-            routeArgs,
-            httpCode,
-            headers,
-            sse
-        });
-    }
-    /** `@Controller({ globalPrefix: false })` opts out, unless the app put it back under. */ takesGlobalPrefix(controller) {
-        const meta = getMeta(MetadataKeys.controller, controller.prototype);
-        return meta?.globalPrefix !== false || this.httpOptions?.underGlobalPrefix.has(controller) === true;
-    }
-    getControllerPrefix(controller) {
-        const meta = getMeta(MetadataKeys.controller, controller.prototype);
-        if (meta?.prefix) {
-            return normalizePrefix(meta.prefix);
-        }
-        const controllerName = controller.name.toLowerCase().replace("controller", "");
-        return controllerName !== "" ? `/${controllerName}` : "";
-    }
-    getRouteArguments(controller, handler) {
-        const types = getFunctionArgs(controller.prototype, handler) ?? [];
-        const args = [];
-        for (const [argumentIndex, argumentType] of types.entries()){
-            const argMeta = getArgumentMeta(MetadataKeys.parameter, handler, argumentIndex);
-            if (argMeta == null && !isConstructable(argumentType)) {
-                continue;
-            }
-            args.push(this.getRouteArgument(argumentType, argumentIndex, handler));
-        }
-        return args;
-    }
-    getRouteArgument(argumentType, argumentIndex, handler) {
-        const argMeta = getArgumentMeta(MetadataKeys.parameter, handler, argumentIndex);
-        // @CurrentUser() / interface params are Object (or other non-DTO types) — no field map.
-        if (isInjectedPart(argMeta?.argumentLocation) || !isConstructable(argumentType)) {
-            return {
-                ...argMeta,
-                pipes: [],
-                argumentIndex,
-                argumentType: isConstructable(argumentType) ? argumentType : Object,
-                fieldMap: new Map()
-            };
-        }
-        const pipes = argMeta != null ? this.getDefaultPipes(argumentType) : [];
-        const fieldMap = this.getFields(argumentType, argumentIndex, argMeta);
-        const routeArg = {
-            ...argMeta,
-            pipes,
-            argumentIndex,
-            argumentType,
-            fieldMap
-        };
-        return routeArg;
-    }
-    getFields(argumentType, argumentIndex, argMeta) {
-        const inst = new argumentType();
-        const fields = getFields(inst);
-        const fieldMap = getMeta(MetadataKeys.fieldMap, argumentType.prototype) ?? new Map();
-        for (const field of fields){
-            const fieldKey = field.key;
-            const fieldMeta = fieldMap.get(field.key);
-            if (fieldMeta && fieldMeta.fieldLocation == null && argMeta?.argumentLocation == null) {
-                throw new RouteConfigurationError(`field ${fieldMeta.fieldKey} must specify a location because location was not specified for the route argument at idx ${argumentIndex}`);
-            }
-            const enriched = this.enrichField(field, fieldMeta, argMeta);
-            fieldMap.set(fieldKey, enriched);
-        }
-        return fieldMap;
-    }
-    enrichField(field, fieldMeta, argMeta) {
-        const fieldLocation = fieldMeta?.fieldLocation ?? argMeta.argumentLocation;
-        const pipes = this.getDefaultPipes(fieldMeta?.fieldType);
-        return {
-            fieldKey: field.key,
-            mappingKey: field.key,
-            ...fieldMeta,
-            fieldLocation,
-            pipes
-        };
-    }
-    getDefaultPipes(argumentType) {
-        if (argumentType == null) {
-            return [];
-        }
-        let pipe;
-        if (!isPrimitiveOrDateType(argumentType)) {
-            pipe = JsonPipe;
-            return [
-                pipe
-            ];
-        }
-        switch(argumentType.name){
-            case "Number":
-                pipe = NumberPipe;
-                break;
-            case "Boolean":
-                pipe = BooleanPipe;
-                break;
-            case "Date":
-                pipe = DatePipe;
-                break;
-            default:
-                return [];
-        }
-        return [
-            pipe
-        ];
-    }
-}
-RouteRegistry = _ts_decorate([
-    injectable(),
-    _ts_param(0, inject(HttpOptionsToken)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HttpOptions === "undefined" ? Object : HttpOptions
-    ])
-], RouteRegistry);
-function isInjectedPart(location) {
-    return location != null && InjectedParts.includes(location);
-}

package/es6/src/routing/services/router.js

@@ -1,148 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { LifetimeScopeToken } from "@decohere/crucible";
-import { inject, injectable, optional } from "@decohere/crucible/decorators";
-import { scribe } from "@decohere/scribe";
-import { AuthorizationServiceToken, HttpOptionsToken, IPrincipalProviderToken, RouteRegistryToken } from "../../const.js";
-import { validateRequest } from "../../openapi/request-validator.js";
-import { SseResponse } from "../../sse/sse.types.js";
-import { RoutingError } from "../anvil.types.js";
-import { getAuthorizeOptions, isAllowAnonymous } from "../decorators/auth.decorator.js";
-import { composeMiddleware } from "../middleware/middleware.js";
-import { RouteArgumentResolve } from "./route-argument-resolver.js";
-import { RouteRegistry } from "./route-registry.js";
-export class Router {
-    argResolver = new RouteArgumentResolve();
-    lifetimeScope;
-    routeRegistry;
-    authService;
-    httpOptions;
-    logger = scribe.logger(Router.name);
-    constructor(routeRegistry, lifetimeScope, authService, httpOptions){
-        this.routeRegistry = routeRegistry;
-        this.lifetimeScope = lifetimeScope;
-        this.authService = authService;
-        this.httpOptions = httpOptions;
-        this.assertAuthConfiguredForProtectedRoutes();
-    }
-    /**
-	 * Without an authorization service nothing checks tokens, so a route marked @Authorize
-	 * would be served to anyone. Refuse to start instead of failing open.
-	 */ assertAuthConfiguredForProtectedRoutes() {
-        if (this.authService != null) {
-            return;
-        }
-        const protectedRoutes = [
-            ...this.routeRegistry.routes
-        ].filter(({ controller, handler })=>getAuthorizeOptions(controller.prototype, controller.prototype[handler])).map(({ controller, handler })=>`${controller.name}.${String(handler)}`);
-        if (protectedRoutes.length > 0) {
-            throw new RoutingError(`Routes use @Authorize but auth is not configured, so they would be open to anyone: ${protectedRoutes.join(", ")}. Add .withAuth() to the builder, or remove @Authorize.`);
-        }
-    }
-    async route(routeKey, httpRequest) {
-        const routeConfig = this.routeRegistry.getRoute(routeKey);
-        if (!routeConfig) {
-            throw new RoutingError(`Route was not configured for key ${routeKey}`);
-        }
-        const { controller, handler, routeArgs } = routeConfig;
-        // Unnamed: the request id comes from the client, so it is not unique.
-        // Disposed before we respond, so async cleanup (e.g. rolling back a DB transaction)
-        // finishes first. An SSE route is the exception: its scope lives as long as the stream.
-        const scope = this.lifetimeScope.beginScope();
-        let scopeHandedOff = false;
-        // Runs inside the middleware chain so rejections (401/403/400) reach middleware such as
-        // the access log. Auth comes first so anonymous callers learn nothing about the body.
-        const handle = async ()=>{
-            const principal = await this.authorize(routeConfig, httpRequest);
-            if (this.httpOptions?.openapi?.validateRequests !== false && this.httpOptions?.openapi) {
-                validateRequest(routeConfig, httpRequest);
-            }
-            const provider = scope.resolve(IPrincipalProviderToken);
-            provider.setPrincipal(principal);
-            const controllerInstance = scope.resolve(controller);
-            const func = controllerInstance[handler];
-            const argValues = this.argResolver.resolveArguments(httpRequest, routeArgs, provider);
-            try {
-                const result = await func.apply(controllerInstance, argValues);
-                if (routeConfig.sse == null) {
-                    return result;
-                }
-                if (typeof result?.[Symbol.asyncIterator] !== "function") {
-                    throw new RoutingError(`${controller.name}.${String(handler)} is marked @Sse() so it must return an AsyncIterable (an async generator method works)`);
-                }
-                scopeHandedOff = true;
-                return new SseResponse(result, ()=>scope[Symbol.asyncDispose]());
-            } catch (error) {
-                this.logger.error(error.message, error.stack);
-                throw error;
-            }
-        };
-        try {
-            const middlewares = this.resolveMiddlewares(scope);
-            if (middlewares.length === 0) {
-                return await handle();
-            }
-            return await composeMiddleware(middlewares, handle, {
-                request: httpRequest,
-                route: routeConfig
-            });
-        } catch (error) {
-            // A middleware failed after the handler returned: nobody will consume the stream.
-            scopeHandedOff = false;
-            throw error;
-        } finally{
-            if (!scopeHandedOff) {
-                await scope[Symbol.asyncDispose]();
-            }
-        }
-    }
-    resolveMiddlewares(scope) {
-        const types = this.httpOptions?.middlewareTypes ?? [];
-        return types.map((type)=>scope.resolve(type));
-    }
-    async authorize(routeConfig, httpRequest) {
-        // Optional DI may resolve as null when auth is not registered.
-        if (this.authService == null) {
-            return;
-        }
-        const { controller, handler } = routeConfig;
-        const handlerFn = controller.prototype[handler];
-        if (isAllowAnonymous(controller.prototype, handlerFn)) {
-            return;
-        }
-        const authOptions = getAuthorizeOptions(controller.prototype, handlerFn);
-        if (authOptions === undefined) {
-            // Auth is enabled but the route has no @Authorize — require a valid
-            // token (fail closed) without checking a specific ability.
-            return this.authService.authenticateRequest(httpRequest);
-        }
-        return this.authService.authorizeRequest(httpRequest, authOptions.action, authOptions.subject);
-    }
-}
-Router = _ts_decorate([
-    injectable(),
-    _ts_param(0, inject(RouteRegistryToken)),
-    _ts_param(1, inject(LifetimeScopeToken)),
-    _ts_param(2, inject(AuthorizationServiceToken)),
-    _ts_param(2, optional()),
-    _ts_param(3, inject(HttpOptionsToken)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof RouteRegistry === "undefined" ? Object : RouteRegistry,
-        typeof LifetimeScope === "undefined" ? Object : LifetimeScope,
-        typeof IAuthorizationService === "undefined" ? Object : IAuthorizationService,
-        typeof HttpOptions === "undefined" ? Object : HttpOptions
-    ])
-], Router);

package/es6/src/sse/index.js

@@ -1,2 +0,0 @@
-export { LastEventId, Signal, Sse } from "./sse.decorator.js";
-export { SseResponse } from "./sse.types.js";

package/es6/src/sse/sse.decorator.js

@@ -1,31 +0,0 @@
-import { defineArgumentMeta, defineMeta } from "@decohere/core/reflection";
-import { MetadataKeys } from "../const.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 function Sse(options = {}) {
-    return (_target, _methodName, descriptor)=>{
-        defineMeta(MetadataKeys.sse, options, descriptor.value);
-    };
-}
-function injected(location) {
-    return ()=>(target, propertyKey, parameterIndex)=>{
-            const fn = target[propertyKey];
-            const meta = {
-                argumentIndex: parameterIndex,
-                argumentLocation: location,
-                mappingKey: undefined,
-                pipes: []
-            };
-            defineArgumentMeta(MetadataKeys.parameter, meta, fn, parameterIndex);
-        };
-}
-/**
- * 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 const Signal = injected("signal");
-/** Inject the `Last-Event-ID` header the browser sends when it reconnects, or `undefined`. */ export const LastEventId = injected("lastEventId");

package/es6/src/sse/sse.encoder.js

@@ -1,67 +0,0 @@
-import { scribe } from "@decohere/scribe";
-import { sseWire } from "./sse.wire.js";
-const logger = scribe.logger("SseEncoder");
-/**
- * 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 async function* encodeSse(source, options) {
-    const { signal, heartbeatMs } = options;
-    const iterator = source[Symbol.asyncIterator]();
-    let onAbort;
-    const abortStep = new Promise((resolve)=>{
-        onAbort = ()=>resolve({
-                kind: "abort"
-            });
-        if (signal.aborted) onAbort();
-        else signal.addEventListener("abort", onAbort, {
-            once: true
-        });
-    });
-    let pending;
-    try {
-        yield sseWire.formatComment("open");
-        while(!signal.aborted){
-            pending ??= iterator.next().then((result)=>({
-                    kind: "item",
-                    result
-                }));
-            let timer;
-            const steps = [
-                pending,
-                abortStep
-            ];
-            if (heartbeatMs > 0) {
-                steps.push(new Promise((resolve)=>{
-                    timer = setTimeout(()=>resolve({
-                            kind: "heartbeat"
-                        }), heartbeatMs);
-                }));
-            }
-            let step;
-            try {
-                step = await Promise.race(steps);
-            } finally{
-                clearTimeout(timer);
-            }
-            if (step.kind === "abort") return;
-            if (step.kind === "heartbeat") {
-                yield sseWire.formatComment("heartbeat");
-                continue;
-            }
-            pending = undefined;
-            if (step.result.done) return;
-            yield sseWire.formatMessage(step.result.value);
-        }
-    } catch (error) {
-        // Headers are already sent, so the only honest thing left is to log and end the stream.
-        if (!signal.aborted) logger.error("SSE producer failed", error);
-    } finally{
-        if (onAbort) signal.removeEventListener("abort", onAbort);
-        // If the producer has not answered its last `next()`, `return()` waits behind it. That is
-        // why handlers must pass the signal to whatever they wait on.
-        options.onProducerStopped(Promise.resolve().then(()=>iterator.return?.()).then(()=>undefined, (error)=>{
-            if (!signal.aborted) logger.error("SSE producer failed while stopping", error);
-        }));
-    }
-}

package/es6/src/sse/sse.types.js

@@ -1,22 +0,0 @@
-/**
- * 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 const DEFAULT_SSE_HEARTBEAT_MS = 15_000;
-/**
- * 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 class SseResponse {
-    events;
-    onRelease;
-    released;
-    constructor(events, onRelease){
-        this.events = events;
-        this.onRelease = onRelease;
-    }
-    /** Safe to call more than once. */ release() {
-        this.released ??= this.onRelease();
-        return this.released;
-    }
-}

package/es6/src/sse/sse.wire.js

@@ -1,30 +0,0 @@
-/** Line breaks would end a field early, so a client-controlled `id` could inject extra fields. */ function singleLine(value) {
-    return value.replace(/[\r\n]+/g, " ");
-}
-function toMessage(item) {
-    if (typeof item === "object" && item !== null && "data" in item) {
-        return item;
-    }
-    return {
-        data: item
-    };
-}
-/** Encode one event as the text a browser's `EventSource` parses. */ function formatMessage(item) {
-    const { data, event, id, retry } = toMessage(item);
-    let frame = "";
-    if (id != null) frame += `id: ${singleLine(String(id))}\n`;
-    if (event != null) frame += `event: ${singleLine(event)}\n`;
-    if (retry != null && Number.isFinite(retry)) frame += `retry: ${Math.trunc(retry)}\n`;
-    const text = typeof data === "string" ? data : JSON.stringify(data) ?? "";
-    for (const line of text.split(/\r\n|\r|\n/)){
-        frame += `data: ${line}\n`;
-    }
-    return `${frame}\n`;
-}
-/** A comment line: ignored by `EventSource`, but it is traffic on the wire. */ function formatComment(text) {
-    return `: ${singleLine(text)}\n\n`;
-}
-export const sseWire = {
-    formatMessage,
-    formatComment
-};

package/es6/src/testing/boot-module.js

@@ -1,35 +0,0 @@
-import { Builder } from "../builder/builder.js";
-import "../http/http.extensions.js";
-import { FastifyProvider } from "../providers/fastify.provider.js";
-import { readEventStream } from "./sse-reader.js";
-/**
- * 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 async function bootModule(options) {
-    let builder = Builder.create().withHttp(options.provider ?? FastifyProvider).withControllers(...options.controllers);
-    if (options.services) builder = builder.withServices(options.services);
-    options.configure?.(builder);
-    const app = await builder.build();
-    await app.start({
-        port: 0,
-        host: "127.0.0.1",
-        shutdownSignals: false
-    });
-    const baseUrl = app.addresses[0];
-    if (baseUrl == null) {
-        await app.dispose();
-        throw new Error("app.start({ port: 0 }) advertised no IPv4 address");
-    }
-    const stop = ()=>app.dispose();
-    return {
-        app,
-        baseUrl,
-        readEvents: (path, readOptions)=>readEventStream(`${baseUrl}${path}`, readOptions),
-        stop,
-        [Symbol.asyncDispose]: stop
-    };
-}

package/es6/src/testing/index.js

@@ -1,2 +0,0 @@
-export { bootModule } from "./boot-module.js";
-export { readEventStream } from "./sse-reader.js";

package/es6/src/testing/sse-reader.js

@@ -1,91 +0,0 @@
-/** Incremental parser for the `text/event-stream` format. */ class SseParser {
-    buffer = "";
-    data = [];
-    current = {
-        data: ""
-    };
-    hasFields = false;
-    events = [];
-    comments = [];
-    push(chunk) {
-        this.buffer += chunk;
-        let newline;
-        while((newline = this.buffer.search(/\r\n|\r|\n/)) !== -1){
-            const line = this.buffer.slice(0, newline);
-            const eol = this.buffer.slice(newline).startsWith("\r\n") ? 2 : 1;
-            this.buffer = this.buffer.slice(newline + eol);
-            this.line(line);
-        }
-    }
-    line(line) {
-        if (line === "") {
-            if (this.hasFields) {
-                this.events.push({
-                    ...this.current,
-                    data: this.data.join("\n")
-                });
-            }
-            this.data = [];
-            this.current = {
-                data: ""
-            };
-            this.hasFields = false;
-            return;
-        }
-        if (line.startsWith(":")) {
-            this.comments.push(line.slice(1).trim());
-            return;
-        }
-        const colon = line.indexOf(":");
-        const field = colon === -1 ? line : line.slice(0, colon);
-        let value = colon === -1 ? "" : line.slice(colon + 1);
-        if (value.startsWith(" ")) value = value.slice(1);
-        this.hasFields = true;
-        if (field === "data") this.data.push(value);
-        else if (field === "event") this.current.event = value;
-        else if (field === "id") this.current.id = value;
-        else if (field === "retry") this.current.retry = Number(value);
-    }
-}
-/**
- * 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 async function readEventStream(url, options = {}) {
-    const count = options.count ?? 1;
-    const abort = new AbortController();
-    const timer = setTimeout(()=>abort.abort(new Error(`No ${count} events from ${url} in time`)), options.timeoutMs ?? 5000);
-    try {
-        const response = await fetch(url, {
-            headers: {
-                accept: "text/event-stream",
-                ...options.headers
-            },
-            signal: abort.signal
-        });
-        const parser = new SseParser();
-        let ended = false;
-        if (response.status === 200 && response.body != null) {
-            const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
-            while(parser.events.length < count){
-                const { done, value } = await reader.read();
-                if (done) {
-                    ended = true;
-                    break;
-                }
-                parser.push(value);
-            }
-            await reader.cancel();
-        } else {
-            await response.body?.cancel();
-        }
-        return {
-            status: response.status,
-            headers: response.headers,
-            events: parser.events.slice(0, count),
-            comments: parser.comments,
-            ended
-        };
-    } finally{
-        clearTimeout(timer);
-    }
-}

package/types/src/app/app.d.ts

@@ -1,41 +0,0 @@
-import { type LifetimeScope } from "@decohere/crucible";
-import { type IConfigurationService } from "@decohere/core/configuration";
-import type { HostedServiceHost } from "../hosting/hosted-service-host.js";
-import type { HttpProvider, StartResponse } from "../routing/anvil.types.js";
-export declare class ApiConfiguration {
-    port: number;
-}
-export type StartOptions = {
-    port: number;
-    host?: string;
-    /**
-     * Signals that stop the app gracefully: stop accepting connections, let in-flight
-     * requests finish, stop hosted services, then dispose services. Default SIGTERM and SIGINT; `false` to
-     * handle signals yourself.
-     */
-    shutdownSignals?: readonly NodeJS.Signals[] | false;
-    /** How long a signalled shutdown may take before the process exits with code 1. Default 10s. */
-    shutdownTimeoutMs?: number;
-};
-export declare class App {
-    private readonly container;
-    private configurationService?;
-    private httpProvider?;
-    private hostedServices?;
-    private _addresses;
-    private logger;
-    private disposing;
-    private disposingContainer;
-    private signalHandler;
-    private shutdownSignals;
-    constructor(container: LifetimeScope, configurationService?: IConfigurationService, httpProvider?: HttpProvider, hostedServices?: HostedServiceHost);
-    get addresses(): readonly string[];
-    start(options?: StartOptions): Promise<StartResponse>;
-    [Symbol.asyncDispose](): Promise<void>;
-    /** Stop the app. Calling it again (or from a signal) returns the same shutdown. */
-    dispose(): Promise<void>;
-    private stop;
-    private stopOnSignals;
-    private removeSignalHandlers;
-    private getPort;
-}

package/types/src/app/module.d.ts

@@ -1,15 +0,0 @@
-import type { ContainerBuilder } from "@decohere/crucible";
-import type { Constructable } from "@decohere/core/reflection";
-export type ModuleDefinition = {
-    name: string;
-    entities?: Constructable[];
-    repositories?: Constructable[];
-    registerServices?(containerBuilder: ContainerBuilder): void;
-};
-export declare abstract class Module {
-    abstract name: string;
-    constructor(data: Partial<Module>);
-    readonly entities?: readonly Constructable[];
-    readonly repositories?: readonly Constructable[];
-    abstract registerServices?(containerBuilder: ContainerBuilder): void;
-}