elysia 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/universal/constants.d.ts

@@ -1,6 +1,7 @@
 //#region src/universal/constants.d.ts
 declare const isBun: boolean;
+declare const isFastly: boolean;
 declare const isCloudflareWorker: boolean;
 declare const hasHeaderShorthand: boolean;
 //#endregion
-export { hasHeaderShorthand, isBun, isCloudflareWorker };
+export { hasHeaderShorthand, isBun, isCloudflareWorker, isFastly };

package/dist/universal/constants.js

@@ -2,6 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/universal/constants.ts
 const isBun = typeof Bun !== "undefined";
+const isFastly = typeof fastly !== "undefined";
 const isCloudflareWorker = (() => {
 	try {
 		if (typeof caches !== "undefined" && typeof caches.default !== "undefined") return true;
@@ -16,4 +17,5 @@ const hasHeaderShorthand = isBun ? "toJSON" in new Headers() : false;
 //#endregion
 exports.hasHeaderShorthand = hasHeaderShorthand;
 exports.isBun = isBun;
-exports.isCloudflareWorker = isCloudflareWorker;
+exports.isCloudflareWorker = isCloudflareWorker;
+exports.isFastly = isFastly;

package/dist/universal/constants.mjs

@@ -1,5 +1,6 @@
 //#region src/universal/constants.ts
 const isBun = typeof Bun !== "undefined";
+const isFastly = typeof fastly !== "undefined";
 const isCloudflareWorker = (() => {
 	try {
 		if (typeof caches !== "undefined" && typeof caches.default !== "undefined") return true;
@@ -12,4 +13,4 @@ const isCloudflareWorker = (() => {
 const hasHeaderShorthand = isBun ? "toJSON" in new Headers() : false;
 
 //#endregion
-export { hasHeaderShorthand, isBun, isCloudflareWorker };
+export { hasHeaderShorthand, isBun, isCloudflareWorker, isFastly };

package/dist/universal/env.js

@@ -1,11 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_universal_constants = require('./constants.js');
 const require_utils = require('../utils.js');
 
 //#region src/universal/env.ts
 const nodeEnv = typeof process !== "undefined" && process?.env ? process.env : void 0;
-const env = require_universal_constants.isBun ? Bun.env : nodeEnv ?? require_utils.nullObject();
-const hasReadableEnv = require_universal_constants.isBun || nodeEnv !== void 0;
+const env = nodeEnv ?? require_utils.nullObject();
+const hasReadableEnv = nodeEnv !== void 0;
 
 //#endregion
 exports.env = env;

package/dist/universal/env.mjs

@@ -1,10 +1,9 @@
-import { isBun } from "./constants.mjs";
 import { nullObject } from "../utils.mjs";
 
 //#region src/universal/env.ts
 const nodeEnv = typeof process !== "undefined" && process?.env ? process.env : void 0;
-const env = isBun ? Bun.env : nodeEnv ?? nullObject();
-const hasReadableEnv = isBun || nodeEnv !== void 0;
+const env = nodeEnv ?? nullObject();
+const hasReadableEnv = nodeEnv !== void 0;
 
 //#endregion
 export { env, hasReadableEnv };

package/dist/universal/file.d.ts

@@ -37,8 +37,6 @@ declare const mime: {
   readonly ppt: "application/vnd.ms-powerpoint";
   readonly pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation";
 };
-/** @internal exported for test/universal/file-extension.test.ts */
-declare function getFileExtension(path: string): string;
 /**
  * Serve a file from a path as the response.
  */
@@ -47,11 +45,15 @@ declare class ElysiaFile {
   #private;
   path: string;
   constructor(path: string);
+  /**
+   * Brand check on the private field: true for subclasses, and unlike
+   * `instanceof` it never walks the prototype chain, so no user trap runs
+   */
+  static isElysiaFile(value: unknown): value is ElysiaFile;
   get stats(): Promise<_$node_fs0.Stats> | undefined;
   get value(): BunFile | _$node_fs0.ReadStream | undefined;
   slice(start: number, end: number): BunFile | _$node_fs0.ReadStream | undefined;
   get type(): any;
-  get length(): number | Promise<number>;
 }
 //#endregion
-export { ElysiaFile, file, getFileExtension, mime };
+export { ElysiaFile, file, mime };

package/dist/universal/file.js

@@ -41,20 +41,14 @@ const mime = {
 	ppt: `${application}vnd.ms-powerpoint`,
 	pptx: `${msft365}presentationml.presentation`
 };
-/** @internal exported for test/universal/file-extension.test.ts */
-function getFileExtension(path) {
-	const index = path.lastIndexOf(".");
-	if (index === -1) return "";
-	return path.slice(index + 1).toLowerCase();
-}
 /**
 * Serve a file from a path as the response.
 */
 const file = (path) => new ElysiaFile(path);
 let createReadStream;
 let stat;
-function warnMissing(name) {
-	console.warn(/* @__PURE__ */ new Error(`[Elysia] \`file\` require \`fs${name ? "." + name : ""}\` ${name?.includes(".") ? "module " : ""}which is not available in this environment`));
+function warnMissing() {
+	console.warn(/* @__PURE__ */ new Error("[Elysia] `file` require `fs` which is not available in this environment"));
 }
 var ElysiaFile = class {
 	#value;
@@ -79,6 +73,13 @@ var ElysiaFile = class {
 			stat = fs.promises.stat;
 		}
 	}
+	/**
+	* Brand check on the private field: true for subclasses, and unlike
+	* `instanceof` it never walks the prototype chain, so no user trap runs
+	*/
+	static isElysiaFile(value) {
+		return typeof value === "object" && value !== null && #value in value;
+	}
 	get stats() {
 		if (require_universal_constants.isBun || !stat) return;
 		const value = stat(this.path);
@@ -101,13 +102,8 @@ var ElysiaFile = class {
 		return stream;
 	}
 	get type() {
-		return mime[getFileExtension(this.path)] || "application/octet-stream";
-	}
-	get length() {
-		if (require_universal_constants.isBun) return this.#value.size;
-		const value = this.stats?.then((x) => x.size);
-		value?.catch(() => {});
-		return value ?? 0;
+		const index = this.path.lastIndexOf(".");
+		return mime[index === -1 ? "" : this.path.slice(index + 1).toLowerCase()] || "application/octet-stream";
 	}
 };
 Object.defineProperty(ElysiaFile, "name", { value: "ElysiaFile" });
@@ -115,5 +111,4 @@ Object.defineProperty(ElysiaFile, "name", { value: "ElysiaFile" });
 //#endregion
 exports.ElysiaFile = ElysiaFile;
 exports.file = file;
-exports.getFileExtension = getFileExtension;
 exports.mime = mime;

package/dist/universal/file.mjs

@@ -40,20 +40,14 @@ const mime = {
 	ppt: `${application}vnd.ms-powerpoint`,
 	pptx: `${msft365}presentationml.presentation`
 };
-/** @internal exported for test/universal/file-extension.test.ts */
-function getFileExtension(path) {
-	const index = path.lastIndexOf(".");
-	if (index === -1) return "";
-	return path.slice(index + 1).toLowerCase();
-}
 /**
 * Serve a file from a path as the response.
 */
 const file = (path) => new ElysiaFile(path);
 let createReadStream;
 let stat;
-function warnMissing(name) {
-	console.warn(/* @__PURE__ */ new Error(`[Elysia] \`file\` require \`fs${name ? "." + name : ""}\` ${name?.includes(".") ? "module " : ""}which is not available in this environment`));
+function warnMissing() {
+	console.warn(/* @__PURE__ */ new Error("[Elysia] `file` require `fs` which is not available in this environment"));
 }
 var ElysiaFile = class {
 	#value;
@@ -78,6 +72,13 @@ var ElysiaFile = class {
 			stat = fs.promises.stat;
 		}
 	}
+	/**
+	* Brand check on the private field: true for subclasses, and unlike
+	* `instanceof` it never walks the prototype chain, so no user trap runs
+	*/
+	static isElysiaFile(value) {
+		return typeof value === "object" && value !== null && #value in value;
+	}
 	get stats() {
 		if (isBun || !stat) return;
 		const value = stat(this.path);
@@ -100,16 +101,11 @@ var ElysiaFile = class {
 		return stream;
 	}
 	get type() {
-		return mime[getFileExtension(this.path)] || "application/octet-stream";
-	}
-	get length() {
-		if (isBun) return this.#value.size;
-		const value = this.stats?.then((x) => x.size);
-		value?.catch(() => {});
-		return value ?? 0;
+		const index = this.path.lastIndexOf(".");
+		return mime[index === -1 ? "" : this.path.slice(index + 1).toLowerCase()] || "application/octet-stream";
 	}
 };
 Object.defineProperty(ElysiaFile, "name", { value: "ElysiaFile" });
 
 //#endregion
-export { ElysiaFile, file, getFileExtension, mime };
+export { ElysiaFile, file, mime };

package/dist/universal/index.d.ts

@@ -1,5 +1,5 @@
+import { isProduction } from "./is-production.js";
+import { ErrorLike, GenericServeOptions, ListenCallback, Serve, ServeOptions, Server, ServerWebSocketSendStatus, SocketAddress } from "./server.js";
 import { file } from "./file.js";
 import { env } from "./env.js";
-import { ErrorLike, GenericServeOptions, ListenCallback, Serve, ServeOptions, Server, ServerWebSocketSendStatus, SocketAddress } from "./server.js";
-import { isProduction } from "./is-production.js";
 export { type ErrorLike, type GenericServeOptions, type ListenCallback, type Serve, type ServeOptions, type Server, type ServerWebSocketSendStatus, type SocketAddress, env, file, isProduction };

package/dist/universal/is-production.d.ts

@@ -1,5 +1,4 @@
 //#region src/universal/is-production.d.ts
-declare const computeIsProduction: (readable: boolean, nodeEnv?: string, elysiaEnv?: string) => boolean;
 declare const isProduction: () => boolean;
 //#endregion
-export { computeIsProduction, isProduction };
+export { isProduction };

package/dist/universal/is-production.js

@@ -2,9 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_universal_env = require('./env.js');
 
 //#region src/universal/is-production.ts
-const computeIsProduction = (readable, nodeEnv, elysiaEnv) => !readable || (nodeEnv ?? elysiaEnv) === "production";
-const isProduction = () => computeIsProduction(require_universal_env.hasReadableEnv, require_universal_env.env.NODE_ENV, require_universal_env.env.ENV);
+const isProduction = () => !require_universal_env.hasReadableEnv || (require_universal_env.env.NODE_ENV ?? require_universal_env.env.ENV) === "production";
 
 //#endregion
-exports.computeIsProduction = computeIsProduction;
 exports.isProduction = isProduction;

package/dist/universal/is-production.mjs

@@ -1,8 +1,7 @@
 import { env, hasReadableEnv } from "./env.mjs";
 
 //#region src/universal/is-production.ts
-const computeIsProduction = (readable, nodeEnv, elysiaEnv) => !readable || (nodeEnv ?? elysiaEnv) === "production";
-const isProduction = () => computeIsProduction(hasReadableEnv, env.NODE_ENV, env.ENV);
+const isProduction = () => !hasReadableEnv || (env.NODE_ENV ?? env.ENV) === "production";
 
 //#endregion
-export { computeIsProduction, isProduction };
+export { isProduction };

package/dist/universal/server.d.ts

@@ -8,96 +8,16 @@ interface ErrorLike extends Error {
   syscall?: string;
 }
 interface GenericServeOptions {
-  /**
-   * What URI should be used to make {@link Request.url} absolute?
-   *
-   * By default, looks at {@link hostname}, {@link port}, and whether or not SSL is enabled to generate one
-   *
-   * @example
-   * ```js
-   * "http://my-app.com"
-   * ```
-   *
-   * @example
-   * ```js
-   * "https://wongmjane.com/"
-   * ```
-   *
-   * This should be the public, absolute URL – include the protocol and {@link hostname}. If the port isn't 80 or 443, then include the {@link port} too.
-   *
-   * @example
-   * "http://localhost:3000"
-   */
-  /**
-   * What is the maximum size of a request body? (in bytes)
-   *
-   * @default 1024 * 1024 * 128 // 128MB
-   */
   maxRequestBodySize?: number;
-  /**
-   * Render contextual errors? This enables bun's error page
-   * @default process.env.NODE_ENV !== 'production'
-   */
   development?: boolean;
   error?: (this: Server, request: ErrorLike) => Response | Promise<Response> | undefined | Promise<undefined>;
-  /**
-   * Uniquely identify a server instance with an ID
-   *
-   * ### When bun is started with the `--hot` flag
-   *
-   * This string will be used to hot reload the server without interrupting
-   * pending requests or websockets. If not provided, a value will be
-   * generated. To disable hot reloading, set this value to `null`.
-   *
-   * ### When bun is not started with the `--hot` flag
-   *
-   * This string will currently do nothing. But in the future it could be useful for logs or metrics.
-   */
   id?: string | null;
 }
 interface ServeOptions extends GenericServeOptions {
-  /**
-   * What port should the server listen on?
-   * @default process.env.PORT || "3000"
-   */
   port?: string | number;
-  /**
-   * If the `SO_REUSEPORT` flag should be set.
-   *
-   * This allows multiple processes to bind to the same port, which is useful for load balancing.
-   *
-   * @default false
-   */
   reusePort?: boolean;
-  /**
-   * What hostname should the server listen on?
-   *
-   * @default
-   * ```js
-   * "0.0.0.0" // listen on all interfaces
-   * ```
-   * @example
-   *  ```js
-   * "127.0.0.1" // Only listen locally
-   * ```
-   * @example
-   * ```js
-   * "remix.run" // Only listen on remix.run
-   * ````
-   *
-   * note: hostname should not include a {@link port}
-   */
   hostname?: string;
-  /**
-   * If set, the HTTP server will listen on a unix socket instead of a port.
-   * (Cannot be used with hostname+port)
-   */
   unix?: never;
-  /**
-   * Handle HTTP requests
-   *
-   * Respond to {@link Request} objects with a {@link Response} object.
-   */
   fetch(this: Server, request: Request, server: Server): Response | Promise<Response>;
   routes: Record<string, Function | Response | Record<string, Function | Response>>;
 }
@@ -105,221 +25,29 @@ type Serve = Equal<Serve$1.Options<unknown>, unknown> extends false ? Serve$1.Op
 type Server = Equal<Server$1<unknown>, unknown> extends false ? Server$1<unknown> : ServerOptions;
 type ServerWebSocketSendStatus = number;
 interface SocketAddress {
-  /**
-   * The IP address of the client.
-   */
   address: string;
-  /**
-   * The port of the client.
-   */
   port: number;
-  /**
-   * The IP family ("IPv4" or "IPv6").
-   */
   family: 'IPv4' | 'IPv6';
 }
 interface ServerOptions extends Disposable {
-  /**
-   * Stop listening to prevent new connections from being accepted.
-   *
-   * By default, it does not cancel in-flight requests or websockets. That means it may take some time before all network activity stops.
-   *
-   * @param closeActiveConnections Immediately terminate in-flight requests, websockets, and stop accepting new connections.
-   * @default false
-   */
   stop(closeActiveConnections?: boolean): void;
-  /**
-   * Update the `fetch` and `error` handlers without restarting the server.
-   *
-   * This is useful if you want to change the behavior of your server without
-   * restarting it or for hot reloading.
-   *
-   * @example
-   *
-   * ```js
-   * // create the server
-   * const server = Bun.serve({
-   *  fetch(request) {
-   *    return new Response("Hello World v1")
-   *  }
-   * });
-   *
-   * // Update the server to return a different response
-   * server.reload({
-   *   fetch(request) {
-   *     return new Response("Hello World v2")
-   *   }
-   * });
-   * ```
-   *
-   * Passing other options such as `port` or `hostname` won't do anything.
-   */
   reload(options: Serve): void;
-  /**
-   * Mock the fetch handler for a running server.
-   *
-   * This feature is not fully implemented yet. It doesn't normalize URLs
-   * consistently in all cases and it doesn't yet call the `error` handler
-   * consistently. This needs to be fixed
-   */
   fetch(request: Request | string): Response | Promise<Response>;
-  /**
-   * Upgrade a {@link Request} to a {@link ServerWebSocket}
-   *
-   * @param request The {@link Request} to upgrade
-   * @param options Pass headers or attach data to the {@link ServerWebSocket}
-   *
-   * @returns `true` if the upgrade was successful and `false` if it failed
-   *
-   * @example
-   * ```js
-   * import { serve } from "bun";
-   *  serve({
-   *    websocket: {
-   *      open: (ws) => {
-   *        console.log("Client connected");
-   *      },
-   *      message: (ws, message) => {
-   *        console.log("Client sent message", message);
-   *      },
-   *      close: (ws) => {
-   *        console.log("Client disconnected");
-   *      },
-   *    },
-   *    fetch(req, server) {
-   *      const url = new URL(req.url);
-   *      if (url.pathname === "/chat") {
-   *        const upgraded = server.upgrade(req);
-   *        if (!upgraded) {
-   *          return new Response("Upgrade failed", { status: 400 });
-   *        }
-   *      }
-   *      return new Response("Hello World");
-   *    },
-   *  });
-   * ```
-   *  What you pass to `data` is available on the {@link ServerWebSocket.data} property
-   */
   upgrade<T = undefined>(request: Request, options?: {
-    /**
-     * Send any additional headers while upgrading, like cookies
-     */
     headers?: Bun.HeadersInit;
-    /**
-     * This value is passed to the {@link ServerWebSocket.data} property
-     */
     data?: T;
   }): boolean;
-  /**
-   * Send a message to all connected {@link ServerWebSocket} subscribed to a topic
-   *
-   * @param topic The topic to publish to
-   * @param data The data to send
-   * @param compress Should the data be compressed? Ignored if the client does not support compression.
-   *
-   * @returns 0 if the message was dropped, -1 if backpressure was applied, or the number of bytes sent.
-   *
-   * @example
-   *
-   * ```js
-   * server.publish("chat", "Hello World");
-   * ```
-   *
-   * @example
-   * ```js
-   * server.publish("chat", new Uint8Array([1, 2, 3, 4]));
-   * ```
-   *
-   * @example
-   * ```js
-   * server.publish("chat", new ArrayBuffer(4), true);
-   * ```
-   *
-   * @example
-   * ```js
-   * server.publish("chat", new DataView(new ArrayBuffer(4)));
-   * ```
-   */
   publish(topic: string, data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, compress?: boolean): ServerWebSocketSendStatus;
-  /**
-   * Returns the client IP address and port of the given Request. If the request was closed or is a unix socket, returns null.
-   *
-   * @example
-   * ```js
-   * export default {
-   *  async fetch(request, server) {
-   *    return new Response(server.requestIP(request));
-   *  }
-   * }
-   * ```
-   */
   requestIP(request: Request): SocketAddress | null;
-  /**
-   * Reset the idleTimeout of the given Request to the number in seconds. 0 means no timeout.
-   *
-   * @example
-   * ```js
-   * export default {
-   *  async fetch(request, server) {
-   *    server.timeout(request, 60);
-   *    await Bun.sleep(30000);
-   *    return new Response("30 seconds have passed");
-   *  }
-   * }
-   * ```
-   */
   timeout(request: Request, seconds: number): void;
-  /**
-   * Undo a call to {@link Server.unref}
-   *
-   * If the Server has already been stopped, this does nothing.
-   *
-   * If {@link Server.ref} is called multiple times, this does nothing. Think of it as a boolean toggle.
-   */
   ref(): void;
-  /**
-   * Don't keep the process alive if this server is the only thing left.
-   * Active connections may continue to keep the process alive.
-   *
-   * By default, the server is ref'd.
-   *
-   * To prevent new connections from being accepted, use {@link Server.stop}
-   */
   unref(): void;
-  /**
-   * How many requests are in-flight right now?
-   */
   readonly pendingRequests: number;
-  /**
-   * How many {@link ServerWebSocket}s are in-flight right now?
-   */
   readonly pendingWebSockets: number;
   readonly url: URL;
   readonly port: number;
-  /**
-   * The hostname the server is listening on. Does not include the port
-   * @example
-   * ```js
-   * "localhost"
-   * ```
-   */
   readonly hostname: string;
-  /**
-   * Is the server running in development mode?
-   *
-   * In development mode, `Bun.serve()` returns rendered error messages with
-   * stack traces instead of a generic 500 error. This makes debugging easier,
-   * but development mode shouldn't be used in production or you will risk
-   * leaking sensitive information.
-   */
   readonly development: boolean;
-  /**
-   * An identifier of the server instance
-   *
-   * When bun is started with the `--hot` flag, this ID is used to hot reload the server without interrupting pending requests or websockets.
-   *
-   * When bun is not started with the `--hot` flag, this ID is currently unused.
-   */
   readonly id: string;
 }
 type ListenCallback = (server: Server) => MaybePromise<void>;

package/dist/utils.d.ts

@@ -1,6 +1,6 @@
-import { AnyLocalHook, AppHook, ElysiaFormData, EventFn, EventScope, GuardSchemaType, InputSchema, Macro, MaybeArray, Prettify, SSEPayload } from "./types.js";
-import { Context } from "./context.js";
 import { AnySchema, StandardSchemaV1Like } from "./type/types.js";
+import { Context } from "./context.js";
+import { AnyLocalHook, AppHook, BunHTMLBundlelike, ElysiaFormData, EventFn, EventScope, GuardSchemaType, InputSchema, Macro, MaybeArray, Prettify, SSEPayload } from "./types.js";
 
 //#region src/utils.d.ts
 type DeriveEntry = Function | readonly [Function, 'mapDerive'];
@@ -49,6 +49,11 @@ declare const isLocalScope: (s: EventScope | undefined) => s is "local" | undefi
  * without flattening - `over` is walked first (older / outer context),
  * then `combine` (newer / inner context)
  *
+ * `tail` is the child's own chain head at that `.use()`. Its local hooks
+ * registered after the child absorbed the route run after the route's own
+ * hooks, as they would with the child as the root (`afterUseHooks` in
+ * `compile/handler`)
+ *
  * Use with {@link flattenChain} to walk tail-first and reconstruct
  * flat `Partial<AppHook>` at compile time
  */
@@ -60,10 +65,17 @@ type ChainNode = {
   propagated?: boolean;
   owner?: object;
 } | {
-  combine: ChainNode;
+  combine: ChainNode | undefined;
   over: ChainNode | undefined;
+  tail?: ChainNode;
   refs: boolean;
 };
+/**
+ * The absorbing instance's chain as it stood at `.use()`: the `over` of a
+ * combine node, or the node itself. A combine node is never on an instance's
+ * own chain, so it can't serve as a `stopAt` directly
+ */
+declare const rootSnapshot: (node: ChainNode | undefined) => ChainNode | undefined;
 interface CompactBeforeHandleChunk {
   parent?: CompactBeforeHandleChunk;
   values: readonly Function[];
@@ -88,8 +100,8 @@ declare const macroEpoch: () => number;
 declare const invalidateMacroEpoch: () => void;
 /** Drop this root's flattened-chain memo. Recomputable on next compile. */
 declare function clearFlattenChainMemo(root: object): void;
-declare function flattenChainMemo(root: object, start: ChainNode | undefined, resolveAdded?: (node: ChainNode) => Partial<AppHook> | undefined): Partial<AppHook> | undefined;
 declare function flattenChainMemoReadonly(root: object, start: ChainNode | undefined, resolveAdded?: (node: ChainNode) => Partial<AppHook> | undefined): Partial<AppHook> | undefined;
+declare function flattenChainMemo(root: object, start: ChainNode | undefined, resolveAdded?: (node: ChainNode) => Partial<AppHook> | undefined): Partial<AppHook> | undefined;
 /**
  *
  * @param url URL to redirect to
@@ -116,6 +128,7 @@ declare function formToFormData(value: Record<keyof any, unknown>): FormData;
  * ```
  */
 declare const form: <const T extends Record<keyof any, unknown>>(value: T) => ElysiaFormData<T>;
+declare const assignOwn: <T extends object>(target: T, source: any) => T;
 declare const getLoosePath: (path: string) => string;
 /**
  * Certify a byte stream for direct Response body pass-through.
@@ -129,6 +142,7 @@ declare const isByteStream: (value: unknown) => value is ReadableStream<Uint8Arr
 type FormatSSEPayload<T = unknown> = T extends string ? {
   readonly data: T;
 } : Prettify<SSEPayload<T>>;
+declare const sseData: (value: string) => string;
 declare const sse: <const T extends string | SSEPayload | Generator | AsyncGenerator | ReadableStream>(_payload: T) => T extends string ? {
   readonly data: T;
 } : T extends SSEPayload ? T : T extends ReadableStream<infer A> ? ReadableStream<FormatSSEPayload<A>> : T extends Generator<infer A, infer B, infer C> ? Generator<FormatSSEPayload<A>, B, C> : T extends AsyncGenerator<infer A, infer B_1, infer C_1> ? AsyncGenerator<FormatSSEPayload<A>, B_1, C_1> : T;
@@ -165,14 +179,34 @@ declare function cloneHook<T extends Partial<AnyLocalHook> | Partial<AppHook>>(s
 declare function clonePlainDeep<T>(value: T, seen?: WeakMap<object, any>): T;
 declare function guardNonPlainLeaves(target: Record<string, unknown>, source: Record<string, unknown>): void;
 declare function joinPath(base: string, path: string): string;
-declare function pushField<K extends keyof any>(target: Record<K, unknown>, key: K, item: unknown, defaultArray?: boolean): void;
-declare const requestId: any;
+declare function pushField<K extends keyof any>(target: Record<K, unknown>, key: K, item: unknown): void;
+declare const requestId: typeof Bun.randomUUIDv7 | (() => `${string}-${string}-${string}-${string}-${string}`);
+/**
+ * Offset of the first byte after `://`, so the authority is never scanned as
+ * path. A fixed offset would let the client-supplied `Host` decide how many
+ * leading path bytes are dropped
+ */
+declare const authorityEnd: (url: string) => number;
 declare function replaceUrlPath(url: string, path: string): string;
+declare function isPlainObject(v: unknown): v is Record<string, unknown>;
 declare function clonePlainDecorators<T extends Record<string, unknown>>(source: T, seen?: WeakMap<object, any>): T;
 declare function prefix<T extends string, Models extends Record<string, AnySchema>>(prefix: T, models: Models): { [k in keyof Models as `${T}.${k & string}`]: Models[k] };
 declare namespace prefix {
   var capitalize: <T extends string, Models extends Record<string, AnySchema>>(prefix: T, models: Models) => { [k in keyof Models as `${T}.${Capitalize<k & string>}`]: Models[k] };
 }
 declare function serializeMacroSeed(_key: string, value: unknown): unknown;
+declare const throwLifecycleErrors: (errors: unknown[]) => void;
+declare const isDisposable: (value: any) => boolean;
+declare const isSingleton: (value: object) => boolean;
+declare const markSingletons: (value: unknown, depth?: number, seen?: Set<object>) => void;
+declare const isSocketQuiet: (socket: {
+  readyState: number;
+  data: {
+    inflight?: number;
+    opening?: unknown;
+    settling?: number;
+  };
+}) => boolean;
+declare const isHTMLBundle: (value: unknown) => value is BunHTMLBundlelike;
 //#endregion
-export { ChainNode, CompactBeforeHandleChunk, CompactBeforeHandlePrefix, DeriveEntry, ELYSIA_FORM_PROTOTYPE, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isElysiaForm, isEmpty, isLocalScope, isMapDeriveEntry, isNotEmpty, isRecordNumber, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, schemaProperties, serializeMacroSeed, sse };
+export { ChainNode, CompactBeforeHandleChunk, CompactBeforeHandlePrefix, DeriveEntry, ELYSIA_FORM_PROTOTYPE, assignOwn, authorityEnd, bytes, clearFlattenChainMemo, cloneHook, clonePlainDecorators, clonePlainDeep, coalesceSchemas, compactBeforeHandleConflicts, compactBeforeHandlePrefix, constantTimeEqual, createErrorEventHandler, deriveEntryFn, eventProperties, evictOldestHalf, flattenChain, flattenChainMemo, flattenChainMemoReadonly, fnOrigin, fnv1a, form, formToFormData, getLoosePath, guardNonPlainLeaves, hookToGuard, invalidateMacroEpoch, isBlob, isByteStream, isCompactBeforeHandleOnly, isDisposable, isElysiaForm, isEmpty, isHTMLBundle, isLocalScope, isMapDeriveEntry, isNotEmpty, isPlainObject, isRecordNumber, isSingleton, isSocketQuiet, joinPath, macroEpoch, macroOrigin, mapDeriveEntry, markSingletons, mergeArray, mergeDeep, mergeHook, mergeResponse, nullObject, prefix, pushField, redirect, replaceUrlPath, requestId, rootSnapshot, schemaProperties, serializeMacroSeed, sse, sseData, throwLifecycleErrors };