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

package/commonjs/src/routing/services/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./router.js"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/commonjs/src/routing/services/route-argument-resolver.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "RouteArgumentResolve", {
-    enumerable: true,
-    get: function() {
-        return RouteArgumentResolve;
-    }
-});
-const _reflection = require("@decohere/core/reflection");
-class RouteArgumentResolve {
-    resolveArguments(httpRequest, routeArgs, principalProvider) {
-        const argsValues = [];
-        for (const [argIdx, routeArg] of routeArgs.entries()){
-            const val = this.getValue(httpRequest, routeArg, principalProvider);
-            argsValues[argIdx] = val;
-        }
-        return argsValues;
-    }
-    getValue(httpRequest, routeArg, principalProvider) {
-        switch(routeArg.argumentLocation){
-            case "principal":
-                return principalProvider?.currentPrincipal;
-            case "signal":
-                return httpRequest.signal;
-            case "lastEventId":
-                return httpRequest.headers["last-event-id"];
-        }
-        const value = (0, _reflection.isPrimitiveOrDateType)(routeArg.argumentType) ? this.mapPrimitive(httpRequest, routeArg) : this.mapObject(httpRequest, routeArg);
-        return value;
-    }
-    mapPrimitive(httpRequest, routeArg) {
-        const { argumentLocation, mappingKey, pipes } = routeArg;
-        const value = httpRequest[argumentLocation][mappingKey];
-        const tranformedValue = this.transform(value, pipes, routeArg.fieldMap);
-        return tranformedValue;
-    }
-    mapObject(httpRequest, routeArg) {
-        const { argumentType } = routeArg;
-        const inst = new argumentType();
-        const { fieldMap } = routeArg;
-        for (const [fieldKey, meta] of fieldMap.entries()){
-            const { fieldLocation, mappingKey, pipes } = meta;
-            const value = httpRequest[fieldLocation][mappingKey];
-            const transformedValue = this.transform(value, pipes, fieldMap);
-            inst[fieldKey] = transformedValue;
-        }
-        return inst;
-    }
-    transform(value, pipes, fieldMap) {
-        let transformed = value;
-        if (value == null) {
-            return value;
-        }
-        const context = this.pipeContext(fieldMap);
-        for (const pipeConstructor of pipes ?? []){
-            const pipe = new pipeConstructor();
-            transformed = pipe.transform(transformed, context);
-        }
-        return transformed;
-    }
-    pipeContext(fieldMap) {
-        if (fieldMap == null || fieldMap.size === 0) {
-            return undefined;
-        }
-        const fieldTypes = {};
-        for (const [key, meta] of fieldMap.entries()){
-            if (meta.fieldType != null) {
-                fieldTypes[key] = meta.fieldType;
-            }
-        }
-        return Object.keys(fieldTypes).length > 0 ? {
-            fieldTypes
-        } : undefined;
-    }
-}

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

@@ -1,194 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "RouteRegistry", {
-    enumerable: true,
-    get: function() {
-        return RouteRegistry;
-    }
-});
-const _decorators = require("@decohere/crucible/decorators");
-const _reflection = require("@decohere/core/reflection");
-const _const = require("../../const.js");
-const _anviltypes = require("../anvil.types.js");
-const _pathutil = require("../path.util.js");
-const _pipes = require("../pipes/pipes.js");
-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);
-    };
-}
-class RouteRegistry {
-    routeMap = new Map();
-    httpOptions;
-    constructor(httpOptions){
-        this.httpOptions = httpOptions;
-    }
-    addController(controller) {
-        const funcs = (0, _reflection.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 = (0, _reflection.getMeta)(_const.MetadataKeys.route, func);
-        if (route == null) {
-            return;
-        }
-        const globalPrefix = this.takesGlobalPrefix(controller) ? (0, _pathutil.normalizePrefix)(this.httpOptions?.globalPrefix) : "";
-        const controllerPrefix = this.getControllerPrefix(controller);
-        const path = (0, _pathutil.applyGlobalPrefix)(globalPrefix, (0, _pathutil.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 _anviltypes.RouteConfigurationError(`Duplicate route ${method.toUpperCase()} ${path}: ${existing.controller.name}.${existing.handler} and ${controller.name}.${handler}`);
-        }
-        const routeArgs = this.getRouteArguments(controller, func);
-        const httpCode = (0, _reflection.getMeta)(_const.MetadataKeys.httpCode, func);
-        const headers = (0, _reflection.getMeta)(_const.MetadataKeys.headers, func);
-        const sse = (0, _reflection.getMeta)(_const.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 = (0, _reflection.getMeta)(_const.MetadataKeys.controller, controller.prototype);
-        return meta?.globalPrefix !== false || this.httpOptions?.underGlobalPrefix.has(controller) === true;
-    }
-    getControllerPrefix(controller) {
-        const meta = (0, _reflection.getMeta)(_const.MetadataKeys.controller, controller.prototype);
-        if (meta?.prefix) {
-            return (0, _pathutil.normalizePrefix)(meta.prefix);
-        }
-        const controllerName = controller.name.toLowerCase().replace("controller", "");
-        return controllerName !== "" ? `/${controllerName}` : "";
-    }
-    getRouteArguments(controller, handler) {
-        const types = (0, _reflection.getFunctionArgs)(controller.prototype, handler) ?? [];
-        const args = [];
-        for (const [argumentIndex, argumentType] of types.entries()){
-            const argMeta = (0, _reflection.getArgumentMeta)(_const.MetadataKeys.parameter, handler, argumentIndex);
-            if (argMeta == null && !(0, _reflection.isConstructable)(argumentType)) {
-                continue;
-            }
-            args.push(this.getRouteArgument(argumentType, argumentIndex, handler));
-        }
-        return args;
-    }
-    getRouteArgument(argumentType, argumentIndex, handler) {
-        const argMeta = (0, _reflection.getArgumentMeta)(_const.MetadataKeys.parameter, handler, argumentIndex);
-        // @CurrentUser() / interface params are Object (or other non-DTO types) — no field map.
-        if (isInjectedPart(argMeta?.argumentLocation) || !(0, _reflection.isConstructable)(argumentType)) {
-            return {
-                ...argMeta,
-                pipes: [],
-                argumentIndex,
-                argumentType: (0, _reflection.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 = (0, _reflection.getFields)(inst);
-        const fieldMap = (0, _reflection.getMeta)(_const.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 _anviltypes.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 (!(0, _reflection.isPrimitiveOrDateType)(argumentType)) {
-            pipe = _pipes.JsonPipe;
-            return [
-                pipe
-            ];
-        }
-        switch(argumentType.name){
-            case "Number":
-                pipe = _pipes.NumberPipe;
-                break;
-            case "Boolean":
-                pipe = _pipes.BooleanPipe;
-                break;
-            case "Date":
-                pipe = _pipes.DatePipe;
-                break;
-            default:
-                return [];
-        }
-        return [
-            pipe
-        ];
-    }
-}
-RouteRegistry = _ts_decorate([
-    (0, _decorators.injectable)(),
-    _ts_param(0, (0, _decorators.inject)(_const.HttpOptionsToken)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HttpOptions === "undefined" ? Object : HttpOptions
-    ])
-], RouteRegistry);
-function isInjectedPart(location) {
-    return location != null && _anviltypes.InjectedParts.includes(location);
-}

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

@@ -1,158 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "Router", {
-    enumerable: true,
-    get: function() {
-        return Router;
-    }
-});
-const _crucible = require("@decohere/crucible");
-const _decorators = require("@decohere/crucible/decorators");
-const _scribe = require("@decohere/scribe");
-const _const = require("../../const.js");
-const _requestvalidator = require("../../openapi/request-validator.js");
-const _ssetypes = require("../../sse/sse.types.js");
-const _anviltypes = require("../anvil.types.js");
-const _authdecorator = require("../decorators/auth.decorator.js");
-const _middleware = require("../middleware/middleware.js");
-const _routeargumentresolver = require("./route-argument-resolver.js");
-const _routeregistry = require("./route-registry.js");
-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);
-    };
-}
-class Router {
-    argResolver = new _routeargumentresolver.RouteArgumentResolve();
-    lifetimeScope;
-    routeRegistry;
-    authService;
-    httpOptions;
-    logger = _scribe.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 })=>(0, _authdecorator.getAuthorizeOptions)(controller.prototype, controller.prototype[handler])).map(({ controller, handler })=>`${controller.name}.${String(handler)}`);
-        if (protectedRoutes.length > 0) {
-            throw new _anviltypes.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 _anviltypes.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) {
-                (0, _requestvalidator.validateRequest)(routeConfig, httpRequest);
-            }
-            const provider = scope.resolve(_const.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 _anviltypes.RoutingError(`${controller.name}.${String(handler)} is marked @Sse() so it must return an AsyncIterable (an async generator method works)`);
-                }
-                scopeHandedOff = true;
-                return new _ssetypes.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 (0, _middleware.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 ((0, _authdecorator.isAllowAnonymous)(controller.prototype, handlerFn)) {
-            return;
-        }
-        const authOptions = (0, _authdecorator.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([
-    (0, _decorators.injectable)(),
-    _ts_param(0, (0, _decorators.inject)(_const.RouteRegistryToken)),
-    _ts_param(1, (0, _decorators.inject)(_crucible.LifetimeScopeToken)),
-    _ts_param(2, (0, _decorators.inject)(_const.AuthorizationServiceToken)),
-    _ts_param(2, (0, _decorators.optional)()),
-    _ts_param(3, (0, _decorators.inject)(_const.HttpOptionsToken)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _routeregistry.RouteRegistry === "undefined" ? Object : _routeregistry.RouteRegistry,
-        typeof LifetimeScope === "undefined" ? Object : LifetimeScope,
-        typeof IAuthorizationService === "undefined" ? Object : IAuthorizationService,
-        typeof HttpOptions === "undefined" ? Object : HttpOptions
-    ])
-], Router);

package/commonjs/src/sse/index.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get LastEventId () {
-        return _ssedecorator.LastEventId;
-    },
-    get Signal () {
-        return _ssedecorator.Signal;
-    },
-    get Sse () {
-        return _ssedecorator.Sse;
-    },
-    get SseResponse () {
-        return _ssetypes.SseResponse;
-    }
-});
-const _ssedecorator = require("./sse.decorator.js");
-const _ssetypes = require("./sse.types.js");

package/commonjs/src/sse/sse.decorator.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get LastEventId () {
-        return LastEventId;
-    },
-    get Signal () {
-        return Signal;
-    },
-    get Sse () {
-        return Sse;
-    }
-});
-const _reflection = require("@decohere/core/reflection");
-const _const = require("../const.js");
-function Sse(options = {}) {
-    return (_target, _methodName, descriptor)=>{
-        (0, _reflection.defineMeta)(_const.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: []
-            };
-            (0, _reflection.defineArgumentMeta)(_const.MetadataKeys.parameter, meta, fn, parameterIndex);
-        };
-}
-const Signal = injected("signal");
-const LastEventId = injected("lastEventId");

package/commonjs/src/sse/sse.encoder.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "encodeSse", {
-    enumerable: true,
-    get: function() {
-        return encodeSse;
-    }
-});
-const _scribe = require("@decohere/scribe");
-const _ssewire = require("./sse.wire.js");
-const logger = _scribe.scribe.logger("SseEncoder");
-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.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.sseWire.formatComment("heartbeat");
-                continue;
-            }
-            pending = undefined;
-            if (step.result.done) return;
-            yield _ssewire.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/commonjs/src/sse/sse.types.js

@@ -1,36 +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.
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get DEFAULT_SSE_HEARTBEAT_MS () {
-        return DEFAULT_SSE_HEARTBEAT_MS;
-    },
-    get SseResponse () {
-        return SseResponse;
-    }
-});
-const DEFAULT_SSE_HEARTBEAT_MS = 15_000;
-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/commonjs/src/sse/sse.wire.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "sseWire", {
-    enumerable: true,
-    get: function() {
-        return sseWire;
-    }
-});
-/** 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`;
-}
-const sseWire = {
-    formatMessage,
-    formatComment
-};