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

package/dist/index.d.ts

@@ -1,23 +1,23 @@
 import { BaseCookie, CookieOptions } from "./cookie/types.js";
-import { Cookie } from "./cookie/cookie.js";
-import { ElysiaFile, file } from "./universal/file.js";
-import { StatusMap, StatusMapBack } from "./constants.js";
-import { env } from "./universal/env.js";
-import { Server } from "./universal/server.js";
-import { bytes, form, prefix, redirect, sse } from "./utils.js";
-import { HTTPHeaders, InputSchema, Macro, MacroToContext, MacroToProperty, RouteSchema, SSEPayload, UnwrapRoute, UnwrapSchema } from "./types.js";
-import { ElysiaError, ElysiaStatus, HTTPError, InternalServerError, NotFound, ParseError, Problem, SelectiveStatus, TaggedHTTPError, ValidationError, problem, status, validationDetail } from "./error.js";
-import { Context, ErrorContext, createBaseContext, createContext } from "./context.js";
-import { InvalidCookie } from "./cookie/error.js";
 import { AnySchema, BaseSchema, StandardJSONSchemaV1Like, StandardSchemaV1Like } from "./type/types.js";
 import { TCookieField, TCookieObject } from "./type/elysia/cookie.js";
-import { FileTypeDetector, fileType, setFileTypeDetector } from "./type/elysia/file-type.js";
 import { TFiles } from "./type/elysia/files.js";
+import { StatusMap, StatusMapBack } from "./constants.js";
+import { ElysiaError, ElysiaStatus, HTTPError, InternalServerError, NotFound, NumericStatus, ParseError, Problem, SelectiveProblem, SelectiveStatus, StatusResponse, TaggedHTTPError, ValidationError, ValidationErrorResponse, problem, status, validationDetail } from "./error.js";
+import { bytes, form, prefix, redirect, sse } from "./utils.js";
+import { Server } from "./universal/server.js";
+import { Cookie } from "./cookie/cookie.js";
+import { Context, ErrorContext, createBaseContext, createContext } from "./context.js";
+import { ElysiaFile, file } from "./universal/file.js";
+import { env } from "./universal/env.js";
+import { DefaultEphemeral, DefaultMetadata, DefaultSingleton, HTTPHeaders, InputSchema, Macro, MacroToContext, MacroToProperty, MacroTypeLambda, RouteSchema, SSEPayload, UnwrapModels, UnwrapRoute, UnwrapSchema } from "./types.js";
 import { setupTypebox } from "./type/compat.js";
+import { FileTypeDetector, fileType, setFileTypeDetector } from "./type/elysia/file-type.js";
 import { MultiValidator, StandardValidator, Validator } from "./validator/index.js";
 import { TypeBoxValidator } from "./type/validator/index.js";
 import { TypeSystem, t } from "./type/index.js";
 import { AotFingerprint, Capture, Compiled, CompilerSession, ProgramId } from "./compile/aot.js";
 import { AnyElysia, Elysia } from "./base.js";
 import { borrow } from "./adapter/response-ownership.js";
-export { AnyElysia, type AnySchema, type AotFingerprint, type BaseCookie, type BaseSchema, Compiled, type CompilerSession, type Context, type Cookie, type CookieOptions, Elysia, Elysia as default, ElysiaError, ElysiaFile, ElysiaStatus, type ErrorContext, type FileTypeDetector, HTTPError, type HTTPHeaders, type InputSchema, InternalServerError, InvalidCookie, type Macro, type MacroToContext, type MacroToProperty, Capture as Manifest, MultiValidator, NotFound, ParseError, type Problem, type ProgramId, type RouteSchema, type SSEPayload, type SelectiveStatus, type Server, type StandardJSONSchemaV1Like, type StandardSchemaV1Like, StandardValidator, StatusMap, StatusMapBack, type TCookieField, type TCookieObject, type TFiles, type TaggedHTTPError, TypeBoxValidator, TypeSystem, type UnwrapRoute, type UnwrapSchema, ValidationError, Validator, borrow, bytes, createBaseContext, createContext, env, file, fileType, form, prefix, problem, redirect, setFileTypeDetector, setupTypebox, sse, status, t, validationDetail };
+import { InvalidCookie } from "./cookie/error.js";
+export { AnyElysia, type AnySchema, type AotFingerprint, type BaseCookie, type BaseSchema, Compiled, type CompilerSession, type Context, type Cookie, type CookieOptions, type DefaultEphemeral, type DefaultMetadata, type DefaultSingleton, Elysia, Elysia as default, ElysiaError, ElysiaFile, ElysiaStatus, type ErrorContext, type FileTypeDetector, HTTPError, type HTTPHeaders, type InputSchema, InternalServerError, InvalidCookie, type Macro, type MacroToContext, type MacroToProperty, type MacroTypeLambda, Capture as Manifest, MultiValidator, NotFound, type NumericStatus, ParseError, type Problem, type ProgramId, type RouteSchema, type SSEPayload, type SelectiveProblem, type SelectiveStatus, type Server, type StandardJSONSchemaV1Like, type StandardSchemaV1Like, StandardValidator, StatusMap, StatusMapBack, type StatusResponse, type TCookieField, type TCookieObject, type TFiles, type TaggedHTTPError, TypeBoxValidator, TypeSystem, type UnwrapModels, type UnwrapRoute, type UnwrapSchema, ValidationError, type ValidationErrorResponse, Validator, borrow, bytes, createBaseContext, createContext, env, file, fileType, form, prefix, problem, redirect, setFileTypeDetector, setupTypebox, sse, status, t, validationDetail };

package/dist/index.js

@@ -1,5 +1,4 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
-const require_runtime = require('./_virtual/_rolldown/runtime.js');
 const require_constants = require('./constants.js');
 const require_universal_file = require('./universal/file.js');
 const require_utils = require('./utils.js');
@@ -8,14 +7,13 @@ const require_error = require('./error.js');
 const require_cookie_error = require('./cookie/error.js');
 const require_adapter_response_ownership = require('./adapter/response-ownership.js');
 const require_compile_aot = require('./compile/aot.js');
-const require_type_elysia_file_type = require('./type/elysia/file-type.js');
 const require_validator_index = require('./validator/index.js');
 const require_context = require('./context.js');
 const require_base = require('./base.js');
+const require_type_elysia_file_type = require('./type/elysia/file-type.js');
 const require_type_validator_index = require('./type/validator/index.js');
 const require_type_compat = require('./type/compat.js');
 const require_type_index = require('./type/index.js');
-let typebox_system = require("typebox/system");
 
 //#region src/index.ts
 var src_default = require_base.Elysia;
@@ -37,12 +35,7 @@ exports.StandardValidator = require_validator_index.StandardValidator;
 exports.StatusMap = require_constants.StatusMap;
 exports.StatusMapBack = require_constants.StatusMapBack;
 exports.TypeBoxValidator = require_type_validator_index.TypeBoxValidator;
-Object.defineProperty(exports, 'TypeSystem', {
-  enumerable: true,
-  get: function () {
-    return typebox_system.System;
-  }
-});
+exports.TypeSystem = require_type_index.TypeSystem;
 exports.ValidationError = require_error.ValidationError;
 exports.Validator = require_validator_index.Validator;
 exports.borrow = require_adapter_response_ownership.borrow;

package/dist/index.mjs

@@ -6,10 +6,10 @@ import { ElysiaError, ElysiaStatus, HTTPError, InternalServerError, NotFound, Pa
 import { InvalidCookie } from "./cookie/error.mjs";
 import { borrow } from "./adapter/response-ownership.mjs";
 import { Capture, Compiled } from "./compile/aot.mjs";
-import { fileType, setFileTypeDetector } from "./type/elysia/file-type.mjs";
 import { MultiValidator, StandardValidator, Validator } from "./validator/index.mjs";
 import { createBaseContext, createContext } from "./context.mjs";
 import { Elysia } from "./base.mjs";
+import { fileType, setFileTypeDetector } from "./type/elysia/file-type.mjs";
 import { TypeBoxValidator } from "./type/validator/index.mjs";
 import { setupTypebox } from "./type/compat.mjs";
 import { TypeSystem, t } from "./type/index.mjs";

package/dist/memory.js

@@ -6,7 +6,7 @@ const require_context = require('./context.js');
 
 //#region src/memory.ts
 function flushMemory() {
-	require_sucrose.clearSucroseCache(0);
+	require_sucrose.clearSucroseCache();
 	require_context.clearContextCache();
 	require_validator_index.Validator.clear();
 	if (require_universal_constants.isBun) Bun.gc();

package/dist/memory.mjs

@@ -5,7 +5,7 @@ import { clearContextCache } from "./context.mjs";
 
 //#region src/memory.ts
 function flushMemory() {
-	clearSucroseCache(0);
+	clearSucroseCache();
 	clearContextCache();
 	Validator.clear();
 	if (isBun) Bun.gc();

package/dist/package.js

@@ -1,6 +1,6 @@
 
 //#region package.json
-var version = "2.0.0-beta.2";
+var version = "2.0.0-beta.21";
 
 //#endregion
 Object.defineProperty(exports, 'version', {

package/dist/package.mjs

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "2.0.0-beta.2";
+var version = "2.0.0-beta.21";
 
 //#endregion
 export { version };

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

@@ -20,7 +20,14 @@ import { BunPlugin } from "bun";
  *
  * process.exit(0)
  * ```
+ *
+ * Skip precompilation and only wire TypeBox statically for a faster plain bundle.
+ * `TypeSystem.Locale` stays opt-in, as in a plain bundle.
+ *
+ * ```ts
+ * plugins: [aot()]
+ * ```
  */
-declare const aot: (entry: string, options?: ElysiaAotOptions) => BunPlugin;
+declare const aot: (entry?: string, options?: ElysiaAotOptions) => BunPlugin;
 //#endregion
 export { aot };

package/dist/plugin/aot/bun.js

@@ -20,16 +20,23 @@ const require_plugin_aot_hooks = require('./hooks.js');
 *
 * process.exit(0)
 * ```
+*
+* Skip precompilation and only wire TypeBox statically for a faster plain bundle.
+* `TypeSystem.Locale` stays opt-in, as in a plain bundle.
+*
+* ```ts
+* plugins: [aot()]
+* ```
 */
-const aot = (entry, options) => ({
-	name: "elysia-aot",
-	async setup(build) {
-		await require_plugin_aot_hooks.setupAotOnLoad(build, require_plugin_aot_hooks.createAotPluginHooks(entry, options), {
-			readText: (path) => Bun.file(path).text(),
-			resolveDir: void 0
-		});
-	}
-});
+const aot = (entry, options) => {
+	if (entry === void 0 && options !== void 0) throw new Error("[elysia-aot] options require an entry");
+	return {
+		name: "elysia-aot",
+		async setup(build) {
+			await require_plugin_aot_hooks.setupAotOnLoad(build, entry === void 0 ? require_plugin_aot_hooks.createTypeboxWiringHooks() : require_plugin_aot_hooks.createAotPluginHooks(entry, options), (path) => Bun.file(path).text());
+		}
+	};
+};
 
 //#endregion
 exports.aot = aot;

package/dist/plugin/aot/bun.mjs

@@ -1,4 +1,4 @@
-import { createAotPluginHooks, setupAotOnLoad } from "./hooks.mjs";
+import { createAotPluginHooks, createTypeboxWiringHooks, setupAotOnLoad } from "./hooks.mjs";
 
 //#region src/plugin/aot/bun.ts
 /**
@@ -19,16 +19,23 @@ import { createAotPluginHooks, setupAotOnLoad } from "./hooks.mjs";
 *
 * process.exit(0)
 * ```
+*
+* Skip precompilation and only wire TypeBox statically for a faster plain bundle.
+* `TypeSystem.Locale` stays opt-in, as in a plain bundle.
+*
+* ```ts
+* plugins: [aot()]
+* ```
 */
-const aot = (entry, options) => ({
-	name: "elysia-aot",
-	async setup(build) {
-		await setupAotOnLoad(build, createAotPluginHooks(entry, options), {
-			readText: (path) => Bun.file(path).text(),
-			resolveDir: void 0
-		});
-	}
-});
+const aot = (entry, options) => {
+	if (entry === void 0 && options !== void 0) throw new Error("[elysia-aot] options require an entry");
+	return {
+		name: "elysia-aot",
+		async setup(build) {
+			await setupAotOnLoad(build, entry === void 0 ? createTypeboxWiringHooks() : createAotPluginHooks(entry, options), (path) => Bun.file(path).text());
+		}
+	};
+};
 
 //#endregion
 export { aot };

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

@@ -1,7 +1,13 @@
+import { CapturedValidator } from "../../compile/aot.js";
 import { JITProbeResult } from "../../compile/jit-probe.js";
-import { AotTarget } from "./source.js";
+import { AotModuleCondition, AotTarget } from "./source.js";
 
 //#region src/plugin/aot/core.d.ts
+/**
+ * A route that differs from the build compiles live with a warning, or fails
+ * when the JIT is stripped. A conditional hook must change the hook list
+ * (`isProd ? [auth] : []`), not swap functions. Keep `async` native
+ */
 interface ElysiaAotOptions {
   /**
    * Specifier the generated module imports `Compiled` from
@@ -93,10 +99,14 @@ interface ElysiaAotOptions {
   verbose?: boolean;
 }
 declare const resolveEntry: (entry: string) => string;
+/** @internal Resolve the package condition used to evaluate an AOT entry. */
+declare const resolveEntryModuleKind: (entry: string) => "esm" | "cjs";
 /** Runtime handler-JIT module a strip build can replace with a throwing stub. */
 interface StubPlan {
   /** Stub the internal handler codegen module. */
   jit: boolean;
+  /** Omit the static-clone resolver when no captured handler aliases scl. */
+  staticClone: boolean;
   /** Stub internal WS route builders when the app declares no WS routes. */
   ws: boolean;
   /**
@@ -118,18 +128,8 @@ interface StubPlan {
    * codegen, frozen reconstruct) only calls in when trace handlers exist, so
    * a throwing stub is unreachable once detection proves trace is unused
    *
-   * NOT moot after the `elysia/trace` capability severance. The reachable
-   * post-severance case is: an app that `.use(trace())` (so the capability
-   * is registered and `dist/trace.mjs` IS in the bundle graph via
-   * `dist/plugin/trace.mjs`) but never attaches `.trace(fn)` (no trace
-   * hooks, so `tr` is unaliased and `mayTrace` is false). Under the frozen
-   * path (`jit`) this flag is still `true`, so the stub replaces the real
-   * trace module with the non-throwing `unionTracePhases(){return new Set()}`
-   * fallback (+ throwing `createTracer`, unreachable with zero hooks).
-   * Measured saving for that shape: ~18KB severing trace also tree-shakes
-   * sucrose's `separateFunction`, which trace is the sole importer of. A
-   * traceless app that never imports the capability (Fixture B) has no
-   * trace module in the graph, so the stub is a no-op there.
+   * Also applies when `.use(trace())` is registered but no `.trace(fn)`
+   * exists: `unionTracePhases` stays a non-throwing `new Set()`
    */
   trace: boolean;
   /**
@@ -137,7 +137,7 @@ interface StubPlan {
    * 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
    * analyzer tree-shake. `flushMemory`'s other clears are preserved, and the
-   * public `elysia/sucrose` module is left untouched
+   * `sucrose` module itself is not stubbed
    */
   sucrose: boolean;
   /**
@@ -156,6 +156,23 @@ 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/validator/exact-mirror` -> its statically-imported `-live`
+   * mirror so the bundler embeds `exact-mirror` instead of leaving the runtime
+   * `require('exact-mirror')` unresolvable, which is what breaks normalization
+   * and sanitize inside a compiled binary
+   *
+   * Set whenever `exact-mirror` resolves at build time, except in sealed mode:
+   * there every mirror is emitted into the manifest, so wiring it would only
+   * add ~15KB of dead code to the bundle the mode exists to shrink
+   */
+  exactMirror: boolean;
   /**
    * Replace `adapter/constants` with a target-specific stub that hard-selects
    * either `BunAdapter` or `WebStandardAdapter`, letting the bundler DCE the
@@ -202,52 +219,29 @@ 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, /** `exact-mirror` resolves from the elysia package at build time. */exactMirror?: boolean): {
   plan: StubPlan;
   mode: BridgeMode;
 };
 declare function adapterConstantsSource(target: 'bun' | 'web-standard'): string;
-/** Filter matching elysia's own `adapter/constants` module (src + dist). */
 declare const ADAPTER_CONSTANTS_FILTER: RegExp;
 declare const ADAPTER_BUN_FILTER: RegExp;
 declare const IS_PRODUCTION_FILTER: RegExp;
-/**
- * Loose fallback filter
- *
- * Matches the `/elysia/(dist|src)/` segment anywhere in a path (node_modules layouts,
- * monorepos, linked installs). Used by esbuild as a broad pre-filter
- *
- * The caller must further check that the path is under the resolved elysia package root
- * to avoid matching user code in a directory that happens to be named "elysia"
- *
- * @internal
- */
+declare const TYPEBOX_TYPE_FILTER: RegExp;
+declare const TYPEBOX_SYSTEM_LITE_FILTER: RegExp;
+declare const TYPEBOX_REQUIRE_FILTER: RegExp;
+declare const EXACT_MIRROR_REQUIRE_FILTER: RegExp;
 declare const ELYSIA_MODULE_FILTER: RegExp;
-/**
- * Build a predicate that returns `true` only for modules that are under the
- * resolved elysia package root (i.e. actually elysia's own files).
- *
- * Anchoring to the real package root prevents user projects rooted in a
- * directory named `elysia` (like this repo itself) from having their code
- * rewritten.
- *
- * Pass the result to both the esbuild `filter` (convert to RegExp via
- * `makeElysiaModuleFilterRegex`) and the Vite transform (`isElysiaModule`).
- */
-declare function resolveElysiaRoot(from?: string): string;
-/**
- * Returns a predicate that is `true` only when the given module path is under
- * the resolved elysia package root AND matches the broad module filter.
- */
+declare function resolveElysiaRoot(from: string): string;
+declare function resolveExactMirror(from: string): boolean;
 declare function makeIsElysiaModule(elysiaRoot: string): (path: string) => boolean;
-/**
- * Build an esbuild-compatible RegExp that anchors to the resolved elysia root
- * so the `onLoad` pre-filter is as tight as possible. esbuild uses this as an
- * initial path filter before calling the callback, so we still double-check
- * with `makeIsElysiaModule` inside the callback.
- */
-declare function makeElysiaModuleFilterRegex(elysiaRoot: string): RegExp;
-declare function rewriteIsProductionCalls(code: string): string;
+declare const rewriteIsProductionCalls: (code: string) => string;
 declare const bunAdapterStubSource: string;
 declare const STUB_SOURCES: Record<Exclude<keyof StubPlan, 'adapter' | 'isProduction'>, Array<{
   filter: RegExp;
@@ -258,7 +252,7 @@ declare const OVERRIDE_MAP: Record<string, {
   leaf: string;
   export: string;
 }>;
-declare function generateVirtualType(typeSpecifier?: string): Promise<string>;
+declare function generateVirtualType(moduleCondition?: AotModuleCondition): Promise<string>;
 interface CompiledArtifacts {
   source: string;
   /** Handler-JIT modules detection proved safe to stub for this app. */
@@ -272,11 +266,6 @@ interface CompiledArtifacts {
    */
   virtualType?: string;
 }
-/** @internal Test diagnostic for deterministic worker cleanup. */
-declare const getAotWorkerDiagnostics: () => {
-  activeWorkers: number;
-  lastExit: Promise<number> | undefined;
-};
 /**
  * Extension mirroring the running module's own build output, so a sibling
  * source file can be resolved from `import.meta.url` in `.mjs`/`.js`/`.ts`
@@ -284,9 +273,12 @@ declare const getAotWorkerDiagnostics: () => {
  */
 declare function siblingModuleExt(moduleUrl: string): '.mjs' | '.js' | '.ts';
 /** @internal Re-evaluate an entry in a disposable worker for watch rebuilds. */
-declare function generateCompiledArtifactsIsolated(file: string, options?: ElysiaAotOptions): Promise<CompiledArtifacts>;
-declare function generateCompiledArtifacts(file: string, options?: ElysiaAotOptions): Promise<CompiledArtifacts>;
+declare function generateCompiledArtifactsIsolated(file: string, options?: ElysiaAotOptions, moduleCondition?: string): Promise<CompiledArtifacts>;
+type ValidatorSlotIdentity = Pick<CapturedValidator, 'method' | 'path' | 'slot'>;
+/** @internal Exact logical-slot gate used by AOT mode selection. */
+declare function validatorSlotSetsMatch(expected: readonly ValidatorSlotIdentity[], captured: readonly ValidatorSlotIdentity[]): boolean;
+declare function generateCompiledArtifacts(file: string, options?: ElysiaAotOptions, moduleCondition?: string): Promise<CompiledArtifacts>;
 declare const SOURCE_REGEX: RegExp;
 declare const realPath: (path: string) => string;
 //#endregion
-export { ADAPTER_BUN_FILTER, ADAPTER_CONSTANTS_FILTER, BridgeMode, CompiledArtifacts, ELYSIA_MODULE_FILTER, ElysiaAotOptions, IS_PRODUCTION_FILTER, NO_STUB, OVERRIDE_MAP, SOURCE_REGEX, STUB_SOURCES, StubPlan, adapterConstantsSource, alignStubExtensions, bunAdapterStubSource, generateCompiledArtifacts, generateCompiledArtifactsIsolated, generateVirtualType, getAotWorkerDiagnostics, makeElysiaModuleFilterRegex, makeIsElysiaModule, planFromReport, realPath, resolveElysiaRoot, resolveEntry, rewriteIsProductionCalls, siblingModuleExt };
+export { ADAPTER_BUN_FILTER, ADAPTER_CONSTANTS_FILTER, BridgeMode, CompiledArtifacts, ELYSIA_MODULE_FILTER, EXACT_MIRROR_REQUIRE_FILTER, ElysiaAotOptions, IS_PRODUCTION_FILTER, NO_STUB, OVERRIDE_MAP, SOURCE_REGEX, STUB_SOURCES, StubPlan, TYPEBOX_REQUIRE_FILTER, TYPEBOX_SYSTEM_LITE_FILTER, TYPEBOX_TYPE_FILTER, adapterConstantsSource, alignStubExtensions, bunAdapterStubSource, generateCompiledArtifacts, generateCompiledArtifactsIsolated, generateVirtualType, makeIsElysiaModule, planFromReport, realPath, resolveElysiaRoot, resolveEntry, resolveEntryModuleKind, resolveExactMirror, rewriteIsProductionCalls, siblingModuleExt, validatorSlotSetsMatch };