@loutrejs/loutre 0.9.2 → 0.10.0

package/dist/graph/model.d.ts

@@ -1,34 +1,45 @@
+import type { CapabilityId, ExtensionName } from '../core/identity.js';
+import type { ModuleId } from '../core/model/identity.js';
 import { type ApplicationModel, type ApplicationModelEdge, type ApplicationModelNode, type Diagnostic, type SourceLocation } from '../core/index.js';
 export type JsonPrimitive = string | number | boolean | null;
 export type JsonValue = JsonPrimitive | {
     readonly [key: string]: JsonValue;
 } | readonly JsonValue[];
-export interface GraphNodeIR {
-    readonly id: string;
-    readonly kind: ApplicationModelNode['kind'];
+interface GraphNodeBase {
     readonly name?: string;
-    readonly module?: string;
+    readonly module?: ModuleId | 'application';
     readonly executionKind?: string;
-    readonly capabilities?: readonly string[];
+    readonly capabilities?: readonly CapabilityId[];
     readonly extension?: {
-        readonly name: string;
+        readonly name: ExtensionName;
         readonly hostNamespace?: string;
         readonly metadata?: JsonValue;
     };
     readonly attributes?: Readonly<Record<string, JsonValue>>;
     readonly source?: SourceLocation;
 }
-export interface GraphEdgeIR {
-    readonly from: string;
-    readonly to: string;
-    readonly kind: ApplicationModelEdge['kind'];
-}
+export type GraphNodeIR = {
+    [Kind in ApplicationModelNode['kind']]: GraphNodeBase & {
+        readonly kind: Kind;
+        readonly id: Extract<ApplicationModelNode, {
+            readonly kind: Kind;
+        }>['id'];
+    };
+}[ApplicationModelNode['kind']];
+export type GraphEdgeIR = ApplicationModelEdge;
 export interface ApplicationModelGraphIR {
     readonly nodes: readonly GraphNodeIR[];
     readonly edges: readonly GraphEdgeIR[];
     readonly diagnostics: readonly Diagnostic[];
-    readonly modules: readonly GraphNodeIR[];
-    readonly providers: readonly GraphNodeIR[];
-    readonly executions: readonly GraphNodeIR[];
+    readonly modules: readonly Extract<GraphNodeIR, {
+        kind: 'module';
+    }>[];
+    readonly providers: readonly Extract<GraphNodeIR, {
+        kind: 'provider';
+    }>[];
+    readonly executions: readonly Extract<GraphNodeIR, {
+        kind: 'execution';
+    }>[];
 }
 export declare function projectApplicationModel(model: ApplicationModel): ApplicationModelGraphIR;
+export {};

package/dist/http/auth.d.ts

@@ -1,5 +1,7 @@
+import type { Brand, Descriptor } from '../internal/brand.js';
+export type BearerCredential = Brand<string, 'http.bearer-credential'>;
 import type { HttpExecutionResult, HttpMiddleware, HttpMiddlewareContext } from './extension.js';
-export interface BasicAuthCredentials {
+export interface BasicAuthCredentials extends Descriptor<'basic-auth-credentials'> {
     readonly username: string;
     readonly password: string;
 }
@@ -39,7 +41,7 @@ export interface BearerAuthDefinition<TContribution extends object, TResponse ex
     readonly factory: () => BearerAuthRuntime<TContribution, TResponse, TUnauthorizedBody>;
 }
 export interface BearerAuthRuntime<TContribution extends object, TResponse extends string, TUnauthorizedBody> {
-    authenticate(token: string): TContribution | null | undefined | Promise<TContribution | null | undefined>;
+    authenticate(token: BearerCredential): TContribution | null | undefined | Promise<TContribution | null | undefined>;
     unauthorized(): HttpAuthenticationFailure<TResponse, TUnauthorizedBody> | Response;
 }
 export declare function bearerAuth<const TContribution extends object, const TResponse extends string, TUnauthorizedBody>(definition: BearerAuthDefinition<TContribution, TResponse, TUnauthorizedBody>): HttpMiddleware<TContribution, HttpMiddlewareContext, AuthenticationShortCircuit<TResponse, TUnauthorizedBody>>;

package/dist/http/client.d.ts

@@ -1,9 +1,10 @@
+import { type RequestPathname, type HttpMethod } from './identity.js';
 import { type SchemaInput, type SchemaOutput, type StandardSchemaV1 } from '../core/index.js';
 import type { HttpContract, HttpExecutionResponseDefinition, HttpExecutionRouteDefinition, HttpHeaders } from './extension.js';
 import { type PathParamNames } from './path.js';
 export interface HttpClientTransportRequest {
-    readonly method: string;
-    readonly path: string;
+    readonly method: HttpMethod;
+    readonly path: RequestPathname;
     readonly query?: unknown;
     readonly headers?: unknown;
     readonly body?: unknown;
@@ -50,7 +51,9 @@ export type HttpClientResponse<TDefinition extends HttpExecutionRouteDefinition>
 }[keyof TDefinition['responses'] & string];
 type HttpClientMethod<TDefinition extends HttpExecutionRouteDefinition> = keyof HttpClientRequest<TDefinition> extends never ? () => Promise<HttpClientResponse<TDefinition>> : (request: HttpClientRequest<TDefinition>) => Promise<HttpClientResponse<TDefinition>>;
 export type HttpClient<TContract extends HttpContract> = {
-    readonly [TName in keyof TContract['routes']]: HttpClientMethod<TContract['routes'][TName]>;
+    readonly [TName in keyof TContract['routes'] as TContract['routes'][TName] extends {
+        readonly raw: true;
+    } ? never : TName]: HttpClientMethod<Extract<TContract['routes'][TName], HttpExecutionRouteDefinition>>;
 };
 export declare class HttpClientResponseError extends Error {
     readonly status: number;

package/dist/http/client.js

@@ -1,3 +1,4 @@
+import { normalizeMediaType, normalizeHttpMethod, httpBaseUrl, requestPathname, } from './identity.js';
 import { SchemaValidationError, validateSchema, } from '../core/index.js';
 import { parseHttpPath } from './path.js';
 import { match } from 'ts-pattern';
@@ -18,9 +19,11 @@ export class HttpClientResponseError extends Error {
 export function createHttpClient(contract, transport) {
     const client = {};
     for (const [procedureName, definition] of Object.entries(contract.routes)) {
+        if (definition.raw === true)
+            continue;
         client[procedureName] = async (request = {}) => {
             const response = await transport({
-                method: definition.method,
+                method: normalizeHttpMethod(definition.method),
                 path: interpolatePath(definition.path, request.params),
                 ...(request.query === undefined ? {} : { query: request.query }),
                 ...(request.headers === undefined ? {} : { headers: request.headers }),
@@ -34,8 +37,8 @@ export function createHttpClient(contract, transport) {
 function interpolatePath(path, params) {
     const segments = parseHttpPath(path);
     if (segments.length === 0)
-        return '/';
-    return `/${segments
+        return requestPathname('/');
+    return requestPathname(`/${segments
         .map((segment) => {
         if (segment.kind === 'static')
             return segment.value;
@@ -45,7 +48,7 @@ function interpolatePath(path, params) {
         }
         return encodeURIComponent(String(value));
     })
-        .join('/')}`;
+        .join('/')}`);
 }
 async function decodeResponse(procedure, definition, response) {
     const target = describeHttpTarget(definition, procedure);
@@ -128,7 +131,7 @@ function isAsyncIterable(value) {
 export function fetchHttpTransport(options) {
     const fetchImplementation = options.fetch ?? globalThis.fetch;
     return async (request) => {
-        const url = new URL(request.path, options.baseUrl);
+        const url = new URL(request.path, httpBaseUrl(options.baseUrl));
         appendQuery(url.searchParams, request.query);
         const headers = new Headers(options.headers);
         appendHeaders(headers, request.headers);
@@ -223,10 +226,6 @@ async function decodeFetchBody(response) {
     }
     return response.text();
 }
-function normalizeMediaType(value) {
-    const mediaType = value?.split(';', 1)[0]?.trim().toLowerCase();
-    return mediaType || undefined;
-}
 async function* decodeServerSentEvents(stream) {
     const reader = stream.getReader();
     const decoder = new TextDecoder();

package/dist/http/cors-internal.d.ts

@@ -1,3 +1,5 @@
+import { type HttpMethod, type HttpHeaderName, type CorsOriginValue } from './identity.js';
+import { type DurationSeconds } from '../core/units.js';
 export type CorsOrigin = string | readonly string[] | ((origin: string) => boolean | Promise<boolean>);
 export interface CorsPolicyOptions {
     readonly origin?: CorsOrigin;
@@ -12,16 +14,16 @@ export type CorsPolicy = Readonly<{
         readonly kind: 'wildcard';
     } | {
         readonly kind: 'exact';
-        readonly origins: ReadonlySet<string>;
+        readonly origins: ReadonlySet<CorsOriginValue>;
     } | {
         readonly kind: 'predicate';
         readonly predicate: (origin: string) => boolean | Promise<boolean>;
     };
-    allowMethods: readonly string[] | undefined;
-    allowHeaders: readonly string[] | undefined;
-    exposeHeaders: readonly string[];
+    allowMethods: readonly HttpMethod[] | undefined;
+    allowHeaders: readonly HttpHeaderName[] | undefined;
+    exposeHeaders: readonly HttpHeaderName[];
     credentials: boolean;
-    maxAge: number | undefined;
+    maxAge: DurationSeconds | undefined;
 }>;
 export declare function normalizeCorsPolicy(options: CorsPolicyOptions): CorsPolicy;
 export declare function registerCorsPolicy(middleware: object, policy: CorsPolicy): void;

package/dist/http/cors-internal.js

@@ -1,3 +1,5 @@
+import { normalizeHttpMethod, httpHeaderName, corsOriginValue, } from './identity.js';
+import { seconds } from '../core/units.js';
 const policies = new WeakMap();
 const httpToken = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
 export function normalizeCorsPolicy(options) {
@@ -6,11 +8,11 @@ export function normalizeCorsPolicy(options) {
         origin: normalizeOrigin(options.origin ?? '*', credentials),
         allowMethods: options.allowMethods === undefined
             ? undefined
-            : normalizeTokens(options.allowMethods, 'allowMethods', true),
+            : normalizeTokens(options.allowMethods, 'allowMethods', true).map(normalizeHttpMethod),
         allowHeaders: options.allowHeaders === undefined
             ? undefined
-            : normalizeTokens(options.allowHeaders, 'allowHeaders', false),
-        exposeHeaders: normalizeTokens(options.exposeHeaders ?? [], 'exposeHeaders', false),
+            : normalizeTokens(options.allowHeaders, 'allowHeaders', false).map(httpHeaderName),
+        exposeHeaders: normalizeTokens(options.exposeHeaders ?? [], 'exposeHeaders', false).map(httpHeaderName),
         credentials,
         maxAge: normalizeMaxAge(options.maxAge),
     });
@@ -89,7 +91,7 @@ async function applyOrigin(headers, policy, origin) {
     }
     appendVary(headers, 'Origin');
     const allowed = policy.origin.kind === 'exact'
-        ? policy.origin.origins.has(origin)
+        ? policy.origin.origins.has(corsOriginValue(origin))
         : await policy.origin.predicate(origin);
     if (allowed)
         headers.set('access-control-allow-origin', origin);
@@ -115,7 +117,7 @@ function normalizeOrigin(origin, credentials) {
     }
     return Object.freeze({
         kind: 'exact',
-        origins: new Set(origins),
+        origins: new Set(origins.map(corsOriginValue)),
     });
 }
 function containsControlCharacter(value) {
@@ -141,7 +143,7 @@ function normalizeMaxAge(maxAge) {
     if (!Number.isSafeInteger(maxAge) || maxAge < 0) {
         throw new TypeError('CORS maxAge must be a non-negative safe integer');
     }
-    return maxAge;
+    return seconds(maxAge);
 }
 function appendVary(headers, value) {
     const current = headers.get('vary');

package/dist/http/extension.d.ts

@@ -1,6 +1,10 @@
-import { type ExecutionDefinition, type ExecutionContextView, type ExecutionExtension, type ExecutionExtensionDrainContext, type GenericLayer, type RuntimeCapabilityBinding, type SchemaInput, type SchemaOutput, type StandardSchemaV1, type SourceLocation, type Type } from '../core/index.js';
-import { type HttpPathSegment, type PathParamNames } from './path.js';
+import type { Descriptor } from '../internal/brand.js';
+import { type HttpMethod, type HttpPathTemplate, type HttpDispatchKey, type HttpProcedureName, type HttpResponseStatus } from './identity.js';
+import type { ParsedHttpPath } from './path.js';
+import { type LayerState, type ExecutionDefinition, type ExecutionContextView, type ExecutionExtension, type ExecutionExtensionDrainContext, type GenericLayer, type RuntimeCapabilityBinding, type SchemaInput, type SchemaOutput, type StandardSchemaV1, type SourceLocation, type Type } from '../core/index.js';
+import { type PathParamNames } from './path.js';
 import type { HttpRequestHeadDefinition } from './request-head.js';
+import { isWebSocketUpgrade } from './websocket-upgrade.js';
 export interface HttpServerDriver {
     readonly runtime: string;
 }
@@ -43,6 +47,7 @@ export interface HttpValidationMiddleware<TPart extends HttpValidationPart = Htt
     readonly part: TPart;
 }
 export interface HttpExecutionRouteDefinition {
+    readonly raw?: false;
     readonly method: string;
     readonly path: string;
     readonly summary?: string;
@@ -63,7 +68,21 @@ export interface HttpContractBranchDefinition {
     readonly middlewares?: readonly AnyHttpMiddleware[];
     readonly routes: HttpContractRouteTree;
 }
-export type HttpContractNodeDefinition = HttpExecutionRouteDefinition | HttpContractBranchDefinition;
+export type HttpContractNodeDefinition = HttpExecutionRouteDefinition | HttpContractRawRouteDefinition | HttpContractBranchDefinition;
+export type HttpContractRouteDefinition = HttpExecutionRouteDefinition | HttpContractRawRouteDefinition;
+export interface HttpContractRawRouteDefinition {
+    readonly raw: true;
+    readonly method: string;
+    readonly path: string;
+    readonly middlewares?: readonly AnyHttpMiddleware[];
+    readonly request?: never;
+    readonly responses?: never;
+}
+declare const httpContractRawRouteBrand: unique symbol;
+export interface HttpContractRawRoute extends HttpContractRawRouteDefinition {
+    readonly [httpContractRawRouteBrand]: true;
+}
+export declare function isHttpRawContractRoute(value: unknown): value is HttpContractRawRoute;
 export type HttpContractRouteTree = Readonly<Record<string, HttpContractNodeDefinition>>;
 declare const httpMiddlewareShortCircuit: unique symbol;
 export type HttpMiddleware<TContribution extends object = object, TContext extends object = HttpMiddlewareContext, TShortCircuit extends HttpExecutionResult = never> = GenericLayer<TContext, TContribution, HttpMiddlewareOutcome> & {
@@ -91,10 +110,11 @@ type BranchResponses<TBranch extends HttpContractBranchDefinition> = TBranch ext
 type BranchMiddlewares<TBranch extends HttpContractBranchDefinition> = TBranch extends {
     readonly middlewares: infer TMiddlewares extends readonly AnyHttpMiddleware[];
 } ? TMiddlewares : readonly [];
-type ResolveHttpRoute<TRoute extends HttpExecutionRouteDefinition, TPathPrefix extends string, TResponses extends Readonly<Record<string, HttpExecutionResponseDefinition>>, TMiddlewares extends readonly HttpRouteMiddleware[]> = Omit<TRoute, 'path' | 'responses' | 'middlewares'> & {
+type ResolveHttpRoute<TRoute extends HttpContractRouteDefinition, TPathPrefix extends string, TResponses extends Readonly<Record<string, HttpExecutionResponseDefinition>>, TMiddlewares extends readonly HttpRouteMiddleware[]> = Omit<TRoute, 'path' | 'responses' | 'middlewares'> & {
     readonly path: JoinHttpPath<TPathPrefix, TRoute['path']>;
+} & (TRoute extends HttpContractRawRouteDefinition ? Omit<HttpContractRawRoute, keyof HttpContractRawRouteDefinition> : {
     readonly responses: TResponses & TRoute['responses'];
-} & (readonly [
+}) & (readonly [
     ...TMiddlewares,
     ...(TRoute extends {
         readonly middlewares: infer TRouteMiddlewares extends readonly HttpRouteMiddleware[];
@@ -107,15 +127,15 @@ type ResolveHttpRoute<TRoute extends HttpExecutionRouteDefinition, TPathPrefix e
         } ? TRouteMiddlewares : readonly [])
     ];
 });
-type ResolveHttpNode<TName extends string, TNode extends HttpContractNodeDefinition, TPathPrefix extends string, TResponses extends Readonly<Record<string, HttpExecutionResponseDefinition>>, TMiddlewares extends readonly HttpRouteMiddleware[]> = TNode extends HttpExecutionRouteDefinition ? Readonly<Record<TName, ResolveHttpRoute<TNode, TPathPrefix, TResponses, TMiddlewares>>> : TNode extends HttpContractBranchDefinition ? ResolveHttpRouteTree<TNode['routes'], JoinHttpPath<TPathPrefix, BranchPath<TNode>>, TResponses & BranchResponses<TNode>, readonly [...TMiddlewares, ...BranchMiddlewares<TNode>]> : never;
+type ResolveHttpNode<TName extends string, TNode extends HttpContractNodeDefinition, TPathPrefix extends string, TResponses extends Readonly<Record<string, HttpExecutionResponseDefinition>>, TMiddlewares extends readonly HttpRouteMiddleware[]> = TNode extends HttpContractRouteDefinition ? Readonly<Record<TName, ResolveHttpRoute<TNode, TPathPrefix, TResponses, TMiddlewares>>> : TNode extends HttpContractBranchDefinition ? ResolveHttpRouteTree<TNode['routes'], JoinHttpPath<TPathPrefix, BranchPath<TNode>>, TResponses & BranchResponses<TNode>, readonly [...TMiddlewares, ...BranchMiddlewares<TNode>]> : never;
 type ResolveHttpRouteTree<TTree extends HttpContractRouteTree, TPathPrefix extends string = '', TResponses extends Readonly<Record<string, HttpExecutionResponseDefinition>> = {}, TMiddlewares extends readonly HttpRouteMiddleware[] = readonly []> = UnionToIntersection<{
     [TName in keyof TTree & string]: ResolveHttpNode<TName, TTree[TName], TPathPrefix, TResponses, TMiddlewares>;
 }[keyof TTree & string]>;
 export type ResolvedHttpContractRoutes<TTree extends HttpContractRouteTree> = ResolveHttpRouteTree<TTree> extends infer TRoutes ? {
-    readonly [TName in keyof TRoutes]: Extract<TRoutes[TName], HttpExecutionRouteDefinition>;
+    readonly [TName in keyof TRoutes]: Extract<TRoutes[TName], HttpContractRouteDefinition>;
 } : never;
 type HasResponseNameCollision<TLeft extends Readonly<Record<string, HttpExecutionResponseDefinition>>, TRight extends Readonly<Record<string, HttpExecutionResponseDefinition>>> = Extract<keyof TLeft, keyof TRight> extends never ? false : true;
-type IsHttpContractNodeInheritanceValid<TNode extends HttpContractNodeDefinition, TResponses extends Readonly<Record<string, HttpExecutionResponseDefinition>>> = TNode extends HttpExecutionRouteDefinition ? HasResponseNameCollision<TResponses, TNode['responses']> extends true ? false : true : TNode extends HttpContractBranchDefinition ? HasResponseNameCollision<TResponses, BranchResponses<TNode>> extends true ? false : IsHttpContractTreeInheritanceValid<TNode['routes'], TResponses & BranchResponses<TNode>> : false;
+type IsHttpContractNodeInheritanceValid<TNode extends HttpContractNodeDefinition, TResponses extends Readonly<Record<string, HttpExecutionResponseDefinition>>> = TNode extends HttpContractRawRouteDefinition ? keyof TResponses extends never ? true : false : TNode extends HttpExecutionRouteDefinition ? HasResponseNameCollision<TResponses, TNode['responses']> extends true ? false : true : TNode extends HttpContractBranchDefinition ? HasResponseNameCollision<TResponses, BranchResponses<TNode>> extends true ? false : IsHttpContractTreeInheritanceValid<TNode['routes'], TResponses & BranchResponses<TNode>> : false;
 type IsHttpContractTreeInheritanceValid<TTree extends HttpContractRouteTree, TResponses extends Readonly<Record<string, HttpExecutionResponseDefinition>> = {}> = string extends keyof TTree ? true : false extends {
     [TName in keyof TTree]: IsHttpContractNodeInheritanceValid<TTree[TName], TResponses>;
 }[keyof TTree] ? false : true;
@@ -123,7 +143,7 @@ type HttpMiddlewareState<TRoute extends HttpExecutionRouteDefinition> = TRoute e
     readonly middlewares: infer TMiddlewares extends readonly HttpRouteMiddleware[];
 } ? UnionToIntersection<MiddlewareContribution<TMiddlewares[number]>> : {};
 declare const httpContractBrand: unique symbol;
-export interface HttpContract<TRoutes extends Readonly<Record<string, HttpExecutionRouteDefinition>> = Readonly<Record<string, HttpExecutionRouteDefinition>>> {
+export interface HttpContract<TRoutes extends Readonly<Record<string, HttpContractRouteDefinition>> = Readonly<Record<string, HttpContractRouteDefinition>>> {
     readonly kind: 'http-contract';
     readonly routes: TRoutes;
     readonly [httpContractBrand]: true;
@@ -193,7 +213,7 @@ export type HttpExecutionContext<TRoute extends HttpExecutionRouteDefinition = H
     readonly state: Readonly<HttpMiddlewareState<TRoute>>;
 };
 export type HttpHandlers<TContract extends HttpContract> = {
-    readonly [TName in keyof TContract['routes']]: (context: HttpExecutionContext<TContract['routes'][TName]>) => DeclaredHttpResults<TContract['routes'][TName]> | Promise<DeclaredHttpResults<TContract['routes'][TName]>>;
+    readonly [TName in keyof TContract['routes'] as TContract['routes'][TName] extends HttpContractRawRouteDefinition ? never : TName]: (context: HttpExecutionContext<Extract<TContract['routes'][TName], HttpExecutionRouteDefinition>>) => DeclaredHttpResults<Extract<TContract['routes'][TName], HttpExecutionRouteDefinition>> | Promise<DeclaredHttpResults<Extract<TContract['routes'][TName], HttpExecutionRouteDefinition>>>;
 };
 export interface HttpImplementationDefinition<TContract extends HttpContract = HttpContract> {
     readonly name: string;
@@ -212,7 +232,7 @@ export interface HttpRawExecutionContext<TState = Readonly<Record<string, unknow
     readonly state: Readonly<TState>;
     readonly execution: ExecutionContextView;
 }
-type RawMiddlewareState<TMiddlewares extends readonly AnyHttpMiddleware[]> = UnionToIntersection<MiddlewareContribution<TMiddlewares[number]>> & object;
+type RawMiddlewareState<TMiddlewares extends readonly AnyHttpMiddleware[]> = LayerState<TMiddlewares>;
 export interface HttpRawDefinition<TMiddlewares extends readonly AnyHttpMiddleware[] = readonly AnyHttpMiddleware[]> {
     readonly name?: string;
     readonly route: HttpRawRouteDefinition & {
@@ -222,21 +242,35 @@ export interface HttpRawDefinition<TMiddlewares extends readonly AnyHttpMiddlewa
 }
 export type HttpRawExecutionDefinition = HttpRawDefinition & ExecutionDefinition<typeof httpExecutionExtension>;
 export declare function defineHttpRaw<const TMiddlewares extends readonly AnyHttpMiddleware[] = readonly []>(definition: HttpRawDefinition<TMiddlewares>): HttpRawDefinition<TMiddlewares> & ExecutionDefinition<typeof httpExecutionExtension>;
+export type CompiledHttpResponseDefinition = HttpExecutionResponseDefinition & Descriptor<'http-response'> & {
+    readonly status: HttpResponseStatus;
+};
+type CompiledHttpRouteDefinition = Omit<HttpExecutionRouteDefinition, 'responses'> & {
+    readonly responses: Readonly<Record<string, CompiledHttpResponseDefinition>>;
+};
 interface CompiledHttpRoute {
-    readonly name: string;
-    readonly method: string;
-    readonly path: string;
-    readonly segments: readonly HttpPathSegment[];
-    readonly dispatch: string;
-    readonly definition: HttpExecutionRouteDefinition;
+    readonly name: HttpProcedureName;
+    readonly method: HttpMethod | '*';
+    readonly path: HttpPathTemplate;
+    readonly segments: ParsedHttpPath;
+    readonly dispatch: HttpDispatchKey;
+    readonly definition: CompiledHttpRouteDefinition;
     readonly middlewares: readonly AnyHttpMiddleware[];
     readonly source?: SourceLocation;
     readonly raw?: boolean;
     readonly protocol?: string;
 }
+interface RuntimeHttpContext {
+    readonly input: HttpMiddlewareContext['input'];
+    readonly response: ReturnType<typeof createHttpResponseHelpers>;
+    readonly signal: AbortSignal;
+    readonly state: Readonly<Record<string, unknown>>;
+    readonly request?: Request;
+    readonly execution?: ExecutionContextView;
+}
 interface CompiledHttpExecution {
     readonly routes: readonly CompiledHttpRoute[];
-    readonly factory: () => Record<string, (context: HttpExecutionContext) => HttpMiddlewareOutcome | Promise<HttpMiddlewareOutcome>>;
+    readonly factory: () => Record<string, (context: RuntimeHttpContext) => HttpMiddlewareOutcome | Promise<HttpMiddlewareOutcome>>;
 }
 export interface HttpExtensionRuntime {
     fetch(request: Request): Promise<Response>;
@@ -323,8 +357,8 @@ type HttpRouteConstraint<TRoute extends HttpExecutionRouteDefinition> = (AreResp
 } : unknown) & (AreMiddlewareShortCircuitsCompatible<TRoute> extends true ? unknown : {
     readonly middlewares: never;
 });
-type HttpContractConstraint<TRoutes extends Readonly<Record<string, HttpExecutionRouteDefinition>>> = {
-    readonly [TName in keyof TRoutes]: HttpRouteConstraint<TRoutes[TName]>;
+type HttpContractConstraint<TRoutes extends Readonly<Record<string, HttpContractRouteDefinition>>> = {
+    readonly [TName in keyof TRoutes]: TRoutes[TName] extends HttpContractRawRouteDefinition ? unknown : HttpRouteConstraint<Extract<TRoutes[TName], HttpExecutionRouteDefinition>>;
 };
 type ErrorOf<TDefinition> = TDefinition extends HttpErrorMatcher<infer TError> ? TError : never;
 export declare function httpError<TDefinition extends HttpErrorMatcher<{
@@ -354,6 +388,7 @@ export declare const validate: Readonly<{
     }>;
 }>;
 export declare const executionHttp: Readonly<{
+    isWebSocketUpgrade: typeof isWebSocketUpgrade;
     raw: typeof defineHttpRaw;
     contract: typeof defineHttpContract;
     implementation: typeof defineHttpImplementation;
@@ -365,11 +400,15 @@ export declare const executionHttp: Readonly<{
         }>;
     }>;
     error: typeof httpError;
-    extension: ExecutionExtension<(HttpImplementationDefinition<HttpContract<Readonly<Record<string, HttpExecutionRouteDefinition>>>> | HttpRawDefinition<readonly AnyHttpMiddleware[]>) & ExecutionDefinition<import("../core/extension.js").AnyExecutionExtension>, CompiledHttpExecution, "http", HttpHostApi, HttpExtensionRuntime> & {
+    extension: ExecutionExtension<(HttpImplementationDefinition<HttpContract<Readonly<Record<string, HttpContractRouteDefinition>>>> | HttpRawDefinition<readonly AnyHttpMiddleware[]>) & ExecutionDefinition<import("../core/extension.js").AnyExecutionExtension>, CompiledHttpExecution, "http", HttpHostApi, HttpExtensionRuntime> & {
         readonly [httpExecutionExtensionIdentity]: true;
     };
     serverCapability: import("../core/extension.js").RuntimeCapability<HttpServerDriver>;
     bindServer: typeof bindHttpServer;
 }>;
 export declare function withHttpFrameworkHeaders(result: HttpExecutionResult, headers: HttpHeaders): HttpExecutionResult;
+declare function createHttpResponseHelpers(responses: HttpExecutionRouteDefinition['responses']): Readonly<Record<string, (value?: {
+    readonly body?: unknown;
+    readonly headers?: HttpHeaders;
+}) => HttpExecutionResult>>;
 export {};