elysia 2.0.0-beta.25 → 2.0.0-beta.27

package/dist/adapter/bun/index.js

@@ -52,15 +52,6 @@ async function settleServerWebSockets(lifecycle, errors) {
 	} while (lifecycle.sockets.size);
 	return true;
 }
-/**
-* ! This may looks like it would cause race condition, but it is not
-* Bun is single-threaded and synchronous, so the `finally` block will
-* always run before the next request comes in
-* @see ../origin.ts
-*
-* `finally` runs on the synchronous return of `fetch` (the returned promise is
-* not awaited), so the slot is live only for the handler's synchronous prologue
-*/
 const withOrigin = (fetch) => (request, server) => {
 	require_adapter_origin.origin.request = request;
 	try {
@@ -92,20 +83,13 @@ function isNativePath(path) {
 	}
 	return true;
 }
-/**
-* HTML bundles served by Bun's native router.
-*
-* A `:param` / `*` bundle matches before `fetch`, so with a `handoff` every
-* other route of that method is registered natively too, pointing at `fetch`;
-* Bun's specificity (exact > param > wildcard) then picks the Elysia route over
-* the bundle (Elysia's own router skips these bundles, see `#buildRouterUnsafe`).
-* If any route can't be expressed in Bun's router, dynamic bundles are skipped
-* entirely, since the bundle would shadow that route.
-*/
 function collectHTMLBundleRoutes(app, handoff, routes) {
 	let dynamic;
 	let bundles;
-	for (const route of app["~routes"]) {
+	const table = app["~generation"]?.routeTable;
+	if (table && !table.handler.some((h, i) => isNativeStaticMethod(table.method[i]) && require_utils.isHTMLBundle(h))) return routes;
+	const declared = table ? table.method.map((_, i) => require_route_table.routeRow(table, i)) : app["~routes"];
+	for (const route of declared) {
 		const [method, path, handler] = route;
 		if (!isNativeStaticMethod(method) || !require_utils.isHTMLBundle(handler)) continue;
 		if (path.indexOf(":") !== -1 || path.indexOf("*") !== -1) {
@@ -122,7 +106,7 @@ function collectHTMLBundleRoutes(app, handoff, routes) {
 	if (!dynamic) return routes;
 	const strictPath = app["~config"]?.strictPath === true;
 	const handoffs = [];
-	for (const [method, path, handler] of app["~routes"]) {
+	for (const [method, path, handler] of declared) {
 		if (require_utils.isHTMLBundle(handler)) continue;
 		const targets = method === "*" ? dynamic : dynamic.has(method) ? [method] : void 0;
 		if (!targets) continue;

package/dist/adapter/bun/index.mjs

@@ -52,15 +52,6 @@ async function settleServerWebSockets(lifecycle, errors) {
 	} while (lifecycle.sockets.size);
 	return true;
 }
-/**
-* ! This may looks like it would cause race condition, but it is not
-* Bun is single-threaded and synchronous, so the `finally` block will
-* always run before the next request comes in
-* @see ../origin.ts
-*
-* `finally` runs on the synchronous return of `fetch` (the returned promise is
-* not awaited), so the slot is live only for the handler's synchronous prologue
-*/
 const withOrigin = (fetch) => (request, server) => {
 	origin.request = request;
 	try {
@@ -92,20 +83,13 @@ function isNativePath(path) {
 	}
 	return true;
 }
-/**
-* HTML bundles served by Bun's native router.
-*
-* A `:param` / `*` bundle matches before `fetch`, so with a `handoff` every
-* other route of that method is registered natively too, pointing at `fetch`;
-* Bun's specificity (exact > param > wildcard) then picks the Elysia route over
-* the bundle (Elysia's own router skips these bundles, see `#buildRouterUnsafe`).
-* If any route can't be expressed in Bun's router, dynamic bundles are skipped
-* entirely, since the bundle would shadow that route.
-*/
 function collectHTMLBundleRoutes(app, handoff, routes) {
 	let dynamic;
 	let bundles;
-	for (const route of app["~routes"]) {
+	const table = app["~generation"]?.routeTable;
+	if (table && !table.handler.some((h, i) => isNativeStaticMethod(table.method[i]) && isHTMLBundle(h))) return routes;
+	const declared = table ? table.method.map((_, i) => routeRow(table, i)) : app["~routes"];
+	for (const route of declared) {
 		const [method, path, handler] = route;
 		if (!isNativeStaticMethod(method) || !isHTMLBundle(handler)) continue;
 		if (path.indexOf(":") !== -1 || path.indexOf("*") !== -1) {
@@ -122,7 +106,7 @@ function collectHTMLBundleRoutes(app, handoff, routes) {
 	if (!dynamic) return routes;
 	const strictPath = app["~config"]?.strictPath === true;
 	const handoffs = [];
-	for (const [method, path, handler] of app["~routes"]) {
+	for (const [method, path, handler] of declared) {
 		if (isHTMLBundle(handler)) continue;
 		const targets = method === "*" ? dynamic : dynamic.has(method) ? [method] : void 0;
 		if (!targets) continue;

package/dist/adapter/origin.js

@@ -1,63 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/adapter/origin.ts
-/**
-* Provenance channel for deferred abort-signal arming.
-*
-* Bun materializes `Request.signal` lazily (~214ns on the first read), so
-* Elysia only pays for it once the pipeline can actually observe an abort,
-* that is, after it suspends. Deferring that read is only sound for the exact
-* `Request` instance `Bun.serve` handed to `fetch`: any other request
-* (`app.handle`, a non-Bun adapter, or a `.wrap()` HOC that substitutes the
-* request) may carry a user-controlled signal that is already aborted at entry
-* and therefore must be observed synchronously.
-*
-* The Bun adapter publishes the untouched original here for the *synchronous*
-* prologue of `app.fetch` and, on the lane where `fetch` has no request hook
-* to run, for the compiled route's own entry probe, which is still inside that
-* same synchronous frame, then clears it in `finally`, so the window closes
-* before the first suspension and cannot leak across concurrent requests.
-* A `.wrap()` HOC that replaces the request or defers calling `next()` past a
-* microtask simply misses the window, fetch handler falls back to eager check
-*
-* ## "A single shared slot that every request writes to, so a race condition?"
-*
-* It looks like one, but it can't be. Explained like you're five:
-*
-* JavaScript only ever does ONE thing at a time. When a request comes in, the
-* adapter writes its name on the whiteboard (`origin.request = request`),
-* walks it down the hall (`fetch(request)` the synchronous part, where the
-* one and only identity check happens, in `fetch`'s prologue, or at the
-* compiled route's entry when `fetch` had no hook to run first), and erases
-* the whiteboard `finally`
-* all in one uninterruptible turn. The next request's turn CANNOT start
-* until this turn is completely finished, because that is how the event loop
-* works: run-to-completion, no preemption. So request B can never see request
-* A's name on the board, by the time B's turn starts, the board was already
-* erased at the end of A's turn.
-*
-* "But the handler is async!" the `await`s inside it run LATER, in separate
-* turns. That is fine, because the check already happened: the verdict was
-* copied onto that request's own context (`'~sig'`) during the synchronous
-* part, and the code that runs after an `await` only ever reads the context,
-* never this slot.
-*
-* And if any assumption here ever breaks, a runtime that re-enters, a wrap
-* that delays, a future edit that sneaks an `await` in before the check the
-* comparison simply MISSES and the request falls back to eager arming, which
-* is the exact pre-optimization behavior. Every failure mode makes a request
-* slightly slower, never incorrect
-*
-* Adversarial proof, not just argument: `test/core/abort-race.test.ts` storms
-* concurrent servers, in-process `handle()` calls, request-substituting and
-* `next()`-delaying wraps at this slot and asserts zero misclassification.
-*
-* Never infer the Bun runtime from `fetch`'s second argument: Cloudflare
-* Workers pass `env` there.
-*
-* It's insanely stupid, but it works. As Bun is single-threaded and synchronous
-* so the `finally` block will always run before the next request comes in.
-*/
 const origin = { request: void 0 };
 
 //#endregion

package/dist/adapter/origin.mjs

@@ -1,62 +1,5 @@
 // @bun
 //#region src/adapter/origin.ts
-/**
-* Provenance channel for deferred abort-signal arming.
-*
-* Bun materializes `Request.signal` lazily (~214ns on the first read), so
-* Elysia only pays for it once the pipeline can actually observe an abort,
-* that is, after it suspends. Deferring that read is only sound for the exact
-* `Request` instance `Bun.serve` handed to `fetch`: any other request
-* (`app.handle`, a non-Bun adapter, or a `.wrap()` HOC that substitutes the
-* request) may carry a user-controlled signal that is already aborted at entry
-* and therefore must be observed synchronously.
-*
-* The Bun adapter publishes the untouched original here for the *synchronous*
-* prologue of `app.fetch` and, on the lane where `fetch` has no request hook
-* to run, for the compiled route's own entry probe, which is still inside that
-* same synchronous frame, then clears it in `finally`, so the window closes
-* before the first suspension and cannot leak across concurrent requests.
-* A `.wrap()` HOC that replaces the request or defers calling `next()` past a
-* microtask simply misses the window, fetch handler falls back to eager check
-*
-* ## "A single shared slot that every request writes to, so a race condition?"
-*
-* It looks like one, but it can't be. Explained like you're five:
-*
-* JavaScript only ever does ONE thing at a time. When a request comes in, the
-* adapter writes its name on the whiteboard (`origin.request = request`),
-* walks it down the hall (`fetch(request)` the synchronous part, where the
-* one and only identity check happens, in `fetch`'s prologue, or at the
-* compiled route's entry when `fetch` had no hook to run first), and erases
-* the whiteboard `finally`
-* all in one uninterruptible turn. The next request's turn CANNOT start
-* until this turn is completely finished, because that is how the event loop
-* works: run-to-completion, no preemption. So request B can never see request
-* A's name on the board, by the time B's turn starts, the board was already
-* erased at the end of A's turn.
-*
-* "But the handler is async!" the `await`s inside it run LATER, in separate
-* turns. That is fine, because the check already happened: the verdict was
-* copied onto that request's own context (`'~sig'`) during the synchronous
-* part, and the code that runs after an `await` only ever reads the context,
-* never this slot.
-*
-* And if any assumption here ever breaks, a runtime that re-enters, a wrap
-* that delays, a future edit that sneaks an `await` in before the check the
-* comparison simply MISSES and the request falls back to eager arming, which
-* is the exact pre-optimization behavior. Every failure mode makes a request
-* slightly slower, never incorrect
-*
-* Adversarial proof, not just argument: `test/core/abort-race.test.ts` storms
-* concurrent servers, in-process `handle()` calls, request-substituting and
-* `next()`-delaying wraps at this slot and asserts zero misclassification.
-*
-* Never infer the Bun runtime from `fetch`'s second argument: Cloudflare
-* Workers pass `env` there.
-*
-* It's insanely stupid, but it works. As Bun is single-threaded and synchronous
-* so the `finally` block will always run before the next request comes in.
-*/
 const origin = { request: void 0 };
 
 //#endregion

package/dist/adapter/utils.js

@@ -132,7 +132,7 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 		const typedSSE = !skipFormat && "sse" in generator && generator.sse === true;
 		const sourceIterator = typeof generator.next === "function" ? generator : void 0;
 		let init = typedSSE ? void 0 : generator.next?.();
-		if (init instanceof Promise) init = await init;
+		if (init instanceof Promise || typeof init?.then === "function") init = await init;
 		const sign = set?.["~sign"];
 		if (sign) try {
 			await sign(set);
@@ -430,12 +430,6 @@ const doneResult = {
 	done: true,
 	value: void 0
 };
-/**
-* Tee a returned `ReadableStream` so afterResponse, `defer()` and derive
-* dispose wait for it, as for a tee'd generator. A `bytes()` stream is left
-* alone (exact-stream contract), and so is a `Response`: reading its `.body`
-* would move it off Bun's native send path
-*/
 function observeStream(source) {
 	if (source.locked || require_utils.isByteStream(source)) return;
 	const reader = source.getReader();
@@ -467,24 +461,6 @@ function observeStream(source) {
 		value
 	];
 }
-/**
-* Split async source into `branches` independent iterators
-*
-* A producer drains the source ahead of consumers
-*
-* To prevent long/infinite stream, the unconsumed window is capped:
-* Consumed-by-every-branch entries are trimmed off the front
-* Producer backpressures whenever the window hits `cap` ENTRIES or
-* `capBytes` bytes, whichever comes first
-*
-* Streams below both caps buffer eagerly
-* Only streams exceeding one gate on the slowest consumer
-*
-* Branch 0 is the value consumer (response/client)
-* When `return()` (client abort / early exit), source is stopped
-* so the observer branches can still reach completion instead of spinning
-* an infinite source
-*/
 function tee(source, branches = 2, cap = 64, capBytes = 1 << 22) {
 	const iterator = source[Symbol.asyncIterator]?.() ?? source[Symbol.iterator]();
 	const buffer = [];

package/dist/adapter/utils.mjs

@@ -132,7 +132,7 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 		const typedSSE = !skipFormat && "sse" in generator && generator.sse === true;
 		const sourceIterator = typeof generator.next === "function" ? generator : void 0;
 		let init = typedSSE ? void 0 : generator.next?.();
-		if (init instanceof Promise) init = await init;
+		if (init instanceof Promise || typeof init?.then === "function") init = await init;
 		const sign = set?.["~sign"];
 		if (sign) try {
 			await sign(set);
@@ -430,12 +430,6 @@ const doneResult = {
 	done: true,
 	value: void 0
 };
-/**
-* Tee a returned `ReadableStream` so afterResponse, `defer()` and derive
-* dispose wait for it, as for a tee'd generator. A `bytes()` stream is left
-* alone (exact-stream contract), and so is a `Response`: reading its `.body`
-* would move it off Bun's native send path
-*/
 function observeStream(source) {
 	if (source.locked || isByteStream(source)) return;
 	const reader = source.getReader();
@@ -467,24 +461,6 @@ function observeStream(source) {
 		value
 	];
 }
-/**
-* Split async source into `branches` independent iterators
-*
-* A producer drains the source ahead of consumers
-*
-* To prevent long/infinite stream, the unconsumed window is capped:
-* Consumed-by-every-branch entries are trimmed off the front
-* Producer backpressures whenever the window hits `cap` ENTRIES or
-* `capBytes` bytes, whichever comes first
-*
-* Streams below both caps buffer eagerly
-* Only streams exceeding one gate on the slowest consumer
-*
-* Branch 0 is the value consumer (response/client)
-* When `return()` (client abort / early exit), source is stopped
-* so the observer branches can still reach completion instead of spinning
-* an infinite source
-*/
 function tee(source, branches = 2, cap = 64, capBytes = 1 << 22) {
 	const iterator = source[Symbol.asyncIterator]?.() ?? source[Symbol.iterator]();
 	const buffer = [];

package/dist/adapter/web-standard/handler.js

@@ -86,7 +86,9 @@ function mapCompactResponse(response, request, owned) {
 		case "String": return new Response(response, textHeaders);
 		case "Array": return Response.json(response);
 		case "ElysiaForm": return new Response(require_utils.formToFormData(response));
-		case "Object": return Response.json(response);
+		case "Object":
+			if (typeof response?.next === "function") return handleStream(response, void 0, request, void 0, owned);
+			return Response.json(response);
 		case "Number":
 		case "Boolean": return new Response(String(response));
 		case "ElysiaFile": return handleElysiaFile(response, void 0, request);

package/dist/adapter/web-standard/handler.mjs

@@ -86,7 +86,9 @@ function mapCompactResponse(response, request, owned) {
 		case "String": return new Response(response, textHeaders);
 		case "Array": return Response.json(response);
 		case "ElysiaForm": return new Response(formToFormData(response));
-		case "Object": return Response.json(response);
+		case "Object":
+			if (typeof response?.next === "function") return handleStream(response, void 0, request, void 0, owned);
+			return Response.json(response);
 		case "Number":
 		case "Boolean": return new Response(String(response));
 		case "ElysiaFile": return handleElysiaFile(response, void 0, request);

package/dist/base.d.ts

@@ -84,8 +84,11 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   '~router'?: Memoirist<CompiledHandler | number>;
   '~map'?: {
     [method: string]: {
-      [path: string]: CompiledHandler;
+      [path: string]: CompiledHandler | number;
     } | undefined;
+    WS?: {
+      [path: string]: CompiledHandler;
+    };
   };
   '~routeTable'?: RouteTable;
   '~hasWS'?: boolean;
@@ -102,8 +105,9 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   constructor(config?: ElysiaConfig<BasePath, Scope>);
   /**
    * Every registered route with its merged hooks.
-   * Development shares a frozen cache. Production rebuilds the list so its
-   * metadata can be released after startup.
+   * Development shares a frozen cache.
+   * Production rebuilds the list on every read
+   * so its metadata can be released after startup.
    */
   get routes(): PublicRoute[];
   /**