@loutrejs/loutre 0.5.0 → 0.7.0

package/dist/devtools/values.js

@@ -0,0 +1,175 @@
+const defaultMaxValueBytes = 64 * 1024;
+const defaultMaxDepth = 8;
+export function previewDevtoolsValue(value, options = {}) {
+    const maxValueBytes = options.maxValueBytes ?? defaultMaxValueBytes;
+    const maxDepth = options.maxDepth ?? defaultMaxDepth;
+    const redactions = new Set((options.redact ?? []).map((entry) => entry.trim().toLowerCase()));
+    let redacted = false;
+    let truncated = false;
+    const seen = new WeakSet();
+    const encode = (current, depth, path) => {
+        if (depth > maxDepth) {
+            truncated = true;
+            return '[Truncated]';
+        }
+        if (current === null)
+            return null;
+        switch (typeof current) {
+            case 'boolean':
+            case 'number':
+            case 'string':
+                return current;
+            case 'undefined':
+                return { $type: 'undefined' };
+            case 'bigint':
+                return { $type: 'bigint', value: current.toString() };
+            case 'function':
+            case 'symbol':
+                truncated = true;
+                return `[${typeof current}]`;
+            case 'object':
+                break;
+        }
+        if (current instanceof Date) {
+            return { $type: 'date', value: current.toISOString() };
+        }
+        if (current instanceof Uint8Array) {
+            return { $type: 'bytes', base64: bytesToBase64(current) };
+        }
+        if (seen.has(current)) {
+            truncated = true;
+            return '[Circular]';
+        }
+        seen.add(current);
+        try {
+            if (Array.isArray(current)) {
+                const output = [];
+                const descriptors = Object.getOwnPropertyDescriptors(current);
+                for (let index = 0; index < current.length; index += 1) {
+                    const descriptor = descriptors[String(index)];
+                    if (!descriptor) {
+                        output.length = index + 1;
+                        continue;
+                    }
+                    if (!('value' in descriptor)) {
+                        truncated = true;
+                        output[index] = '[Accessor]';
+                        continue;
+                    }
+                    output[index] = encode(descriptor.value, depth + 1, [
+                        ...path,
+                        String(index),
+                    ]);
+                }
+                return output;
+            }
+            if (current instanceof Map) {
+                return {
+                    $type: 'map',
+                    entries: [...current.entries()].map(([key, item], index) => [
+                        encode(key, depth + 1, [...path, String(index), 'key']),
+                        encode(item, depth + 1, [...path, String(index), 'value']),
+                    ]),
+                };
+            }
+            if (current instanceof Set) {
+                return {
+                    $type: 'set',
+                    values: [...current.values()].map((item, index) => encode(item, depth + 1, [...path, String(index)])),
+                };
+            }
+            const output = {};
+            for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(current))) {
+                if (!descriptor.enumerable)
+                    continue;
+                const nextPath = [...path, key];
+                if (shouldRedact(key, nextPath, redactions)) {
+                    redacted = true;
+                    output[key] = { $type: 'redacted' };
+                    continue;
+                }
+                if (!('value' in descriptor)) {
+                    truncated = true;
+                    output[key] = '[Accessor]';
+                    continue;
+                }
+                output[key] = encode(descriptor.value, depth + 1, nextPath);
+            }
+            return output;
+        }
+        finally {
+            seen.delete(current);
+        }
+    };
+    try {
+        const encoded = encode(value, 0, []);
+        const serialized = JSON.stringify(encoded);
+        const bytes = utf8ByteLength(serialized);
+        const preview = serialized.length > 512 ? `${serialized.slice(0, 509)}...` : serialized;
+        if (bytes > maxValueBytes) {
+            return {
+                preview,
+                truncated: true,
+                ...(redacted ? { redacted: true } : {}),
+                type: valueType(value),
+            };
+        }
+        return {
+            value: encoded,
+            preview,
+            ...(truncated ? { truncated: true } : {}),
+            ...(redacted ? { redacted: true } : {}),
+            type: valueType(value),
+        };
+    }
+    catch {
+        const type = safeValueType(value);
+        return {
+            preview: `[${type}]`,
+            truncated: true,
+            type,
+        };
+    }
+}
+function shouldRedact(key, path, redactions) {
+    if (redactions.size === 0)
+        return false;
+    const normalizedKey = key.toLowerCase();
+    const normalizedPath = path.join('.').toLowerCase();
+    return redactions.has(normalizedKey) || redactions.has(normalizedPath);
+}
+function valueType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    if (value instanceof Date)
+        return 'date';
+    if (value instanceof Uint8Array)
+        return 'bytes';
+    if (value instanceof Map)
+        return 'map';
+    if (value instanceof Set)
+        return 'set';
+    return typeof value === 'object' ? 'object' : typeof value;
+}
+function safeValueType(value) {
+    try {
+        return valueType(value);
+    }
+    catch {
+        return typeof value;
+    }
+}
+function utf8ByteLength(value) {
+    return new TextEncoder().encode(value).byteLength;
+}
+function bytesToBase64(value) {
+    let binary = '';
+    for (const byte of value)
+        binary += String.fromCharCode(byte);
+    const encoder = globalThis.btoa;
+    if (typeof encoder === 'function')
+        return encoder(binary);
+    return binary;
+}

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const LOUTRE_VERSION = "0.5.0";
+export declare const LOUTRE_VERSION = "0.7.0";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // package manifestとのずれを避けるため、scripts/generate-version.mjsがbuild前に更新する。
-export const LOUTRE_VERSION = '0.5.0';
+export const LOUTRE_VERSION = '0.7.0';

package/dist/graph/index.d.ts

@@ -1,3 +1,2 @@
-export * from './ir.js';
-export { StaticValidationError, assertValidCompilation, validateGraph, type ApplicationCompilationInput, } from './graph.js';
-export { buildApplicationGraph, compileApplication } from './compiler.js';
+export { projectApplicationModel } from './model.js';
+export type { ApplicationModelGraphIR, GraphEdgeIR, GraphNodeIR, JsonPrimitive, JsonValue, } from './model.js';

package/dist/graph/index.js

@@ -1,3 +1 @@
-export * from './ir.js';
-export { StaticValidationError, assertValidCompilation, validateGraph, } from './graph.js';
-export { buildApplicationGraph, compileApplication } from './compiler.js';
+export { projectApplicationModel } from './model.js';

package/dist/graph/model.d.ts

@@ -0,0 +1,34 @@
+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'];
+    readonly name?: string;
+    readonly module?: string;
+    readonly executionKind?: string;
+    readonly capabilities?: readonly string[];
+    readonly extension?: {
+        readonly name: string;
+        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 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[];
+}
+export declare function projectApplicationModel(model: ApplicationModel): ApplicationModelGraphIR;

package/dist/graph/model.js

@@ -0,0 +1,127 @@
+import { diagnostic, tokenName, } from '../core/index.js';
+export function projectApplicationModel(model) {
+    const diagnostics = [...model.diagnostics];
+    const projectedExecutions = new Map();
+    for (const group of model.extensions) {
+        for (const execution of projectExtensionGroup(group, diagnostics)) {
+            projectedExecutions.set(execution.id, execution);
+        }
+    }
+    const nodes = model.nodes.map((node) => node.kind === 'execution'
+        ? (projectedExecutions.get(node.id) ?? projectExecutionBase(node))
+        : projectCoreNode(node));
+    const edges = model.edges.map((edge) => ({ ...edge }));
+    return Object.freeze({
+        nodes: Object.freeze(nodes),
+        edges: Object.freeze(edges),
+        diagnostics: Object.freeze(diagnostics),
+        modules: Object.freeze(nodes.filter((node) => node.kind === 'module')),
+        providers: Object.freeze(nodes.filter((node) => node.kind === 'provider')),
+        executions: Object.freeze(nodes.filter((node) => node.kind === 'execution')),
+    });
+}
+function projectCoreNode(node) {
+    switch (node.kind) {
+        case 'module':
+            return {
+                id: node.id,
+                kind: node.kind,
+                ...(node.source === undefined ? {} : { source: node.source }),
+                ...(node.name === undefined ? {} : { name: node.name }),
+                ...(node.description === undefined
+                    ? {}
+                    : { attributes: { description: node.description } }),
+            };
+        case 'provider':
+            return {
+                id: node.id,
+                kind: node.kind,
+                name: tokenName(node.token),
+                module: node.moduleId,
+                ...(node.source === undefined ? {} : { source: node.source }),
+                attributes: {
+                    providerKind: node.provider.kind,
+                    scope: node.provider.scope,
+                },
+            };
+        case 'lifecycle':
+            return {
+                id: node.id,
+                kind: node.kind,
+                name: node.phase,
+                module: node.moduleId,
+                ...(node.source === undefined ? {} : { source: node.source }),
+            };
+        case 'framework':
+            return {
+                id: node.id,
+                kind: node.kind,
+                name: node.name,
+                ...(node.source === undefined ? {} : { source: node.source }),
+                attributes: { frameworkKind: node.frameworkKind },
+            };
+    }
+}
+function projectExtensionGroup(group, diagnostics) {
+    return group.executions.map((execution) => {
+        let metadata;
+        const project = group.extension.projectGraph;
+        if (project) {
+            try {
+                const projected = project({ execution });
+                if (projected !== undefined) {
+                    if (!isJsonValue(projected)) {
+                        diagnostics.push(diagnostic('LUTRE_EXTENSION_PROJECTION_NOT_SERIALIZABLE', `Extension ${group.extension.name} returned non-serializable metadata.`, execution.id));
+                    }
+                    else {
+                        metadata = projected;
+                    }
+                }
+            }
+            catch (error) {
+                diagnostics.push(diagnostic('LUTRE_EXTENSION_PROJECTION', error instanceof Error ? error.message : String(error), execution.id));
+            }
+        }
+        return {
+            ...projectExecutionBase(execution),
+            extension: {
+                name: group.extension.name,
+                ...(group.extension.host === undefined
+                    ? {}
+                    : { hostNamespace: group.extension.host.namespace }),
+                ...(metadata === undefined ? {} : { metadata }),
+            },
+        };
+    });
+}
+function projectExecutionBase(execution) {
+    return {
+        id: execution.id,
+        kind: execution.kind,
+        module: execution.moduleId,
+        executionKind: execution.executionKind,
+        capabilities: execution.capabilities.map((capability) => capability.id),
+        ...(execution.source === undefined ? {} : { source: execution.source }),
+    };
+}
+function isJsonValue(value, ancestors = new Set()) {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'boolean') {
+        return true;
+    }
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (typeof value !== 'object')
+        return false;
+    if (ancestors.has(value))
+        return false;
+    const nextAncestors = new Set(ancestors).add(value);
+    if (Array.isArray(value)) {
+        return value.every((item) => isJsonValue(item, nextAncestors));
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return false;
+    return Object.values(value).every((item) => isJsonValue(item, nextAncestors));
+}

package/dist/http/auth.d.ts

@@ -0,0 +1,46 @@
+import type { HttpExecutionResult, HttpMiddleware, HttpMiddlewareContext } from './extension.js';
+export interface BasicAuthCredentials {
+    readonly username: string;
+    readonly password: string;
+}
+export interface HttpAuthenticationFailure<TResponse extends string, TBody> {
+    readonly response: TResponse;
+    readonly body: TBody;
+}
+export type BasicAuthUnauthorized<TResponse extends string, TBody> = HttpAuthenticationFailure<TResponse, TBody>;
+export type BearerAuthUnauthorized<TResponse extends string, TBody> = HttpAuthenticationFailure<TResponse, TBody>;
+export interface BasicAuthContext {
+    readonly input: {
+        readonly headers: Readonly<Record<string, string | undefined>>;
+    };
+}
+export interface BearerAuthContext {
+    readonly input: {
+        readonly headers: Readonly<Record<string, string | undefined>>;
+    };
+}
+type AuthenticationChallengeHeaders = {
+    readonly 'www-authenticate': string;
+};
+type AuthenticationShortCircuit<TResponse extends string, TBody> = HttpExecutionResult<TResponse, TBody, AuthenticationChallengeHeaders>;
+export interface BasicAuthDefinition<TContribution extends object, TResponse extends string, TUnauthorizedBody> {
+    readonly name?: string;
+    readonly realm: string;
+    readonly factory: () => BasicAuthRuntime<TContribution, TResponse, TUnauthorizedBody>;
+}
+export interface BasicAuthRuntime<TContribution extends object, TResponse extends string, TUnauthorizedBody> {
+    authenticate(credentials: BasicAuthCredentials): TContribution | null | undefined | Promise<TContribution | null | undefined>;
+    unauthorized(): HttpAuthenticationFailure<TResponse, TUnauthorizedBody>;
+}
+export declare function basicAuth<const TContribution extends object, const TResponse extends string, TUnauthorizedBody>(definition: BasicAuthDefinition<TContribution, TResponse, TUnauthorizedBody>): HttpMiddleware<TContribution, HttpMiddlewareContext, AuthenticationShortCircuit<TResponse, TUnauthorizedBody>>;
+export interface BearerAuthDefinition<TContribution extends object, TResponse extends string, TUnauthorizedBody> {
+    readonly name?: string;
+    readonly realm: string;
+    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>;
+    unauthorized(): HttpAuthenticationFailure<TResponse, TUnauthorizedBody>;
+}
+export declare function bearerAuth<const TContribution extends object, const TResponse extends string, TUnauthorizedBody>(definition: BearerAuthDefinition<TContribution, TResponse, TUnauthorizedBody>): HttpMiddleware<TContribution, HttpMiddlewareContext, AuthenticationShortCircuit<TResponse, TUnauthorizedBody>>;
+export {};

package/dist/http/auth.js

@@ -0,0 +1,96 @@
+import { defineLayer } from '../core/index.js';
+export function basicAuth(definition) {
+    const challenge = formatBasicChallenge(definition.realm);
+    return defineLayer({
+        name: definition.name ?? 'basicAuth',
+        factory: () => {
+            const runtime = definition.factory();
+            return async (context, next) => {
+                const credentials = decodeBasicCredentials(context.request.headers.get('authorization'));
+                if (!credentials) {
+                    return authenticationFailure(runtime.unauthorized(), challenge);
+                }
+                const contribution = await runtime.authenticate(credentials);
+                if (contribution == null) {
+                    return authenticationFailure(runtime.unauthorized(), challenge);
+                }
+                await next(contribution);
+            };
+        },
+    });
+}
+export function bearerAuth(definition) {
+    const challenge = formatBearerChallenge(definition.realm);
+    return defineLayer({
+        name: definition.name ?? 'bearerAuth',
+        factory: () => {
+            const runtime = definition.factory();
+            return async (context, next) => {
+                const token = readBearerToken(context.request.headers.get('authorization'));
+                if (!token) {
+                    return authenticationFailure(runtime.unauthorized(), challenge);
+                }
+                const contribution = await runtime.authenticate(token);
+                if (contribution == null) {
+                    return authenticationFailure(runtime.unauthorized(), challenge);
+                }
+                await next(contribution);
+            };
+        },
+    });
+}
+function authenticationFailure(failure, challenge) {
+    return {
+        kind: 'http-result',
+        response: failure.response,
+        body: failure.body,
+        headers: { 'www-authenticate': challenge },
+    };
+}
+function formatBasicChallenge(realm) {
+    assertValidRealm(realm, 'Basic');
+    return `Basic realm="${escapeChallengeValue(realm)}", charset="UTF-8"`;
+}
+function formatBearerChallenge(realm) {
+    assertValidRealm(realm, 'Bearer');
+    return `Bearer realm="${escapeChallengeValue(realm)}"`;
+}
+function assertValidRealm(realm, scheme) {
+    if (realm.length === 0 || containsControlCharacter(realm)) {
+        throw new TypeError(`${scheme} authentication realm cannot be empty or contain control characters`);
+    }
+}
+function containsControlCharacter(value) {
+    for (const character of value) {
+        const code = character.charCodeAt(0);
+        if (code <= 0x1f || code === 0x7f)
+            return true;
+    }
+    return false;
+}
+function decodeBasicCredentials(authorization) {
+    const encoded = /^Basic +([A-Za-z0-9+/]+={0,2})$/i.exec(authorization ?? '')?.[1];
+    if (!encoded)
+        return undefined;
+    try {
+        const binary = atob(encoded);
+        const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+        const decoded = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        const separator = decoded.indexOf(':');
+        if (separator < 0)
+            return undefined;
+        return {
+            username: decoded.slice(0, separator),
+            password: decoded.slice(separator + 1),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function readBearerToken(authorization) {
+    return /^Bearer +([^\s]+)$/i.exec(authorization ?? '')?.[1];
+}
+function escapeChallengeValue(value) {
+    return value.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+}

package/dist/http/client.d.ts

@@ -1,13 +1,12 @@
-import { type ContractBinding, type ContractDefinition, type ContractOfBinding, type ProcedureDefinition, type SchemaInput, type SchemaOutput, type StandardSchemaV1 } from '../core/index.js';
-import type { HttpHeaders, HttpParamsSchemas, HttpProtocol, HttpProtocolDefinition, HttpRequestBodyDefinition, HttpResponseDefinition } from './definitions.js';
-import { type PathParamNames, type RawPathParams } from './path.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 query?: unknown;
     readonly headers?: unknown;
     readonly body?: unknown;
-    readonly contentType?: string;
 }
 export interface HttpClientTransportResponse {
     readonly status: number;
@@ -15,45 +14,43 @@ export interface HttpClientTransportResponse {
     readonly headers?: HttpHeaders;
 }
 export type HttpClientTransport = (request: HttpClientTransportRequest) => Promise<HttpClientTransportResponse>;
-type HttpProtocolOf<TProcedure extends ProcedureDefinition> = TProcedure['protocols'] extends {
-    readonly http: infer TProtocol;
-} ? TProtocol extends HttpProtocol<infer TDefinition> ? HttpProtocol<TDefinition> : never : never;
-type HttpProcedureNames<TContract extends ContractDefinition> = {
-    [TProcedure in keyof TContract['procedures'] & string]: HttpProtocolOf<TContract['procedures'][TProcedure]> extends never ? never : TProcedure;
-}[keyof TContract['procedures'] & string];
-type HttpDefinitionOf<TContract extends ContractDefinition, TProcedure extends HttpProcedureNames<TContract>> = HttpProtocolOf<TContract['procedures'][TProcedure]>['definition'];
-type RequestBodySchema<TBody> = TBody extends HttpRequestBodyDefinition<infer TSchema> ? TSchema : never;
-type PathParamsInput<TDefinition extends HttpProtocolDefinition> = PathParamNames<TDefinition['path']> extends never ? never : TDefinition['request'] extends {
-    readonly params: infer TSchemas extends HttpParamsSchemas;
+type PathParamsInput<TDefinition extends HttpExecutionRouteDefinition> = PathParamNames<TDefinition['path']> extends never ? never : TDefinition['request'] extends {
+    readonly params: infer TSchemas extends Readonly<Record<string, StandardSchemaV1>>;
 } ? Readonly<{
     [TName in keyof TSchemas]: SchemaInput<TSchemas[TName]>;
-}> : RawPathParams<TDefinition['path']>;
-type RequestPartInput<TDefinition extends HttpProtocolDefinition, TPart extends 'query' | 'headers'> = TDefinition['request'] extends infer TRequest ? TRequest extends Record<TPart, infer TSchema extends StandardSchemaV1> ? SchemaInput<TSchema> : never : never;
-type RequestBodyInput<TDefinition extends HttpProtocolDefinition> = TDefinition['request'] extends {
-    readonly body: infer TBody extends HttpRequestBodyDefinition;
-} ? SchemaInput<RequestBodySchema<TBody>> : never;
+}> : Readonly<{
+    [TName in PathParamNames<TDefinition['path']>]: string;
+}>;
+type RequestPartInput<TDefinition extends HttpExecutionRouteDefinition, TPart extends 'query' | 'headers'> = TDefinition['request'] extends infer TRequest ? TRequest extends Record<TPart, infer TSchema extends StandardSchemaV1> ? SchemaInput<TSchema> : never : never;
+type RequestBodyInput<TDefinition extends HttpExecutionRouteDefinition> = TDefinition['request'] extends {
+    readonly body: infer TBody extends StandardSchemaV1;
+} ? SchemaInput<TBody> : never;
 type RequestField<TName extends string, TValue> = [TValue] extends [never] ? object : undefined extends TValue ? {
     readonly [TKey in TName]?: Exclude<TValue, undefined>;
 } : {
     readonly [TKey in TName]: TValue;
 };
-export type HttpClientRequest<TDefinition extends HttpProtocolDefinition> = RequestField<'params', PathParamsInput<TDefinition>> & RequestField<'query', RequestPartInput<TDefinition, 'query'>> & RequestField<'headers', RequestPartInput<TDefinition, 'headers'>> & RequestField<'body', RequestBodyInput<TDefinition>>;
-type ResponseBodyOutput<TResponse extends HttpResponseDefinition> = TResponse extends {
+export type HttpClientRequest<TDefinition extends HttpExecutionRouteDefinition> = RequestField<'params', PathParamsInput<TDefinition>> & RequestField<'query', RequestPartInput<TDefinition, 'query'>> & RequestField<'headers', RequestPartInput<TDefinition, 'headers'>> & RequestField<'body', RequestBodyInput<TDefinition>>;
+type ResponseBodyOutput<TResponse extends HttpExecutionResponseDefinition> = TResponse extends {
     readonly stream: 'server';
-} ? AsyncIterable<SchemaOutput<TResponse['body']>> : SchemaOutput<TResponse['body']>;
-type ResponseHeadersOutput<TResponse extends HttpResponseDefinition> = TResponse extends {
-    readonly headers: infer THeaders extends StandardSchemaV1;
-} ? SchemaOutput<THeaders> : HttpHeaders;
-export type HttpClientResponse<TDefinition extends HttpProtocolDefinition> = {
-    [TVariant in keyof TDefinition['responses'] & string]: NonNullable<TDefinition['responses'][TVariant]> extends infer TResponse extends HttpResponseDefinition ? {
+    readonly body: infer TBody extends StandardSchemaV1;
+} ? AsyncIterable<SchemaOutput<TBody>> : TResponse['body'] extends StandardSchemaV1 ? SchemaOutput<TResponse['body']> : undefined;
+type ResponseHeadersSchema<TResponse extends HttpExecutionResponseDefinition> = TResponse extends {
+    readonly headers: infer THeaders;
+} ? THeaders extends StandardSchemaV1 ? THeaders : THeaders extends {
+    readonly schema: infer TSchema extends StandardSchemaV1;
+} ? TSchema : never : never;
+type ResponseHeadersOutput<TResponse extends HttpExecutionResponseDefinition> = ResponseHeadersSchema<TResponse> extends infer TSchema ? [TSchema] extends [never] ? HttpHeaders : TSchema extends StandardSchemaV1 ? SchemaOutput<TSchema> : HttpHeaders : HttpHeaders;
+export type HttpClientResponse<TDefinition extends HttpExecutionRouteDefinition> = {
+    [TVariant in keyof TDefinition['responses'] & string]: TDefinition['responses'][TVariant] extends infer TResponse extends HttpExecutionResponseDefinition ? {
         readonly status: TResponse['status'];
         readonly body: ResponseBodyOutput<TResponse>;
         readonly headers: ResponseHeadersOutput<TResponse>;
     } : never;
 }[keyof TDefinition['responses'] & string];
-type HttpClientMethod<TDefinition extends HttpProtocolDefinition> = keyof HttpClientRequest<TDefinition> extends never ? () => Promise<HttpClientResponse<TDefinition>> : (request: HttpClientRequest<TDefinition>) => Promise<HttpClientResponse<TDefinition>>;
-export type HttpClient<TBinding extends ContractBinding> = {
-    readonly [TProcedure in HttpProcedureNames<ContractOfBinding<TBinding>>]: HttpClientMethod<HttpDefinitionOf<ContractOfBinding<TBinding>, TProcedure>>;
+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]>;
 };
 export declare class HttpClientResponseError extends Error {
     readonly status: number;
@@ -62,7 +59,7 @@ export declare class HttpClientResponseError extends Error {
     readonly procedure: string;
     constructor(status: number, method: string, path: string, procedure: string, message: string, options?: ErrorOptions);
 }
-export declare function createHttpClient<const TBinding extends ContractBinding>(binding: TBinding, transport: HttpClientTransport): HttpClient<TBinding>;
+export declare function createHttpClient<const TContract extends HttpContract>(contract: TContract, transport: HttpClientTransport): HttpClient<TContract>;
 export interface FetchHttpTransportOptions {
     readonly baseUrl: string | URL;
     readonly fetch?: typeof globalThis.fetch;