elysia 1.4.28 → 2.0.0-beta.0

package/dist/adapter/origin.d.ts

@@ -0,0 +1,63 @@
+//#region src/adapter/origin.d.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.
+ */
+declare const origin: {
+  request: Request | undefined;
+};
+//#endregion
+export { origin };

package/dist/adapter/origin.js

@@ -0,0 +1,64 @@
+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
+exports.origin = origin;

package/dist/adapter/origin.mjs

@@ -0,0 +1,62 @@
+//#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
+export { origin };

package/dist/adapter/response-ownership.d.ts

@@ -0,0 +1,5 @@
+//#region src/adapter/response-ownership.d.ts
+declare function borrow<const T extends Response>(response: T): T;
+declare const isBorrowedResponse: (response: Response) => boolean;
+//#endregion
+export { borrow, isBorrowedResponse };

package/dist/adapter/response-ownership.js

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/adapter/response-ownership.ts
+const borrowedResponses = /* @__PURE__ */ new WeakSet();
+function borrow(response) {
+	borrowedResponses.add(response);
+	return response;
+}
+const isBorrowedResponse = (response) => borrowedResponses.has(response);
+
+//#endregion
+exports.borrow = borrow;
+exports.isBorrowedResponse = isBorrowedResponse;

package/dist/adapter/response-ownership.mjs

@@ -0,0 +1,10 @@
+//#region src/adapter/response-ownership.ts
+const borrowedResponses = /* @__PURE__ */ new WeakSet();
+function borrow(response) {
+	borrowedResponses.add(response);
+	return response;
+}
+const isBorrowedResponse = (response) => borrowedResponses.has(response);
+
+//#endregion
+export { borrow, isBorrowedResponse };

package/dist/adapter/skip-clone.d.ts

@@ -0,0 +1,4 @@
+//#region src/adapter/skip-clone.d.ts
+declare const skipClone: WeakSet<object>;
+//#endregion
+export { skipClone };

package/dist/adapter/skip-clone.js

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/adapter/skip-clone.ts
+const skipClone = /* @__PURE__ */ new WeakSet();
+
+//#endregion
+exports.skipClone = skipClone;

package/dist/adapter/skip-clone.mjs

@@ -0,0 +1,5 @@
+//#region src/adapter/skip-clone.ts
+const skipClone = /* @__PURE__ */ new WeakSet();
+
+//#endregion
+export { skipClone };

package/dist/adapter/types.d.ts

@@ -1,130 +1,55 @@
-import type { Serve, ListenCallback } from '../universal/server';
-import type { AnyElysia } from '..';
-import type { Context } from '../context';
-import type { Sucrose } from '../sucrose';
-import type { Prettify, AnyLocalHook, MaybePromise } from '../types';
-import type { AnyWSLocalHook } from '../ws/types';
-export interface ElysiaAdapter {
-    name: string;
-    listen(app: AnyElysia): (options: string | number | Partial<Serve>, callback?: ListenCallback) => void;
+import { ListenCallback, Serve } from "../universal/server.js";
+import { MaybePromise } from "../types.js";
+import { Context } from "../context.js";
+import { AnyElysia } from "../base.js";
+
+//#region src/adapter/types.d.ts
+/**
+ * Elysia adapter 2
+ *
+ * @since 2.0.0
+ */
+interface ElysiaAdapterOptions<App extends AnyElysia | void = void> {
+  /**
+   * Name of the adapter, preferably runtime
+   */
+  name: string;
+  /**
+   *
+   * @param app
+   */
+  runtime: 'node' | 'deno' | 'bun' | 'cloudflare-worker' | 'browser' | 'vercel' | 'netlify' | 'lambda' | 'fastly' | 'edge' | 'unknown' | (string & {});
+  /**
+   * Whether this adapter is web standard
+   */
+  isWebStandard: boolean;
+  /**
+   * Whether this adapter supports WebSocket.
+   *
+   * `.ws()` throws on non-Bun runtimes unless this is set.
+   */
+  websocket?: boolean;
+  listen?(app: AnyElysia, options: string | number | Partial<Serve>, callback?: ListenCallback): void;
+  parse: {
+    json: (context: Context) => MaybePromise<Record<keyof any, undefined> | unknown[]>;
+    text: (context: Context) => MaybePromise<string>;
+    urlencoded: (context: Context) => MaybePromise<Record<string, string | string[]>>;
+    arrayBuffer: (context: Context) => MaybePromise<ArrayBuffer>;
+    formData: (context: Context) => MaybePromise<Record<string, unknown>>;
+    default: (context: Context, contentType: string, normalized?: boolean) => MaybePromise<any>;
+  };
+  response: {
     /**
-     * Stop server from serving
-     *
-     * ---
-     * @example
-     * ```typescript
-     * app.stop()
-     * ```
-     *
-     * @example
-     * ```typescript
-     * app.stop(true) // Abruptly any requests inflight
-     * ```
+     * Map return response on every case
      */
-    stop?(app: AnyElysia, closeActiveConnections?: boolean): Promise<void>;
-    isWebStandard?: boolean;
-    handler: {
-        /**
-         * Map return response on every case
-         */
-        mapResponse(response: unknown, set: Context['set'], ...params: unknown[]): unknown;
-        /**
-         * Map response on truthy value
-         */
-        mapEarlyResponse(response: unknown, set: Context['set'], ...params: unknown[]): unknown;
-        /**
-         * Map response without cookie, status or headers
-         */
-        mapCompactResponse(response: unknown, ...params: unknown[]): unknown;
-        /**
-         * Compile inline to value
-         *
-         * @example
-         * ```ts
-         * Elysia().get('/', 'static')
-         * ```
-         */
-        createStaticHandler?(handle: unknown, hooks: AnyLocalHook, setHeaders?: Context['set']['headers'], ...params: unknown[]): (() => unknown) | undefined;
-        /**
-         * If the runtime support cloning response
-         *
-         * eg. Bun.serve({ static })
-         */
-        createNativeStaticHandler?(handle: unknown, hooks: AnyLocalHook, set?: Context['set']): (() => MaybePromise<Response>) | undefined;
-    };
-    composeHandler: {
-        mapResponseContext?: string;
-        /**
-         * Declare any variable that will be used in the general handler
-         */
-        declare?(inference: Sucrose.Inference): string | undefined;
-        /**
-         * Inject variable to the general handler
-         */
-        inject?: Record<string, unknown>;
-        /**
-         * Whether retriving headers should be using webstandard headers
-         *
-         * @default false
-         */
-        preferWebstandardHeaders?: boolean;
-        /**
-         * fnLiteral for parsing request headers
-         *
-         * @declaration
-         * c.headers: Context headers
-         */
-        headers: string;
-        /**
-         * fnLiteral for parsing the request body
-         *
-         * @declaration
-         * c.body: Context body
-         */
-        parser: Prettify<Record<'json' | 'text' | 'urlencoded' | 'arrayBuffer' | 'formData', (isOptional: boolean) => string> & {
-            declare?: string;
-        }>;
-    };
-    composeGeneralHandler: {
-        parameters?: string;
-        error404(hasEventHook: boolean, hasErrorHook: boolean, afterResponseHandler?: string): {
-            declare: string;
-            code: string;
-        };
-        /**
-         * fnLiteral of the general handler
-         *
-         * @declaration
-         * c: Context
-         * p: pathname
-         */
-        createContext(app: AnyElysia): string;
-        /**
-         * Inject variable to the general handler
-         */
-        inject?: Record<string, unknown>;
-    };
-    composeError: {
-        declare?: string;
-        inject?: Record<string, unknown>;
-        mapResponseContext: string;
-        validationError: string;
-        /**
-         * Handle thrown error which is instance of Error
-         *
-         * Despite its name of `unknownError`, it also handle named error like `NOT_FOUND`, `VALIDATION_ERROR`
-         * It's named `unknownError` because it also catch unknown error
-         */
-        unknownError: string;
-    };
-    ws?(app: AnyElysia, path: string, handler: AnyWSLocalHook): unknown;
+    map(response: unknown, set: Context['set'], ...params: unknown[]): unknown; /** Support immutable shared default headers. */
+    supportsDefaultHeaderSink?: true;
     /**
-     * Whether or not the runtime or framework the is built on top on has a router
-     * eg. Bun.serve.routes, uWebSocket
-     **/
-    createSystemRouterHandler?(method: string, path: string, hook: AnyLocalHook, app: AnyElysia): void;
-    /**
-     * Call thing before compile
+     * Map response without cookie, status or headers
      */
-    beforeCompile?(app: AnyElysia): void;
+    compact?(response: unknown, ...params: unknown[]): unknown;
+  };
+  setup?(app: AnyElysia): App;
 }
+//#endregion
+export { ElysiaAdapterOptions };

package/dist/adapter/types.js

@@ -1,14 +1 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from == "object" || typeof from == "function")
-    for (let key of __getOwnPropNames(from))
-      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

package/dist/adapter/types.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/adapter/utils.d.ts

@@ -1,22 +1,50 @@
-import { StatusMap } from '../utils';
-import type { Context } from '../context';
-export declare const handleFile: (response: File | Blob, set?: Context["set"], request?: Request) => Response;
-export declare const parseSetCookies: (headers: Headers, setCookie: string[]) => Headers;
-export declare const responseToSetHeaders: (response: Response, set?: Context["set"]) => {
-    headers: import("../types").HTTPHeaders;
-    status?: number | keyof StatusMap;
-    redirect?: string;
-    cookie?: Record<string, import("../cookies").ElysiaCookie>;
+import { BaseCookie } from "../cookie/types.js";
+import { StatusMap } from "../constants.js";
+import { ElysiaFile } from "../universal/file.js";
+import { HTTPHeaders } from "../types.js";
+import { Context } from "../context.js";
+//#region src/adapter/utils.d.ts
+declare function materializeSetHeaders(set: Context['set']): any;
+declare function normalizeContentType(contentType: string): string;
+declare function handleFile(response: File | Blob | ElysiaFile, set?: Context['set'], request?: Request, size?: number): Response;
+declare function parseSetCookies(headers: Headers, setCookie: string[]): Headers;
+declare function responseToSetHeaders(response: Response, set?: Context['set']): {
+  headers: HTTPHeaders;
+  status?: number | keyof StatusMap;
+  cookie?: Record<string, BaseCookie>;
+} | {
+  headers: any;
+  status: number | "Continue" | "Switching Protocols" | "Processing" | "Early Hints" | "OK" | "Created" | "Accepted" | "Non-Authoritative Information" | "No Content" | "Reset Content" | "Partial Content" | "Multi-Status" | "Already Reported" | "Multiple Choices" | "Moved Permanently" | "Found" | "See Other" | "Not Modified" | "Temporary Redirect" | "Permanent Redirect" | "Bad Request" | "Unauthorized" | "Payment Required" | "Forbidden" | "Not Found" | "Method Not Allowed" | "Not Acceptable" | "Proxy Authentication Required" | "Request Timeout" | "Conflict" | "Gone" | "Length Required" | "Precondition Failed" | "Payload Too Large" | "URI Too Long" | "Unsupported Media Type" | "Range Not Satisfiable" | "Expectation Failed" | "I'm a teapot" | "Enhance Your Calm" | "Misdirected Request" | "Unprocessable Content" | "Locked" | "Failed Dependency" | "Too Early" | "Upgrade Required" | "Precondition Required" | "Too Many Requests" | "Request Header Fields Too Large" | "Unavailable For Legal Reasons" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "HTTP Version Not Supported" | "Variant Also Negotiates" | "Insufficient Storage" | "Loop Detected" | "Not Extended" | "Network Authentication Required";
 };
 interface CreateHandlerParameter {
-    mapResponse(response: unknown, set: Context['set'], request?: Request): Response;
-    mapCompactResponse(response: unknown, request?: Request): Response;
+  mapResponse(response: unknown, set: Context['set'], request?: Request, owned?: boolean): Response;
+  mapCompactResponse(response: unknown, request?: Request, owned?: boolean): Response;
 }
-export declare const createStreamHandler: ({ mapResponse, mapCompactResponse }: CreateHandlerParameter) => (generator: Generator | AsyncGenerator | ReadableStream, set?: Context["set"], request?: Request, skipFormat?: boolean) => Promise<Response>;
-export declare function streamResponse(response: Response): AsyncGenerator<string, void, unknown>;
-export declare const handleSet: (set: Context["set"]) => void;
-export declare function mergeHeaders(responseHeaders: Headers, setHeaders: Context['set']['headers']): Headers;
-export declare function mergeStatus(responseStatus: number, setStatus: Context['set']['status']): number | undefined;
-export declare const createResponseHandler: (handler: CreateHandlerParameter) => (response: Response, set: Context["set"], request?: Request) => any;
-export declare function tee<T>(source: AsyncIterable<T>, branches?: number): Promise<AsyncIterableIterator<T>[]>;
-export {};
+declare function createStreamHandler({
+  mapResponse,
+  mapCompactResponse
+}: CreateHandlerParameter): (generator: Generator | AsyncGenerator | ReadableStream, set?: Context["set"], request?: Request, skipFormat?: boolean, owned?: boolean) => Promise<Response>;
+declare function streamResponse(response: Response): AsyncGenerator<any, void, any>;
+declare function handleSet(set: Context['set']): void;
+declare function createResponseHandler(handler: CreateHandlerParameter): (response: Response, set?: Context["set"], request?: Request, owned?: boolean) => any;
+/**
+ * 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
+ */
+declare function tee<T>(source: AsyncIterable<T>, branches?: number, cap?: number, capBytes?: number): AsyncIterableIterator<T>[];
+//#endregion
+export { createResponseHandler, createStreamHandler, handleFile, handleSet, materializeSetHeaders, normalizeContentType, parseSetCookies, responseToSetHeaders, streamResponse, tee };