elysia 2.0.0-beta.2 → 2.0.0-beta.3

package/dist/plugin/aot/core.d.ts

@@ -156,6 +156,21 @@ interface StubPlan {
    * least one validator that is not bridge-free, so the bridge is still needed
    */
   bridge: boolean;
+  /**
+   * Re-route `type/typebox-value` -> its statically-imported `-live` mirror
+   * (bundlers can't follow the runtime `require`)
+   * Every mode except sealed, there the unresolvable `require` is what lets TypeBox collapse
+   */
+  typeboxValue: boolean;
+  /**
+   * Re-route `type/typebox-type` -> its `-live` mirror
+   * Every mode, sealed included (unlike `typeboxValue`), sealed still executes
+   * user `t.*()` at route definition and `typebox/type` is already in the bundle
+   * via the virtual `elysia/type` module
+   *
+   * skipping the rewrite collapses nothing and only buys a startup crash on loader-less runtimes
+   */
+  typeboxType: boolean;
   /**
    * Replace `adapter/constants` with a target-specific stub that hard-selects
    * either `BunAdapter` or `WebStandardAdapter`, letting the bundler DCE the
@@ -202,7 +217,13 @@ declare const NO_STUB: StubPlan;
  *   is not active, so the bridge must stay wired the ordinary way. No compat
  *   stub, no reroute.
  */
-declare function planFromReport(strip: boolean | 'auto', report: JITProbeResult, hasWS: boolean, mayTrace: boolean, aliases: Set<string>, allBridgeFree: boolean, zeroCapture: boolean, adapterStub?: 'bun' | 'web-standard' | false, productionStub?: boolean): {
+declare function planFromReport(strip: boolean | 'auto', report: JITProbeResult, hasWS: boolean, mayTrace: boolean, aliases: Set<string>, allBridgeFree: boolean, zeroCapture: boolean, adapterStub?: 'bun' | 'web-standard' | false, productionStub?: boolean,
+/**
+ * A WS route declares a `cookie` schema. Its upgrade path handles cookies
+ * outside the handler JIT, so it emits no `cc` alias — stubbing on that
+ * alias alone would hand `src/ws/route.ts` a throwing `parseCookieRaw`
+ */
+wsCookie?: boolean): {
   plan: StubPlan;
   mode: BridgeMode;
 };

package/dist/plugin/aot/core.js

@@ -29,6 +29,8 @@ const NO_STUB = {
 	sucrose: false,
 	compat: false,
 	bridge: false,
+	typeboxValue: false,
+	typeboxType: false,
 	adapter: false,
 	isProduction: false
 };
@@ -49,7 +51,7 @@ const NO_STUB = {
 *   is not active, so the bridge must stay wired the ordinary way. No compat
 *   stub, no reroute.
 */
-function planFromReport(strip, report, hasWS, mayTrace, aliases, allBridgeFree, zeroCapture, adapterStub = false, productionStub = true) {
+function planFromReport(strip, report, hasWS, mayTrace, aliases, allBridgeFree, zeroCapture, adapterStub = false, productionStub = true, wsCookie = false) {
 	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 ? "off" : allBridgeFree ? "sealed" : hasWS && zeroCapture ? "off" : "wired";
@@ -58,11 +60,13 @@ function planFromReport(strip, report, hasWS, mayTrace, aliases, allBridgeFree,
 			jit,
 			ws: !hasWS,
 			reconstruct: jit && !aliases.has("va") && !aliases.has("cc") && !aliases.has("tr"),
-			cookie: jit && !aliases.has("cc"),
+			cookie: jit && !aliases.has("cc") && !wsCookie,
 			trace: !aliases.has("tr") && (jit || !mayTrace),
 			sucrose: jit,
 			compat: mode !== "off",
 			bridge: mode === "wired",
+			typeboxValue: mode !== "sealed",
+			typeboxType: true,
 			adapter: adapterStub,
 			isProduction: productionStub
 		},
@@ -172,6 +176,14 @@ const STUB_SOURCES = {
 	bridge: [{
 		filter: /[\\/]elysia[\\/](dist|src)[\\/]type[\\/]bridge\.(m?js|ts)$/,
 		source: `export * from './bridge-live'\n`
+	}],
+	typeboxValue: [{
+		filter: /[\\/]elysia[\\/](dist|src)[\\/]type[\\/]typebox-value\.(m?js|ts)$/,
+		source: `export * from './typebox-value-live'\n`
+	}],
+	typeboxType: [{
+		filter: /[\\/]elysia[\\/](dist|src)[\\/]type[\\/]typebox-type\.(m?js|ts)$/,
+		source: `export * from './typebox-type-live'\n`
 	}]
 };
 const alignStubExtensions = (stubSource, targetPath) => {
@@ -379,6 +391,21 @@ function isStandardResponse(response) {
 	if (entries.length === 0) return false;
 	return entries.every((v) => require_compile_handler_frozen_validator.isStandardSchema(v));
 }
+/**
+* The manifest is one flat `method -> path` table with no per-app namespace,
+* bound to whichever app builds a router first, so a mounted sub-app (a second
+* Elysia building on its own schedule) is not representable
+*
+* refuse at build time rather than ship a coin flip
+*/
+const assertNoMount = (app, entry) => {
+	const routes = app["~routes"];
+	if (!routes) return;
+	const mounted = [];
+	for (const route of routes) if (route[2]?.["~mount"] && !mounted.includes(route[1])) mounted.push(route[1]);
+	if (!mounted.length) return;
+	throw new Error(`[elysia-aot] "${entry}" mounts a sub-app (${mounted.join(", ")}). AOT cannot compile a mounted sub-app. Compose with .use() instead of .mount(), or disable AOT plugin`);
+};
 async function generateCompiledArtifacts(file, options) {
 	const previousAotBuild = process.env.ELYSIA_AOT_BUILD;
 	process.env.ELYSIA_AOT_BUILD = "1";
@@ -394,6 +421,7 @@ async function generateCompiledArtifacts(file, options) {
 		const app = mod.app ?? mod.default;
 		if (!app || typeof app.compile !== "function") throw new Error(`[elysia-aot] "${entry}" must export an Elysia app`);
 		const typedApp = app;
+		assertNoMount(typedApp, entry);
 		const sourceOptions = {
 			register: true,
 			registerFrom: options?.registerFrom,
@@ -408,6 +436,8 @@ async function generateCompiledArtifacts(file, options) {
 			source: await require_plugin_aot_source.compileToSource(typedApp, sourceOptions),
 			stub: {
 				...NO_STUB,
+				typeboxValue: true,
+				typeboxType: true,
 				adapter: adapterStub,
 				isProduction: productionStub
 			},
@@ -422,9 +452,11 @@ async function generateCompiledArtifacts(file, options) {
 		const mayTrace = !!typedApp["~hasTrace"] || history.some((route) => (route?.[4])?.trace?.length || route?.[2]?.["~mount"]);
 		let expectedSlots = 0;
 		let routesForbidSeal = false;
+		let wsCookie = false;
 		for (const route of history) {
 			const [, , , instance, hook, appHook, inheritedChain, macroScope] = route;
 			const hooks = require_compile_handler_index.composeRouteHook(instance, hook, appHook, inheritedChain, typedApp, macroScope);
+			if (route[0] === "WS" && (hook?.cookie !== void 0 || hooks?.cookie !== void 0)) wsCookie = true;
 			if (!hooks) continue;
 			let routeHasTypeBoxDirectSlot = false;
 			for (const slot of [
@@ -451,7 +483,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, mayTrace, 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, adapterStub, productionStub);
+		const { plan: stub, mode } = planFromReport(strip, report, hasWS, mayTrace, 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, adapterStub, productionStub, wsCookie);
 		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.`);

package/dist/plugin/aot/core.mjs

@@ -27,6 +27,8 @@ const NO_STUB = {
 	sucrose: false,
 	compat: false,
 	bridge: false,
+	typeboxValue: false,
+	typeboxType: false,
 	adapter: false,
 	isProduction: false
 };
@@ -47,7 +49,7 @@ const NO_STUB = {
 *   is not active, so the bridge must stay wired the ordinary way. No compat
 *   stub, no reroute.
 */
-function planFromReport(strip, report, hasWS, mayTrace, aliases, allBridgeFree, zeroCapture, adapterStub = false, productionStub = true) {
+function planFromReport(strip, report, hasWS, mayTrace, aliases, allBridgeFree, zeroCapture, adapterStub = false, productionStub = true, wsCookie = false) {
 	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 ? "off" : allBridgeFree ? "sealed" : hasWS && zeroCapture ? "off" : "wired";
@@ -56,11 +58,13 @@ function planFromReport(strip, report, hasWS, mayTrace, aliases, allBridgeFree,
 			jit,
 			ws: !hasWS,
 			reconstruct: jit && !aliases.has("va") && !aliases.has("cc") && !aliases.has("tr"),
-			cookie: jit && !aliases.has("cc"),
+			cookie: jit && !aliases.has("cc") && !wsCookie,
 			trace: !aliases.has("tr") && (jit || !mayTrace),
 			sucrose: jit,
 			compat: mode !== "off",
 			bridge: mode === "wired",
+			typeboxValue: mode !== "sealed",
+			typeboxType: true,
 			adapter: adapterStub,
 			isProduction: productionStub
 		},
@@ -170,6 +174,14 @@ const STUB_SOURCES = {
 	bridge: [{
 		filter: /[\\/]elysia[\\/](dist|src)[\\/]type[\\/]bridge\.(m?js|ts)$/,
 		source: `export * from './bridge-live'\n`
+	}],
+	typeboxValue: [{
+		filter: /[\\/]elysia[\\/](dist|src)[\\/]type[\\/]typebox-value\.(m?js|ts)$/,
+		source: `export * from './typebox-value-live'\n`
+	}],
+	typeboxType: [{
+		filter: /[\\/]elysia[\\/](dist|src)[\\/]type[\\/]typebox-type\.(m?js|ts)$/,
+		source: `export * from './typebox-type-live'\n`
 	}]
 };
 const alignStubExtensions = (stubSource, targetPath) => {
@@ -377,6 +389,21 @@ function isStandardResponse(response) {
 	if (entries.length === 0) return false;
 	return entries.every((v) => isStandardSchema(v));
 }
+/**
+* The manifest is one flat `method -> path` table with no per-app namespace,
+* bound to whichever app builds a router first, so a mounted sub-app (a second
+* Elysia building on its own schedule) is not representable
+*
+* refuse at build time rather than ship a coin flip
+*/
+const assertNoMount = (app, entry) => {
+	const routes = app["~routes"];
+	if (!routes) return;
+	const mounted = [];
+	for (const route of routes) if (route[2]?.["~mount"] && !mounted.includes(route[1])) mounted.push(route[1]);
+	if (!mounted.length) return;
+	throw new Error(`[elysia-aot] "${entry}" mounts a sub-app (${mounted.join(", ")}). AOT cannot compile a mounted sub-app. Compose with .use() instead of .mount(), or disable AOT plugin`);
+};
 async function generateCompiledArtifacts(file, options) {
 	const previousAotBuild = process.env.ELYSIA_AOT_BUILD;
 	process.env.ELYSIA_AOT_BUILD = "1";
@@ -392,6 +419,7 @@ async function generateCompiledArtifacts(file, options) {
 		const app = mod.app ?? mod.default;
 		if (!app || typeof app.compile !== "function") throw new Error(`[elysia-aot] "${entry}" must export an Elysia app`);
 		const typedApp = app;
+		assertNoMount(typedApp, entry);
 		const sourceOptions = {
 			register: true,
 			registerFrom: options?.registerFrom,
@@ -406,6 +434,8 @@ async function generateCompiledArtifacts(file, options) {
 			source: await compileToSource(typedApp, sourceOptions),
 			stub: {
 				...NO_STUB,
+				typeboxValue: true,
+				typeboxType: true,
 				adapter: adapterStub,
 				isProduction: productionStub
 			},
@@ -420,9 +450,11 @@ async function generateCompiledArtifacts(file, options) {
 		const mayTrace = !!typedApp["~hasTrace"] || history.some((route) => (route?.[4])?.trace?.length || route?.[2]?.["~mount"]);
 		let expectedSlots = 0;
 		let routesForbidSeal = false;
+		let wsCookie = false;
 		for (const route of history) {
 			const [, , , instance, hook, appHook, inheritedChain, macroScope] = route;
 			const hooks = composeRouteHook(instance, hook, appHook, inheritedChain, typedApp, macroScope);
+			if (route[0] === "WS" && (hook?.cookie !== void 0 || hooks?.cookie !== void 0)) wsCookie = true;
 			if (!hooks) continue;
 			let routeHasTypeBoxDirectSlot = false;
 			for (const slot of [
@@ -449,7 +481,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, mayTrace, 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, adapterStub, productionStub);
+		const { plan: stub, mode } = planFromReport(strip, report, hasWS, mayTrace, 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, adapterStub, productionStub, wsCookie);
 		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.`);

package/dist/route-table.js

@@ -47,16 +47,18 @@ function buildRouteTable(declaredRoutes) {
 		macroScope
 	};
 }
-const routeRow = (table, id) => [
-	table.method[id],
-	table.path[id],
-	table.handler[id],
-	table.owner[id],
-	table.localHook[id],
-	table.appHook[id],
-	table.inheritedChain[id],
-	table.macroScope?.get(id)
-];
+const routeRow = (table, id) => {
+	return [
+		table.method[id],
+		table.path[id],
+		table.handler[id],
+		table.owner[id],
+		table.localHook[id],
+		table.appHook[id],
+		table.inheritedChain[id],
+		table.macroScope?.get(id)
+	];
+};
 
 //#endregion
 exports.RouteFlag = RouteFlag;

package/dist/route-table.mjs

@@ -46,16 +46,18 @@ function buildRouteTable(declaredRoutes) {
 		macroScope
 	};
 }
-const routeRow = (table, id) => [
-	table.method[id],
-	table.path[id],
-	table.handler[id],
-	table.owner[id],
-	table.localHook[id],
-	table.appHook[id],
-	table.inheritedChain[id],
-	table.macroScope?.get(id)
-];
+const routeRow = (table, id) => {
+	return [
+		table.method[id],
+		table.path[id],
+		table.handler[id],
+		table.owner[id],
+		table.localHook[id],
+		table.appHook[id],
+		table.inheritedChain[id],
+		table.macroScope?.get(id)
+	];
+};
 
 //#endregion
 export { RouteFlag, buildRouteTable, routeRow };

package/dist/type/bridge-live.d.ts

@@ -5,8 +5,8 @@ import { TypeBoxValidatorCache, mayHaveFileType } from "./validator/validator-ca
 import { TypeBoxValidator } from "./validator/index.js";
 import { applyCoercions, coerceBody, coerceFormData, coerceQuery, coerceRoot, coerceStringToStructure } from "./coerce.js";
 import { Ref } from "typebox/type";
-import { Compile } from "typebox/compile";
 import { Check, Clone, Create, Decode, Default, HasCodec } from "typebox/value";
+import { Compile } from "typebox/compile";
 
 //#region src/type/bridge-live.d.ts
 declare function useTypebox(_mod?: Parameters<typeof useTypebox$1>[0]): void;

package/dist/type/bridge-live.js

@@ -5,8 +5,8 @@ const require_type_coerce = require('./coerce.js');
 const require_type_validator_validator_cache = require('./validator/validator-cache.js');
 const require_type_validator_index = require('./validator/index.js');
 const require_type_elysia_intersect = require('./elysia/intersect.js');
-let typebox_type = require("typebox/type");
 let typebox_compile = require("typebox/compile");
+let typebox_type = require("typebox/type");
 let typebox_value = require("typebox/value");
 let typebox_system = require("typebox/system");
 

package/dist/type/bridge-live.mjs

@@ -3,8 +3,8 @@ import { applyCoercions, coerceBody, coerceFormData, coerceQuery, coerceRoot, co
 import { TypeBoxValidatorCache, mayHaveFileType } from "./validator/validator-cache.mjs";
 import { TypeBoxValidator } from "./validator/index.mjs";
 import { Intersect } from "./elysia/intersect.mjs";
-import { Ref } from "typebox/type";
 import { Compile } from "typebox/compile";
+import { Ref } from "typebox/type";
 import { Check, Clone, Create, Decode, Default, HasCodec } from "typebox/value";
 import { Settings } from "typebox/system";
 

package/dist/type/bridge.d.ts

@@ -4,8 +4,8 @@ import { TypeBoxValidatorCache as TypeBoxValidatorCache$1, mayHaveFileType as ma
 import { TypeBoxValidator as TypeBoxValidator$1 } from "./validator/index.js";
 import { applyCoercions as applyCoercions$1, coerceBody as coerceBody$1, coerceFormData as coerceFormData$1, coerceQuery as coerceQuery$1, coerceRoot as coerceRoot$1, coerceStringToStructure as coerceStringToStructure$1 } from "./coerce.js";
 import { Ref as Ref$1, TAny, TSchema } from "typebox/type";
-import { Compile as Compile$1 } from "typebox/compile";
 import { Check as Check$1, Clone as Clone$1, Create as Create$1, Decode as Decode$2, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
+import { Compile as Compile$1 } from "typebox/compile";
 
 //#region src/type/bridge.d.ts
 interface TypeboxModule {

package/dist/type/coerce-plan.js

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../_virtual/_rolldown/runtime.js');
 const require_utils = require('../utils.js');
 const require_type_constants = require('./constants.js');
 const require_type_shared = require('./shared.js');
+const require_type_typebox_type = require('./typebox-type.js');
 const require_type_elysia_array = require('./elysia/array.js');
 const require_type_elysia_string = require('./elysia/string.js');
 const require_type_elysia_union = require('./elysia/union.js');
@@ -11,7 +11,6 @@ const require_type_elysia_object = require('./elysia/object.js');
 const require_type_elysia_numeric = require('./elysia/numeric.js');
 const require_type_elysia_boolean_string = require('./elysia/boolean-string.js');
 const require_type_elysia_integer_string = require('./elysia/integer-string.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/coerce-plan.ts
 const COERCE_LEAF_CTOR = {
@@ -28,13 +27,13 @@ const icPlaceholder = () => {
 function ObjectStringShape(property, _options) {
 	const [{ properties, ...constraints }, meta] = require_type_elysia_utils.getMeta(_options ?? require_utils.nullObject());
 	const object = require_type_elysia_object.ObjectType(property, constraints);
-	const objectString = (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), icPlaceholder, () => "must be an object"), icPlaceholder);
+	const objectString = require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_elysia_string.StringType(), icPlaceholder, () => "must be an object"), icPlaceholder);
 	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.ObjectString, require_type_elysia_union.Union([object, objectString], meta));
 }
 function ArrayStringShape(property, _options) {
 	const [constraints, meta] = require_type_elysia_utils.getMeta(_options ?? require_utils.nullObject());
 	const array = require_type_elysia_array.ArrayType(property, constraints);
-	const arrayString = (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), icPlaceholder, () => "must be an array"), icPlaceholder);
+	const arrayString = require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_elysia_string.StringType(), icPlaceholder, () => "must be an array"), icPlaceholder);
 	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.ArrayString, require_type_elysia_union.Union([array, arrayString], meta));
 }
 const rebuildObjStrShape = (original, site) => {

package/dist/type/coerce-plan.mjs

@@ -1,6 +1,7 @@
 import { evictOldestHalf, nullObject } from "../utils.mjs";
 import { ELYSIA_TYPES } from "./constants.mjs";
 import { clearCoerceLeafCache, coerceLeafCache, coerceLeafCacheSize } from "./shared.mjs";
+import { Decode, Refine } from "./typebox-type.mjs";
 import { ArrayType } from "./elysia/array.mjs";
 import { StringType } from "./elysia/string.mjs";
 import { Union } from "./elysia/union.mjs";
@@ -9,7 +10,6 @@ import { ObjectType } from "./elysia/object.mjs";
 import { Numeric } from "./elysia/numeric.mjs";
 import { BooleanString } from "./elysia/boolean-string.mjs";
 import { IntegerString } from "./elysia/integer-string.mjs";
-import { Decode, Refine } from "typebox/type";
 
 //#region src/type/coerce-plan.ts
 const COERCE_LEAF_CTOR = {

package/dist/type/compat.d.ts

@@ -1,8 +1,11 @@
+import { TypeboxTypeNamespaces } from "./typebox-type.js";
+import { TypeboxNamespaces } from "./typebox-value.js";
 import { CreateMirror } from "./validator/exact-mirror.js";
 
 //#region src/type/compat.d.ts
 declare function setupTypebox(options?: {
   exactMirror?: CreateMirror;
+  typebox?: Partial<TypeboxNamespaces & TypeboxTypeNamespaces>;
 }): void;
 //#endregion
 export { setupTypebox };

package/dist/type/compat.js

@@ -1,28 +1,46 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../_virtual/_rolldown/runtime.js');
 const require_type_bridge = require('./bridge.js');
 const require_type_utils = require('./utils.js');
+const require_type_typebox_type = require('./typebox-type.js');
+const require_type_typebox_value = require('./typebox-value.js');
 const require_type_coerce = require('./coerce.js');
 const require_type_validator_exact_mirror = require('./validator/exact-mirror.js');
 const require_type_validator_validator_cache = require('./validator/validator-cache.js');
 const require_type_validator_index = require('./validator/index.js');
 const require_type_elysia_intersect = require('./elysia/intersect.js');
-let typebox_type = require("typebox/type");
-let typebox_compile = require("typebox/compile");
-let typebox_value = require("typebox/value");
-let typebox_system = require("typebox/system");
 
 //#region src/type/compat.ts
 let setup = false;
 function setupTypebox(options) {
 	if (options?.exactMirror) require_type_validator_exact_mirror.setExactMirror(options.exactMirror);
+	const typebox = options?.typebox;
+	if (typebox) {
+		const typeSide = [typebox.type, typebox.system];
+		const typeSideProvided = typeSide.filter(Boolean).length;
+		if (typeSideProvided > 0 && typeSideProvided < typeSide.length) throw new Error(`setupTypebox({ typebox }) received an incomplete type-side namespace (only '${typebox.type ? "type" : "system"}' was set). 'type' and 'system' must be provided together.`);
+		const valueSide = [
+			typebox.value,
+			typebox.schema,
+			typebox.compile
+		];
+		const valueSideProvided = valueSide.filter(Boolean).length;
+		if (valueSideProvided > 0 && valueSideProvided < valueSide.length) {
+			const missing = [
+				"value",
+				"schema",
+				"compile"
+			].filter((key) => !typebox[key]);
+			throw new Error(`setupTypebox({ typebox }) received an incomplete value-side namespace (missing '${missing.join("', '")}'). 'value', 'schema', and 'compile' must be provided together.`);
+		}
+		if (typebox.type && typebox.system) require_type_typebox_type.injectTypeboxType(typebox);
+		if (typebox.value && typebox.schema && typebox.compile) require_type_typebox_value.injectTypebox(typebox);
+	}
 	if (setup) return;
 	setup = true;
-	typebox_system.Settings.Set({ unionPrioritySort: false });
 	require_type_bridge.useTypebox({
-		Compile: typebox_compile.Compile,
-		Create: typebox_value.Create,
-		Decode: typebox_value.Decode,
+		Compile: require_type_typebox_value.Compile,
+		Create: require_type_typebox_value.Create,
+		Decode: require_type_typebox_value.Decode,
 		applyCoercions: require_type_coerce.applyCoercions,
 		TypeBoxValidator: require_type_validator_index.TypeBoxValidator,
 		TypeBoxValidatorCache: require_type_validator_validator_cache.TypeBoxValidatorCache,
@@ -33,12 +51,12 @@ function setupTypebox(options) {
 		coerceBody: require_type_coerce.coerceBody,
 		hasTypes: require_type_utils.hasTypes,
 		mayHaveFileType: require_type_validator_validator_cache.mayHaveFileType,
-		HasCodec: typebox_value.HasCodec,
+		HasCodec: require_type_typebox_value.HasCodec,
 		Intersect: require_type_elysia_intersect.Intersect,
-		Default: typebox_value.Default,
-		Ref: typebox_type.Ref,
-		Clone: typebox_value.Clone,
-		Check: typebox_value.Check
+		Default: require_type_typebox_value.Default,
+		Ref: require_type_typebox_type.Ref,
+		Clone: require_type_typebox_value.Clone,
+		Check: require_type_typebox_value.Check
 	});
 }
 

package/dist/type/compat.mjs

@@ -1,26 +1,45 @@
 import { useTypebox } from "./bridge.mjs";
 import { hasTypes } from "./utils.mjs";
+import { Ref, injectTypeboxType } from "./typebox-type.mjs";
+import { Check, Clone, Compile, Create, Decode, Default, HasCodec, injectTypebox } from "./typebox-value.mjs";
 import { applyCoercions, coerceBody, coerceFormData, coerceQuery, coerceRoot, coerceStringToStructure } from "./coerce.mjs";
 import { setExactMirror } from "./validator/exact-mirror.mjs";
 import { TypeBoxValidatorCache, mayHaveFileType } from "./validator/validator-cache.mjs";
 import { TypeBoxValidator } from "./validator/index.mjs";
-import { Intersect as Intersect$1 } from "./elysia/intersect.mjs";
-import { Ref } from "typebox/type";
-import { Compile } from "typebox/compile";
-import { Check, Clone, Create, Decode as Decode$1, Default, HasCodec } from "typebox/value";
-import { Settings } from "typebox/system";
+import { Intersect } from "./elysia/intersect.mjs";
 
 //#region src/type/compat.ts
 let setup = false;
 function setupTypebox(options) {
 	if (options?.exactMirror) setExactMirror(options.exactMirror);
+	const typebox = options?.typebox;
+	if (typebox) {
+		const typeSide = [typebox.type, typebox.system];
+		const typeSideProvided = typeSide.filter(Boolean).length;
+		if (typeSideProvided > 0 && typeSideProvided < typeSide.length) throw new Error(`setupTypebox({ typebox }) received an incomplete type-side namespace (only '${typebox.type ? "type" : "system"}' was set). 'type' and 'system' must be provided together.`);
+		const valueSide = [
+			typebox.value,
+			typebox.schema,
+			typebox.compile
+		];
+		const valueSideProvided = valueSide.filter(Boolean).length;
+		if (valueSideProvided > 0 && valueSideProvided < valueSide.length) {
+			const missing = [
+				"value",
+				"schema",
+				"compile"
+			].filter((key) => !typebox[key]);
+			throw new Error(`setupTypebox({ typebox }) received an incomplete value-side namespace (missing '${missing.join("', '")}'). 'value', 'schema', and 'compile' must be provided together.`);
+		}
+		if (typebox.type && typebox.system) injectTypeboxType(typebox);
+		if (typebox.value && typebox.schema && typebox.compile) injectTypebox(typebox);
+	}
 	if (setup) return;
 	setup = true;
-	Settings.Set({ unionPrioritySort: false });
 	useTypebox({
 		Compile,
 		Create,
-		Decode: Decode$1,
+		Decode,
 		applyCoercions,
 		TypeBoxValidator,
 		TypeBoxValidatorCache,
@@ -32,7 +51,7 @@ function setupTypebox(options) {
 		hasTypes,
 		mayHaveFileType,
 		HasCodec,
-		Intersect: Intersect$1,
+		Intersect,
 		Default,
 		Ref,
 		Clone,

package/dist/type/elysia/array-buffer.js

@@ -1,15 +1,14 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_utils = require('../../utils.js');
 const require_type_constants = require('../constants.js');
+const require_type_typebox_type = require('../typebox-type.js');
 const require_type_elysia_utils = require('./utils.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/array-buffer.ts
 let BaseArrayBuffer;
 let emptyArrayBuffer;
 function ArrayBufferType(property) {
-	BaseArrayBuffer ??= (0, typebox_type.Refine)((0, typebox_type.Unsafe)({ "~kind": "ArrayBuffer" }), (value) => value instanceof ArrayBuffer, () => "must be ArrayBuffer");
+	BaseArrayBuffer ??= require_type_typebox_type.Refine(require_type_typebox_type.Unsafe({ "~kind": "ArrayBuffer" }), (value) => value instanceof ArrayBuffer, () => "must be ArrayBuffer");
 	if (!property || require_utils.isEmpty(property)) return emptyArrayBuffer ??= Object.freeze(require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.ArrayBuffer, BaseArrayBuffer));
 	const refines = [[(value) => value instanceof ArrayBuffer, "must be ArrayBuffer"]];
 	if (property.minByteLength !== void 0) refines.push([(value) => value.byteLength >= property.minByteLength, `Expect byte to be more than ${property.minByteLength}`]);

package/dist/type/elysia/array-buffer.mjs

@@ -1,7 +1,7 @@
 import { isEmpty } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
+import { Refine, Unsafe } from "../typebox-type.mjs";
 import { Refines, cloneSchema, elyType, getMeta } from "./utils.mjs";
-import { Refine, Unsafe } from "typebox/type";
 
 //#region src/type/elysia/array-buffer.ts
 let BaseArrayBuffer;

package/dist/type/elysia/array-string.js

@@ -1,13 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_utils = require('../../utils.js');
 const require_type_bridge = require('../bridge.js');
 const require_type_constants = require('../constants.js');
+const require_type_typebox_type = require('../typebox-type.js');
 const require_type_elysia_array = require('./array.js');
 const require_type_elysia_string = require('./string.js');
 const require_type_elysia_union = require('./union.js');
 const require_type_elysia_utils = require('./utils.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/array-string.ts
 const MEMO_LIMIT = 8192;
@@ -28,18 +27,22 @@ function ArrayString(property, _options) {
 	};
 	let raw;
 	let parsed;
-	const arrayString = (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), (value) => {
+	const arrayString = require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_elysia_string.StringType(), (value) => {
 		if (value.charCodeAt(0) !== 91) return false;
 		if (value === raw) return true;
 		try {
 			const next = JSON.parse(value);
-			if (!checkInner(next)) return false;
+			if (!checkInner(next)) {
+				raw = parsed = void 0;
+				return false;
+			}
 			if (value.length <= MEMO_LIMIT) {
 				raw = value;
 				parsed = next;
 			}
 			return true;
 		} catch {
+			raw = parsed = void 0;
 			return false;
 		}
 	}, () => "must be an array"), (value) => {