@supacloud/elysia 0.19.0 → 0.20.1

package/README.md

@@ -8,13 +8,19 @@ is a separately authorized business command, never an assumed rollback.
 
 ## Compatibility and Acceptance Boundary
 
-The dependency range is not a claim that every allowed version has been tested.
-The focused conformance suite was verified with Bun 1.4.2 and Elysia 1.4.30.
-The package declares Elysia `^1.4.30` as a peer and TypeScript `^7.0.2` as a
-development dependency. `compatibility.json` records the exact exercised tuple,
-including the compiler's separate TypeScript 6 semantic API. The contract-upgrade
-gate checks both that semantic API and the TypeScript 7 CLI. These tests do not
-establish a wider version matrix or Node.js runtime compatibility.
+The Elysia peer and development dependency are pinned to `2.0.0-beta.19`.
+`compatibility.json` records the acceptance target: Bun 1.4.2, Elysia
+2.0.0-beta.19, `typebox` 1.3.34, `exact-mirror` 1.2.6, TypeScript CLI 7.0.2
+and the compiler's separate TypeScript 6 semantic API 6.0.2. The matrix is a
+required target, not proof of an execution. See the dated, commit-specific
+[framework acceptance record](../../docs/framework-acceptance.md) for actual
+results. The contract-upgrade gate checks both TypeScript engines. These tests
+do not establish a wider beta version matrix or Node.js runtime compatibility.
+
+Keep the exact Elysia peer until additional versions have their own acceptance
+evidence. A server using this adapter still installs Elysia; application metadata
+and business modules need not import native Elysia types. See the
+[dependency boundary and upgrade policy](../../docs/elysia-compatibility.md).
 
 Run `bun run test:conformance` in this package after building the local
 `@supacloud/contracts` and `@supacloud/app` dependencies and installing this
@@ -99,9 +105,11 @@ for the evidence boundaries and upgrade policy.
 
 Pass a native Elysia plugin as `http` to `createApplication`, `createTestApp`,
 or the options argument of `createModulePlugin`. `decorate` shares existing
-instances; `derive` runs before validation; `resolve` runs after validation.
-Use scoped/global hooks, or finish a context plugin with `.as("scoped")`.
-Local hooks retain native encapsulation and do not extend the consuming routes.
+instances. In Elysia 2, `derive` runs after validation; do not assume the Elysia 1
+pre-validation derive/resolve split. Use `.derive("plugin", callback)` for a
+shared derived context, or finish a guarded context plugin with `.as("plugin")`.
+Global hooks use `.as("global")`. Local hooks retain native encapsulation and
+do not extend the consuming routes.
 
 ```ts
 import { Elysia, t } from "elysia";
@@ -109,10 +117,12 @@ import { createApplication } from "@supacloud/elysia";
 
 const http = new Elysia({ name: "application-context" })
   .decorate("clock", { now: () => Date.now() })
-  .derive(({ clock }) => ({ startedAt: clock.now() }))
   .guard({ query: t.Object({ locale: t.Optional(t.String()) }) })
-  .resolve(({ query }) => ({ locale: query.locale ?? "en" }))
-  .as("scoped");
+  .derive(({ clock, query }) => ({
+    startedAt: clock.now(),
+    locale: query.locale ?? "en",
+  }))
+  .as("plugin");
 
 const app = createApplication({
   http,
@@ -132,13 +142,13 @@ The second `requestContext` argument contains the validated HTTP inputs and
 the inferred native plugin extensions. Existing one-argument factories remain
 valid. Its result is passed to generated request-scoped constructors and the
 controller's `context`/`requestContext` input. It is built once per request;
-early resolver responses and validation failures do not construct DI scopes.
+early derived-context responses and validation failures do not construct DI scopes.
 Request scopes are created inside the existing governed handler and released
 after the response, including handler failures. They are not application
-singletons or native `resolve` hooks.
+singletons or native context hooks.
 
-Native routes added to the returned app retain the HTTP plugin's decorator,
-derive and resolve types. `createModulePlugin` also preserves the concrete
+Native routes added to the returned app retain the HTTP plugin's decorator
+and derived context types. `createModulePlugin` also preserves the concrete
 `services` type supplied by its caller. Module service bags are attached by
 the module-local resolver, not merged into a root `decorator.services` bag;
 the service instances themselves remain shared. This prevents same-named
@@ -153,13 +163,13 @@ Compiled route schemas are runtime
 descriptors: their body/params/query/header/cookie fields in the application-wide
 context factory remain `unknown`-based instead of pretending to infer one
 route's schema for every route. Use shared guards for schema-typed native
-resolvers and the existing generated contracts for individual compiled routes.
+context derivation and the existing generated contracts for individual compiled routes.
 Do not store per-request identity or transaction handles in decorated singletons.
 
 The `http` plugin is composed into each compiled module and subsequently into
 the root for native routes. Keep it focused on reusable context extensions;
 register unrelated endpoints on the returned app. Hook execution is tested
-for named/anonymous plugins and scoped/global hooks without duplicate work.
+for named/anonymous plugins and plugin/global hooks without duplicate work.
 Anonymous extensions receive a stable internal plugin identity for native
 hook deduplication; the caller's plugin configuration is not mutated.
 This is native HTTP composition, not a replacement runtime DI container or
@@ -298,7 +308,7 @@ Runtime adapter that turns `@supacloud/compiler` output into a production-ready
 ## Installation
 
 ```bash
-bun add @supacloud/elysia elysia
+bun add --exact @supacloud/elysia elysia@2.0.0-beta.19
 ```
 
 ## Usage
@@ -383,7 +393,7 @@ read-back protocol. A custom `errorMapper` can override this public envelope.
 
 Native `Response` objects are passed through by Elysia, including JSON responses.
 Use `validatedJsonResponse` to opt into validation when constructing a native
-JSON response. Otherwise handlers must validate their JSON payload themselves.
+JSON response. Otherwise handlers must validate their JSON payloads themselves.
 The adapter does not consume or parse binary/streaming responses.
 
 Jobs are executed explicitly with `executeJob(compiledModule, services, job,
@@ -657,9 +667,8 @@ does not add Eden-style client inference to an existing Elysia instance; the
 compiler-generated client remains the source of transport types.
 
 Response maps may use concrete statuses, `1XX`-`5XX` families, and `default`.
-Because Elysia 1.4 only compiles numeric response keys, the adapter expands
-family/default entries to concrete validators before registration. Exact
-statuses take precedence over families, which take precedence over `default`.
+The adapter expands family/default entries to concrete validators before
+registration. Exact statuses take precedence over families, which take precedence over `default`.
 An actual status absent from a structured response map fails the route contract
 before Elysia can silently accept a default `200`; binary/stream routes may
 intentionally leave successful transport statuses unschematized when only their
@@ -700,12 +709,12 @@ const app = createApplication({
 });
 ```
 
-`identityPlugin` is an application-owned scoped/global Elysia plugin that verifies
+`identityPlugin` is an application-owned plugin/global Elysia context plugin that verifies
 credentials and resolves `identity`; the adapter does not trust a raw user/tenant
 header as identity. Policy callbacks preserve its native context types.
 
 Policies become native route-local `beforeHandle` hooks. They execute sequentially
-after schema validation, native resolvers and the application request-context
+after schema validation, native context derivation and the application request-context
 factory, but before compiled request-scope construction and command execution.
 Return `undefined` to continue or a `Response` to stop; thrown errors use the
 application error mapper. Native earlier hooks can still short-circuit the request.

package/compatibility.json

@@ -1,9 +1,10 @@
 {
   "bun": "1.4.2",
   "packages": {
-    "elysia": "1.4.30",
+    "elysia": "2.0.0-beta.19",
     "typescript": "7.0.2",
-    "@sinclair/typebox": "0.34.52",
+    "typebox": "1.3.34",
+    "exact-mirror": "1.2.6",
     "@typescript/typescript6": "6.0.2"
   }
 }

package/dist/fixtures/webhook/contracts.d.ts

@@ -1,42 +1,42 @@
-export declare const WebhookInputSchema: import("@sinclair/typebox").TObject<{
-    id: import("@sinclair/typebox").TString;
-    enabled: import("@sinclair/typebox").TBoolean;
+export declare const WebhookInputSchema: import("typebox").TObject<{
+    id: import("typebox").TString;
+    enabled: import("typebox").TBoolean;
 }>;
-export declare const WebhookHeadersSchema: import("@sinclair/typebox").TObject<{
-    "idempotency-key": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+export declare const WebhookHeadersSchema: import("typebox").TObject<{
+    "idempotency-key": import("typebox").TOptional<import("typebox").TString>;
 }>;
 export declare const decodeWebhookInput: (value: unknown) => {
     id: string;
     enabled: boolean;
 };
-export declare const WebhookReceiptSchema: import("@sinclair/typebox").TObject<{
-    tenantId: import("@sinclair/typebox").TString;
-    actorId: import("@sinclair/typebox").TString;
-    command: import("@sinclair/typebox").TLiteral<"webhook.update.v1">;
-    operationId: import("@sinclair/typebox").TString;
-    dispatchKey: import("@sinclair/typebox").TString;
-    status: import("@sinclair/typebox").TLiteral<"confirmed">;
-    audit: import("@sinclair/typebox").TLiteral<"complete">;
-    result: import("@sinclair/typebox").TObject<{
-        id: import("@sinclair/typebox").TString;
-        enabled: import("@sinclair/typebox").TBoolean;
+export declare const WebhookReceiptSchema: import("typebox").TObject<{
+    tenantId: import("typebox").TString;
+    actorId: import("typebox").TString;
+    command: import("typebox").TLiteral<"webhook.update.v1">;
+    operationId: import("typebox").TString;
+    dispatchKey: import("typebox").TString;
+    status: import("typebox").TLiteral<"confirmed">;
+    audit: import("typebox").TLiteral<"complete">;
+    result: import("typebox").TObject<{
+        id: import("typebox").TString;
+        enabled: import("typebox").TBoolean;
     }>;
 }>;
-export declare const WebhookKeySchema: import("@sinclair/typebox").TObject<{
-    key: import("@sinclair/typebox").TString;
+export declare const WebhookKeySchema: import("typebox").TObject<{
+    key: import("typebox").TString;
 }>;
-export declare const WebhookLookupSchema: import("@sinclair/typebox").TObject<{
-    receipt: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
-        tenantId: import("@sinclair/typebox").TString;
-        actorId: import("@sinclair/typebox").TString;
-        command: import("@sinclair/typebox").TLiteral<"webhook.update.v1">;
-        operationId: import("@sinclair/typebox").TString;
-        dispatchKey: import("@sinclair/typebox").TString;
-        status: import("@sinclair/typebox").TLiteral<"confirmed">;
-        audit: import("@sinclair/typebox").TLiteral<"complete">;
-        result: import("@sinclair/typebox").TObject<{
-            id: import("@sinclair/typebox").TString;
-            enabled: import("@sinclair/typebox").TBoolean;
+export declare const WebhookLookupSchema: import("typebox").TObject<{
+    receipt: import("typebox").TUnion<[import("typebox").TObject<{
+        tenantId: import("typebox").TString;
+        actorId: import("typebox").TString;
+        command: import("typebox").TLiteral<"webhook.update.v1">;
+        operationId: import("typebox").TString;
+        dispatchKey: import("typebox").TString;
+        status: import("typebox").TLiteral<"confirmed">;
+        audit: import("typebox").TLiteral<"complete">;
+        result: import("typebox").TObject<{
+            id: import("typebox").TString;
+            enabled: import("typebox").TBoolean;
         }>;
-    }>, import("@sinclair/typebox").TNull]>;
+    }>, import("typebox").TNull]>;
 }>;

package/dist/http-policy-suite.d.ts

@@ -44,32 +44,8 @@ export declare function principalKey(context: SupAuthRequestContext): unknown[];
 /** Pair the returned factory and registry; only this verifier can populate policy identity. */
 export declare function createHttpPolicySuite(options: HttpPolicySuiteOptions): {
     requestContext: (request: Request) => Promise<SupaCloudRequestContext | SupAuthRequestContext>;
-    httpPolicies: Readonly<Record<string, (options: unknown, route: Readonly<Pick<import("./index").CompiledRoute, "method" | "path" | "command">>) => HttpPolicy<import("elysia").default<"", {
-        decorator: {};
-        store: {};
-        derive: {};
-        resolve: {};
-    }, {
+    httpPolicies: Readonly<Record<string, (options: unknown, route: Readonly<Pick<import("./index").CompiledRoute, "method" | "path" | "command">>) => HttpPolicy<import("elysia").Elysia<"", "local", import("elysia").DefaultSingleton, {
         typebox: {};
-        error: {};
-    }, {
-        schema: {};
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: {};
-    }, {}, {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    }, {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    }>>>>;
+        error: [];
+    }, import("elysia").DefaultMetadata, {}, import("elysia").DefaultEphemeral, import("elysia").DefaultEphemeral>>>>;
 };

package/dist/http-policy.d.ts

@@ -10,6 +10,8 @@ export interface HttpPolicyContext<Http extends AnyElysia = Elysia> {
 }
 export interface HttpPolicyResponseContext<Http extends AnyElysia = Elysia> extends HttpPolicyContext<Http> {
     response: unknown;
+    /** Validate and encode before replacing a handler value with a native Response. */
+    encodeResponse?: (value: unknown) => unknown | Promise<unknown>;
 }
 export type HttpPolicy<Http extends AnyElysia = Elysia> = ((context: HttpPolicyContext<Http>) => void | Response | Promise<void | Response>) & {
     /** Terminal policies (cache hits) must not skip later security checks. */

package/dist/http-telemetry.d.ts

@@ -10,31 +10,18 @@ export interface HttpTelemetryEvent {
 }
 export type HttpTelemetryObserver = (event: Readonly<HttpTelemetryEvent>) => void | Promise<void>;
 /** Request tracing is best effort, not a durable business audit. */
-export declare function createHttpTelemetry(observe: HttpTelemetryObserver): Elysia<"", {
+export declare function createHttpTelemetry(observe: HttpTelemetryObserver): Elysia<"", "local", {
     decorator: {};
     store: {};
     derive: {};
-    resolve: {};
 }, {
     typebox: {};
-    error: {};
+    error: [];
 }, {
     schema: {};
-    standaloneSchema: {};
+    schemas: {};
     macro: {};
     macroFn: {};
     parser: {};
     response: {};
-}, {}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}>;
+}, {}, import("elysia").DefaultEphemeral, import("elysia").DefaultEphemeral>;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Elysia, type AnyElysia, type InferContext, type StatusMap } from "elysia";
+import { Elysia, type AnyElysia, type Context, type StatusMap } from "elysia";
 import type { CommandRuntimeAudit, CommandRuntimeAuthorizer, CommandRuntimeGovernance, CommandRuntimeInvocation, CommandRuntimeMiddleware } from "@supacloud/app";
 import { type CommandPreview } from "@supacloud/contracts";
 import { type HttpPolicyRegistry } from "./http-policy";
@@ -236,71 +236,11 @@ export interface ErrorContext {
     frameworkCode: string | number | undefined;
 }
 export type ErrorMapper = (error: unknown, context: ErrorContext) => Response | undefined | Promise<Response | undefined>;
-declare function mountHttp<const Http extends AnyElysia = Elysia>(http?: Http, name?: string, normalize?: boolean): Elysia<"", {
-    decorator: {} & Http["~Singleton"]["decorator"];
-    store: ({} & Http["~Singleton"]["store"] extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1]; } : never) extends infer T ? { [K in keyof T]: T[K]; } : never;
-    derive: {} & Http["~Singleton"]["derive"];
-    resolve: {} & Http["~Singleton"]["resolve"];
-}, {
-    typebox: {};
-    error: {};
-} & Http["~Definitions"], {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-} & Http["~Metadata"], {} & Http["~Routes"], {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-} & {
-    derive: {} & ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["derive"];
-    resolve: {} & ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["resolve"];
-    schema: import("elysia").MergeSchema<({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["schema"], {}, "">;
-    standaloneSchema: ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["standaloneSchema"] & {};
-    response: ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["response"] & {};
-}>;
-export type ApplicationHttpContext<Http extends AnyElysia = Elysia> = Omit<InferContext<ReturnType<typeof mountHttp<Http>>>, "body" | "params" | "query" | "headers" | "cookie"> & Pick<HttpContext, "body" | "params" | "query" | "headers" | "cookie">;
+export type ApplicationHttpContext<Http extends AnyElysia = Elysia> = Omit<Context<{}, {
+    decorator: Http["~Singleton"]["decorator"];
+    store: Http["~Singleton"]["store"];
+    derive: Http["~Singleton"]["derive"] & Http["~Ephemeral"]["derive"];
+}>, "body" | "params" | "query" | "headers" | "cookie"> & Pick<HttpContext, "body" | "params" | "query" | "headers" | "cookie">;
 export type HttpRequestContextFactory<Http extends AnyElysia = Elysia, Value = unknown> = (request: Request, context: ApplicationHttpContext<Http>) => Value | Promise<Value>;
 export interface ApplicationOptions<Http extends AnyElysia = Elysia, RequestContext = unknown> {
     name?: string;
@@ -396,69 +336,25 @@ interface HttpContext {
  * and passed to the controller input as `scope`. Request-scoped controllers
  * are looked up on that scope, everything else on `services`.
  */
-export declare function createModulePlugin<const Services extends Record<string, unknown>, const Http extends AnyElysia = Elysia>(compiled: CompiledModule, services: Services, ctxFactory?: HttpRequestContextFactory<Http>, options?: Pick<ApplicationOptions<Http>, "http" | "httpPolicies" | "commandGovernance" | "commandExecutor" | "errorMapper" | "onExecution" | "normalize">, imported?: Record<string, Record<string, unknown>>): Elysia<"", {
+export declare function createModulePlugin<const Services extends Record<string, unknown>, const Http extends AnyElysia = Elysia>(compiled: CompiledModule, services: Services, ctxFactory?: HttpRequestContextFactory<Http>, options?: Pick<ApplicationOptions<Http>, "http" | "httpPolicies" | "commandGovernance" | "commandExecutor" | "errorMapper" | "onExecution" | "normalize">, imported?: Record<string, Record<string, unknown>>): import("elysia/types").LocalHookReturn<"", "local", {
     decorator: {} & Http["~Singleton"]["decorator"];
     store: ({} & Http["~Singleton"]["store"] extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1]; } : never) extends infer T ? { [K in keyof T]: T[K]; } : never;
     derive: {} & Http["~Singleton"]["derive"];
-    resolve: {} & Http["~Singleton"]["resolve"];
 }, {
-    typebox: {};
-    error: {};
-} & Http["~Definitions"], {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-} & Http["~Metadata"], {} & Http["~Routes"], {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}, {
-    derive: {} & ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["derive"];
-    resolve: ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["resolve"] & {
-        readonly services: Services;
-        readonly requestContext: unknown;
-    };
-    schema: {} & import("elysia").MergeSchema<({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["schema"], {}, "">;
-    standaloneSchema: {} & ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["standaloneSchema"];
-    response: import("elysia/types").UnionResponseStatus<{} & ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["response"], import("elysia").ExtractErrorFromHandle<{
-        readonly services: Services;
-        readonly requestContext: unknown;
-    }>>;
+    typebox: {} & Http["~Definitions"]["typebox"];
+    error: [...Http["~Definitions"]["error"]];
+}, import("elysia").DefaultMetadata & Http["~Metadata"], import("elysia/types").ResolveRouteErrors<{}, [...Http["~Definitions"]["error"], ...Http["~Ephemeral"]["error"]]> & Http["~Routes"], import("elysia").DefaultEphemeral, {
+    derive: {} & Http["~Ephemeral"]["derive"];
+    schema: {} & import("elysia/types").MergeSchema<{} & Http["~Ephemeral"]["schema"], {}, "", false>;
+    schemas: {} & Http["~Ephemeral"]["schemas"];
+    response: {} & Http["~Ephemeral"]["response"];
+    error: [...Http["~Ephemeral"]["error"]];
+}, import("elysia/types").ExtractErrorFromHandle<{
+    readonly services: Services;
+    readonly requestContext: unknown;
+}>, {
+    readonly services: Services;
+    readonly requestContext: unknown;
 }>;
 /**
  * Execute one compiler-emitted Job descriptor.
@@ -476,134 +372,48 @@ export declare function defaultErrorResponse(error: unknown, frameworkCode?: str
  * `createServices` receives `deps` plus the services of all previously
  * created modules, keyed by module name.
  */
-export declare function createApplication<const Http extends AnyElysia = Elysia>(options: ApplicationOptions<Http>): Elysia<"", {
+export declare function createApplication<const Http extends AnyElysia = Elysia>(options: ApplicationOptions<Http>): Elysia<"", "local", {
     decorator: {} & Http["~Singleton"]["decorator"];
     store: ({} & Http["~Singleton"]["store"] extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1]; } : never) extends infer T ? { [K in keyof T]: T[K]; } : never;
-    derive: {} & Http["~Singleton"]["derive"];
-    resolve: {} & Http["~Singleton"]["resolve"];
+    derive: {} & Http["~Singleton"]["derive"] & Http["~Ephemeral"]["derive"];
 }, {
-    typebox: {};
-    error: {};
-} & Http["~Definitions"], {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-} & Http["~Metadata"], {} & Http["~Routes"], {
+    typebox: {} & Http["~Definitions"]["typebox"];
+    error: [...Http["~Definitions"]["error"], ...Http["~Ephemeral"]["error"]];
+}, import("elysia").DefaultMetadata & {
+    schema: import("elysia/types").MergeSchema<import("elysia/types").MergeSchema<{} & Http["~Ephemeral"]["schema"], {}, "", false>, (import("elysia").DefaultMetadata & Http["~Metadata"])["schema"], "", false>;
+    schemas: (import("elysia").DefaultMetadata & Http["~Metadata"])["schemas"] & {} & Http["~Ephemeral"]["schemas"];
+    macro: (import("elysia").DefaultMetadata & Http["~Metadata"])["macro"];
+    macroFn: (import("elysia").DefaultMetadata & Http["~Metadata"])["macroFn"];
+    parser: (import("elysia").DefaultMetadata & Http["~Metadata"])["parser"];
+    response: import("elysia/types").UnionResponseStatus<(import("elysia").DefaultMetadata & Http["~Metadata"])["response"], import("elysia/types").UnionResponseStatus<{} & Http["~Ephemeral"]["response"], {}>>;
+}, import("elysia/types").ResolveRouteErrors<{}, [...Http["~Definitions"]["error"], ...Http["~Ephemeral"]["error"]]> & Http["~Routes"], import("elysia").DefaultEphemeral, {
     derive: {};
-    resolve: {};
     schema: {};
-    standaloneSchema: {};
+    schemas: {};
     response: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-} & {
-    derive: {} & ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["derive"];
-    resolve: {} & ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["resolve"];
-    schema: import("elysia").MergeSchema<({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["schema"], {}, "">;
-    standaloneSchema: ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["standaloneSchema"] & {};
-    response: ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["response"] & {};
+    error: [];
 }>;
 /** Semantic alias of createApplication for readable tests. */
-export declare function createTestApp<const Http extends AnyElysia = Elysia>(options: ApplicationOptions<Http>): Elysia<"", {
+export declare function createTestApp<const Http extends AnyElysia = Elysia>(options: ApplicationOptions<Http>): Elysia<"", "local", {
     decorator: {} & Http["~Singleton"]["decorator"];
     store: ({} & Http["~Singleton"]["store"] extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1]; } : never) extends infer T ? { [K in keyof T]: T[K]; } : never;
-    derive: {} & Http["~Singleton"]["derive"];
-    resolve: {} & Http["~Singleton"]["resolve"];
-}, {
-    typebox: {};
-    error: {};
-} & Http["~Definitions"], {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-} & Http["~Metadata"], {} & Http["~Routes"], {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
+    derive: {} & Http["~Singleton"]["derive"] & Http["~Ephemeral"]["derive"];
 }, {
+    typebox: {} & Http["~Definitions"]["typebox"];
+    error: [...Http["~Definitions"]["error"], ...Http["~Ephemeral"]["error"]];
+}, import("elysia").DefaultMetadata & {
+    schema: import("elysia/types").MergeSchema<import("elysia/types").MergeSchema<{} & Http["~Ephemeral"]["schema"], {}, "", false>, (import("elysia").DefaultMetadata & Http["~Metadata"])["schema"], "", false>;
+    schemas: (import("elysia").DefaultMetadata & Http["~Metadata"])["schemas"] & {} & Http["~Ephemeral"]["schemas"];
+    macro: (import("elysia").DefaultMetadata & Http["~Metadata"])["macro"];
+    macroFn: (import("elysia").DefaultMetadata & Http["~Metadata"])["macroFn"];
+    parser: (import("elysia").DefaultMetadata & Http["~Metadata"])["parser"];
+    response: import("elysia/types").UnionResponseStatus<(import("elysia").DefaultMetadata & Http["~Metadata"])["response"], import("elysia/types").UnionResponseStatus<{} & Http["~Ephemeral"]["response"], {}>>;
+}, import("elysia/types").ResolveRouteErrors<{}, [...Http["~Definitions"]["error"], ...Http["~Ephemeral"]["error"]]> & Http["~Routes"], import("elysia").DefaultEphemeral, {
     derive: {};
-    resolve: {};
     schema: {};
-    standaloneSchema: {};
+    schemas: {};
     response: {};
-} & {
-    derive: {} & ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["derive"];
-    resolve: {} & ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["resolve"];
-    schema: import("elysia").MergeSchema<({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["schema"], {}, "">;
-    standaloneSchema: ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["standaloneSchema"] & {};
-    response: ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & Http["~Ephemeral"])["response"] & {};
+    error: [];
 }>;
 export { createMemorySandbox, } from "./memory";
 export type { HandleLike as MemoryHandleLike, MemoryDatabase, MemorySandbox, MemorySandboxOptions, MemoryStorage, MemoryStorageObject, } from "./memory";

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { Elysia as Elysia3 } from "elysia";
+import { Elysia as Elysia3, setupTypebox, Validator as Validator2 } from "elysia";
 import { decodeCommandPreview } from "@supacloud/contracts";
 
 // src/command-errors.ts
@@ -83,15 +83,15 @@ function httpRequestId(request) {
 }
 function createHttpTelemetry(observe) {
   const starts = new WeakMap;
-  return new Elysia().onRequest(({ request, set }) => {
+  return new Elysia().request(({ request, set }) => {
     const supplied = request.headers.get("x-request-id");
     const requestId = supplied && /^[A-Za-z0-9._:-]{1,128}$/.test(supplied) ? supplied : crypto.randomUUID();
     starts.set(request, { time: performance.now(), requestId });
     requestIds.set(request, requestId);
     set.headers["x-request-id"] = requestId;
-  }).onError(() => {
+  }).error(() => {
     return;
-  }).onAfterResponse(async ({ request, response, set, route }) => {
+  }).afterResponse(async ({ request, responseValue: response, set, route }) => {
     const start = starts.get(request);
     if (!start)
       return;
@@ -193,7 +193,7 @@ function unauthenticated() {
 }
 
 // src/http-response-cache.ts
-import { mapResponse } from "elysia/adapter/web-standard/handler";
+import { WebStandardAdapter } from "elysia/adapter/web-standard";
 function mayStore({ http, response }) {
   if (response === null || typeof response !== "object" || response instanceof Response || !Array.isArray(response) && Object.getPrototypeOf(response) !== Object.prototype)
     return false;
@@ -277,7 +277,10 @@ function createCachePolicy(options) {
   policy.mapResponse = async (context) => {
     if (!misses.has(context.http.request) || !mayStore(context))
       return;
-    const response = await mapResponse(context.response, context.http.set, context.http.request);
+    const value = context.encodeResponse ? await context.encodeResponse(context.response) : context.response;
+    const response = await WebStandardAdapter.response.map(value, context.http.set, context.http.request);
+    if (!(response instanceof Response))
+      throw new Error("HTTP response mapping did not return a Response");
     const body = boundedBody(response.clone(), options.maxBodyBytes).catch(() => {
       try {
         options.onWriteError();
@@ -695,9 +698,10 @@ function executionTrace(context) {
 
 // src/schema_contract.ts
 import {
-  getSchemaValidator,
+  Validator,
+  t,
   StatusMap as StatusMap2,
-  ElysiaCustomStatusResponse
+  ElysiaStatus
 } from "elysia";
 function defineRouteContract(schemas) {
   return Object.freeze({ ...schemas });
@@ -708,7 +712,7 @@ var RESPONSE_STATUS_MAX = 599;
 var RESPONSE_FAMILY_PATTERN = /^([1-5])(?:xx|XX)$/;
 var RESPONSE_STATUS_PATTERN = /^[1-5]\d{2}$/;
 function isSchema(value) {
-  return value !== null && typeof value === "object" && ((TYPEBOX_KIND in value) || ("~standard" in value));
+  return value !== null && typeof value === "object" && ((TYPEBOX_KIND in value) || ("~kind" in value) || ("~standard" in value));
 }
 function isJsonSchemaObject(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
@@ -769,8 +773,8 @@ function responseStatusDeclared(responses, status) {
 function responseStatusOf(value, configuredStatus) {
   if (value instanceof Response)
     return value.status;
-  if (value instanceof ElysiaCustomStatusResponse) {
-    const code = value.code;
+  if (value instanceof ElysiaStatus) {
+    const code = value.status;
     if (typeof code === "number" && Number.isInteger(code) && code >= RESPONSE_STATUS_MIN && code <= RESPONSE_STATUS_MAX) {
       return code;
     }
@@ -884,7 +888,7 @@ function registerElysiaRoute(app, route) {
     }
     return value;
   };
-  app.route(route.method, route.path, handler, toElysiaRouteSchema(route.contract));
+  app.method(route.method, route.path, toElysiaRouteSchema(route.contract), handler);
   return app;
 }
 
@@ -896,13 +900,19 @@ class SchemaContractError extends Error {
   }
 }
 function createSchemaDecoder(schema, options = {}) {
-  const validator = getSchemaValidator(schema, {
-    coerce: options.coerce ?? false,
+  const validator = Validator.create(schema, {
+    ...options.coerce ? { coerces: [[[
+      ["number", (value) => t.Numeric(value)],
+      ["integer", (value) => t.IntegerString(value)],
+      ["boolean", (value) => t.BooleanString(value)]
+    ]]] } : {},
     normalize: options.normalize ?? true
   });
   return (value) => {
     try {
-      return validator.parse(value);
+      if (validator.isAsync)
+        throw new SchemaContractError;
+      return validator.FromSync(value);
     } catch {
       throw new SchemaContractError;
     }
@@ -1008,12 +1018,12 @@ function createDocumentationPlugin(options = {}) {
     reserve(specPath);
     reserve(uiPath);
     const title = options.openApi.title ?? "OpenAPI Documentation";
-    app.get(specPath, async () => jsonResponse(await resolveSource(options.openApi.document)), {
+    app.get(specPath, {
       detail: { hide: true }
-    });
-    app.get(uiPath, () => new Response(renderViewerPage(title, specPath, "json"), {
+    }, async () => jsonResponse(await resolveSource(options.openApi.document)));
+    app.get(uiPath, { detail: { hide: true } }, () => new Response(renderViewerPage(title, specPath, "json"), {
       headers: { "content-type": "text/html; charset=utf-8" }
-    }), { detail: { hide: true } });
+    }));
   }
   if (options.graphql) {
     const schemaPath = normalizePath(options.graphql.schemaPath, "/graphql/schema.graphql");
@@ -1021,12 +1031,12 @@ function createDocumentationPlugin(options = {}) {
     reserve(schemaPath);
     reserve(uiPath);
     const title = options.graphql.title ?? "GraphQL Schema";
-    app.get(schemaPath, async () => textResponse(await resolveSource(options.graphql.schema)), {
+    app.get(schemaPath, {
       detail: { hide: true }
-    });
-    app.get(uiPath, () => new Response(renderViewerPage(title, schemaPath, "text"), {
+    }, async () => textResponse(await resolveSource(options.graphql.schema)));
+    app.get(uiPath, { detail: { hide: true } }, () => new Response(renderViewerPage(title, schemaPath, "text"), {
       headers: { "content-type": "text/html; charset=utf-8" }
-    }), { detail: { hide: true } });
+    }));
   }
   return app;
 }
@@ -1832,6 +1842,7 @@ function createWorker(options) {
 }
 
 // src/index.ts
+setupTypebox();
 var VERIFIED_JWT_SUBJECT_HEADER = "x-supacloud-jwt-sub";
 var EXECUTION_ID_HEADER = "x-sb-execution-id";
 var IDEMPOTENCY_KEY_HEADER = "idempotency-key";
@@ -1974,7 +1985,7 @@ function contextPlugin(http) {
     seed = ++nextHttpPluginId;
     httpPluginIds.set(http, seed);
   }
-  return new Elysia3({ name: "supacloud:http-context", seed }).use(http ?? new Elysia3).as("scoped");
+  return new Elysia3({ name: "supacloud:http-context", seed }).use(http ?? new Elysia3).as("plugin");
 }
 function mountHttp(http, name, normalize = true) {
   return new Elysia3({ name, normalize }).use(contextPlugin(http));
@@ -2363,7 +2374,7 @@ function createModulePlugin(compiled, services, ctxFactory = defaultRequestConte
   const requestContexts = new WeakMap;
   const governanceExecutor = options.commandGovernance ? createCommandExecutor(options.commandGovernance, options.onExecution) : undefined;
   const commandExecutor = options.commandExecutor && governanceExecutor ? composeCommandExecutors(options.commandExecutor, governanceExecutor) : options.commandExecutor ?? governanceExecutor;
-  const plugin = mountHttp(options.http, `supacloud:${compiled.name}`, options.normalize ?? true).resolve(async (context) => {
+  const plugin = mountHttp(options.http, `supacloud:${compiled.name}`, options.normalize ?? true).derive(async (context) => {
     const requestContext = await ctxFactory(context.request, context);
     requestContexts.set(context.request, requestContext);
     return { services, requestContext };
@@ -2372,7 +2383,7 @@ function createModulePlugin(compiled, services, ctxFactory = defaultRequestConte
   const requestScopes = new WeakMap;
   if (compiled.destroyRequestScope) {
     const destroyRequestScope = compiled.destroyRequestScope;
-    plugin.onAfterResponse(async ({ request }) => {
+    plugin.afterResponse(async ({ request }) => {
       const scope = requestScopes.get(request);
       if (!scope)
         return;
@@ -2384,7 +2395,8 @@ function createModulePlugin(compiled, services, ctxFactory = defaultRequestConte
       }
     });
   }
-  plugin.onError(async ({ code, error, request }) => {
+  plugin.error(async ({ error, request }) => {
+    const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code.toUpperCase().replaceAll("-", "_") : "UNKNOWN";
     const context = {
       request,
       requestContext: requestContexts.get(request),
@@ -2399,12 +2411,14 @@ function createModulePlugin(compiled, services, ctxFactory = defaultRequestConte
       const path = joinPaths(controller.path, route.path);
       const documentation = route.data?.openapi;
       const hidden = documentation !== null && typeof documentation === "object" && "hide" in documentation && documentation.hide === true;
+      const tags = documentation !== null && typeof documentation === "object" && "tags" in documentation && Array.isArray(documentation.tags) ? documentation.tags.filter((tag) => typeof tag === "string") : undefined;
       const schema = {
         ...toElysiaRouteSchema(route),
         ...route.parse === "none" ? { parse: "none" } : {},
-        ...route.title || hidden ? { detail: {
+        ...route.title || hidden || tags ? { detail: {
           ...route.title ? { summary: route.title } : {},
-          ...hidden ? { hide: true } : {}
+          ...hidden ? { hide: true } : {},
+          ...tags ? { tags } : {}
         } } : {}
       };
       const policies = compileHttpPolicies(route, path, options.httpPolicies);
@@ -2428,15 +2442,28 @@ function createModulePlugin(compiled, services, ctxFactory = defaultRequestConte
       const responsePolicies = policies.filter((policy) => policy.afterResponse);
       const mappingPolicies = policies.filter((policy) => policy.mapResponse);
       if (mappingPolicies.length > 0) {
+        const responseValidators = Validator2.response(schema.response, { normalize: options.normalize ?? true });
         Object.assign(schema, {
           mapResponse: async (context) => {
-            let response = context.response;
+            let response = context.responseValue;
             let mapped;
             for (const policy of mappingPolicies) {
               const result = await policy.mapResponse({
                 http: context,
                 requestContext: requestContexts.get(context.request),
-                response
+                response,
+                encodeResponse: async (value) => {
+                  const validator = responseValidators?.[responseStatusOf(value, context.set.status)];
+                  if (!validator)
+                    return value;
+                  if (!("EncodeFrom" in validator) || typeof validator.EncodeFrom !== "function") {
+                    throw new ApplicationError("Response validation failed", { code: "RESPONSE_VALIDATION_FAILED" });
+                  }
+                  if ("mayReturnPromise" in validator && validator.mayReturnPromise && "From" in validator && typeof validator.From === "function") {
+                    return await Reflect.apply(validator.From, validator, [value, "response", true]);
+                  }
+                  return await Reflect.apply(validator.EncodeFrom, validator, [value, "response"]);
+                }
               });
               if (result !== undefined) {
                 if (!(result instanceof Response))
@@ -2456,7 +2483,7 @@ function createModulePlugin(compiled, services, ctxFactory = defaultRequestConte
               await policy.afterResponse({
                 http: context,
                 requestContext: requestContexts.get(context.request),
-                response: context.response
+                response: context.responseValue
               });
             }
           }
@@ -2555,25 +2582,25 @@ function createModulePlugin(compiled, services, ctxFactory = defaultRequestConte
       };
       switch (route.method) {
         case "GET":
-          routeRegistrar.get(path, handler, schema);
+          routeRegistrar.get(path, schema, handler);
           break;
         case "POST":
-          routeRegistrar.post(path, handler, schema);
+          routeRegistrar.post(path, schema, handler);
           break;
         case "PUT":
-          routeRegistrar.put(path, handler, schema);
+          routeRegistrar.put(path, schema, handler);
           break;
         case "PATCH":
-          routeRegistrar.patch(path, handler, schema);
+          routeRegistrar.patch(path, schema, handler);
           break;
         case "DELETE":
-          routeRegistrar.delete(path, handler, schema);
+          routeRegistrar.delete(path, schema, handler);
           break;
         case "HEAD":
-          routeRegistrar.head(path, handler, schema);
+          routeRegistrar.head(path, schema, handler);
           break;
         case "OPTIONS":
-          routeRegistrar.options(path, handler, schema);
+          routeRegistrar.options(path, schema, handler);
           break;
       }
     }
@@ -2675,7 +2702,7 @@ function isPublicApplicationError(error) {
   return error.expose === true && typeof error.status === "number" && Number.isInteger(error.status) && error.status >= 400 && error.status <= 599 && typeof error.code === "string" && error.code.length > 0;
 }
 function createApplication(options) {
-  const app = new Elysia3({ name: options.name ?? "supacloud:app", normalize: options.normalize ?? true });
+  const app = new Elysia3({ name: options.name ?? "supacloud:app", normalize: options.normalize ?? true }).use(contextPlugin(options.http).as("global"));
   if (options.documentation)
     app.use(createDocumentationPlugin(options.documentation));
   const configuredContextFactory = options.requestContext ?? defaultRequestContext;
@@ -2692,9 +2719,9 @@ function createApplication(options) {
   for (const module of options.modules ?? []) {
     const services = module.createServices(options.deps ?? {}, imported);
     imported[module.name] = services;
-    app.use(createModulePlugin(module, services, ctxFactory, options, imported));
+    app.use(createModulePlugin(module, services, ctxFactory, { ...options, http: undefined }, imported));
   }
-  return app.use(contextPlugin(options.http));
+  return app;
 }
 function createTestApp(options) {
   return createApplication(options);

package/dist/schema_contract.d.ts

@@ -1,4 +1,6 @@
-import { StatusMap, ElysiaCustomStatusResponse, type Cookie, type AnyElysia, type HTTPMethod, type InputSchema, type MaybePromise, type TSchema, type UnwrapSchema } from "elysia";
+import { StatusMap, ElysiaStatus, type Cookie, type AnyElysia, type InputSchema } from "elysia";
+import type { HTTPMethod, MaybePromise } from "elysia/types";
+import type { TSchema, StaticDecode as UnwrapSchema } from "typebox";
 import type { ResponseMapSelector as AppResponseMapSelector, RouteContractSchemas as AppRouteContractSchemas } from "@supacloud/app";
 /** Response selectors are owned by @supacloud/app and re-exported by the adapter. */
 export type ResponseMapSelector = AppResponseMapSelector;
@@ -40,17 +42,20 @@ type FamilyResponseCodes<Value> = Value extends Readonly<Record<string | number,
 }[keyof Value & string] : never;
 type ResponseStatusCodes<Value> = NumericResponseCodes<Value> | FamilyResponseCodes<Value> | ([DefaultResponseKey<Value>] extends [never] ? never : AllHttpStatusCodes);
 type DecodedSchema<Value> = Value extends TSchema ? UnwrapSchema<Value> : unknown;
-type DecodedResponse<Schemas extends RouteContractSchemas> = ResponseField<Schemas> extends infer Response ? Response extends TSchema ? DecodedSchema<Response> : Response extends Readonly<Record<string | number, unknown>> ? DecodedSchema<Response[keyof Response]> : DecodedSchema<Response> : unknown;
-type StatusResponse<Schemas extends RouteContractSchemas> = ResponseField<Schemas> extends infer Response ? Response extends TSchema ? never : Response extends Readonly<Record<string | number, unknown>> ? {
-    [Code in ResponseStatusCodes<Response>]: ElysiaCustomStatusResponse<Code, DecodedSchema<ResponseSchemaForCode<Response, Code>>>;
-}[ResponseStatusCodes<Response>] : never : never;
+type StatusResponse<Schemas extends RouteContractSchemas> = [
+    DeclaredResponses<Schemas>
+] extends [never] ? never : {
+    [Code in ResponseStatusCodes<DeclaredResponses<Schemas>>]: ElysiaStatus<Code, DecodedSchema<ResponseSchemaForCode<DeclaredResponses<Schemas>, Code>>>;
+}[ResponseStatusCodes<DeclaredResponses<Schemas>>];
 /**
  * A plain handler return is sent as the default HTTP 200 response.  When a
  * status map declares several payloads, only the schema selected for 200 is
  * valid here; every other payload must use `status(code, value)` so its
  * status and schema stay coupled at runtime.
  */
-type PlainResponse<Schemas extends RouteContractSchemas> = ResponseField<Schemas> extends infer Response ? Response extends Readonly<Record<string | number, unknown>> ? AllowsPlainSuccessResponse<Response> extends true ? DecodedSchema<ResponseSchemaForCode<Response, 200>> : never : DecodedResponse<Schemas> : never;
+type PlainResponse<Schemas extends RouteContractSchemas> = [
+    DeclaredResponses<Schemas>
+] extends [never] ? DecodedSchema<LegacyResponse<Schemas>> : AllowsPlainSuccessResponse<DeclaredResponses<Schemas>> extends true ? DecodedSchema<ResponseSchemaForCode<DeclaredResponses<Schemas>, 200>> : never;
 type ElysiaRouteOutput<Schemas extends RouteContractSchemas> = PlainResponse<Schemas> | StatusResponse<Schemas> | Response | void;
 /** Raw schema shape consumed by Elysia's route registration API. */
 export interface ElysiaRouteSchema<Schemas extends RouteContractSchemas> {
@@ -71,9 +76,11 @@ type DecodedField<Schemas extends RouteContractSchemas, Key extends keyof RouteC
 type DecodedCookie<Schemas extends RouteContractSchemas> = DecodedField<Schemas, "cookie"> extends infer Value ? Value extends Record<string, unknown> ? Record<string, Cookie<unknown>> & {
     [Key in keyof Value]-?: Cookie<Value[Key]>;
 } : Record<string, Cookie<unknown>> : Record<string, Cookie<unknown>>;
-type StatusCode<Schemas extends RouteContractSchemas> = ResponseField<Schemas> extends infer Response ? Response extends TSchema ? never : Response extends Readonly<Record<string | number, unknown>> ? ResponseStatusCodes<Response> : never : never;
-type StatusResponseValue<Schemas extends RouteContractSchemas, Code extends number> = ResponseField<Schemas> extends infer Response ? Response extends TSchema ? DecodedSchema<Response> : Response extends Readonly<Record<string | number, unknown>> ? DecodedSchema<ResponseSchemaForCode<Response, Code>> : DecodedSchema<Response> : unknown;
-type RouteStatus<Schemas extends RouteContractSchemas> = [StatusCode<Schemas>] extends [never] ? <const Code extends number, const Value>(code: Code, response: Value) => ElysiaCustomStatusResponse<Code, Value> : <const Code extends StatusCode<Schemas>, const Value extends StatusResponseValue<Schemas, Code>>(code: Code, response: Value) => ElysiaCustomStatusResponse<Code, Value>;
+type StatusCode<Schemas extends RouteContractSchemas> = [
+    DeclaredResponses<Schemas>
+] extends [never] ? never : ResponseStatusCodes<DeclaredResponses<Schemas>>;
+type StatusResponseValue<Schemas extends RouteContractSchemas, Code extends number> = DecodedSchema<ResponseSchemaForCode<DeclaredResponses<Schemas>, Code>>;
+type RouteStatus<Schemas extends RouteContractSchemas> = [StatusCode<Schemas>] extends [never] ? <const Code extends number, const Value>(code: Code, response: Value) => ElysiaStatus<Code, Value> : <const Code extends StatusCode<Schemas>, const Value extends StatusResponseValue<Schemas, Code>>(code: Code, response: Value) => ElysiaStatus<Code, Value>;
 /** Elysia-compatible decoded context inferred from one route contract and path. */
 export type ElysiaRouteContext<Schemas extends RouteContractSchemas, Path extends string = ""> = {
     body: DecodedField<Schemas, "body">;
@@ -147,8 +154,8 @@ export declare function defineJsonContract<const Input extends TSchema, const Re
     url: string;
     body?: unknown;
 }, options?: SchemaDecoderOptions): Readonly<{
-    input: (value: unknown) => UnwrapSchema<Input, {}>;
-    result: (value: unknown) => UnwrapSchema<Result, {}>;
+    input: (value: unknown) => import("typebox").StaticType<[], "Decode", {}, {}, Input>;
+    result: (value: unknown) => import("typebox").StaticType<[], "Decode", {}, {}, Result>;
     request: (input: NoInfer<UnwrapSchema<Input>>) => {
         method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
         url: string;

package/dist/webhook-migration-example.d.ts

@@ -18,39 +18,26 @@ export declare function createWebhookMigrationExample(options: {
     authorize(identity: CommandIdentity, transaction: CommandTransaction): Promise<CommandAuthorization>;
     writeAudit?(transaction: CommandTransaction): Promise<void>;
 }): {
-    app: import("elysia").default<"", {
+    app: import("elysia").Elysia<"", "local", {
         decorator: {};
         store: {};
         derive: {};
-        resolve: {};
     }, {
         typebox: {};
-        error: {};
-    }, {
+        error: [];
+    }, import("elysia").DefaultMetadata & {
         schema: {};
-        standaloneSchema: {};
+        schemas: {};
         macro: {};
         macroFn: {};
         parser: {};
         response: {};
-    }, {}, {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    }, {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & {
+    }, {}, import("elysia").DefaultEphemeral, {
         derive: {};
-        resolve: {};
         schema: {};
-        standaloneSchema: {};
+        schemas: {};
         response: {};
+        error: [];
     }>;
     modules: import("./fixtures/webhook-generated/application").CompiledApplicationModule[];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supacloud/elysia",
-  "version": "0.19.0",
+  "version": "0.20.1",
   "description": "Elysia runtime adapter for SupaCloud compiled modules: application/request scopes, route registration and validation",
   "type": "module",
   "main": "./dist/index.js",
@@ -47,23 +47,27 @@
     "directory": "packages/elysia"
   },
   "dependencies": {
-    "@supacloud/app": "0.17.0",
+    "@supacloud/app": "0.18.0",
     "@supacloud/contracts": "0.5.0",
-    "jose": "^6.2.11"
+    "exact-mirror": "1.2.6",
+    "jose": "^6.2.11",
+    "typebox": "1.3.34"
   },
   "overrides": {
+    "@supacloud/delivery": "0.2.0",
     "@supacloud/contracts": "0.5.0",
     "@supacloud/commands": "0.7.0"
   },
   "peerDependencies": {
-    "elysia": "^1.4.30"
+    "elysia": "2.0.0-beta.19"
   },
   "devDependencies": {
-    "@supacloud/compiler": "0.26.0",
+    "@supacloud/compiler": "0.27.2",
+    "@supacloud/delivery": "0.2.0",
     "@supacloud/commands": "0.7.0",
-    "@supacloud/db": "0.8.0",
+    "@supacloud/db": "0.9.0",
     "@types/bun": "^1.4.2",
-    "elysia": "^1.4.30",
+    "elysia": "2.0.0-beta.19",
     "typescript": "^7.0.2"
   }
 }