elysia 2.0.0-beta.2 → 2.0.0-beta.21

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'];
@@ -20,6 +20,8 @@ declare const isNotEmpty: <T extends Object>(obj?: T) => boolean | undefined;
  */
 declare function evictOldestHalf(cache: Map<any, any>): void;
 declare function fnv1a(str: string): number;
+declare const compositionKeys: readonly string[];
+declare function refTargets(roots: unknown[], models?: Record<string, unknown>): (name: string) => Iterable<unknown>;
 /**
  * Maps each lifecycle/derive function to the hash of the named plugin it was
  * first registered on. Used by `.use()` to dedup absorbed hooks: if a fn's
@@ -49,6 +51,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 +67,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 +102,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 +130,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 +144,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 +181,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, compositionKeys, 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, refTargets, replaceUrlPath, requestId, rootSnapshot, schemaProperties, serializeMacroSeed, sse, sseData, throwLifecycleErrors };

package/dist/utils.js

@@ -37,6 +37,27 @@ function fnv1a(str) {
 	}
 	return hash >>> 0;
 }
+const compositionKeys = Object.freeze([
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"~cookieFrom"
+]);
+function refTargets(roots, models = {}) {
+	const targets = nullObject();
+	const add = (name, schema) => (targets[name] ??= /* @__PURE__ */ new Set()).add(schema);
+	const seen = /* @__PURE__ */ new Set();
+	const index = (node) => {
+		if (!node || typeof node !== "object" || seen.has(node)) return;
+		seen.add(node);
+		if (typeof node.$id === "string") add(node.$id.slice(node.$id.lastIndexOf("/") + 1), node);
+		for (const key in node) index(node[key]);
+		index(node["~cookieFrom"]);
+	};
+	for (const name in models) add(name, models[name]);
+	roots.concat(Object.values(models)).forEach(index);
+	return (name) => targets[name] ?? [];
+}
 /**
 * Maps each lifecycle/derive function to the hash of the named plugin it was
 * first registered on. Used by `.use()` to dedup absorbed hooks: if a fn's
@@ -49,6 +70,12 @@ function fnv1a(str) {
 const fnOrigin = /* @__PURE__ */ new WeakMap();
 const macroOrigin = /* @__PURE__ */ new WeakMap();
 const isLocalScope = (s) => s === "local" || s === void 0;
+/**
+* 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
+*/
+const rootSnapshot = (node) => node && "combine" in node ? node.over : node;
 const COMPACT_CHUNK_SIZE = 32;
 const emptyCompactBeforeHandlePrefix = {
 	length: 0,
@@ -73,30 +100,6 @@ function compactBeforeHandleConflicts(hook) {
 	for (let i = 0; i < values.length; i++) if (compactBeforeHandleFunctions.has(values[i])) return true;
 	return false;
 }
-function appendCompactBeforeHandle(previous, added) {
-	if (!added.length) return previous;
-	let tail = previous.tail;
-	let length = previous.length;
-	for (let i = 0; i < added.length; i++) {
-		const fn = added[i];
-		compactBeforeHandleFunctions.add(fn);
-		if (tail && tail.values.length < COMPACT_CHUNK_SIZE) tail = {
-			parent: tail.parent,
-			values: [...tail.values, fn]
-		};
-		else tail = {
-			parent: tail,
-			values: [fn]
-		};
-		length++;
-	}
-	return {
-		tail,
-		length,
-		previous: previous.length ? previous : void 0,
-		added
-	};
-}
 function compactBeforeHandlePrefix(start) {
 	if (!start) return;
 	const pending = [];
@@ -104,34 +107,51 @@ function compactBeforeHandlePrefix(start) {
 	let prefix = emptyCompactBeforeHandlePrefix;
 	while (node) {
 		const cached = compactBeforeHandleMemos.get(node);
-		if (cached !== void 0) {
-			if (cached === false) {
-				for (let i = 0; i < pending.length; i++) compactBeforeHandleMemos.set(pending[i].node, false);
-				return;
-			}
+		if (cached) {
 			prefix = cached;
 			break;
 		}
-		if ("combine" in node) {
-			compactBeforeHandleMemos.set(node, false);
-			for (let i = 0; i < pending.length; i++) compactBeforeHandleMemos.set(pending[i].node, false);
-			return;
-		}
-		const values = compactBeforeHandleValues(node.added);
-		if (values === false) {
-			compactBeforeHandleMemos.set(node, false);
-			for (let i = 0; i < pending.length; i++) compactBeforeHandleMemos.set(pending[i].node, false);
-			return;
+		if (cached === void 0 && !("combine" in node)) {
+			const values = compactBeforeHandleValues(node.added);
+			if (values !== false) {
+				pending.push({
+					node,
+					values
+				});
+				node = node.parent;
+				continue;
+			}
 		}
-		pending.push({
-			node,
-			values
-		});
-		node = node.parent;
+		compactBeforeHandleMemos.set(node, false);
+		for (let i = 0; i < pending.length; i++) compactBeforeHandleMemos.set(pending[i].node, false);
+		return;
 	}
 	for (let i = pending.length - 1; i >= 0; i--) {
 		const item = pending[i];
-		prefix = appendCompactBeforeHandle(prefix, item.values);
+		const added = item.values;
+		if (added.length) {
+			let tail = prefix.tail;
+			let length = prefix.length;
+			for (let j = 0; j < added.length; j++) {
+				const fn = added[j];
+				compactBeforeHandleFunctions.add(fn);
+				if (tail && tail.values.length < COMPACT_CHUNK_SIZE) tail = {
+					parent: tail.parent,
+					values: [...tail.values, fn]
+				};
+				else tail = {
+					parent: tail,
+					values: [fn]
+				};
+				length++;
+			}
+			prefix = {
+				tail,
+				length,
+				previous: prefix.length ? prefix : void 0,
+				added
+			};
+		}
 		compactBeforeHandleMemos.set(item.node, prefix);
 	}
 	return prefix.length ? prefix : void 0;
@@ -157,13 +177,30 @@ function flattenChain(start, keep, stopAt, resolveAdded) {
 		const node = nodes.pop();
 		if (phases.pop() === 1) {
 			const added = resolveAdded ? resolveAdded(node) : node.added;
-			if (added) appendInto(result, added, keep, node.scope);
+			if (added) {
+				const nodeScope = node.scope;
+				if (!(keep && !keep(nodeScope))) for (const key in added) {
+					const v = added[key];
+					if (v === void 0 || v === null) continue;
+					if (eventProperties.has(key) || key === "schemas" || key === "~deriveEntries") {
+						const existing = result[key];
+						if (Array.isArray(v)) if (existing) {
+							const arr = existing;
+							for (let i = 0; i < v.length; i++) arr.push(v[i]);
+						} else result[key] = v.slice();
+						else if (existing) existing.push(v);
+						else result[key] = [v];
+					} else result[key] = v;
+				}
+			}
 			continue;
 		}
 		if (stopAt && node === stopAt) continue;
 		if ("combine" in node) {
-			nodes.push(node.combine);
-			phases.push(0);
+			if (node.combine) {
+				nodes.push(node.combine);
+				phases.push(0);
+			}
 			if (node.over) {
 				nodes.push(node.over);
 				phases.push(0);
@@ -197,7 +234,8 @@ function clearFlattenChainMemo(root) {
 	flattenChainMemos.delete(root);
 }
 const emptyFlatten = Object.freeze(nullObject());
-function flattenChainCached(root, start, resolveAdded) {
+function flattenChainMemoReadonly(root, start, resolveAdded) {
+	if (!start) return;
 	let bucket = flattenChainMemos.get(root);
 	if (!bucket || bucket.e !== macroTableEpoch) {
 		bucket = {
@@ -216,30 +254,8 @@ function flattenChainCached(root, start, resolveAdded) {
 	return cached;
 }
 function flattenChainMemo(root, start, resolveAdded) {
-	if (!start) return;
-	const cached = flattenChainCached(root, start, resolveAdded);
-	if (cached === void 0) return;
-	return cloneHook(cached);
-}
-function flattenChainMemoReadonly(root, start, resolveAdded) {
-	if (!start) return;
-	return flattenChainCached(root, start, resolveAdded);
-}
-function appendInto(target, src, keep, nodeScope) {
-	if (keep && !keep(nodeScope)) return;
-	for (const key in src) {
-		const v = src[key];
-		if (v === void 0 || v === null) continue;
-		if (eventProperties.has(key) || key === "schemas" || key === "~deriveEntries") {
-			const existing = target[key];
-			if (Array.isArray(v)) if (existing) {
-				const arr = existing;
-				for (let i = 0; i < v.length; i++) arr.push(v[i]);
-			} else target[key] = v.slice();
-			else if (existing) existing.push(v);
-			else target[key] = [v];
-		} else target[key] = v;
-	}
+	const cached = flattenChainMemoReadonly(root, start, resolveAdded);
+	if (cached) return cloneHook(cached);
 }
 const notLatin = /[^\x00-\xFF]/;
 /**
@@ -287,6 +303,7 @@ function formToFormData(value) {
 * ```
 */
 const form = (value) => Object.setPrototypeOf({ ...value }, ELYSIA_FORM_PROTOTYPE);
+const assignOwn = (target, source) => source != null && Object.hasOwn(source, "__proto__") ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : Object.assign(target, source);
 const getLoosePath = (path) => path.charCodeAt(path.length - 1) === 47 ? path.slice(0, -1) : path + "/";
 const byteStreams = /* @__PURE__ */ new WeakSet();
 /**
@@ -322,6 +339,7 @@ const sse = (_payload) => {
 		if (payload.data === null) s += "data: null\n";
 		else if (typeof payload.data === "string") s += sseData(payload.data);
 		else if (typeof payload.data === "object") s += `data: ${JSON.stringify(payload.data)}\n`;
+		else if (payload.data !== void 0) s += sseData(String(payload.data));
 		if (s) s += "\n";
 		return s;
 	};
@@ -331,11 +349,11 @@ const _enc = new TextEncoder();
 let _constantTimeEqual;
 const _resolveConstantTimeEqual = () => {
 	let native;
-	try {
+	if (require_universal_constants.isBun && typeof crypto?.timingSafeEqual === "function") native = (a, b) => crypto.timingSafeEqual(a, b);
+	else try {
 		const _crypto = globalThis.process?.getBuiltinModule?.("node:crypto");
 		if (typeof _crypto?.timingSafeEqual === "function") native = _crypto.timingSafeEqual;
 	} catch {}
-	if (!native && typeof crypto?.timingSafeEqual === "function") native = (a, b) => crypto.timingSafeEqual(a, b);
 	if (!native) return (a, b) => {
 		if (a.length !== b.length) return false;
 		let mismatch = 0;
@@ -429,14 +447,26 @@ function dedupedMergeArray(a, b, reverse = false) {
 	for (let i = 0; i < aArr.length; i++) if (!seen.has(aArr[i])) filtered.push(aArr[i]);
 	return reverse ? bArr.concat(filtered) : filtered.concat(bArr);
 }
-const schemaProperties = new Set([
+const hookSchemaKeys = [
 	"body",
 	"headers",
 	"params",
 	"query",
 	"cookie",
 	"response"
-]);
+];
+const schemaProperties = new Set(hookSchemaKeys);
+const hookEventKeys = [
+	"parse",
+	"transform",
+	"derive",
+	"beforeHandle",
+	"afterHandle",
+	"mapResponse",
+	"afterResponse",
+	"error",
+	"trace"
+];
 const eventProperties = new Set([
 	"start",
 	"stop",
@@ -451,33 +481,16 @@ const eventProperties = new Set([
 	"error"
 ]);
 function hookToGuard(a) {
-	if (a.schema !== "merge") return a;
+	if (a.schema !== "merge") {
+		if (a.schema !== void 0 && a.schema !== "override") throw new Error(`[Elysia] Invalid guard schema ${JSON.stringify(a.schema)}, expected 'merge' or 'override' (1.x 'standalone' is 'merge')`);
+		return a;
+	}
 	if (a.body || a.headers || a.params || a.query || a.cookie || a.response) {
 		a.schemas ??= [];
 		const schema = Object.create(null);
-		if (a.body) {
-			schema.body = a.body;
-			a.body = void 0;
-		}
-		if (a.headers) {
-			schema.headers = a.headers;
-			a.headers = void 0;
-		}
-		if (a.params) {
-			schema.params = a.params;
-			a.params = void 0;
-		}
-		if (a.query) {
-			schema.query = a.query;
-			a.query = void 0;
-		}
-		if (a.cookie) {
-			schema.cookie = a.cookie;
-			a.cookie = void 0;
-		}
-		if (a.response) {
-			schema.response = a.response;
-			a.response = void 0;
+		for (const key of hookSchemaKeys) if (a[key]) {
+			schema[key] = a[key];
+			a[key] = void 0;
 		}
 		a.schemas.push(schema);
 	}
@@ -507,30 +520,22 @@ function mergeHook(a, b, reverse = false, dedup = false) {
 	if (!b) return a;
 	if (!a) return b;
 	const merge = dedup ? dedupedMergeArray : mergeArray;
-	if (!a.body && b.body) a.body = b.body;
-	if (!a.headers && b.headers) a.headers = b.headers;
-	if (!a.params && b.params) a.params = b.params;
-	if (!a.query && b.query) a.query = b.query;
-	if (!a.cookie && b.cookie) a.cookie = b.cookie;
-	if (!a.response && b.response) a.response = b.response;
-	else if (a.response && b.response) a.response = mergeResponse(b.response, a.response);
-	if (a.parse || b.parse) a.parse = merge(a.parse, b.parse, reverse);
-	if (a.transform || b.transform) a.transform = merge(a.transform, b.transform, reverse);
-	if (a.derive || b.derive) a.derive = merge(a.derive, b.derive, reverse);
-	if (a.beforeHandle || b.beforeHandle) a.beforeHandle = merge(a.beforeHandle, b.beforeHandle, reverse);
-	if (a.afterHandle || b.afterHandle) a.afterHandle = merge(a.afterHandle, b.afterHandle, reverse);
-	if (a.mapResponse || b.mapResponse) a.mapResponse = merge(a.mapResponse, b.mapResponse, reverse);
-	if (a.afterResponse || b.afterResponse) a.afterResponse = merge(a.afterResponse, b.afterResponse, reverse);
-	if (a.error || b.error) a.error = merge(a.error, b.error, reverse);
-	if (a.trace || b.trace) a.trace = merge(a.trace, b.trace, reverse);
+	for (const key of hookSchemaKeys) if (!a[key] && b[key]) a[key] = b[key];
+	else if (key === "response" && a.response && b.response) a.response = mergeResponse(b.response, a.response);
+	for (const key of hookEventKeys) if (a[key] || b[key]) a[key] = merge(a[key], b[key], reverse);
 	if (a.schemas || b.schemas) a.schemas = mergeArray(a.schemas, b.schemas, reverse);
 	const aDerive = a["~deriveEntries"];
 	const bDerive = b["~deriveEntries"];
 	if (aDerive || bDerive) a["~deriveEntries"] = mergeArray(aDerive, bDerive, reverse);
 	return a;
 }
-const createErrorEventHandler = (fn, error) => (context) => {
-	if (context.error instanceof error) return fn(context);
+const createErrorEventHandler = (fn, error) => {
+	const handler = (context) => {
+		if (context.error instanceof error) return fn(context);
+	};
+	const p = error?.prototype;
+	if (typeof p === "object" && p !== null && p !== Error.prototype && !(p instanceof Error)) handler["~errorClass"] = error;
+	return handler;
 };
 const isObject = (item) => item && typeof item === "object" && !Array.isArray(item);
 const isClassRegex = /^\s*class\s+/;
@@ -619,15 +624,21 @@ function joinPath(base, path) {
 	if (!baseEndsWithSlash && !pathStartsWithSlash) return base + "/" + path;
 	return base + path;
 }
-function pushField(target, key, item, defaultArray = false) {
+function pushField(target, key, item) {
 	const v = target[key];
 	if (v) if (Array.isArray(v)) target[key].push(item);
 	else target[key] = [v, item];
-	else target[key] = defaultArray ? [item] : item;
+	else target[key] = item;
 }
-const requestId = require_universal_constants.isBun ? Bun.randomUUIDv7 : crypto.randomUUIDv7?.bind(crypto) ?? crypto.randomUUID?.bind(crypto);
+const requestId = require_universal_constants.isBun ? Bun.randomUUIDv7 : crypto.randomUUID.bind(crypto);
+/**
+* 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
+*/
+const authorityEnd = (url) => url.charCodeAt(4) === 58 ? 7 : url.charCodeAt(5) === 58 ? 8 : url.indexOf("://") + 3;
 function replaceUrlPath(url, path) {
-	const i = url.indexOf("/", 11);
+	const i = url.indexOf("/", authorityEnd(url));
 	const qs = url.indexOf("?", i);
 	return `${url.slice(0, i)}${path.charCodeAt(0) === 47 ? "" : "/"}${path}${qs === -1 ? "" : url.slice(qs)}`;
 }
@@ -652,7 +663,6 @@ function clonePlainDecorators(source, seen) {
 	}
 	return out;
 }
-const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
 function prefix(prefix, models) {
 	const prefixed = nullObject();
 	for (const key in models) prefixed[`${prefix}.${key}`] = models[key];
@@ -660,7 +670,7 @@ function prefix(prefix, models) {
 }
 prefix.capitalize = function prefixModelsCapitalize(prefix, models) {
 	const prefixed = nullObject();
-	for (const key in models) prefixed[`${prefix}.${capitalize(key)}`] = models[key];
+	for (const key in models) prefixed[`${prefix}.${key.charAt(0).toUpperCase() + key.slice(1)}`] = models[key];
 	return prefixed;
 };
 const macroSeedRefIds = /* @__PURE__ */ new WeakMap();
@@ -679,9 +689,43 @@ function serializeMacroSeed(_key, value) {
 		default: return value;
 	}
 }
+const throwLifecycleErrors = (errors) => {
+	if (errors.length === 1) throw errors[0];
+	if (errors.length) throw new AggregateError(errors, "Multiple lifecycle failures");
+};
+const isDisposable = (value) => {
+	if (value == null) return false;
+	const kind = typeof value;
+	if (kind !== "object" && kind !== "function") return false;
+	try {
+		return typeof value[Symbol.asyncDispose] === "function" || typeof value[Symbol.dispose] === "function";
+	} catch {
+		return false;
+	}
+};
+const singletons = /* @__PURE__ */ new WeakSet();
+const isSingleton = (value) => singletons.has(value);
+const markSingletons = (value, depth = 4, seen = /* @__PURE__ */ new Set()) => {
+	if (value == null) return;
+	const kind = typeof value;
+	if (kind !== "object" && kind !== "function") return;
+	const object = value;
+	if (seen.has(object)) return;
+	seen.add(object);
+	singletons.add(object);
+	if (depth <= 0) return;
+	for (const key of Object.keys(object)) {
+		const descriptor = Object.getOwnPropertyDescriptor(object, key);
+		if (descriptor && "value" in descriptor) markSingletons(descriptor.value, depth - 1, seen);
+	}
+};
+const isSocketQuiet = (socket) => socket.readyState === 3 && !socket.data.inflight && !socket.data.opening && !socket.data.settling;
+const isHTMLBundle = (value) => Object.prototype.toString.call(value) === "[object HTMLBundle]" || typeof value?.index === "string" && Array.isArray(value.files);
 
 //#endregion
 exports.ELYSIA_FORM_PROTOTYPE = ELYSIA_FORM_PROTOTYPE;
+exports.assignOwn = assignOwn;
+exports.authorityEnd = authorityEnd;
 exports.bytes = bytes;
 exports.clearFlattenChainMemo = clearFlattenChainMemo;
 exports.cloneHook = cloneHook;
@@ -690,6 +734,7 @@ exports.clonePlainDeep = clonePlainDeep;
 exports.coalesceSchemas = coalesceSchemas;
 exports.compactBeforeHandleConflicts = compactBeforeHandleConflicts;
 exports.compactBeforeHandlePrefix = compactBeforeHandlePrefix;
+exports.compositionKeys = compositionKeys;
 exports.constantTimeEqual = constantTimeEqual;
 exports.createErrorEventHandler = createErrorEventHandler;
 exports.deriveEntryFn = deriveEntryFn;
@@ -709,16 +754,22 @@ exports.invalidateMacroEpoch = invalidateMacroEpoch;
 exports.isBlob = isBlob;
 exports.isByteStream = isByteStream;
 exports.isCompactBeforeHandleOnly = isCompactBeforeHandleOnly;
+exports.isDisposable = isDisposable;
 exports.isElysiaForm = isElysiaForm;
 exports.isEmpty = isEmpty;
+exports.isHTMLBundle = isHTMLBundle;
 exports.isLocalScope = isLocalScope;
 exports.isMapDeriveEntry = isMapDeriveEntry;
 exports.isNotEmpty = isNotEmpty;
+exports.isPlainObject = isPlainObject;
 exports.isRecordNumber = isRecordNumber;
+exports.isSingleton = isSingleton;
+exports.isSocketQuiet = isSocketQuiet;
 exports.joinPath = joinPath;
 exports.macroEpoch = macroEpoch;
 exports.macroOrigin = macroOrigin;
 exports.mapDeriveEntry = mapDeriveEntry;
+exports.markSingletons = markSingletons;
 exports.mergeArray = mergeArray;
 exports.mergeDeep = mergeDeep;
 exports.mergeHook = mergeHook;
@@ -727,8 +778,12 @@ exports.nullObject = nullObject;
 exports.prefix = prefix;
 exports.pushField = pushField;
 exports.redirect = redirect;
+exports.refTargets = refTargets;
 exports.replaceUrlPath = replaceUrlPath;
 exports.requestId = requestId;
+exports.rootSnapshot = rootSnapshot;
 exports.schemaProperties = schemaProperties;
 exports.serializeMacroSeed = serializeMacroSeed;
-exports.sse = sse;
+exports.sse = sse;
+exports.sseData = sseData;
+exports.throwLifecycleErrors = throwLifecycleErrors;