@ayepi/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2004 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_retry = require("./retry.cjs");
+const require_stats = require("./stats.cjs");
+const require_ws_transport = require("./ws-transport.cjs");
+let zod = require("zod");
+//#region src/endpoint.ts
+/**
+* # Endpoint specs
+*
+* Endpoint configuration ({@link EndpointConfig}), the compile-time config
+* validator ({@link CheckCfg}), event configuration, and the two entry points
+* that turn declarations into a runtime spec: {@link endpoint} and {@link spec}.
+*
+* The central invariant is **disjoint kinds**: every path-param key is declared
+* exactly once (loader XOR template XOR `params` schema) and positioned exactly
+* once; query keys are disjoint from path; body keys from path∪query; files keys
+* from all. That disjointness is what lets the four kinds merge losslessly into a
+* single `data` payload. It is enforced both at compile time (via {@link CheckCfg})
+* and at `spec()` time (via {@link normalizeEndpoint}).
+*
+* @module
+*/
+function makeEndpoint(cfg, mws, prefixes) {
+	return {
+		kind: "endpoint",
+		cfg,
+		mws,
+		prefixes
+	};
+}
+/**
+* Define a bare endpoint with no middleware.
+*
+* @example
+* ```ts
+* const getReport = endpoint({
+*   method: 'GET',
+*   path: reportPath,
+*   response: z.object({ year: z.number(), slug: z.string() }),
+* })
+* ```
+*/
+function endpoint(cfg) {
+	return makeEndpoint(cfg, [], []);
+}
+/**
+* Finalize a set of endpoints + events into a spec, validating every endpoint at
+* definition time.
+*
+* Beyond the compile-time {@link CheckCfg} guarantees, this performs runtime
+* sanity checks (flag exclusivity, kind shapes) and full
+* {@link normalizeEndpoint | path/coverage/disjointness} validation — throwing
+* immediately on any violation so misconfiguration fails at module init.
+*
+* @returns the same spec object, now type-branded and validated.
+*/
+function spec(spec) {
+	for (const [name, def] of Object.entries(spec.endpoints)) {
+		const c = def.cfg;
+		if (c.streamIn && (c.body || c.files)) throw new Error(`endpoint "${name}": streamIn excludes body/files`);
+		if (c.files && "body" in c.files) throw new Error(`endpoint "${name}": "body" is reserved as the multipart JSON field name`);
+		if (c.streamOut && c.response) throw new Error(`endpoint "${name}": streamOut excludes response`);
+		if (c.responses && c.response) throw new Error(`endpoint "${name}": responses (multi-status) excludes response`);
+		if (c.responses && c.streamOut) throw new Error(`endpoint "${name}": responses excludes streamOut`);
+		if (c.streamEncoding && !(c.streamOut instanceof zod.z.ZodType)) throw new Error(`endpoint "${name}": streamEncoding requires a typed (schema) streamOut`);
+		if (c.bodyEncoding === "urlencoded" && !(c.body instanceof zod.z.ZodObject)) throw new Error(`endpoint "${name}": urlencoded bodies must be z.object(...)`);
+		if (c.download && typeof c.streamOut !== "string") throw new Error(`endpoint "${name}": download requires a raw (content-type) streamOut`);
+		for (const kind of [
+			"params",
+			"query",
+			"headers",
+			"cookies"
+		]) {
+			const s = c[kind];
+			if (s && !(s instanceof zod.z.ZodObject)) throw new Error(`endpoint "${name}": ${kind} must be a z.object(...)`);
+		}
+		normalizeEndpoint(name, def);
+	}
+	let cached;
+	Object.defineProperty(spec, SPEC_MANIFEST, {
+		value: () => cached ??= manifestFromSpec(spec),
+		enumerable: false,
+		configurable: true
+	});
+	return spec;
+}
+/**
+* Global-registry symbol under which {@link spec} stashes its lazy
+* {@link manifestFromSpec} builder. Global (`Symbol.for`) so consumers — notably
+* the zod-free `client` — can read it off a spec value **without importing this
+* module**, so a manifest-only bundle never pulls in the deriver or zod.
+*
+* @internal
+*/
+const SPEC_MANIFEST = Symbol.for("ayepi.manifest");
+/**
+* Derive the zod-free {@link Manifest} from a spec — exactly the routing data
+* `app.manifest()` returns, computed purely from the endpoint/event definitions.
+* Used by {@link server} and stamped (cached) onto every spec by {@link spec}, so
+* {@link client} can take a spec directly.
+*
+* This runs the zod-bearing {@link normalizeEndpoint}, so importing it — or
+* handing a spec to the client — brings zod into the bundle. Pass a prebuilt
+* manifest instead to keep a frontend schema-free.
+*/
+function manifestFromSpec(spec) {
+	const eps = Object.entries(spec.endpoints).map(([name, def]) => normalizeEndpoint(name, def));
+	return {
+		endpoints: Object.fromEntries(eps.map((e) => [e.name, {
+			method: e.method,
+			path: e.path,
+			ws: e.ws,
+			httpOnly: e.httpOnly,
+			streamIn: e.streamInCt,
+			itemsIn: e.itemsIn,
+			streamOut: e.streamOutCt,
+			items: e.items,
+			p: e.p,
+			q: e.q,
+			b: e.bRaw ? "raw" : e.b,
+			f: e.f,
+			hasBody: Boolean(e.def.cfg.body),
+			hasHeaders: Boolean(e.def.cfg.headers),
+			multi: e.multi,
+			bodyEnc: e.bodyEnc
+		}])),
+		events: Object.fromEntries(Object.entries(spec.events ?? {}).map(([name, cfg]) => [name, {
+			ws: cfg.ws ?? name,
+			hasParams: Boolean(cfg.params)
+		}]))
+	};
+}
+/** Read the keys of a `z.object` schema, or `null` for any other (or absent) schema. @internal */
+function objectKeys(s) {
+	if (!s) return null;
+	if (s instanceof zod.z.ZodObject) return Object.keys(s.shape);
+	return null;
+}
+/**
+* Resolve an endpoint declaration into a {@link NormalizedEp}: assemble its path
+* parts (prefixes → own path → default), verify exact-once param declaration and
+* positioning, and enforce kind disjointness. Throws on any violation.
+*
+* @internal
+*/
+function normalizeEndpoint(name, def) {
+	const c = def.cfg;
+	const chain = resolveChain(def.mws);
+	const fail = (msg) => {
+		throw new Error(`endpoint "${name}": ${msg}`);
+	};
+	const loaders = /* @__PURE__ */ new Map();
+	for (const m of chain) if (m.paramKey && m.paramSchema) loaders.set(m.paramKey, m.paramSchema);
+	const tplSchemas = /* @__PURE__ */ new Map();
+	const declareTpl = (tpl, where) => {
+		for (const k of tpl.keys) {
+			if (loaders.has(k) || tplSchemas.has(k)) fail(`param ":${k}" is declared more than once (${where})`);
+			tplSchemas.set(k, tpl.schemas[k]);
+		}
+	};
+	for (const pre of def.prefixes) if (typeof pre !== "string") declareTpl(pre, "prefix path");
+	const ownTpl = typeof c.path === "object" && c.path !== null ? c.path : null;
+	if (ownTpl) declareTpl(ownTpl, "endpoint path");
+	const cfgP = objectKeys(c.params) ?? [];
+	for (const k of cfgP) if (loaders.has(k) || tplSchemas.has(k)) fail(`param ":${k}" is declared more than once (params schema)`);
+	const declared = new Set([
+		...loaders.keys(),
+		...tplSchemas.keys(),
+		...cfgP
+	]);
+	const parts = [];
+	for (const pre of def.prefixes) parts.push(...typeof pre === "string" ? require_ws_transport.splitPattern(pre) : pre.parts);
+	if (ownTpl) parts.push(...ownTpl.parts);
+	else if (typeof c.path === "string") parts.push(...require_ws_transport.splitPattern(c.path));
+	else {
+		parts.push({
+			t: "lit",
+			v: name
+		});
+		const positioned = new Set(require_ws_transport.paramKeys(parts));
+		for (const k of declared) if (!positioned.has(k)) parts.push({
+			t: "param",
+			k
+		});
+	}
+	const positions = require_ws_transport.paramKeys(parts);
+	const posSet = new Set(positions);
+	if (positions.length !== posSet.size) fail(`path positions a param more than once: ${require_ws_transport.joinPattern(parts)}`);
+	for (const k of positions) if (!declared.has(k)) fail(`path references undeclared param ":${k}"`);
+	for (const k of declared) if (!posSet.has(k)) fail(`declared param ":${k}" has no position in path ${require_ws_transport.joinPattern(parts)}`);
+	const p = [...declared];
+	const q = objectKeys(c.query) ?? [];
+	const b = c.body ? objectKeys(c.body) : null;
+	const bRaw = Boolean(c.body) && b === null;
+	const f = Object.keys(c.files ?? {});
+	const taken = /* @__PURE__ */ new Map();
+	for (const [kind, keys] of [
+		["path", p],
+		["query", q],
+		["body", b ?? []],
+		["files", f]
+	]) for (const k of keys) {
+		const prev = taken.get(k);
+		if (prev) fail(`key "${k}" appears in both ${prev} and ${kind} — kinds must be disjoint`);
+		taken.set(k, kind);
+	}
+	if (bRaw && (p.length > 0 || q.length > 0 || f.length > 0)) fail("a non-object body is the entire data payload — params/query/files are not allowed alongside it");
+	const itemsIn = c.streamIn instanceof zod.z.ZodType;
+	const streamInCt = typeof c.streamIn === "string" ? c.streamIn : itemsIn ? "application/x-ndjson" : null;
+	const items = c.streamOut instanceof zod.z.ZodType;
+	const sse = items && c.streamEncoding === "sse";
+	const streamOutCt = typeof c.streamOut === "string" ? c.streamOut : items ? sse ? "text/event-stream" : "application/x-ndjson" : null;
+	const httpOnly = Boolean(c.httpOnly || typeof c.streamIn === "string" || typeof c.streamOut === "string" || f.length > 0);
+	return {
+		name,
+		def,
+		method: c.method ?? "POST",
+		parts,
+		path: require_ws_transport.joinPattern(parts),
+		ws: c.ws ?? null,
+		wsEligible: !httpOnly,
+		httpOnly,
+		streamInCt,
+		itemsIn,
+		streamOutCt,
+		items,
+		sse,
+		multi: Boolean(c.responses && Object.keys(c.responses).length > 0),
+		bodyEnc: c.body ? c.bodyEncoding ?? "json" : null,
+		p,
+		q,
+		b,
+		bRaw,
+		f,
+		loaders,
+		tplSchemas,
+		chain
+	};
+}
+//#endregion
+//#region src/middleware.ts
+/**
+* Declare the context a middleware def provides — `provides: ctx<{ user: User }>()`.
+* Returns a type-only token; carries no runtime value.
+*/
+function ctx() {
+	return {};
+}
+function placeholderRun(name) {
+	return () => {
+		throw new Error(`middleware "${name}" has no implementation — bind it with implement(api).middleware(def, impl)`);
+	};
+}
+function makeMiddleware(name, requires, optional, paramKey, paramSchema, doc) {
+	const self = {
+		kind: "middleware",
+		name,
+		requires,
+		optional,
+		paramKey,
+		paramSchema,
+		doc,
+		run: placeholderRun(name),
+		with(...mws) {
+			return makeStack([self, ...mws], []);
+		},
+		path(p) {
+			return makeStack([self], [p]);
+		},
+		endpoint(cfg) {
+			return makeStack([self], []).endpoint(cfg);
+		},
+		group(g) {
+			return makeStack([self], []).group(g);
+		}
+	};
+	return self;
+}
+function makeStack(mws, prefixes) {
+	return {
+		kind: "stack",
+		mws,
+		prefixes,
+		with(...more) {
+			return makeStack([...mws, ...more], prefixes);
+		},
+		path(p) {
+			return makeStack(mws, [...prefixes, p]);
+		},
+		endpoint(cfg) {
+			return makeEndpoint(cfg, mws, prefixes);
+		},
+		group(g) {
+			const out = {};
+			for (const [k, cfg] of Object.entries(g)) out[k] = makeEndpoint(cfg, mws, prefixes);
+			return out;
+		}
+	};
+}
+/**
+* Compose one or more middleware into a {@link Stack} — the free-function form of
+* {@link Middleware.with | mw.with(...)}, which reads more naturally when bundling
+* several middleware at a group: `...use(auth, tel).group({ … })` instead of
+* `...auth.with(tel).group({ … })`.
+*
+* The middleware run in the order given (subject to `requires`/`optional`
+* resolution), exactly as with `.with()`.
+*
+* @typeParam M - the middleware list, in declared order (at least one).
+*
+* @example
+* ```ts
+* spec({
+*   endpoints: {
+*     ...use(auth, tel).group({ me, createJob }),
+*     ...use(auth, jobLoader).path('/jobs/:jobId').group({ jobStatus }),
+*   },
+* })
+* ```
+*/
+function use(...mws) {
+	return makeStack([...mws], []);
+}
+function middlewareImpl(name, opts) {
+	return makeMiddleware(name, opts?.requires ?? [], opts?.optional ?? [], void 0, void 0, opts?.doc);
+}
+function loaderImpl(key, schema, opts) {
+	return makeMiddleware(key, opts?.requires ?? [], opts?.optional ?? [], key, schema, opts?.doc);
+}
+/**
+* Create a middleware **def** — a frontend-safe contract (name, contributed
+* context, docs, dependencies) with **no** runtime fn. Bind the implementation
+* with `implement(api).middleware(def, impl)` in your server entry.
+*
+* @example A plain def that provides `{ user }`:
+* ```ts
+* const auth = middleware('auth', { provides: ctx<{ user: User }>() })
+* // server.ts:
+* implement(api).middleware(auth, async (io) => io.next({ user: await authenticate(io.req) }))
+* ```
+*
+* @example A def that requires `auth` (auto-included) and provides `{ org }`:
+* ```ts
+* const org = middleware('org', { provides: ctx<{ org: Org }>(), requires: [auth] })
+* // server.ts:
+* implement(api).middleware(org, async (io) => io.next({ org: await loadOrg(io.ctx.user) }))
+* ```
+*
+* @example A no-context, purely-runtime def (e.g. logging/telemetry):
+* ```ts
+* const log = middleware('log')
+* implement(api).middleware(log, async (io) => io.next())
+* ```
+*
+* @example A loader def that owns the `:projectId` path param:
+* ```ts
+* const project = middleware.loader('projectId', z.uuid(), { provides: ctx<{ project: Project }>() })
+* // server.ts:
+* implement(api).middleware(project, async (io) => io.next({ project: await loadProject(io.value) }))
+* ```
+*/
+const middleware = Object.assign(middlewareImpl, { loader: loaderImpl });
+/**
+* Create a middleware that **injects a typed value** onto the handler context under
+* `name` — the one-call form of `middleware(name, { provides: ctx<{ [name]: V }>() })`
+* plus its impl. Hand it a function, a service object, config, or any data, and every
+* endpoint whose chain includes it reads `io.ctx[name]`.
+*
+* The result is **both** the def (use it in the spec: `use(svc).group(…)` /
+* `svc.endpoint(…)`) and the bound def+impl (bind it once:
+* `implement(api).middleware(svc)`).
+*
+* @typeParam N - the context key (a string literal).
+* @typeParam V - the injected value's type.
+* @param name  - the key the value is injected under (also the middleware name).
+* @param value - the value to inject, or a factory `(io) => value` re-run per
+*   invocation (may be async). A **callable** `value` is treated as a factory — to
+*   inject a bare function as the value, wrap it: `provide('fn', () => myFn)`.
+*
+* @example
+* ```ts
+* const services = provide('services', { db, mailer });        // shared.ts / spec
+* export const api = spec({ endpoints: { ...services.group({ sendInvite }) } });
+* implement(api).middleware(services);                          // server.ts (bind once)
+* // handler: ({ services }) => services.mailer.send(…)
+* ```
+*/
+function provide(name, value) {
+	const def = middleware(name, { provides: ctx() });
+	const impl = async (io) => {
+		const v = typeof value === "function" ? await value(io) : value;
+		return io.next({ [name]: v });
+	};
+	return Object.assign(def, {
+		def,
+		impl
+	});
+}
+/**
+* Expand `requires` (auto-include) and topologically order a middleware list.
+*
+* `requires` edges pull dependencies in and force them earlier; `optional` edges
+* only reorder middleware that are *already present*. Throws on a dependency
+* cycle.
+*
+* @internal
+*/
+function resolveChain(mws) {
+	const present = /* @__PURE__ */ new Set();
+	const order = [];
+	const visit = (m, trail) => {
+		if (present.has(m)) return;
+		if (trail.has(m)) throw new Error(`middleware cycle involving "${m.name}"`);
+		trail.add(m);
+		for (const r of m.requires) visit(r, trail);
+		trail.delete(m);
+		present.add(m);
+		order.push(m);
+	};
+	for (const m of mws) visit(m, /* @__PURE__ */ new Set());
+	const idx = new Map(order.map((m, i) => [m, i]));
+	return [...order].sort((a, b) => {
+		if (a.optional.includes(b)) return 1;
+		if (b.optional.includes(a)) return -1;
+		return idx.get(a) - idx.get(b);
+	});
+}
+//#endregion
+//#region src/broker.ts
+/**
+* In-process {@link Broker} — the default when no broker is supplied.
+*
+* Share a single instance between multiple {@link Server}s to simulate a
+* multi-pod deployment in tests: an `emit` on one server is heard by
+* subscribers on the other.
+*
+* @example
+* ```ts
+* const broker = localBroker()
+* const a = server(api, handlers, { broker })
+* const b = server(api, handlers, { broker })
+* a.emit('systemNotice', { msg: 'hi' }) // delivered to b's subscribers too
+* ```
+*/
+function localBroker() {
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		publish(m) {
+			for (const l of listeners) l(m);
+		},
+		subscribe(l) {
+			listeners.add(l);
+			return () => void listeners.delete(l);
+		}
+	};
+}
+//#endregion
+//#region src/jsonschema.ts
+/**
+* # JSON Schema helpers
+*
+* Thin wrappers over `z.toJSONSchema` shared by the OpenAPI and AsyncAPI
+* generators. Internal to the package.
+*
+* @module
+*/
+/**
+* Convert a zod schema to a JSON Schema (input view), degrading gracefully to a
+* placeholder for schemas zod can't represent.
+*
+* @internal
+*/
+function jsonSchema(s) {
+	try {
+		return zod.z.toJSONSchema(s, { io: "input" });
+	} catch {
+		return {
+			type: "string",
+			description: "unrepresentable schema"
+		};
+	}
+}
+/**
+* Extract the `properties` map of an object schema's JSON Schema, or `{}` when
+* the schema is absent or not object-shaped.
+*
+* @internal
+*/
+function propSchemas(s) {
+	const js = s ? jsonSchema(s) : null;
+	if (js && typeof js === "object" && !Array.isArray(js) && typeof js.properties === "object") return js.properties;
+	return {};
+}
+//#endregion
+//#region src/openapi.ts
+/**
+* Build the OpenAPI 3.1 document for a set of normalized endpoints.
+*
+* @param eps     - the spec's normalized endpoints.
+* @param specDoc - spec-level doc patches (`doc.openapi`).
+* @param info    - optional document `info` (title/version).
+* @internal
+*/
+function buildOpenapi(eps, specDoc, info) {
+	const paths = {};
+	const securitySchemes = {};
+	for (const e of eps) {
+		const c = e.def.cfg;
+		const oaPath = "/" + e.parts.map((part) => part.t === "param" ? `{${part.k}}` : part.v).join("/");
+		const pProps = {
+			...propSchemas(c.params),
+			...Object.fromEntries([...e.tplSchemas].map(([k, s]) => [k, jsonSchema(s)])),
+			...Object.fromEntries([...e.loaders].map(([k, s]) => [k, jsonSchema(s)]))
+		};
+		const qProps = propSchemas(c.query);
+		const hProps = propSchemas(c.headers);
+		const ckProps = propSchemas(c.cookies);
+		const parameters = [
+			...e.p.map((k) => ({
+				name: k,
+				in: "path",
+				required: true,
+				schema: pProps[k] ?? { type: "string" }
+			})),
+			...e.q.map((k) => ({
+				name: k,
+				in: "query",
+				required: false,
+				schema: qProps[k] ?? { type: "string" }
+			})),
+			...Object.entries(hProps).map(([k, schema]) => ({
+				name: k,
+				in: "header",
+				required: true,
+				schema
+			})),
+			...Object.entries(ckProps).map(([k, schema]) => ({
+				name: k,
+				in: "cookie",
+				required: false,
+				schema
+			}))
+		];
+		let requestBody;
+		if (c.streamIn) requestBody = e.itemsIn ? {
+			required: true,
+			content: { [e.streamInCt]: { schema: {
+				type: "array",
+				items: jsonSchema(c.streamIn)
+			} } }
+		} : {
+			required: true,
+			content: { [e.streamInCt]: { schema: {
+				type: "string",
+				format: "binary"
+			} } }
+		};
+		else if (e.f.length > 0) {
+			const props = { ...c.body ? { body: jsonSchema(c.body) } : {} };
+			for (const k of e.f) props[k] = {
+				type: "string",
+				format: "binary"
+			};
+			requestBody = {
+				required: true,
+				content: { "multipart/form-data": { schema: {
+					type: "object",
+					properties: props
+				} } }
+			};
+		} else if (c.body) requestBody = {
+			required: true,
+			content: { [e.bodyEnc === "urlencoded" ? "application/x-www-form-urlencoded" : "application/json"]: { schema: jsonSchema(c.body) } }
+		};
+		const responses = c.streamOut ? e.items ? { "200": {
+			description: "NDJSON item stream",
+			content: { [e.streamOutCt]: { schema: {
+				type: "array",
+				items: jsonSchema(c.streamOut)
+			} } }
+		} } : { "200": {
+			description: "stream",
+			content: { [e.streamOutCt]: { schema: {
+				type: "string",
+				format: "binary"
+			} } }
+		} } : c.responses ? Object.fromEntries(Object.entries(c.responses).map(([st, schema]) => [st, {
+			description: `status ${st}`,
+			content: { "application/json": { schema: jsonSchema(schema) } }
+		}])) : c.response ? { "200": {
+			description: "ok",
+			content: { "application/json": { schema: jsonSchema(c.response) } }
+		} } : { "204": { description: "no content" } };
+		for (const [status, schema] of Object.entries(c.errors ?? {})) responses[status] = {
+			description: `declared error ${status}`,
+			content: { "application/json": { schema: jsonSchema(schema) } }
+		};
+		let op = {
+			operationId: c.doc?.operationId ?? e.name,
+			parameters,
+			responses
+		};
+		if (requestBody) op.requestBody = requestBody;
+		if (c.doc?.summary) op.summary = c.doc.summary;
+		if (c.doc?.description) op.description = c.doc.description;
+		if (c.doc?.tags) op.tags = [...c.doc.tags];
+		if (c.doc?.deprecated) op.deprecated = true;
+		const security = [];
+		for (const m of e.chain) for (const [schemeName, scheme] of Object.entries(m.doc?.security ?? {})) {
+			securitySchemes[schemeName] = scheme;
+			security.push({ [schemeName]: [] });
+		}
+		if (security.length > 0) op.security = security;
+		for (const m of e.chain) if (m.doc?.openapi) op = m.doc.openapi(op);
+		if (c.doc?.openapi) op = c.doc.openapi(op);
+		const entry = paths[oaPath] ?? {};
+		entry[e.method.toLowerCase()] = op;
+		paths[oaPath] = entry;
+	}
+	let doc = {
+		openapi: "3.1.0",
+		info: {
+			title: info?.title ?? "api",
+			version: info?.version ?? "0.0.0"
+		},
+		paths,
+		...Object.keys(securitySchemes).length > 0 ? { components: { securitySchemes } } : {}
+	};
+	if (specDoc?.openapi) doc = specDoc.openapi(doc);
+	return doc;
+}
+//#endregion
+//#region src/asyncapi.ts
+/**
+* Convert a params object's JSON-Schema `properties` into AsyncAPI 3.0 **Parameter
+* Objects**. Channel parameters are string-valued and must NOT carry a JSON-Schema
+* `type`/`format` (the 3.0 Parameter Object only allows `description`/`enum`/`default`/
+* `examples`/`location`) — emitting `type` makes a validator reject the document.
+*/
+function paramObjects(props) {
+	const out = {};
+	for (const [k, v] of Object.entries(props)) {
+		const o = v;
+		const param = {};
+		if (typeof o.description === "string") param.description = o.description;
+		if (Array.isArray(o.enum)) param.enum = o.enum.map((e) => String(e));
+		if (o.default !== void 0) param.default = String(o.default);
+		out[k] = param;
+	}
+	return out;
+}
+/**
+* Build the AsyncAPI 3.0 document for a set of normalized endpoints and events.
+*
+* @param eps     - the spec's normalized endpoints.
+* @param events  - the spec's normalized events (name + config + resolved ws id).
+* @param specDoc - spec-level doc patches (`doc.asyncapi`).
+* @param info    - optional document `info` (title/version).
+* @internal
+*/
+function buildAsyncapi(eps, events, specDoc, info) {
+	const channels = {};
+	const operations = {};
+	for (const ev of events) {
+		let channel = {
+			address: ev.ws,
+			...ev.cfg.doc?.summary ? { summary: ev.cfg.doc.summary } : {},
+			...ev.cfg.doc?.description ? { description: ev.cfg.doc.description } : {},
+			...ev.cfg.params ? { parameters: paramObjects(propSchemas(ev.cfg.params)) } : {},
+			messages: { event: { payload: jsonSchema(ev.cfg.data) } }
+		};
+		if (ev.cfg.doc?.asyncapi) channel = ev.cfg.doc.asyncapi(channel);
+		channels[ev.ws] = channel;
+		operations[`receive.${ev.name}`] = {
+			action: "receive",
+			channel: { $ref: `#/channels/${ev.ws}` }
+		};
+	}
+	for (const e of eps) {
+		if (!e.wsEligible) continue;
+		const c = e.def.cfg;
+		const address = e.ws ?? e.path;
+		const dataSchema = e.bRaw ? jsonSchema(c.body) : {
+			type: "object",
+			properties: {
+				...Object.fromEntries([...e.tplSchemas].map(([k, sch]) => [k, jsonSchema(sch)])),
+				...Object.fromEntries([...e.loaders].map(([k, sch]) => [k, jsonSchema(sch)])),
+				...propSchemas(c.params),
+				...propSchemas(c.query),
+				...propSchemas(c.body)
+			}
+		};
+		const ref = (key) => `#/channels/${key.replace(/\//g, "~1")}`;
+		channels[address] = {
+			address,
+			...e.ws ? {} : { description: `frame: { id, type: "${e.path}", method: "${e.method}", data }` },
+			messages: { request: { payload: {
+				type: "object",
+				properties: {
+					id: { type: "string" },
+					type: { const: address },
+					...e.ws ? {} : { method: { const: e.method } },
+					data: dataSchema
+				}
+			} } }
+		};
+		const replyKey = `${address}/reply`;
+		const declared = c.errors ? Object.keys(c.errors) : [];
+		const replyProps = {
+			id: { type: "string" },
+			$status: {
+				type: "integer",
+				description: "2xx on success"
+			}
+		};
+		if (c.response) replyProps.data = jsonSchema(c.response);
+		channels[replyKey] = {
+			address,
+			messages: {
+				reply: { payload: {
+					type: "object",
+					properties: replyProps
+				} },
+				error: {
+					...declared.length > 0 ? { description: `error frame — declared statuses: ${declared.join(", ")}` } : {},
+					payload: {
+						type: "object",
+						required: ["$status"],
+						properties: {
+							id: { type: "string" },
+							$status: {
+								type: "integer",
+								description: "non-2xx — the client throws an ApiError"
+							},
+							$error: {
+								type: "string",
+								description: "human-readable error message"
+							},
+							$code: {
+								type: "string",
+								description: "machine-readable error code (e.g. UNAUTHORIZED, VALIDATION)"
+							},
+							data: { description: "typed error body for declared errors" }
+						}
+					}
+				}
+			}
+		};
+		const op = {
+			action: "send",
+			channel: { $ref: ref(address) },
+			messages: [{ $ref: `${ref(address)}/messages/request` }],
+			reply: {
+				channel: { $ref: ref(replyKey) },
+				messages: [{ $ref: `${ref(replyKey)}/messages/reply` }, { $ref: `${ref(replyKey)}/messages/error` }]
+			}
+		};
+		operations[`call.${e.name}`] = op;
+	}
+	let doc = {
+		asyncapi: "3.0.0",
+		info: {
+			title: info?.title ?? "api",
+			version: info?.version ?? "0.0.0"
+		},
+		channels,
+		operations
+	};
+	if (specDoc?.asyncapi) doc = specDoc.asyncapi(doc);
+	return doc;
+}
+//#endregion
+//#region src/docs-ui.ts
+const DEFAULTS = {
+	openapiJson: "/docs/openapi.json",
+	asyncapiJson: "/docs/asyncapi.json",
+	swagger: "/docs/swagger",
+	redoc: "/docs/redoc",
+	asyncapi: "/docs/asyncapi"
+};
+/** Resolve the `docs` option into concrete routes, or `null` when disabled. @internal */
+function normalizeDocs(opt) {
+	if (!opt) return null;
+	const o = opt === true ? {} : opt;
+	const pick = (v, d) => v === false ? null : v ?? d;
+	return {
+		info: o.info,
+		openapiJson: pick(o.openapiJson, DEFAULTS.openapiJson),
+		asyncapiJson: pick(o.asyncapiJson, DEFAULTS.asyncapiJson),
+		swagger: pick(o.swagger, DEFAULTS.swagger),
+		redoc: pick(o.redoc, DEFAULTS.redoc),
+		asyncapi: pick(o.asyncapi, DEFAULTS.asyncapi)
+	};
+}
+/** Escape a string for safe inclusion in an HTML attribute. */
+function attr(s) {
+	return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/** A self-contained Swagger UI page (loaded from unpkg) pointed at `specUrl`. */
+function swaggerHtml(specUrl, title = "API — Swagger UI") {
+	return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${attr(title)}</title>
+    <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css" />
+  </head>
+  <body>
+    <div id="swagger-ui"></div>
+    <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js" crossorigin><\/script>
+    <script>
+      window.ui = SwaggerUIBundle({ url: ${JSON.stringify(specUrl)}, dom_id: '#swagger-ui' })
+    <\/script>
+  </body>
+</html>`;
+}
+/** A self-contained ReDoc page (loaded from the Redocly CDN) pointed at `specUrl`. */
+function redocHtml(specUrl, title = "API — ReDoc") {
+	return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${attr(title)}</title>
+  </head>
+  <body style="margin: 0">
+    <redoc spec-url="${attr(specUrl)}"></redoc>
+    <script src="https://cdn.redocly.com/redoc/latest/bundles/redoc.standalone.js" crossorigin><\/script>
+  </body>
+</html>`;
+}
+/** A self-contained AsyncAPI page (the `@asyncapi/web-component`, loaded from unpkg) pointed at `specUrl`. */
+function asyncapiHtml(specUrl, title = "API — AsyncAPI") {
+	const css = "https://unpkg.com/@asyncapi/react-component@2/styles/default.min.css";
+	return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${attr(title)}</title>
+    <link rel="stylesheet" href="${css}" />
+  </head>
+  <body>
+    <asyncapi-component schemaUrl="${attr(specUrl)}" cssImportPath="${css}"></asyncapi-component>
+    <script src="https://unpkg.com/@asyncapi/web-component@2/lib/asyncapi-web-component.js" defer><\/script>
+  </body>
+</html>`;
+}
+//#endregion
+//#region src/server.ts
+/**
+* # Server
+*
+* The fetch-native server. {@link server} takes a {@link AnySpec | spec} and
+* handler bags and returns a {@link Server} whose `fetch(Request) => Response` is
+* the whole HTTP surface, plus a `ws` object (`open`/`message`/`close`) that
+* speaks the JSON frame protocol. Everything is web-standard `Request`/`Response`
+* /streams — Node/Express/etc. live in adapters at the edge, never here.
+*
+* Responsibilities: middleware chain execution, payload assembly from the single
+* `data` kind tables, HTTP body parsing (JSON/urlencoded/multipart/raw/items),
+* raw + item + SSE streaming with Range/206/HEAD, CORS, the WebSocket call /
+* stream / sub-unsub protocol, event fanout through the {@link Broker}, and
+* OpenAPI/AsyncAPI generation (delegated to {@link buildOpenapi}/{@link buildAsyncapi}).
+*
+* @module
+*/
+/** Readable-side highWaterMark for the `$out` transform: accept the first chunk before a reader attaches so headers can commit. */
+const OUT_HIGH_WATER_MARK = 1;
+/** Synthetic status for an aborted/cancelled call (no HTTP response is produced). */
+const ABORTED_STATUS = 0;
+function parseCookieHeader(header) {
+	const out = {};
+	if (!header) return out;
+	for (const part of header.split(";")) {
+		const i = part.indexOf("=");
+		if (i < 0) continue;
+		out[part.slice(0, i).trim()] = decodeURIComponent(part.slice(i + 1).trim());
+	}
+	return out;
+}
+function serializeCookie(name, value, o) {
+	let s = `${name}=${encodeURIComponent(value)}`;
+	if (o?.path) s += `; Path=${o.path}`;
+	if (o?.domain) s += `; Domain=${o.domain}`;
+	if (o?.maxAge !== void 0) s += `; Max-Age=${o.maxAge}`;
+	if (o?.expires) s += `; Expires=${o.expires.toUTCString()}`;
+	if (o?.httpOnly) s += "; HttpOnly";
+	if (o?.secure) s += "; Secure";
+	if (o?.sameSite) s += `; SameSite=${o.sameSite}`;
+	return s;
+}
+/**
+* Begin implementing a spec. The returned {@link Implementor} is a chainable
+* builder: bind middleware impls with `.middleware(def, impl)` and endpoint
+* handlers with `.handlers({...})`/`.handle(name, fn)`, then hand it to
+* {@link server}. Split work across multiple `implement()` builders if you like —
+* `server()` merges them.
+*
+* @example
+* ```ts
+* const impl = implement(api)
+*   .middleware(auth, async (io) => io.next({ user: await authenticate(io.req) }))
+*   .handlers({ getUser: ({ data }) => loadUser(data.id) })
+* ```
+*/
+function implement(spec) {
+	const bag = {
+		handlers: /* @__PURE__ */ new Map(),
+		middleware: /* @__PURE__ */ new Map()
+	};
+	const self = {
+		__bag: bag,
+		middleware(defOrBound, impl) {
+			if (impl) bag.middleware.set(defOrBound, impl);
+			else {
+				const b = defOrBound;
+				bag.middleware.set(b.def, b.impl);
+			}
+			return self;
+		},
+		handlers(h) {
+			for (const [k, fn] of Object.entries(h)) {
+				if (bag.handlers.has(k)) throw new Error(`duplicate handler for endpoint "${k}"`);
+				bag.handlers.set(k, fn);
+			}
+			return self;
+		},
+		handle(name, fn) {
+			if (bag.handlers.has(name)) throw new Error(`duplicate handler for endpoint "${name}"`);
+			bag.handlers.set(name, fn);
+			return self;
+		}
+	};
+	return self;
+}
+/**
+* View a running {@link Server} as a typed {@link LocalClient} for spec `S` — for
+* calling endpoints in-process (full chain + validation, no HTTP) by name + data.
+*
+* @param app  - the running server (its `call` is the in-process caller).
+* @param spec - the spec to type against (its endpoints/`CallReturn` shape `S`).
+*
+* @example
+* ```ts
+* const users = localClient(app, usersSpec);
+* const u = await users.call('getUser', { id: 'u1' });   // typed, in-process
+* ```
+*/
+function localClient(app, spec) {
+	return app;
+}
+/**
+* Assemble a {@link Server} from a spec and one or more {@link implement} builders.
+*
+* Every endpoint must have exactly one handler: a missing handler is a **compile
+* error** that names the offending endpoints (via the final `error` argument), and
+* a duplicate/unknown handler throws at startup. Every middleware in an endpoint or
+* event-guard chain must be bound via `.middleware(def, impl)` — an unbound def
+* throws at assembly.
+*
+* @param spec     - the validated spec from {@link spec}.
+* @param builders - one or more builders from {@link implement}.
+* @param rest     - `[options?]` when all handlers are present, else `[{ missingHandlers }]`.
+*
+* @example
+* ```ts
+* const app = server(api, [implement(api).middleware(auth, authImpl).handlers({ … })], { cors, broker })
+* const res = await app.fetch(new Request('http://x/getUser/u1', { method: 'POST' }))
+* ```
+*/
+function server(spec, builders, ...rest) {
+	const options = rest[0];
+	const table = /* @__PURE__ */ new Map();
+	const implMap = /* @__PURE__ */ new Map();
+	const eps = [];
+	const routes = [];
+	const events = [];
+	const byName = /* @__PURE__ */ new Map();
+	const byWs = /* @__PURE__ */ new Map();
+	const byRoute = /* @__PURE__ */ new Map();
+	const boundChains = /* @__PURE__ */ new Map();
+	const eventsByWs = /* @__PURE__ */ new Map();
+	const subscribers = /* @__PURE__ */ new Map();
+	const specDocs = [];
+	let manifestCache = null;
+	let openapiJsonCache = null;
+	let asyncapiJsonCache = null;
+	const invalidate = () => {
+		manifestCache = null;
+		openapiJsonCache = null;
+		asyncapiJsonCache = null;
+	};
+	const bind = (chain, where) => chain.map((m) => {
+		const impl = implMap.get(m);
+		if (!impl) throw new Error(`middleware "${m.name}" (${where}) has no implementation — bind it with implement(api).middleware(def, impl)`);
+		return {
+			...m,
+			run: impl
+		};
+	});
+	function register(regSpec, regBuilders) {
+		const newHandlers = [];
+		const newImpls = [];
+		for (const b of regBuilders) {
+			for (const [k, fn] of b.__bag.handlers) {
+				if (table.has(k) || newHandlers.some(([n]) => n === k)) throw new Error(`duplicate handler for endpoint "${k}"`);
+				if (!(k in regSpec.endpoints)) throw new Error(`handler for unknown endpoint "${k}"`);
+				newHandlers.push([k, fn]);
+			}
+			for (const [def, impl] of b.__bag.middleware) {
+				if (implMap.has(def) || newImpls.some(([d]) => d === def)) throw new Error(`duplicate implementation for middleware "${def.name}"`);
+				newImpls.push([def, impl]);
+			}
+		}
+		for (const k of Object.keys(regSpec.endpoints)) if (!newHandlers.some(([n]) => n === k)) throw new Error(`missing handler for endpoint "${k}"`);
+		const newEps = Object.entries(regSpec.endpoints).map(([name, def]) => normalizeEndpoint(name, def));
+		for (const e of newEps) {
+			if (e.wsEligible && byRoute.has(`${e.method} ${e.path}`)) throw new Error(`route "${e.method} ${e.path}" is already installed`);
+			if (e.ws !== null && e.wsEligible && (byWs.has(e.ws) || eventsByWs.has(e.ws))) throw new Error(`ws id "${e.ws}" is already installed`);
+		}
+		const newEvents = Object.entries(regSpec.events ?? {}).map(([name, cfg]) => ({
+			name,
+			cfg,
+			ws: cfg.ws ?? name
+		}));
+		for (const ev of newEvents) {
+			if (events.some((x) => x.name === ev.name)) throw new Error(`event "${ev.name}" is already installed`);
+			if (eventsByWs.has(ev.ws) || byWs.has(ev.ws) || newEps.some((e) => e.ws === ev.ws)) throw new Error(`event channel "${ev.ws}" collides with an existing channel or ws id`);
+		}
+		for (const [def, impl] of newImpls) implMap.set(def, impl);
+		for (const [k, fn] of newHandlers) table.set(k, fn);
+		for (const e of newEps) {
+			boundChains.set(e, bind(e.chain, `endpoint "${e.name}"`));
+			byName.set(e.name, e);
+			eps.push(e);
+			routes.push({
+				e,
+				parts: e.parts
+			});
+			if (e.wsEligible) byRoute.set(`${e.method} ${e.path}`, e);
+			if (e.ws !== null && e.wsEligible) byWs.set(e.ws, e);
+		}
+		const liveEvents = newEvents.map((ev) => ({
+			...ev,
+			chain: bind(resolveChain(ev.cfg.guard ?? []), `event "${ev.name}"`)
+		}));
+		for (const ev of liveEvents) {
+			events.push(ev);
+			eventsByWs.set(ev.ws, ev);
+		}
+		if (regSpec.doc) specDocs.push(regSpec.doc);
+		invalidate();
+		return {
+			eps: newEps,
+			events: liveEvents,
+			impls: newImpls.map(([d]) => d),
+			doc: regSpec.doc
+		};
+	}
+	function unregister(handle) {
+		for (const e of handle.eps) {
+			boundChains.delete(e);
+			byName.delete(e.name);
+			table.delete(e.name);
+			if (e.wsEligible) byRoute.delete(`${e.method} ${e.path}`);
+			if (e.ws !== null && e.wsEligible) byWs.delete(e.ws);
+			const ri = routes.findIndex((r) => r.e === e);
+			if (ri >= 0) routes.splice(ri, 1);
+			const ei = eps.indexOf(e);
+			if (ei >= 0) eps.splice(ei, 1);
+		}
+		for (const ev of handle.events) {
+			const i = events.indexOf(ev);
+			if (i >= 0) events.splice(i, 1);
+			eventsByWs.delete(ev.ws);
+			for (const key of [...subscribers.keys()]) if (key === ev.ws || key.startsWith(`${ev.ws}|`)) subscribers.delete(key);
+		}
+		for (const def of handle.impls) implMap.delete(def);
+		if (handle.doc) {
+			const di = specDocs.indexOf(handle.doc);
+			if (di >= 0) specDocs.splice(di, 1);
+		}
+		invalidate();
+	}
+	register(spec, builders);
+	const buildManifest = () => ({
+		endpoints: Object.fromEntries(eps.map((e) => [e.name, {
+			method: e.method,
+			path: e.path,
+			ws: e.ws,
+			httpOnly: e.httpOnly,
+			streamIn: e.streamInCt,
+			itemsIn: e.itemsIn,
+			streamOut: e.streamOutCt,
+			items: e.items,
+			p: e.p,
+			q: e.q,
+			b: e.bRaw ? "raw" : e.b,
+			f: e.f,
+			hasBody: Boolean(e.def.cfg.body),
+			hasHeaders: Boolean(e.def.cfg.headers),
+			multi: e.multi,
+			bodyEnc: e.bodyEnc
+		}])),
+		events: Object.fromEntries(events.map((ev) => [ev.name, {
+			ws: ev.ws,
+			hasParams: Boolean(ev.cfg.params)
+		}]))
+	});
+	const getManifest = () => manifestCache ??= buildManifest();
+	/** Compose every installed spec's doc patches into one (applied last, in install order). */
+	const composeDoc = () => ({
+		openapi: (doc) => specDocs.reduce((acc, d) => d.openapi ? d.openapi(acc) : acc, doc),
+		asyncapi: (doc) => specDocs.reduce((acc, d) => d.asyncapi ? d.asyncapi(acc) : acc, doc)
+	});
+	const docs = normalizeDocs(options?.docs);
+	const openapiJson = () => openapiJsonCache ??= JSON.stringify(buildOpenapi(eps, composeDoc(), docs?.info));
+	const asyncapiJson = () => asyncapiJsonCache ??= JSON.stringify(buildAsyncapi(eps, events, composeDoc(), docs?.info));
+	const jsonDoc = (body) => new Response(body, { headers: { "content-type": "application/json; charset=utf-8" } });
+	const htmlDoc = (body) => new Response(body, { headers: { "content-type": "text/html; charset=utf-8" } });
+	function docResponse(pathname) {
+		if (!docs) return null;
+		if (docs.openapiJson && pathname === docs.openapiJson) return jsonDoc(openapiJson());
+		if (docs.asyncapiJson && pathname === docs.asyncapiJson) return jsonDoc(asyncapiJson());
+		if (docs.swagger && docs.openapiJson && pathname === docs.swagger) return htmlDoc(swaggerHtml(docs.openapiJson));
+		if (docs.redoc && docs.openapiJson && pathname === docs.redoc) return htmlDoc(redocHtml(docs.openapiJson));
+		if (docs.asyncapi && docs.asyncapiJson && pathname === docs.asyncapi) return htmlDoc(asyncapiHtml(docs.asyncapiJson));
+		return null;
+	}
+	async function runChain(chain, req, rawParams, terminal, info) {
+		const fns = metaFns(info.meta);
+		let ctx = {};
+		const loaderVals = {};
+		const step = async (i) => {
+			if (i >= chain.length) return terminal(ctx, loaderVals);
+			const m = chain[i];
+			let nextCalled = false;
+			const io = {
+				req,
+				body: info.body,
+				get ctx() {
+					return ctx;
+				},
+				next: async (add) => {
+					nextCalled = true;
+					if (add) ctx = {
+						...ctx,
+						...add
+					};
+					return step(i + 1);
+				},
+				transport: info.transport,
+				route: info.route,
+				signal: info.signal,
+				setHeader: fns.setHeader,
+				status: fns.status
+			};
+			if (info.ws) io.ws = info.ws;
+			if (m.paramKey && m.paramSchema) {
+				if (!(m.paramKey in rawParams)) throw require_ws_transport.reject(400, "BAD_REQUEST", `missing path param "${m.paramKey}"`);
+				const v = m.paramSchema.parse(rawParams[m.paramKey]);
+				io.value = v;
+				loaderVals[m.paramKey] = v;
+			}
+			const out = await m.run(io);
+			if (out instanceof Response) return out;
+			if (!nextCalled) throw new Error(`middleware "${m.name}" returned without calling next()`);
+			return out;
+		};
+		return step(0);
+	}
+	const makeMeta = () => ({
+		status: null,
+		headers: [],
+		length: null,
+		committed: false
+	});
+	const metaFns = (meta) => ({
+		status: (code) => {
+			if (!meta) return;
+			if (meta.committed) throw new Error("$status must be called before the response is committed");
+			meta.status = code;
+		},
+		setHeader: (name, value) => {
+			if (!meta) return;
+			if (meta.committed) throw new Error("$setHeader must be called before the response is committed");
+			meta.headers.push([name, value]);
+		},
+		setCookie: (name, value, opts) => {
+			if (!meta) return;
+			if (meta.committed) throw new Error("$setCookie must be called before the response is committed");
+			meta.headers.push(["set-cookie", serializeCookie(name, value, opts)]);
+		}
+	});
+	/** disjoint kinds: split a flat data payload back into p/q/b by the endpoint's key tables */
+	function kindsFromData(e, data) {
+		if (e.bRaw) return {
+			p: {},
+			q: {},
+			b: data
+		};
+		const p = {};
+		const q = {};
+		const b = {};
+		const pSet = new Set(e.p);
+		const qSet = new Set(e.q);
+		const bSet = new Set(e.b ?? []);
+		const fSet = new Set(e.f);
+		for (const [k, v] of Object.entries(data ?? {})) if (pSet.has(k)) p[k] = v;
+		else if (qSet.has(k)) q[k] = v;
+		else if (bSet.has(k)) b[k] = v;
+		else if (fSet.has(k)) continue;
+		else throw require_ws_transport.reject(400, "VALIDATION", `key "${k}" does not belong to this endpoint`);
+		return {
+			p,
+			q,
+			b: e.b !== null ? b : void 0
+		};
+	}
+	/** root payload names owned by the framework — middleware ctx may not collide with them */
+	const RESERVED_CTX = new Set([
+		"data",
+		"stream",
+		"headers",
+		"cookies",
+		"out",
+		"download",
+		"length",
+		"fail",
+		"status",
+		"header",
+		"cookie",
+		"req",
+		"signal",
+		"emit"
+	]);
+	function assemble(e, ctx, kinds, req, signal, streamCtl, meta) {
+		const data = e.bRaw ? kinds.b : {
+			...kinds.p,
+			...kinds.q,
+			...e.b !== null ? kinds.b : {},
+			...kinds.f
+		};
+		const payload = {};
+		for (const [k, v] of Object.entries(ctx)) {
+			if (RESERVED_CTX.has(k)) throw new Error(`middleware ctx key "${k}" collides with a reserved payload name`);
+			payload[k] = v;
+		}
+		if (e.bRaw || Object.keys(data).length > 0) payload.data = data;
+		if (kinds.stream) payload.stream = kinds.stream;
+		if (streamCtl) {
+			payload.out = streamCtl.out;
+			payload.download = streamCtl.download;
+			payload.length = streamCtl.length;
+		}
+		if (e.def.cfg.headers) payload.headers = kinds.h;
+		if (e.def.cfg.cookies) payload.cookies = kinds.ck;
+		const errors = e.def.cfg.errors;
+		if (errors && Object.keys(errors).length > 0) payload.fail = (status, data2) => {
+			const schema = errors[status];
+			if (!schema) throw new Error(`endpoint "${e.name}": fail(${status}) is not a declared error status`);
+			throw new require_ws_transport.ApiFailure(status, schema.parse(data2));
+		};
+		const fns = metaFns(meta);
+		payload.status = fns.status;
+		payload.header = fns.setHeader;
+		payload.cookie = fns.setCookie;
+		payload.req = req;
+		payload.signal = signal;
+		payload.emit = emit;
+		return payload;
+	}
+	async function parseFiles(e, form) {
+		const files = {};
+		for (const [key, schema] of Object.entries(e.def.cfg.files ?? {})) {
+			const all = form.getAll(key).filter((v) => typeof v !== "string");
+			const raw = schema instanceof zod.z.ZodArray || schema instanceof zod.z.ZodOptional && schema.unwrap() instanceof zod.z.ZodArray ? all : all[0];
+			files[key] = schema.parse(raw);
+		}
+		const rawBody = form.get("body");
+		return {
+			files,
+			body: typeof rawBody === "string" ? JSON.parse(rawBody) : void 0
+		};
+	}
+	function queryToObject(e, sp) {
+		const out = {};
+		for (const k of e.q) {
+			const vals = sp.getAll(k);
+			if (vals.length === 0) continue;
+			out[k] = vals.length === 1 ? vals[0] : vals;
+		}
+		return out;
+	}
+	async function invoke(e, req, rawParams, rawQuery, rawBody, rawFiles, stream, streamCtl, meta, signal, chainCtx) {
+		const route = {
+			kind: "endpoint",
+			name: e.name,
+			method: e.method,
+			path: e.path,
+			ws: e.ws
+		};
+		return runChain(boundChains.get(e), req, rawParams, async (ctx, loaderVals) => {
+			const c = e.def.cfg;
+			const cfgParamKeys = (objectKeys(c.params) ?? []).filter((k) => !e.loaders.has(k) && !e.tplSchemas.has(k));
+			const picked = {};
+			for (const k of cfgParamKeys) picked[k] = rawParams[k];
+			const tplVals = {};
+			for (const [k, schema] of e.tplSchemas) tplVals[k] = schema.parse(rawParams[k]);
+			const p = {
+				...loaderVals,
+				...tplVals,
+				...c.params ? c.params.parse(picked) : {}
+			};
+			const q = c.query ? c.query.parse(rawQuery) : {};
+			const b = c.body ? c.body.parse(rawBody) : void 0;
+			const f = {};
+			if (rawFiles) for (const [k, schema] of Object.entries(c.files ?? {})) f[k] = rawFiles[k] !== void 0 ? rawFiles[k] : schema.parse(void 0);
+			let h;
+			if (c.headers) {
+				const raw = {};
+				for (const k of objectKeys(c.headers) ?? []) {
+					const v = req.headers.get(k);
+					if (v !== null) raw[k] = v;
+				}
+				h = c.headers.parse(raw);
+			}
+			let ck;
+			if (c.cookies) ck = c.cookies.parse(parseCookieHeader(req.headers.get("cookie")));
+			const result = await table.get(e.name)(assemble(e, ctx, {
+				p,
+				q,
+				b,
+				f: rawFiles ? f : {},
+				stream,
+				h,
+				ck
+			}, req, signal ?? req.signal, streamCtl, meta));
+			if (c.streamOut) return result;
+			if (c.responses) {
+				const r = result;
+				const schema = c.responses[r.status];
+				if (!schema) throw new Error(`endpoint "${e.name}": status ${r.status} is not a declared response status`);
+				return {
+					status: r.status,
+					data: schema.parse(r.data)
+				};
+			}
+			if (c.response) return c.response.parse(result);
+		}, {
+			route,
+			transport: chainCtx.transport,
+			signal: signal ?? req.signal,
+			meta,
+			ws: chainCtx.ws,
+			body: rawBody
+		});
+	}
+	/** In-process call: route by name, split the flat data, run the full chain via {@link invoke} (transport `'local'`). */
+	function callLocal(name, ...args) {
+		const e = byName.get(name);
+		if (!e) throw new Error(`unknown endpoint "${name}"`);
+		const hasInput = e.bRaw || e.b !== null || e.p.length > 0 || e.q.length > 0;
+		const data = hasInput ? args[0] : void 0;
+		const opts = hasInput ? args[1] : args[0];
+		const { p, q, b } = kindsFromData(e, data);
+		return invoke(e, new Request(`http://local/${name}`, {
+			method: e.method,
+			headers: new Headers(opts?.headers ?? {})
+		}), p, q, b, null, void 0, void 0, makeMeta(), opts?.signal, { transport: "local" });
+	}
+	function toStream(v) {
+		if (v instanceof ReadableStream) return v;
+		const iter = v;
+		const enc = new TextEncoder();
+		return new ReadableStream({ async start(controller) {
+			for await (const chunk of iter) controller.enqueue(typeof chunk === "string" ? enc.encode(chunk) : chunk);
+			controller.close();
+		} });
+	}
+	function asyncQueue() {
+		const buf = [];
+		let done = false;
+		let err;
+		let wake = null;
+		return {
+			push(v) {
+				buf.push(v);
+				wake?.();
+			},
+			end() {
+				done = true;
+				wake?.();
+			},
+			fail(e) {
+				err = e;
+				done = true;
+				wake?.();
+			},
+			async *[Symbol.asyncIterator]() {
+				for (;;) {
+					if (buf.length > 0) {
+						yield buf.shift();
+						continue;
+					}
+					if (err !== void 0) throw err;
+					if (done) return;
+					await new Promise((r) => wake = r);
+					wake = null;
+				}
+			}
+		};
+	}
+	/** NDJSON request body → typed async iterable; each item validated as the handler pulls it. */
+	async function* decodeItems(body, schema) {
+		const reader = body.getReader();
+		const dec = new TextDecoder();
+		let buf = "";
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				buf += dec.decode(value, { stream: true });
+				let nl;
+				while ((nl = buf.indexOf("\n")) >= 0) {
+					const line = buf.slice(0, nl);
+					buf = buf.slice(nl + 1);
+					if (line.trim()) yield schema.parse(JSON.parse(line));
+				}
+			}
+			buf += dec.decode();
+			if (buf.trim()) yield schema.parse(JSON.parse(buf));
+		} finally {
+			await reader.cancel().catch(() => {});
+		}
+	}
+	/** Identity transform behind `out`: encodes strings, signals the first write, can error mid-stream. */
+	function createOut() {
+		const enc = new TextEncoder();
+		let wrote = false;
+		let resolveFirst;
+		const firstWrite = new Promise((r) => resolveFirst = r);
+		let ctl;
+		const ts = new TransformStream({
+			start(c) {
+				ctl = c;
+			},
+			transform(chunk, c) {
+				if (!wrote) {
+					wrote = true;
+					resolveFirst();
+				}
+				c.enqueue(typeof chunk === "string" ? enc.encode(chunk) : chunk);
+			}
+		}, void 0, { highWaterMark: OUT_HIGH_WATER_MARK });
+		return {
+			readable: ts.readable,
+			writable: ts.writable,
+			firstWrite,
+			wrote: () => wrote,
+			fail: (err) => {
+				try {
+					ctl.error(err);
+				} catch {}
+			}
+		};
+	}
+	/** Typed item stream → NDJSON or SSE bytes; each item validated against the schema as it flows. */
+	function itemStream(v, schema, sse) {
+		const it = v[Symbol.asyncIterator]();
+		const enc = new TextEncoder();
+		return new ReadableStream({
+			async pull(controller) {
+				const { done, value } = await it.next();
+				if (done) return controller.close();
+				const json = JSON.stringify(schema.parse(value));
+				controller.enqueue(enc.encode(sse ? `data: ${json}\n\n` : json + "\n"));
+			},
+			async cancel() {
+				await it.return?.(void 0);
+			}
+		});
+	}
+	/** Byte-range slicer for resumable downloads: skip `start`, stop after `end` (inclusive). */
+	function sliceStream(src, start, end) {
+		let pos = 0;
+		const reader = src.getReader();
+		return new ReadableStream({
+			async pull(controller) {
+				for (;;) {
+					const { done, value } = await reader.read();
+					if (done) return controller.close();
+					const from = pos;
+					pos += value.byteLength;
+					if (pos <= start) continue;
+					const sliceFrom = Math.max(0, start - from);
+					const sliceTo = Math.min(value.byteLength, end + 1 - from);
+					controller.enqueue(value.subarray(sliceFrom, sliceTo));
+					if (pos > end) {
+						await reader.cancel().catch(() => {});
+						return controller.close();
+					}
+					return;
+				}
+			},
+			async cancel() {
+				await reader.cancel().catch(() => {});
+			}
+		});
+	}
+	function parseRange(header) {
+		const m = header ? /^bytes=(\d+)-(\d*)$/.exec(header) : null;
+		if (!m) return null;
+		return {
+			start: Number(m[1]),
+			end: m[2] ? Number(m[2]) : null
+		};
+	}
+	function errorResponse(err) {
+		if (err instanceof require_ws_transport.ApiFailure) return Response.json(err.data, { status: err.status });
+		if (err instanceof require_ws_transport.ApiError) return Response.json({ error: {
+			code: err.code,
+			message: err.message
+		} }, { status: err.status });
+		if (err instanceof zod.z.ZodError) return Response.json({ error: {
+			code: "VALIDATION",
+			issues: err.issues
+		} }, { status: 400 });
+		return Response.json({ error: {
+			code: "INTERNAL",
+			message: err instanceof Error ? err.message : "internal error"
+		} }, { status: 500 });
+	}
+	async function fetchHandler(req) {
+		const url = new URL(req.url);
+		if (req.method === "GET") {
+			const doc = docResponse(url.pathname);
+			if (doc) return doc;
+		}
+		const effMethod = req.method === "HEAD" ? "GET" : req.method;
+		for (const { e, parts } of routes) {
+			if (effMethod !== e.method) continue;
+			const matched = require_ws_transport.matchParts(parts, url.pathname);
+			if (!matched) continue;
+			try {
+				const rawParams = { ...matched };
+				const c = e.def.cfg;
+				let rawBody;
+				let rawFiles = null;
+				let stream;
+				if (c.streamIn) {
+					const body = req.body ?? new ReadableStream({ start: (ctl) => ctl.close() });
+					stream = e.itemsIn ? decodeItems(body, c.streamIn) : body;
+				} else if (e.f.length > 0) {
+					const parsed = await parseFiles(e, await req.formData());
+					rawFiles = parsed.files;
+					rawBody = parsed.body;
+				} else if (c.body) if (e.bodyEnc === "urlencoded") {
+					const form = new URLSearchParams(await req.text());
+					const obj = {};
+					for (const k of new Set(form.keys())) {
+						const all = form.getAll(k);
+						obj[k] = all.length === 1 ? all[0] : all;
+					}
+					rawBody = obj;
+				} else rawBody = await req.json();
+				const rawQuery = queryToObject(e, url.searchParams);
+				const meta = makeMeta();
+				if (c.streamOut && !e.items) {
+					const t = createOut();
+					const dl = {
+						filename: c.download ?? null,
+						ct: e.streamOutCt,
+						committed: false
+					};
+					const download = (filename, contentType) => {
+						if (dl.committed) throw new Error("$download must be called before streaming starts");
+						dl.filename = filename;
+						if (contentType) dl.ct = contentType;
+					};
+					const length = (totalBytes) => {
+						if (meta.committed) throw new Error("$length must be called before streaming starts");
+						meta.length = totalBytes;
+					};
+					const handlerDone = invoke(e, req, rawParams, rawQuery, rawBody, rawFiles, stream, {
+						out: t.writable,
+						download,
+						length
+					}, meta, void 0, { transport: "http" });
+					const winner = await Promise.race([t.firstWrite.then(() => ({ kind: "wrote" })), handlerDone.then((result) => ({
+						kind: "done",
+						result
+					}), (err) => ({
+						kind: "fail",
+						err
+					}))]);
+					if (winner.kind === "fail" && !t.wrote()) return errorResponse(winner.err);
+					if (winner.kind === "done" && winner.result instanceof Response) {
+						if (!t.writable.locked) t.writable.close().catch(() => {});
+						return winner.result;
+					}
+					/* v8 ignore next 3 */ if (winner.kind === "done" && winner.result != null && t.wrote()) return errorResponse(/* @__PURE__ */ new Error(`endpoint "${e.name}": handler both wrote to $out and returned a stream`));
+					dl.committed = true;
+					meta.committed = true;
+					const headers = new Headers(meta.headers);
+					headers.set("content-type", dl.ct);
+					headers.set("accept-ranges", "bytes");
+					if (dl.filename) headers.set("content-disposition", `attachment; filename="${dl.filename}"`);
+					let body;
+					if (winner.kind === "done" && winner.result != null) body = toStream(winner.result);
+					else {
+						if (winner.kind === "done" && !t.wrote() && !t.writable.locked) t.writable.close();
+						else handlerDone.then((result) => {
+							if (result != null) t.fail(/* @__PURE__ */ new Error(`endpoint "${e.name}": handler both wrote to $out and returned a stream`));
+						}, (err) => t.fail(err));
+						body = t.readable;
+					}
+					const range = e.method === "GET" ? parseRange(req.headers.get("range")) : null;
+					if (meta.length !== null) {
+						if (range) {
+							const start = range.start;
+							const end = Math.min(range.end ?? meta.length - 1, meta.length - 1);
+							if (start >= meta.length || start > end) {
+								body.cancel().catch(() => {});
+								headers.set("content-range", `bytes */${meta.length}`);
+								return new Response(null, {
+									status: 416,
+									headers
+								});
+							}
+							headers.set("content-range", `bytes ${start}-${end}/${meta.length}`);
+							headers.set("content-length", String(end - start + 1));
+							return new Response(sliceStream(body, start, end), {
+								status: 206,
+								headers
+							});
+						}
+						headers.set("content-length", String(meta.length));
+					}
+					return new Response(body, {
+						status: meta.status ?? 200,
+						headers
+					});
+				}
+				const result = await invoke(e, req, rawParams, rawQuery, rawBody, rawFiles, stream, void 0, meta, void 0, { transport: "http" });
+				if (result instanceof Response) return result;
+				meta.committed = true;
+				const headers = new Headers(meta.headers);
+				if (c.streamOut) {
+					headers.set("content-type", e.streamOutCt);
+					return new Response(itemStream(result, c.streamOut, e.sse), {
+						status: meta.status ?? 200,
+						headers
+					});
+				}
+				if (c.responses) {
+					const r = result;
+					return Response.json(r.data, {
+						status: r.status,
+						headers
+					});
+				}
+				if (c.response) return Response.json(result, {
+					status: meta.status ?? 200,
+					headers
+				});
+				return new Response(null, {
+					status: meta.status ?? 204,
+					headers
+				});
+			} catch (err) {
+				return errorResponse(err);
+			}
+		}
+		return Response.json({ error: { code: "NOT_FOUND" } }, { status: 404 });
+	}
+	function corsHeadersFor(req) {
+		const cors = options?.cors;
+		if (!cors) return null;
+		const origin = req.headers.get("origin");
+		if (!origin) return null;
+		const allowed = cors.origin === "*" ? "*" : typeof cors.origin === "string" ? cors.origin === origin ? origin : null : cors.origin.includes(origin) ? origin : null;
+		if (!allowed) return null;
+		const h = { "access-control-allow-origin": allowed };
+		if (cors.credentials) h["access-control-allow-credentials"] = "true";
+		if (allowed !== "*") h.vary = "origin";
+		if (cors.exposeHeaders?.length) h["access-control-expose-headers"] = cors.exposeHeaders.join(", ");
+		return h;
+	}
+	async function fetchEntry(req) {
+		const ch = corsHeadersFor(req);
+		if (options?.cors && req.method === "OPTIONS" && req.headers.get("access-control-request-method")) {
+			const headers = new Headers(ch ?? {});
+			headers.set("access-control-allow-methods", [...new Set(eps.map((e) => e.method))].join(", "));
+			headers.set("access-control-allow-headers", req.headers.get("access-control-request-headers") ?? "*");
+			if (options.cors.maxAge !== void 0) headers.set("access-control-max-age", String(options.cors.maxAge));
+			return new Response(null, {
+				status: 204,
+				headers
+			});
+		}
+		let res = await fetchHandler(req);
+		if (ch || req.method === "HEAD") {
+			const headers = new Headers(res.headers);
+			for (const [k, v] of Object.entries(ch ?? {})) headers.set(k, v);
+			if (req.method === "HEAD") {
+				res.body?.cancel().catch(() => {});
+				return new Response(null, {
+					status: res.status,
+					headers
+				});
+			}
+			res = new Response(res.body, {
+				status: res.status,
+				headers
+			});
+		}
+		return res;
+	}
+	let connSeq = 0;
+	const canon = (v) => JSON.stringify(v, Object.keys(v ?? {}).sort());
+	const subKey = (ws, params) => `${ws}|${canon(params ?? {})}`;
+	const broker = options?.broker ?? localBroker();
+	function deliverLocal(msg) {
+		const frame = JSON.stringify({
+			type: msg.ch,
+			params: msg.params,
+			data: msg.data
+		});
+		const conns = subscribers.get(subKey(msg.ch, msg.params));
+		if (conns) for (const c of conns) try {
+			c.send(frame);
+		} catch {}
+	}
+	broker.subscribe((raw) => {
+		try {
+			deliverLocal(JSON.parse(raw));
+		} catch {}
+	});
+	function emitImpl(name, ...args) {
+		const ev = events.find((x) => x.name === name);
+		if (!ev) throw new Error(`unknown event "${name}"`);
+		const [params, data] = ev.cfg.params ? [args[0], args[1]] : [void 0, args[0]];
+		const pOut = ev.cfg.params ? ev.cfg.params.parse(params) : {};
+		const dOut = ev.cfg.data.parse(data);
+		try {
+			const published = broker.publish(JSON.stringify({
+				ch: ev.ws,
+				params: pOut,
+				data: dOut
+			}));
+			if (published) Promise.resolve(published).catch(() => {});
+		} catch {}
+	}
+	const emit = emitImpl;
+	/** Map a middleware short-circuit Response to a ws frame: JSON body → result frame, else error frame. */
+	async function sendShortCircuit(conn, id, res) {
+		const isJson = (res.headers.get("content-type") ?? "").includes("application/json");
+		if (res.ok && isJson) {
+			const data = await res.json().catch(() => null);
+			conn.send(JSON.stringify({
+				id,
+				$status: res.status,
+				data
+			}));
+			return;
+		}
+		let data = null;
+		try {
+			data = isJson ? await res.json() : await res.text();
+		} catch {}
+		conn.send(JSON.stringify({
+			id,
+			$status: res.status,
+			$code: "SHORT_CIRCUIT",
+			$error: typeof data === "string" ? data : void 0,
+			data
+		}));
+	}
+	return {
+		spec,
+		fetch: fetchEntry,
+		manifest: getManifest,
+		emit,
+		openapi: (info) => buildOpenapi(eps, composeDoc(), info),
+		asyncapi: (info) => buildAsyncapi(eps, events, composeDoc(), info),
+		call: callLocal,
+		install: ((regSpec, regBuilders) => register(regSpec, regBuilders)),
+		uninstall: unregister,
+		ws: {
+			open(send, req) {
+				return {
+					id: ++connSeq,
+					req,
+					send,
+					subs: /* @__PURE__ */ new Set(),
+					streams: /* @__PURE__ */ new Map(),
+					calls: /* @__PURE__ */ new Map()
+				};
+			},
+			async message(conn, raw) {
+				let frame;
+				try {
+					frame = JSON.parse(raw);
+				} catch {
+					conn.send(JSON.stringify({
+						$status: 400,
+						$code: "BAD_FRAME",
+						$error: "bad frame"
+					}));
+					return;
+				}
+				const id = frame.id;
+				const fail = (err) => {
+					const out = err instanceof require_ws_transport.ApiFailure ? {
+						id,
+						$status: err.status,
+						data: err.data
+					} : err instanceof require_ws_transport.ApiError ? {
+						id,
+						$status: err.status,
+						$code: err.code,
+						$error: err.message
+					} : err instanceof zod.z.ZodError ? {
+						id,
+						$status: 400,
+						$code: "VALIDATION",
+						$error: "VALIDATION",
+						data: { issues: err.issues }
+					} : {
+						id,
+						$status: 500,
+						$code: "INTERNAL",
+						$error: err instanceof Error ? err.message : "internal error"
+					};
+					conn.send(JSON.stringify(out));
+				};
+				try {
+					if (frame.ping === true) {
+						conn.send(JSON.stringify({ pong: true }));
+						return;
+					}
+					if (typeof frame.sub === "string") {
+						const ev = eventsByWs.get(frame.sub);
+						if (!ev) throw require_ws_transport.reject(404, "NOT_FOUND", `unknown channel "${frame.sub}"`);
+						const pOut = ev.cfg.params ? ev.cfg.params.parse(frame.params) : {};
+						const guard = await runChain(ev.chain, conn.req, {}, async () => void 0, {
+							route: {
+								kind: "event",
+								name: ev.name,
+								ws: ev.ws
+							},
+							transport: "ws",
+							signal: conn.req.signal,
+							meta: void 0,
+							ws: {
+								id: String(id),
+								data: frame.params,
+								conn
+							}
+						});
+						if (guard instanceof Response) {
+							await sendShortCircuit(conn, id, guard);
+							return;
+						}
+						const key = subKey(ev.ws, pOut);
+						let set = subscribers.get(key);
+						if (!set) subscribers.set(key, set = /* @__PURE__ */ new Set());
+						set.add(conn);
+						conn.subs.add(key);
+						conn.send(JSON.stringify({
+							id,
+							$status: 200
+						}));
+					} else if (typeof frame.unsub === "string") {
+						const ev = eventsByWs.get(frame.unsub);
+						if (ev) {
+							const pOut = ev.cfg.params ? ev.cfg.params.parse(frame.params) : {};
+							const key = subKey(ev.ws, pOut);
+							subscribers.get(key)?.delete(conn);
+							conn.subs.delete(key);
+						}
+						conn.send(JSON.stringify({
+							id,
+							$status: 200
+						}));
+					} else if ("chunk" in frame) conn.streams.get(String(id))?.push(frame.chunk);
+					else if (frame.end === true) conn.streams.get(String(id))?.end();
+					else if (frame.abort === true) {
+						conn.calls.get(String(id))?.abort();
+						conn.streams.get(String(id))?.fail(new require_ws_transport.ApiError(ABORTED_STATUS, "ABORTED"));
+					} else if (typeof frame.type === "string") {
+						const e = typeof frame.method === "string" ? byRoute.get(`${frame.method} ${frame.type}`) : byWs.get(frame.type);
+						if (!e) throw require_ws_transport.reject(404, "NOT_FOUND", `unknown ws endpoint "${frame.type}"`);
+						const { p, q, b } = kindsFromData(e, frame.data);
+						const ac = new AbortController();
+						conn.calls.set(String(id), ac);
+						const wsMeta = makeMeta();
+						let stream;
+						if (e.itemsIn) {
+							const queue = asyncQueue();
+							conn.streams.set(String(id), queue);
+							const schema = e.def.cfg.streamIn;
+							stream = (async function* () {
+								for await (const raw of queue) yield schema.parse(raw);
+							})();
+						}
+						try {
+							const result = await invoke(e, conn.req, p, q, b, null, stream, void 0, wsMeta, ac.signal, {
+								transport: "ws",
+								ws: {
+									id: String(id),
+									data: frame.data,
+									conn
+								}
+							});
+							if (result instanceof Response) await sendShortCircuit(conn, id, result);
+							else if (e.items) {
+								const schema = e.def.cfg.streamOut;
+								for await (const item of result) {
+									if (ac.signal.aborted) break;
+									conn.send(JSON.stringify({
+										id,
+										chunk: schema.parse(item)
+									}));
+								}
+								if (!ac.signal.aborted) conn.send(JSON.stringify({
+									id,
+									end: true
+								}));
+							} else if (e.multi) {
+								const r = result;
+								if (!ac.signal.aborted) conn.send(JSON.stringify({
+									id,
+									$status: r.status,
+									data: {
+										status: r.status,
+										data: r.data
+									}
+								}));
+							} else if (!ac.signal.aborted) conn.send(JSON.stringify({
+								id,
+								$status: wsMeta.status ?? 200,
+								data: result
+							}));
+						} finally {
+							conn.streams.delete(String(id));
+							conn.calls.delete(String(id));
+						}
+					} else throw require_ws_transport.reject(400, "BAD_FRAME", "unrecognized frame");
+				} catch (err) {
+					fail(err);
+				}
+			},
+			close(conn) {
+				for (const key of conn.subs) subscribers.get(key)?.delete(conn);
+				conn.subs.clear();
+				for (const ac of conn.calls.values()) ac.abort();
+				conn.calls.clear();
+				for (const s of conn.streams.values()) s.fail(new require_ws_transport.ApiError(ABORTED_STATUS, "ABORTED"));
+				conn.streams.clear();
+			}
+		}
+	};
+}
+//#endregion
+exports.ApiError = require_ws_transport.ApiError;
+exports.CallerRateLimited = require_ws_transport.CallerRateLimited;
+exports.DEFAULT_BUCKETS = require_stats.DEFAULT_BUCKETS;
+exports.DEFAULT_RETRY_OPTIONS = require_retry.DEFAULT_RETRY_OPTIONS;
+exports.RetryAbort = require_retry.RetryAbort;
+exports.asyncapiHtml = asyncapiHtml;
+exports.backoff = require_retry.backoff;
+exports.buildParts = require_ws_transport.buildParts;
+exports.client = require_ws_transport.client;
+exports.createCallerContext = require_ws_transport.createCallerContext;
+exports.createClientCache = require_ws_transport.createClientCache;
+exports.createMetrics = require_stats.createMetrics;
+exports.ctx = ctx;
+exports.endpoint = endpoint;
+exports.formatPrometheus = require_stats.formatPrometheus;
+exports.getDefaultRetryOptions = require_retry.getDefaultRetryOptions;
+exports.implement = implement;
+exports.joinPattern = require_ws_transport.joinPattern;
+exports.localBroker = localBroker;
+exports.localClient = localClient;
+exports.manifestFromSpec = manifestFromSpec;
+exports.matchParts = require_ws_transport.matchParts;
+exports.middleware = middleware;
+exports.path = require_ws_transport.path;
+exports.provide = provide;
+exports.redocHtml = redocHtml;
+exports.reject = require_ws_transport.reject;
+exports.retry = require_retry.retry;
+exports.server = server;
+exports.setDefaultRetryOptions = require_retry.setDefaultRetryOptions;
+exports.spec = spec;
+exports.splitPattern = require_ws_transport.splitPattern;
+exports.stableStringify = require_ws_transport.stableStringify;
+exports.swaggerHtml = swaggerHtml;
+exports.use = use;
+exports.wsTransport = require_ws_transport.wsTransport;