elysia 2.0.0-exp.29 → 2.0.0-exp.30

package/dist/base.d.ts

@@ -56,6 +56,14 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   '~scopeChild'?: boolean;
   '~scopeChildren'?: AnyElysia[];
   constructor(config?: ElysiaConfig<BasePath, Scope>);
+  /**
+   * @deprecated use `app.history` instead
+   *
+   * Elysia changes it store route internally
+   * This API is provided as compatibility
+   *
+   * Will remove in 2.1
+   */
   get routes(): PublicRoute[];
   /**
    * ### decorate

package/dist/base.js

@@ -55,6 +55,14 @@ var Elysia = class Elysia {
 		if (this["~Prefix"] && !this["~Prefix"].startsWith("/")) this["~Prefix"] = `/${this["~Prefix"]}`;
 		if (config?.name) this.#hash = require_utils.fnv1a(config.seed ? `${config.name}_${typeof config.seed === "object" ? JSON.stringify(config.seed) : config.seed}` : config.name);
 	}
+	/**
+	* @deprecated use `app.history` instead
+	*
+	* Elysia changes it store route internally
+	* This API is provided as compatibility
+	*
+	* Will remove in 2.1
+	*/
 	get routes() {
 		if (!this.#history) return [];
 		if (this.#cachedRoutes) return this.#cachedRoutes;
@@ -1106,7 +1114,7 @@ var Elysia = class Elysia {
 			if (seen.has(key)) {
 				hasDuplicate = true;
 				if (!require_error.isProduction()) {
-					if (this.#history[seen.get(key)][2] !== route[2]) console.warn(`[Elysia] Duplicate route ${key} — the later definition overrides the earlier one (its schema/hooks are dropped).`);
+					if (this.#history[seen.get(key)][2] !== route[2]) console.warn(`[Elysia] Duplicate route ${key} at`, (/* @__PURE__ */ new Error()).stack);
 				}
 			}
 			seen.set(key, i);

package/dist/base.mjs

@@ -52,6 +52,14 @@ var Elysia = class Elysia {
 		if (this["~Prefix"] && !this["~Prefix"].startsWith("/")) this["~Prefix"] = `/${this["~Prefix"]}`;
 		if (config?.name) this.#hash = fnv1a(config.seed ? `${config.name}_${typeof config.seed === "object" ? JSON.stringify(config.seed) : config.seed}` : config.name);
 	}
+	/**
+	* @deprecated use `app.history` instead
+	*
+	* Elysia changes it store route internally
+	* This API is provided as compatibility
+	*
+	* Will remove in 2.1
+	*/
 	get routes() {
 		if (!this.#history) return [];
 		if (this.#cachedRoutes) return this.#cachedRoutes;
@@ -1103,7 +1111,7 @@ var Elysia = class Elysia {
 			if (seen.has(key)) {
 				hasDuplicate = true;
 				if (!isProduction()) {
-					if (this.#history[seen.get(key)][2] !== route[2]) console.warn(`[Elysia] Duplicate route ${key} — the later definition overrides the earlier one (its schema/hooks are dropped).`);
+					if (this.#history[seen.get(key)][2] !== route[2]) console.warn(`[Elysia] Duplicate route ${key} at`, (/* @__PURE__ */ new Error()).stack);
 				}
 			}
 			seen.set(key, i);

package/dist/compile/aot.d.ts

@@ -71,11 +71,14 @@ interface CompiledSnapshot {
   lazyGroups: Array<() => ValidatorManifest> | undefined;
   lazyGroupOf: Record<string, Record<string, number>> | undefined;
   builtGroups: number[];
+  planRebuilder: ((original: unknown, plan: CoercePlan) => any) | undefined;
 }
 declare abstract class Compiled {
   static get handlers(): HandlerManifest | undefined;
   static set handlers(manifest: HandlerManifest);
   static get validators(): ValidatorManifest | undefined;
+  static get planRebuilder(): ((original: unknown, plan: CoercePlan) => any) | undefined;
+  static set planRebuilder(rebuild: ((original: unknown, plan: CoercePlan) => any) | undefined);
   static set validators(manifest: ValidatorManifest);
   static registerLazyValidators(groups: Array<() => ValidatorManifest>, groupOf: Record<string, Record<string, number>>): void;
   static getValidator(method: string, path: string, slot: ValidatorSlot): FrozenValidator | undefined;
@@ -226,7 +229,7 @@ declare const Capture: {
 };
 /**
  * Reset module-level capture lifecycle state.
- * FOR TESTS ONLY — not exported from the package index.
+ * FOR TESTS ONLY
  */
 declare const resetCaptureLifecycleForTests: () => void;
 //#endregion

package/dist/compile/aot.js

@@ -6,6 +6,7 @@ const require_universal_env = require('../universal/env.js');
 //#region src/compile/aot.ts
 let validators;
 let handlers;
+let planRebuilder;
 let lazyGroups;
 let lazyGroupOf;
 const builtGroups = /* @__PURE__ */ new Set();
@@ -19,6 +20,12 @@ var Compiled = class {
 	static get validators() {
 		return validators;
 	}
+	static get planRebuilder() {
+		return planRebuilder;
+	}
+	static set planRebuilder(rebuild) {
+		planRebuilder = rebuild;
+	}
 	static set validators(manifest) {
 		validators = manifest;
 		lazyGroups = void 0;
@@ -56,7 +63,8 @@ var Compiled = class {
 			handlers,
 			lazyGroups,
 			lazyGroupOf,
-			builtGroups: [...builtGroups]
+			builtGroups: [...builtGroups],
+			planRebuilder
 		};
 	}
 	/** @internal restore registry after in-process AOT analysis */
@@ -67,6 +75,7 @@ var Compiled = class {
 		lazyGroupOf = snapshot.lazyGroupOf;
 		builtGroups.clear();
 		for (const group of snapshot.builtGroups) builtGroups.add(group);
+		planRebuilder = snapshot.planRebuilder;
 	}
 	/** @internal test isolation */
 	static clear() {
@@ -75,6 +84,7 @@ var Compiled = class {
 		lazyGroups = void 0;
 		lazyGroupOf = void 0;
 		builtGroups.clear();
+		planRebuilder = void 0;
 	}
 };
 function reconstructCheck(build) {
@@ -336,7 +346,7 @@ const Capture = {
 };
 /**
 * Reset module-level capture lifecycle state.
-* FOR TESTS ONLY — not exported from the package index.
+* FOR TESTS ONLY
 */
 const resetCaptureLifecycleForTests = () => void 0;
 

package/dist/compile/aot.mjs

@@ -5,6 +5,7 @@ import { env } from "../universal/env.mjs";
 //#region src/compile/aot.ts
 let validators;
 let handlers;
+let planRebuilder;
 let lazyGroups;
 let lazyGroupOf;
 const builtGroups = /* @__PURE__ */ new Set();
@@ -18,6 +19,12 @@ var Compiled = class {
 	static get validators() {
 		return validators;
 	}
+	static get planRebuilder() {
+		return planRebuilder;
+	}
+	static set planRebuilder(rebuild) {
+		planRebuilder = rebuild;
+	}
 	static set validators(manifest) {
 		validators = manifest;
 		lazyGroups = void 0;
@@ -55,7 +62,8 @@ var Compiled = class {
 			handlers,
 			lazyGroups,
 			lazyGroupOf,
-			builtGroups: [...builtGroups]
+			builtGroups: [...builtGroups],
+			planRebuilder
 		};
 	}
 	/** @internal restore registry after in-process AOT analysis */
@@ -66,6 +74,7 @@ var Compiled = class {
 		lazyGroupOf = snapshot.lazyGroupOf;
 		builtGroups.clear();
 		for (const group of snapshot.builtGroups) builtGroups.add(group);
+		planRebuilder = snapshot.planRebuilder;
 	}
 	/** @internal test isolation */
 	static clear() {
@@ -74,6 +83,7 @@ var Compiled = class {
 		lazyGroups = void 0;
 		lazyGroupOf = void 0;
 		builtGroups.clear();
+		planRebuilder = void 0;
 	}
 };
 function reconstructCheck(build) {
@@ -335,7 +345,7 @@ const Capture = {
 };
 /**
 * Reset module-level capture lifecycle state.
-* FOR TESTS ONLY — not exported from the package index.
+* FOR TESTS ONLY
 */
 const resetCaptureLifecycleForTests = () => void 0;
 

package/dist/compile/handler/frozen-validator.d.ts

@@ -7,6 +7,7 @@ declare const isBridgeNotInitialized: (error: unknown) => boolean;
 declare class FrozenSlotValidator {
   #private;
   isAsync: boolean;
+  hasCodec: boolean;
   schema: unknown;
   constructor(frozen: FrozenValidator, schema: unknown, raw: unknown, normalize: boolean | 'exactMirror' | 'typebox' | undefined);
   Check(value: unknown): boolean;
@@ -23,9 +24,6 @@ interface FrozenRouteValidatorShape {
   response?: Record<number, FrozenSlotValidator>;
 }
 declare function buildFrozenRouteValidator(hook: AnyLocalHook, root: AnyElysia, method: HTTPMethod, path: string): FrozenRouteValidatorShape | undefined;
-/**
- * Build-time twin of `isBridgeFreeComplete`, operating on the captured entry & its schema
- */
-declare function isCapturedBridgeFree(c: CapturedValidator, schema: unknown): boolean;
+declare function isCapturedBridgeFree(c: CapturedValidator, schema: unknown, coerced?: unknown): boolean;
 //#endregion
 export { buildFrozenRouteValidator, isBridgeNotInitialized, isCapturedBridgeFree };

package/dist/compile/handler/frozen-validator.js

@@ -3,7 +3,6 @@ const require_utils = require('../../utils.js');
 const require_type_constants = require('../../type/constants.js');
 const require_error = require('../../error.js');
 const require_compile_aot = require('../aot.js');
-const require_type_coerce_plan = require('../../type/coerce-plan.js');
 
 //#region src/compile/handler/frozen-validator.ts
 const isBridgeNotInitialized = (error) => error instanceof Error && error.message.startsWith("Typebox module isn't initialized");
@@ -69,8 +68,10 @@ var FrozenSlotValidator = class {
 	#noValidate;
 	constructor(frozen, schema, raw, normalize) {
 		this.isAsync = false;
+		this.hasCodec = false;
 		this.schema = schema;
 		if (frozen.ic) require_compile_aot.reconstructInnerCodecs(frozen.ic, schema);
+		this.hasCodec = frozen.k === 1;
 		if (frozen.k === 1 && frozen.dm) {
 			const both = require_compile_aot.instantiateFrozenBoth(frozen, schema, raw);
 			this.#check = both.check;
@@ -159,7 +160,12 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 		if (!schema) return void 0;
 		const frozen = require_compile_aot.Compiled.getValidator(method, path, slot);
 		if (!frozen) return void 0;
-		const coerced = frozen.cp ? require_type_coerce_plan.buildCoercedFromPlan(schema, frozen.cp) : schema;
+		let coerced = schema;
+		if (frozen.cp) {
+			const rebuild = require_compile_aot.Compiled.planRebuilder;
+			if (!rebuild) return void 0;
+			coerced = rebuild(schema, frozen.cp);
+		}
 		if (!isBridgeFreeComplete(frozen, coerced, schema)) return void 0;
 		out[slot] = new FrozenSlotValidator(frozen, coerced, schema, normalize);
 	}
@@ -181,10 +187,7 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 	return out;
 }
 const isResponseMap = (schema) => !("~kind" in schema || "~elyAcl" in schema || "~standard" in schema);
-/**
-* Build-time twin of `isBridgeFreeComplete`, operating on the captured entry & its schema
-*/
-function isCapturedBridgeFree(c, schema) {
+function isCapturedBridgeFree(c, schema, coerced = schema) {
 	if (typeof schema === "string") return false;
 	/**
 	* A captured `cm` entry is one that froze BOTH check and mirror
@@ -193,10 +196,7 @@ function isCapturedBridgeFree(c, schema) {
 	* @see plugin/source.ts `entryParts`
 	*/
 	if (!(c.checkValue && c.mirror)) return false;
-	if (c.hasCodec && !!c.decodeMirror && !c.encodeMirror && !c.customErrors?.length && !c.async && !(c.hasDefault && !c.precomputeSafe)) {
-		const coerced = c.coercePlan ? require_type_coerce_plan.buildCoercedFromPlan(schema, c.coercePlan) : schema;
-		return innerCodecsAligned(c.innerCodecs?.length, coerced) && mirrorUnionsAligned(c.mirror.u, schema) && mirrorUnionsAligned(c.decodeMirror.u, coerced);
-	}
+	if (c.hasCodec && !!c.decodeMirror && !c.encodeMirror && !c.customErrors?.length && !c.async && !(c.hasDefault && !c.precomputeSafe)) return innerCodecsAligned(c.innerCodecs?.length, coerced) && mirrorUnionsAligned(c.mirror.u, schema) && mirrorUnionsAligned(c.decodeMirror.u, coerced);
 	if (c.external || c.mirror.u || c.decodeMirror || c.encodeMirror || c.hasCodec || c.customErrors?.length || c.innerCodecs?.length || c.async) return false;
 	if (c.hasDefault && !c.precomputeSafe) return false;
 	if (isFullyClosedObject(schema)) return false;

package/dist/compile/handler/frozen-validator.mjs

@@ -2,7 +2,6 @@ import { nullObject } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../../type/constants.mjs";
 import { ValidationError } from "../../error.mjs";
 import { Compiled, EMPTY_EXTERNALS, collectMirrorUnions, collectStringCodecNodes, instantiateFrozenBoth, instantiateFrozenDecodeMirror, reconstructInnerCodecs } from "../aot.mjs";
-import { buildCoercedFromPlan } from "../../type/coerce-plan.mjs";
 
 //#region src/compile/handler/frozen-validator.ts
 const isBridgeNotInitialized = (error) => error instanceof Error && error.message.startsWith("Typebox module isn't initialized");
@@ -68,8 +67,10 @@ var FrozenSlotValidator = class {
 	#noValidate;
 	constructor(frozen, schema, raw, normalize) {
 		this.isAsync = false;
+		this.hasCodec = false;
 		this.schema = schema;
 		if (frozen.ic) reconstructInnerCodecs(frozen.ic, schema);
+		this.hasCodec = frozen.k === 1;
 		if (frozen.k === 1 && frozen.dm) {
 			const both = instantiateFrozenBoth(frozen, schema, raw);
 			this.#check = both.check;
@@ -158,7 +159,12 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 		if (!schema) return void 0;
 		const frozen = Compiled.getValidator(method, path, slot);
 		if (!frozen) return void 0;
-		const coerced = frozen.cp ? buildCoercedFromPlan(schema, frozen.cp) : schema;
+		let coerced = schema;
+		if (frozen.cp) {
+			const rebuild = Compiled.planRebuilder;
+			if (!rebuild) return void 0;
+			coerced = rebuild(schema, frozen.cp);
+		}
 		if (!isBridgeFreeComplete(frozen, coerced, schema)) return void 0;
 		out[slot] = new FrozenSlotValidator(frozen, coerced, schema, normalize);
 	}
@@ -180,10 +186,7 @@ function buildFrozenRouteValidator(hook, root, method, path) {
 	return out;
 }
 const isResponseMap = (schema) => !("~kind" in schema || "~elyAcl" in schema || "~standard" in schema);
-/**
-* Build-time twin of `isBridgeFreeComplete`, operating on the captured entry & its schema
-*/
-function isCapturedBridgeFree(c, schema) {
+function isCapturedBridgeFree(c, schema, coerced = schema) {
 	if (typeof schema === "string") return false;
 	/**
 	* A captured `cm` entry is one that froze BOTH check and mirror
@@ -192,10 +195,7 @@ function isCapturedBridgeFree(c, schema) {
 	* @see plugin/source.ts `entryParts`
 	*/
 	if (!(c.checkValue && c.mirror)) return false;
-	if (c.hasCodec && !!c.decodeMirror && !c.encodeMirror && !c.customErrors?.length && !c.async && !(c.hasDefault && !c.precomputeSafe)) {
-		const coerced = c.coercePlan ? buildCoercedFromPlan(schema, c.coercePlan) : schema;
-		return innerCodecsAligned(c.innerCodecs?.length, coerced) && mirrorUnionsAligned(c.mirror.u, schema) && mirrorUnionsAligned(c.decodeMirror.u, coerced);
-	}
+	if (c.hasCodec && !!c.decodeMirror && !c.encodeMirror && !c.customErrors?.length && !c.async && !(c.hasDefault && !c.precomputeSafe)) return innerCodecsAligned(c.innerCodecs?.length, coerced) && mirrorUnionsAligned(c.mirror.u, schema) && mirrorUnionsAligned(c.decodeMirror.u, coerced);
 	if (c.external || c.mirror.u || c.decodeMirror || c.encodeMirror || c.hasCodec || c.customErrors?.length || c.innerCodecs?.length || c.async) return false;
 	if (c.hasDefault && !c.precomputeSafe) return false;
 	if (isFullyClosedObject(schema)) return false;

package/dist/error.d.ts

@@ -183,7 +183,7 @@ declare const PROBLEM_JSON = "application/problem+json";
  */
 type Problem<Code extends number | keyof StatusMap = number | keyof StatusMap, Extension extends Record<string, unknown> = {}> = {
   /** URI (or slug) identifying the problem type. @default 'about:blank' */type?: string; /** Short, human-readable summary of the problem type */
-  title?: string; /** HTTP status — a number or a `StatusMap` name (e.g. `'Conflict'`) */
+  title?: string; /** HTTP status. A number or a `StatusMap` name (e.g. `'Conflict'`) */
   status?: Code; /** Human-readable explanation specific to this occurrence */
   detail?: string; /** URI identifying the specific occurrence of the problem */
   instance?: string;

package/dist/plugin/core.d.ts

@@ -15,7 +15,7 @@ interface ElysiaAotOptions {
    * Validator entries are registered as grouped thunks: a group's
    * validators are constructed on the first request to any route in that
    * group, trading first-request latency in unbuilt groups for lower
-   * startup cost. Handlers are always eager — only validator construction
+   * startup cost. Handlers are always eager. Only validator construction
    * is deferred. Pass a number to set the group size explicitly.
    *
    * @default decided by Elysia based on route batch scale
@@ -84,7 +84,7 @@ interface StubPlan {
   /**
    * Stub the `memory` module's `clearSucroseCache` edge when handler JIT is
    * stubbed. Sucrose never runs in a precompiled app, so its caches are always
-   * empty and the flush is a no-op — dropping the import lets the Sucrose
+   * empty and the flush is a no-op. Dropping the import lets the Sucrose
    * analyzer tree-shake. `flushMemory`'s other clears are preserved, and the
    * public `elysia/sucrose` module is left untouched
    */
@@ -92,7 +92,7 @@ interface StubPlan {
   /**
    * Stub `type/compat` so `setupTypebox` becomes a no-op, un-wiring the
    * TypeBox bridge from the bundle. Set in BOTH sealed (mode A) and wired
-   * (mode B) builds. In mode A the bridge is severed entirely — every captured
+   * (mode B) builds. In mode A the bridge is severed entirely. Every captured
    * validator is bridge-free so nothing reaches it. In mode B the mirror
    * (`bridge` → `bridge-live` reroute) replaces the latch, so `setupTypebox`
    * must still be a no-op to guarantee the bridge is wired exactly once
@@ -109,13 +109,13 @@ interface StubPlan {
 /**
  * Chosen TypeBox-collapse strategy for the build, logged in the dry-run line.
  *
- * - `'sealed'` (mode A): every captured validator is bridge-free and the app is
- *   fully stripped (handler JIT unused, no WS). `compat` is stubbed and the
- *   bridge is severed — TypeBox collapses entirely
+ * - `'sealed'` (mode A): every captured validator is bridge-free (HTTP and WS
+ *   alike) and the app is fully stripped (handler JIT unused). `compat` is
+ *   stubbed and the bridge is severed, TypeBox collapses entirely
  * - `'wired'` (mode B): at least one validator still needs the bridge. `compat`
  *   is stubbed AND the bridge is re-routed to the statically-wired mirror so it
  *   works without the DCE-fragile `setupTypebox()` anchor
- * - `'off'`: no bridge action (strip disabled, or handler JIT still reachable —
+ * - `'off'`: no bridge action (strip disabled, or handler JIT still reachable,
  *   the frozen path is not active so the bridge stays wired the normal way)
  */
 type BridgeMode = 'sealed' | 'wired' | 'off';
@@ -123,51 +123,11 @@ declare const STUB_SOURCES: Record<keyof StubPlan, Array<{
   filter: RegExp;
   source: string;
 }>>;
-/**
- * Rewrite a stub's extensionless relative imports to match the extension of the
- * real module it replaces
- *
- * The sucrose stub replaces `memory.(mjs|js|ts)`. Its bare relative specifiers
- * (`./context`, …) are correct against the `.ts` source, but against a `.mjs`
- * dist module esbuild's node resolver defaults an extensionless specifier to the
- * sibling CJS `.js` (elysia's package.json has no `"type": "module"`), pulling a
- * whole duplicate CJS copy of the elysia subtree alongside the app's `.mjs` one.
- * Anchoring the specifiers to the replaced file's extension keeps the stub on the
- * same module instances the app already resolves. `./validator` is a directory,
- * so it expands to `./validator/index`
- */
 declare const alignStubExtensions: (stubSource: string, targetPath: string) => string;
-/**
- * Elysia's `t.*` overrides — the 27 names `elysia/type` replaces (or adds) over
- * `typebox/type`. Each maps to its leaf module basename (under `type/elysia/`)
- * and the name it is exported as from that leaf (some leaves rename to avoid
- * shadowing a JS global, e.g. `Array` → `ArrayType`).
- *
- * SINGLE SOURCE OF TRUTH: mirrors `src/type/index.ts` (the runtime `t` object)
- * and `src/type/exports.ts`. `test/aot/virtual-type-drift.test.ts` pins it
- * against the live `t` object vs `typebox/type` (`Object.keys` diff) so a future
- * `t.*` addition/removal that skips this table trips the drift test.
- */
 declare const OVERRIDE_MAP: Record<string, {
   leaf: string;
   export: string;
 }>;
-/**
- * Build the virtual `elysia/type` module source — a plain re-export surface with
- * NO `setupTypebox` call (that is the whole point: consuming `t` this way must
- * not drag the bridge latch).
- *
- * TypeBox's `t.*` names pass through to the user's own `typebox/type` (resolved
- * to an absolute path — the same copy the bundle uses); the 27 Elysia overrides
- * re-export from their leaf modules (absolute paths, because elysia's `exports`
- * map blocks `./dist/*` subpaths). Emitting STATIC NAMED re-exports (not
- * `export *`) is what lets `import * as t from 'elysia/type'` — the specifier the
- * treeshake rewrite emits — tree-shake unused constructors per-member.
- *
- * `typeSpecifier` is the specifier the plugin intercepts (`elysia/type`); it is
- * resolved to locate the dist `type/elysia/*` leaf modules and to derive their
- * extension.
- */
 declare function generateVirtualType(typeSpecifier?: string): Promise<string>;
 declare function generateCompiledModule(file: string, options?: ElysiaAotOptions): Promise<string>;
 interface CompiledArtifacts {

package/dist/plugin/core.js

@@ -38,21 +38,21 @@ const NO_STUB = {
 * `true` throws when handler JIT is still reachable; `false` disables.
 *
 * Also decides the TypeBox-collapse `mode`:
-* - `'sealed'` (mode A): the frozen path is active (`jit`), no WS, and EVERY
-*   captured validator is bridge-free (`bridgeFree`). `setupTypebox` is stubbed
-*   and the bridge is severed — nothing reaches it, TypeBox collapses.
-* - `'wired'` (mode B): the frozen path is active but at least one validator
+* - `'sealed'`: the frozen path is active (`jit`) and EVERY captured
+*   validator, HTTP and WS is bridge-free (`bridgeFree`). `setupTypebox` is
+*   stubbed and the bridge is severe, nothing reaches it, TypeBox collapses.
+* - `'wired'`: the frozen path is active but at least one validator
 *   still needs the bridge. `setupTypebox` is stubbed AND the bridge is
 *   re-routed to the statically-wired mirror (works without the DCE-fragile
 *   `setupTypebox()` anchor).
 * - `'off'`: handler JIT still reachable (or strip disabled). The frozen path
-*   is not active, so the bridge must stay wired the ordinary way — no compat
+*   is not active, so the bridge must stay wired the ordinary way. No compat
 *   stub, no reroute.
 */
-function planFromReport(strip, report, hasWS, aliases, allBridgeFree) {
+function planFromReport(strip, report, hasWS, aliases, allBridgeFree, zeroCapture) {
 	const jit = report.jit;
 	if (strip === true && !jit) throw new Error(`[elysia-aot] strip: true requires every route to be covered by the AOT handler manifest, but handler JIT is still reachable (${report.reasons.join(", ") || "unknown"}). Use strip: 'auto' to skip stubbing when the app is not fully precompiled.`);
-	const mode = !(jit && !hasWS) ? "off" : allBridgeFree ? "sealed" : "wired";
+	const mode = !jit ? "off" : allBridgeFree ? "sealed" : hasWS && zeroCapture ? "off" : "wired";
 	return {
 		plan: {
 			jit,
@@ -104,35 +104,11 @@ const STUB_SOURCES = {
 		source: `export * from './bridge-live'\n`
 	}]
 };
-/**
-* Rewrite a stub's extensionless relative imports to match the extension of the
-* real module it replaces
-*
-* The sucrose stub replaces `memory.(mjs|js|ts)`. Its bare relative specifiers
-* (`./context`, …) are correct against the `.ts` source, but against a `.mjs`
-* dist module esbuild's node resolver defaults an extensionless specifier to the
-* sibling CJS `.js` (elysia's package.json has no `"type": "module"`), pulling a
-* whole duplicate CJS copy of the elysia subtree alongside the app's `.mjs` one.
-* Anchoring the specifiers to the replaced file's extension keeps the stub on the
-* same module instances the app already resolves. `./validator` is a directory,
-* so it expands to `./validator/index`
-*/
 const alignStubExtensions = (stubSource, targetPath) => {
 	const ext = targetPath.slice(targetPath.lastIndexOf("."));
 	if (ext !== ".mjs" && ext !== ".js" && ext !== ".cjs") return stubSource;
 	return stubSource.replace(/(from ')(\.[^']+)(')/g, (_m, open, spec, close) => open + (spec === "./validator" ? spec + "/index" : spec) + ext + close);
 };
-/**
-* Elysia's `t.*` overrides — the 27 names `elysia/type` replaces (or adds) over
-* `typebox/type`. Each maps to its leaf module basename (under `type/elysia/`)
-* and the name it is exported as from that leaf (some leaves rename to avoid
-* shadowing a JS global, e.g. `Array` → `ArrayType`).
-*
-* SINGLE SOURCE OF TRUTH: mirrors `src/type/index.ts` (the runtime `t` object)
-* and `src/type/exports.ts`. `test/aot/virtual-type-drift.test.ts` pins it
-* against the live `t` object vs `typebox/type` (`Object.keys` diff) so a future
-* `t.*` addition/removal that skips this table trips the drift test.
-*/
 const OVERRIDE_MAP = {
 	Accelerate: {
 		leaf: "accelerate",
@@ -244,17 +220,6 @@ const OVERRIDE_MAP = {
 	}
 };
 const requireFromHere = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
-/**
-* Resolve a specifier to an absolute path using the SAME resolution the ESM
-* bundle will use (the `import` condition, so `elysia/type` → `.mjs` — the
-* extension every ESM bundle here resolves to, and the one the leaf modules must
-* carry to avoid the CJS dual-copy the `alignStubExtensions` lesson warns of).
-*
-* `import.meta.resolve` honours the `import` condition and is present in the ESM
-* plugin build (the one every bundler integration loads). In the CJS build
-* Rolldown lowers `import.meta` to `{}`, so `import.meta.resolve` is `undefined`
-* and we fall back to `require.resolve`.
-*/
 const resolveSpecifier = (specifier) => {
 	const meta = {};
 	if (typeof meta.resolve === "function") {
@@ -263,22 +228,6 @@ const resolveSpecifier = (specifier) => {
 	}
 	return requireFromHere.resolve(specifier);
 };
-/**
-* Build the virtual `elysia/type` module source — a plain re-export surface with
-* NO `setupTypebox` call (that is the whole point: consuming `t` this way must
-* not drag the bridge latch).
-*
-* TypeBox's `t.*` names pass through to the user's own `typebox/type` (resolved
-* to an absolute path — the same copy the bundle uses); the 27 Elysia overrides
-* re-export from their leaf modules (absolute paths, because elysia's `exports`
-* map blocks `./dist/*` subpaths). Emitting STATIC NAMED re-exports (not
-* `export *`) is what lets `import * as t from 'elysia/type'` — the specifier the
-* treeshake rewrite emits — tree-shake unused constructors per-member.
-*
-* `typeSpecifier` is the specifier the plugin intercepts (`elysia/type`); it is
-* resolved to locate the dist `type/elysia/*` leaf modules and to derive their
-* extension.
-*/
 async function generateVirtualType(typeSpecifier = "elysia/type") {
 	const typePath = resolveSpecifier(typeSpecifier);
 	const typeboxPath = resolveSpecifier("typebox/type");
@@ -288,7 +237,7 @@ async function generateVirtualType(typeSpecifier = "elysia/type") {
 	const overrideNames = new Set(Object.keys(OVERRIDE_MAP));
 	const passthrough = Object.keys(typebox).filter((name) => !overrideNames.has(name));
 	const toSpecifier = (p) => JSON.stringify(p.replace(/\\/g, "/"));
-	let source = `// Generated by Elysia build plugin — virtual 'elysia/type' re-export surface.\n`;
+	let source = `// Generated by Elysia build plugin. Virtual 'elysia/type' re-export surface.\n`;
 	source += `export { ${passthrough.join(", ")} } from ${toSpecifier(typeboxPath)}\n`;
 	for (const [name, { leaf, export: exported }] of Object.entries(OVERRIDE_MAP)) {
 		const spec = toSpecifier((0, node_path.join)(leafDir, leaf + ext));
@@ -308,7 +257,7 @@ async function generateCompiledArtifacts(file, options) {
 		const entryReal = realPath(entry);
 		let mod;
 		if (_importedEntries.has(entryReal)) {
-			console.warn("[elysia-aot] re-importing \"" + entry + "\" for rebuild — top-level side effects will re-run. This is expected in watch/rebuild flows.");
+			console.warn("[elysia-aot] re-importing \"" + entry + "\" for rebuild. top-level side effects will re-run. This is expected in watch/rebuild flows.");
 			const cacheBustSpecifier = entry + "?elysia-aot=" + Date.now();
 			try {
 				mod = await import(cacheBustSpecifier);
@@ -358,7 +307,7 @@ async function generateCompiledArtifacts(file, options) {
 		}
 		if (typedApp["~config"]?.normalize === "typebox") routesForbidSeal = true;
 		const frozenSlots = artifacts.validators.length;
-		const { plan: stub, mode } = planFromReport(strip, report, hasWS, aliases, artifacts.handlers.length > 0 && !routesForbidSeal && frozenSlots >= expectedSlots && artifacts.validators.every((v) => v.bridgeFree === true));
+		const { plan: stub, mode } = planFromReport(strip, report, hasWS, aliases, (artifacts.handlers.length > 0 || artifacts.validators.length > 0) && !routesForbidSeal && frozenSlots >= expectedSlots && artifacts.validators.every((v) => v.bridgeFree === true), artifacts.handlers.length === 0 && artifacts.validators.length === 0);
 		if (options?.target === "workerd") {
 			if (!report.jit) throw new Error(`[elysia-aot] target 'workerd' but handler JIT is still reachable (${report.reasons.join(", ") || "unknown"}). Every route must be captured into the AOT manifest.`);
 			if (frozenSlots < expectedSlots) console.warn(`[elysia-aot] target 'workerd': only ${frozenSlots}/${expectedSlots} validator slots were frozen unfrozen slots compile at runtime and will fail on workerd.`);