@duplojs/http 0.8.4 → 0.9.5

package/dist/core/builders/preflight/builder.d.ts

@@ -1,16 +1,15 @@
 import { type Floor } from "../../floor";
-import { type MakeRequestFromHooks, type HookRouteLifeCycle, type RoutePreFlightSteps } from "../../route";
-import { type Builder, type NeverCoalescing } from "@duplojs/utils";
-import { type Request } from "../../request";
+import { type HookRouteLifeCycle, type RoutePreFlightSteps } from "../../route";
+import { type Builder } from "@duplojs/utils";
 import { type Metadata } from "../../metadata";
 export interface PreflightBuilderDefinition {
     readonly preflightSteps: readonly RoutePreFlightSteps[];
     readonly hooks: readonly HookRouteLifeCycle[];
     readonly metadata: readonly Metadata[];
 }
-export interface PreflightBuilder<GenericDefinition extends PreflightBuilderDefinition = PreflightBuilderDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> extends Builder<PreflightBuilderDefinition> {
+export interface PreflightBuilder<GenericDefinition extends PreflightBuilderDefinition = PreflightBuilderDefinition, GenericFloor extends Floor = {}> extends Builder<PreflightBuilderDefinition> {
 }
-export declare const preflightBuilder: import("@duplojs/utils").BuilderHandler<PreflightBuilder<PreflightBuilderDefinition, {}, Request>>;
+export declare const preflightBuilder: import("@duplojs/utils").BuilderHandler<PreflightBuilder<PreflightBuilderDefinition, {}>>;
 export declare function usePreflightBuilder<const GenericHooks extends readonly HookRouteLifeCycle[] = readonly [], const GenericMetadata extends readonly Metadata[] = readonly []>(options?: {
     hooks?: GenericHooks | readonly HookRouteLifeCycle[];
     metadata?: GenericMetadata;
@@ -18,4 +17,4 @@ export declare function usePreflightBuilder<const GenericHooks extends readonly
     readonly preflightSteps: readonly [];
     readonly hooks: GenericHooks;
     readonly metadata: GenericMetadata;
-}, {}, NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>>;
+}, {}>;

package/dist/core/builders/preflight/process.d.ts

@@ -1,11 +1,10 @@
 import { type Floor } from "../../floor";
 import { type ProcessStep } from "../../steps";
 import { type O, type NeverCoalescing, type FixDeepFunctionInfer, type Adaptor, type AnyFunction } from "@duplojs/utils";
-import { type GetProcessRequest, type GetProcessExportValue, type Process } from "../../process";
-import { type Request } from "../../request";
+import { type GetProcessExportValue, type Process } from "../../process";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
-    interface PreflightBuilder<GenericDefinition extends PreflightBuilderDefinition = PreflightBuilderDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+    interface PreflightBuilder<GenericDefinition extends PreflightBuilderDefinition = PreflightBuilderDefinition, GenericFloor extends Floor = {}> {
         exec<GenericProcess extends Process, GenericProcessExportValue extends GetProcessExportValue<GenericProcess>, const GenericImportation extends readonly Extract<keyof GenericProcessExportValue, string>[] = never, GenericOptions extends (GenericProcess["definition"]["options"] | ((floor: GenericFloor) => Exclude<GenericProcess["definition"]["options"], undefined>)) = never, const GenericMetadata extends readonly Metadata[] = readonly []>(process: GenericProcess, params?: {
             readonly imports?: GenericImportation;
             readonly options?: FixDeepFunctionInfer<GenericProcess["definition"]["options"] | ((floor: GenericFloor) => GenericProcess["definition"]["options"]), GenericOptions>;
@@ -19,6 +18,6 @@ declare module "./builder" {
                     readonly metadata: GenericMetadata;
                 }>
             ];
-        }>, O.AssignObjects<GenericFloor, Pick<GenericProcessExportValue, GenericImportation[number]>>, GenericRequest & NeverCoalescing<GetProcessRequest<GenericProcess>, Request>>;
+        }>, O.AssignObjects<GenericFloor, Pick<GenericProcessExportValue, GenericImportation[number]>>>;
     }
 }

package/dist/core/builders/preflight/route.d.ts

@@ -1,11 +1,10 @@
 import { type Floor } from "../../floor";
-import { type RequestMethods, type Request, type BodyController } from "../../request";
-import { type MakeRequestFromHooks, type HookRouteLifeCycle, type RoutePath } from "../../route";
+import { type RequestMethods, type BodyController } from "../../request";
+import { type HookRouteLifeCycle, type RoutePath } from "../../route";
 import { type RouteBuilder } from "../route";
-import { type NeverCoalescing } from "@duplojs/utils";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
-    interface PreflightBuilder<GenericDefinition extends PreflightBuilderDefinition = PreflightBuilderDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+    interface PreflightBuilder<GenericDefinition extends PreflightBuilderDefinition = PreflightBuilderDefinition, GenericFloor extends Floor = {}> {
         useRouteBuilder<GenericMethod extends RequestMethods, const GenericPaths extends RoutePath | readonly [RoutePath, ...RoutePath[]], const GenericHooks extends readonly HookRouteLifeCycle[] = readonly [], const GenericMetadata extends readonly Metadata[] = readonly [], const GenericBodyController extends BodyController | null = null>(method: GenericMethod, path: GenericPaths, options?: {
             hooks?: GenericHooks | readonly HookRouteLifeCycle[];
             metadata?: GenericMetadata;
@@ -24,6 +23,6 @@ declare module "./builder" {
                 ...GenericDefinition["metadata"]
             ];
             readonly bodyController: GenericBodyController;
-        }, GenericFloor, (GenericRequest & NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>)>;
+        }, GenericFloor>;
     }
 }

package/dist/core/builders/process/builder.d.ts

@@ -1,12 +1,11 @@
 import { type ProcessDefinition } from "../../process";
 import { type Floor } from "../../floor";
 import { type Builder, type IsEqual, type NeverCoalescing } from "@duplojs/utils";
-import { type MakeRequestFromHooks, type HookRouteLifeCycle } from "../../route";
-import { type Request } from "../../request";
+import { type HookRouteLifeCycle } from "../../route";
 import { type Metadata } from "../../metadata";
-export interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> extends Builder<ProcessDefinition> {
+export interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}> extends Builder<ProcessDefinition> {
 }
-export declare const processBuilder: import("@duplojs/utils").BuilderHandler<ProcessBuilder<ProcessDefinition, {}, Request>>;
+export declare const processBuilder: import("@duplojs/utils").BuilderHandler<ProcessBuilder<ProcessDefinition, {}>>;
 export declare function useProcessBuilder<GenericOptions extends ProcessDefinition["options"] = never, const GenericHooks extends readonly HookRouteLifeCycle[] = readonly [], const GenericMetadata extends readonly Metadata[] = readonly []>(params?: {
     options?: GenericOptions;
     hooks?: GenericHooks | readonly HookRouteLifeCycle[];
@@ -18,4 +17,4 @@ export declare function useProcessBuilder<GenericOptions extends ProcessDefiniti
     readonly metadata: GenericMetadata;
 }, IsEqual<GenericOptions, never> extends true ? {} : {
     options: GenericOptions;
-}, NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>>;
+}>;

package/dist/core/builders/process/checker.d.ts

@@ -4,10 +4,9 @@ import { type O, type MaybeArray, type NeverCoalescing, type FixDeepFunctionInfe
 import { type GetCheckerResult, type Checker, type GetCheckerInput, type GetCheckerOptions } from "../../checker";
 import { type ClientErrorResponseCode, type ResponseContract } from "../../response";
 import { type ProcessDefinition } from "../../process";
-import { type Request } from "../../request";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
-    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}> {
         check<GenericChecker extends Checker, GenericResultInformation extends MaybeArray<Awaited<GetCheckerResult<GenericChecker>>["information"]>, GenericInput extends GetCheckerInput<GenericChecker>, GenericResponseContract extends ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>, GenericIndex extends string = never, GenericOptions extends (GetCheckerOptions<GenericChecker> | ((floor: GenericFloor) => Exclude<GetCheckerOptions<GenericChecker>, undefined>)) = never, const GenericMetadata extends readonly Metadata[] = readonly []>(checker: GenericChecker, params: {
             input(floor: GenericFloor): GenericInput;
             readonly result: GenericResultInformation;
@@ -31,6 +30,6 @@ declare module "./builder" {
             [Prop in GenericIndex]: Extract<Awaited<GetCheckerResult<GenericChecker>>, {
                 information: A.ArrayCoalescing<GenericResultInformation>[number];
             }>["value"];
-        }>, GenericRequest>;
+        }>>;
     }
 }

package/dist/core/builders/process/cut.d.ts

@@ -3,19 +3,18 @@ import { type ResponseContract } from "../../response";
 import { type CutStepFunctionOutput, type CutStep, type CutStepFunctionParams } from "../../steps";
 import { type Unwrap, type O, type MaybePromise, type IsEqual, type A } from "@duplojs/utils";
 import { type ProcessDefinition } from "../../process";
-import { type Request } from "../../request";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
-    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        cut<const GenericResponseContract extends (ResponseContract.Contract | readonly ResponseContract.Contract[]), GenericResponse extends ResponseContract.Convert<A.ArrayCoalescing<GenericResponseContract>[number]>, GenericOutput extends CutStepFunctionOutput | GenericResponse, const GenericMetadata extends readonly Metadata[] = readonly []>(responseContract: GenericResponseContract, theFunction: (floor: GenericFloor, param: CutStepFunctionParams<GenericRequest, GenericResponse>) => MaybePromise<GenericOutput>, ...metadata: GenericMetadata): ProcessBuilder<O.AssignObjects<GenericDefinition, {
+    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}> {
+        cut<const GenericResponseContract extends (ResponseContract.Contract | readonly ResponseContract.Contract[]), GenericResponse extends ResponseContract.Convert<A.ArrayCoalescing<GenericResponseContract>[number]>, GenericOutput extends CutStepFunctionOutput | GenericResponse, const GenericMetadata extends readonly Metadata[] = readonly []>(responseContract: GenericResponseContract, theFunction: (floor: GenericFloor, param: CutStepFunctionParams<GenericResponse>) => MaybePromise<GenericOutput>, ...metadata: GenericMetadata): ProcessBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 CutStep<{
                     readonly responseContract: GenericResponseContract;
-                    theFunction(floor: GenericFloor, param: CutStepFunctionParams<GenericRequest, GenericResponse>): MaybePromise<GenericOutput>;
+                    theFunction(floor: GenericFloor, param: CutStepFunctionParams<GenericResponse>): MaybePromise<GenericOutput>;
                     readonly metadata: GenericMetadata;
                 }>
             ];
-        }>, IsEqual<Extract<GenericOutput, CutStepFunctionOutput>, never> extends true ? GenericFloor : (GenericOutput extends infer InferredOutputData extends CutStepFunctionOutput ? O.AssignObjects<GenericFloor, Unwrap<InferredOutputData>> : never), GenericRequest>;
+        }>, IsEqual<Extract<GenericOutput, CutStepFunctionOutput>, never> extends true ? GenericFloor : (GenericOutput extends infer InferredOutputData extends CutStepFunctionOutput ? O.AssignObjects<GenericFloor, Unwrap<InferredOutputData>> : never)>;
     }
 }

package/dist/core/builders/process/exports.d.ts

@@ -1,12 +1,11 @@
 import { type Floor } from "../../floor";
 import { type SimplifyTopLevel, type IsEqual, type Or } from "@duplojs/utils";
-import { type Process, type ProcessExportValue, type ProcessDefinition, type ProcessRequest } from "../../process";
-import { type Request } from "../../request";
+import { type Process, type ProcessExportValue, type ProcessDefinition } from "../../process";
 declare module "./builder" {
-    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}> {
         exports<GenericExportation extends (keyof GenericFloor)[] = never>(exportedKey?: GenericExportation): Process<SimplifyTopLevel<GenericDefinition & (Or<[
             IsEqual<GenericExportation, never>,
             IsEqual<GenericExportation, never[]>
-        ]> extends true ? {} : ProcessExportValue<SimplifyTopLevel<Pick<GenericFloor, GenericExportation[number]>>>) & (IsEqual<GenericRequest, Request> extends true ? {} : ProcessRequest<GenericRequest>)>>;
+        ]> extends true ? {} : ProcessExportValue<SimplifyTopLevel<Pick<GenericFloor, GenericExportation[number]>>>)>>;
     }
 }

package/dist/core/builders/process/extract.d.ts

@@ -3,10 +3,9 @@ import { type ExtractShape, type ExtractStep } from "../../steps";
 import { type DP, type ObjectEntry, type O, type SimplifyTopLevel, type NeverCoalescing } from "@duplojs/utils";
 import { type ClientErrorResponseCode, type ResponseContract } from "../../response";
 import { type ProcessDefinition } from "../../process";
-import { type Request } from "../../request";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
-    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}> {
         extract<GenericShape extends ExtractShape, GenericResponseContract extends (ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty> | undefined) = never, const GenericMetadata extends readonly Metadata[] = readonly []>(shape: GenericShape, responseContract?: GenericResponseContract, ...metadata: GenericMetadata): ProcessBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
@@ -22,6 +21,6 @@ declare module "./builder" {
             }[keyof InferredSubShape] : never;
         }[keyof GenericShape] extends infer InferredEntry extends ObjectEntry ? SimplifyTopLevel<{
             [Entry in InferredEntry as Entry[0]]: Entry[1];
-        }> : never>, GenericRequest>;
+        }> : never>>;
     }
 }

package/dist/core/builders/process/presetChecker.d.ts

@@ -1,12 +1,11 @@
 import { type Floor } from "../../floor";
 import { type PresetCheckerStep } from "../../steps";
 import { type O, type A } from "@duplojs/utils";
-import { type Request } from "../../request";
 import { type GetPresetCheckerIndex, type GetPresetCheckerInformation, type GetPresetCheckerResult, type GetPresetCheckerInput, type PresetChecker } from "../../presetChecker";
 import { type ProcessDefinition } from "../../process";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
-    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}> {
         presetCheck<GenericPresetChecker extends PresetChecker, GenericInput extends GetPresetCheckerInput<GenericPresetChecker>, const GenericMetadata extends readonly Metadata[] = readonly []>(presetChecker: GenericPresetChecker, input: (floor: GenericFloor) => GenericInput, ...metadata: GenericMetadata): ProcessBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
@@ -20,6 +19,6 @@ declare module "./builder" {
             [Prop in GetPresetCheckerIndex<GenericPresetChecker>]: Extract<Awaited<GetPresetCheckerResult<GenericPresetChecker>>, {
                 information: A.ArrayCoalescing<GetPresetCheckerInformation<GenericPresetChecker>>[number];
             }>["value"];
-        }>, GenericRequest>;
+        }>>;
     }
 }

package/dist/core/builders/process/process.d.ts

@@ -1,11 +1,10 @@
 import { type Floor } from "../../floor";
 import { type ProcessStep } from "../../steps";
 import { type O, type NeverCoalescing, type FixDeepFunctionInfer, type Adaptor, type AnyFunction } from "@duplojs/utils";
-import { type ProcessDefinition, type GetProcessExportValue, type Process, type GetProcessRequest } from "../../process";
-import { type Request } from "../../request";
+import { type ProcessDefinition, type GetProcessExportValue, type Process } from "../../process";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
-    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}> {
         exec<GenericProcess extends Process, GenericProcessExportValue extends GetProcessExportValue<GenericProcess>, const GenericImportation extends readonly Extract<keyof GenericProcessExportValue, string>[] = never, GenericOptions extends (GenericProcess["definition"]["options"] | ((floor: GenericFloor) => Exclude<GenericProcess["definition"]["options"], undefined>)) = never, const GenericMetadata extends readonly Metadata[] = readonly []>(process: GenericProcess, params?: {
             readonly imports?: GenericImportation;
             readonly options?: FixDeepFunctionInfer<GenericProcess["definition"]["options"] | ((floor: GenericFloor) => GenericProcess["definition"]["options"]), GenericOptions>;
@@ -19,6 +18,6 @@ declare module "./builder" {
                     readonly metadata: GenericMetadata;
                 }>
             ];
-        }>, O.AssignObjects<GenericFloor, Pick<GenericProcessExportValue, GenericImportation[number]>>, GenericRequest & NeverCoalescing<GetProcessRequest<GenericProcess>, Request>>;
+        }>, O.AssignObjects<GenericFloor, Pick<GenericProcessExportValue, GenericImportation[number]>>>;
     }
 }

package/dist/core/builders/route/builder.d.ts

@@ -1,11 +1,11 @@
-import { type MakeRequestFromHooks, type HookRouteLifeCycle, type RouteDefinition, type RoutePath } from "../../route";
+import { type HookRouteLifeCycle, type RouteDefinition, type RoutePath } from "../../route";
 import { type Floor } from "../../floor";
-import { type RequestMethods, type Request, type BodyController } from "../../request";
-import { type Builder, type NeverCoalescing } from "@duplojs/utils";
+import { type RequestMethods, type BodyController } from "../../request";
+import { type Builder } from "@duplojs/utils";
 import { type Metadata } from "../../metadata";
-export interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> extends Builder<RouteDefinition> {
+export interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}> extends Builder<RouteDefinition> {
 }
-export declare const routeBuilderHandler: import("@duplojs/utils").BuilderHandler<RouteBuilder<RouteDefinition, {}, Request>>;
+export declare const routeBuilderHandler: import("@duplojs/utils").BuilderHandler<RouteBuilder<RouteDefinition, {}>>;
 export declare function useRouteBuilder<GenericMethod extends RequestMethods, const GenericPaths extends RoutePath | readonly [RoutePath, ...RoutePath[]], const GenericHooks extends readonly HookRouteLifeCycle[] = readonly [], const GenericMetadata extends readonly Metadata[] = readonly [], const GenericBodyController extends BodyController | null = null>(method: GenericMethod, path: GenericPaths, options?: {
     hooks?: GenericHooks | readonly HookRouteLifeCycle[];
     metadata?: GenericMetadata;
@@ -18,4 +18,4 @@ export declare function useRouteBuilder<GenericMethod extends RequestMethods, co
     readonly hooks: GenericHooks;
     readonly metadata: GenericMetadata;
     readonly bodyController: GenericBodyController;
-}, {}, NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>>;
+}, {}>;

package/dist/core/builders/route/checker.d.ts

@@ -4,10 +4,9 @@ import { type CheckerStep } from "../../steps";
 import { type O, type MaybeArray, type NeverCoalescing, type FixDeepFunctionInfer, type Adaptor, type AnyFunction, type DP, type A } from "@duplojs/utils";
 import { type GetCheckerInput, type Checker, type GetCheckerResult, type GetCheckerOptions } from "../../checker";
 import { type ClientErrorResponseCode, type ResponseContract } from "../../response";
-import { type Request } from "../../request";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
-    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}> {
         check<GenericChecker extends Checker, GenericResultInformation extends MaybeArray<Awaited<GetCheckerResult<GenericChecker>>["information"]>, GenericInput extends GetCheckerInput<GenericChecker>, GenericResponseContract extends ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>, GenericIndex extends string = never, GenericOptions extends (GetCheckerOptions<GenericChecker> | ((floor: GenericFloor) => Exclude<GetCheckerOptions<GenericChecker>, undefined>)) = never, const GenericMetadata extends readonly Metadata[] = readonly []>(checker: GenericChecker, params: {
             input(floor: GenericFloor): GenericInput;
             readonly result: GenericResultInformation;
@@ -31,6 +30,6 @@ declare module "./builder" {
             [Prop in GenericIndex]: Extract<Awaited<GetCheckerResult<GenericChecker>>, {
                 information: A.ArrayCoalescing<GenericResultInformation>[number];
             }>["value"];
-        }>, GenericRequest>;
+        }>>;
     }
 }

package/dist/core/builders/route/cut.d.ts

@@ -3,19 +3,18 @@ import { type ResponseContract } from "../../response";
 import { type RouteDefinition } from "../../route";
 import { type CutStepFunctionOutput, type CutStep, type CutStepFunctionParams } from "../../steps";
 import { type Unwrap, type O, type MaybePromise, type IsEqual, type A } from "@duplojs/utils";
-import { type Request } from "../../request";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
-    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        cut<const GenericResponseContract extends (ResponseContract.Contract | readonly ResponseContract.Contract[]), GenericResponse extends ResponseContract.Convert<A.ArrayCoalescing<GenericResponseContract>[number]>, GenericOutput extends CutStepFunctionOutput | GenericResponse, const GenericMetadata extends readonly Metadata[] = readonly []>(responseContract: GenericResponseContract, theFunction: (floor: GenericFloor, params: CutStepFunctionParams<GenericRequest, GenericResponse>) => MaybePromise<GenericOutput>, ...metadata: GenericMetadata): RouteBuilder<O.AssignObjects<GenericDefinition, {
+    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}> {
+        cut<const GenericResponseContract extends (ResponseContract.Contract | readonly ResponseContract.Contract[]), GenericResponse extends ResponseContract.Convert<A.ArrayCoalescing<GenericResponseContract>[number]>, GenericOutput extends CutStepFunctionOutput | GenericResponse, const GenericMetadata extends readonly Metadata[] = readonly []>(responseContract: GenericResponseContract, theFunction: (floor: GenericFloor, params: CutStepFunctionParams<GenericResponse>) => MaybePromise<GenericOutput>, ...metadata: GenericMetadata): RouteBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 CutStep<{
                     readonly responseContract: GenericResponseContract;
-                    theFunction(floor: GenericFloor, param: CutStepFunctionParams<GenericRequest, GenericResponse>): MaybePromise<GenericOutput>;
+                    theFunction(floor: GenericFloor, param: CutStepFunctionParams<GenericResponse>): MaybePromise<GenericOutput>;
                     readonly metadata: GenericMetadata;
                 }>
             ];
-        }>, IsEqual<Extract<GenericOutput, CutStepFunctionOutput>, never> extends true ? GenericFloor : (GenericOutput extends infer InferredOutputData extends CutStepFunctionOutput ? O.AssignObjects<GenericFloor, Unwrap<InferredOutputData>> : never), GenericRequest>;
+        }>, IsEqual<Extract<GenericOutput, CutStepFunctionOutput>, never> extends true ? GenericFloor : (GenericOutput extends infer InferredOutputData extends CutStepFunctionOutput ? O.AssignObjects<GenericFloor, Unwrap<InferredOutputData>> : never)>;
     }
 }

package/dist/core/builders/route/extract.d.ts

@@ -6,8 +6,8 @@ import { type ClientErrorResponseCode, type ResponseContract } from "../../respo
 import { type Request } from "../../request";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
-    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        extract<GenericShape extends ExtractShape<GenericRequest>, GenericResponseContract extends (ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty> | undefined) = never, const GenericMetadata extends readonly Metadata[] = readonly []>(shape: GenericShape, responseContract?: GenericResponseContract, ...metadata: GenericMetadata): RouteBuilder<O.AssignObjects<GenericDefinition, {
+    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}> {
+        extract<GenericShape extends ExtractShape<Request>, GenericResponseContract extends (ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty> | undefined) = never, const GenericMetadata extends readonly Metadata[] = readonly []>(shape: GenericShape, responseContract?: GenericResponseContract, ...metadata: GenericMetadata): RouteBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 ExtractStep<{
@@ -22,6 +22,6 @@ declare module "./builder" {
             }[keyof InferredSubShape] : never;
         }[keyof GenericShape] extends infer InferredEntry extends ObjectEntry ? SimplifyTopLevel<{
             [Entry in InferredEntry as Entry[0]]: Entry[1];
-        }> : never>, GenericRequest>;
+        }> : never>>;
     }
 }

package/dist/core/builders/route/handler.d.ts

@@ -3,19 +3,18 @@ import { type ResponseContract } from "../../response";
 import { type Route, type RouteDefinition } from "../../route";
 import { type HandlerStep, type HandlerStepFunctionParams } from "../../steps";
 import { type MaybePromise, type O } from "@duplojs/utils";
-import { type Request } from "../../request";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
-    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}> {
         handler<GenericResponseContract extends (ResponseContract.Contract | ResponseContract.ServerSentEventsContract | readonly [
             (ResponseContract.Contract | ResponseContract.ServerSentEventsContract),
             ...(ResponseContract.Contract | ResponseContract.ServerSentEventsContract)[]
-        ]), GenericResponse extends ResponseContract.Convert<GenericResponseContract extends readonly any[] ? GenericResponseContract[number] : GenericResponseContract>, const GenericMetadata extends readonly Metadata[] = readonly []>(responseContract: GenericResponseContract, theFunction: (floor: GenericFloor, param: HandlerStepFunctionParams<GenericRequest, GenericResponse>) => MaybePromise<GenericResponse>, ...metadata: GenericMetadata): Route<O.AssignObjects<GenericDefinition, {
+        ]), GenericResponse extends ResponseContract.Convert<GenericResponseContract extends readonly any[] ? GenericResponseContract[number] : GenericResponseContract>, const GenericMetadata extends readonly Metadata[] = readonly []>(responseContract: GenericResponseContract, theFunction: (floor: GenericFloor, param: HandlerStepFunctionParams<GenericResponse>) => MaybePromise<GenericResponse>, ...metadata: GenericMetadata): Route<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 HandlerStep<{
                     readonly responseContract: GenericResponseContract;
-                    theFunction(floor: GenericFloor, param: HandlerStepFunctionParams<GenericRequest, GenericResponse>): MaybePromise<GenericResponse>;
+                    theFunction(floor: GenericFloor, param: HandlerStepFunctionParams<GenericResponse>): MaybePromise<GenericResponse>;
                     readonly metadata: GenericMetadata;
                 }>
             ];

package/dist/core/builders/route/presetChecker.d.ts

@@ -2,11 +2,10 @@ import { type Floor } from "../../floor";
 import { type RouteDefinition } from "../../route";
 import { type PresetCheckerStep } from "../../steps";
 import { type O, type A } from "@duplojs/utils";
-import { type Request } from "../../request";
 import { type GetPresetCheckerIndex, type GetPresetCheckerInformation, type GetPresetCheckerResult, type GetPresetCheckerInput, type PresetChecker } from "../../presetChecker";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
-    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}> {
         presetCheck<GenericPresetChecker extends PresetChecker, GenericInput extends GetPresetCheckerInput<GenericPresetChecker>, const GenericMetadata extends readonly Metadata[] = readonly []>(presetChecker: GenericPresetChecker, input: (floor: GenericFloor) => GenericInput, ...metadata: GenericMetadata): RouteBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
@@ -20,6 +19,6 @@ declare module "./builder" {
             [Prop in GetPresetCheckerIndex<GenericPresetChecker>]: Extract<Awaited<GetPresetCheckerResult<GenericPresetChecker>>, {
                 information: A.ArrayCoalescing<GetPresetCheckerInformation<GenericPresetChecker>>[number];
             }>["value"];
-        }>, GenericRequest>;
+        }>>;
     }
 }

package/dist/core/builders/route/process.d.ts

@@ -2,11 +2,10 @@ import { type Floor } from "../../floor";
 import { type RouteDefinition } from "../../route";
 import { type ProcessStep } from "../../steps";
 import { type O, type NeverCoalescing, type FixDeepFunctionInfer, type Adaptor, type AnyFunction } from "@duplojs/utils";
-import { type GetProcessRequest, type GetProcessExportValue, type Process } from "../../process";
-import { type Request } from "../../request";
+import { type GetProcessExportValue, type Process } from "../../process";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
-    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}> {
         exec<GenericProcess extends Process, GenericProcessExportValue extends GetProcessExportValue<GenericProcess>, const GenericImportation extends readonly Extract<keyof GenericProcessExportValue, string>[] = never, GenericOptions extends (GenericProcess["definition"]["options"] | ((floor: GenericFloor) => Exclude<GenericProcess["definition"]["options"], undefined>)) = never, const GenericMetadata extends readonly Metadata[] = readonly []>(process: GenericProcess, params?: {
             readonly imports?: GenericImportation;
             readonly options?: FixDeepFunctionInfer<GenericProcess["definition"]["options"] | ((floor: GenericFloor) => GenericProcess["definition"]["options"]), GenericOptions>;
@@ -20,6 +19,6 @@ declare module "./builder" {
                     readonly metadata: GenericMetadata;
                 }>
             ];
-        }>, O.AssignObjects<GenericFloor, Pick<GenericProcessExportValue, GenericImportation[number]>>, GenericRequest & NeverCoalescing<GetProcessRequest<GenericProcess>, Request>>;
+        }>, O.AssignObjects<GenericFloor, Pick<GenericProcessExportValue, GenericImportation[number]>>>;
     }
 }

package/dist/core/defaultHooks/index.d.ts

@@ -1,5 +1,5 @@
 import { type Hub } from "../hub";
 import { type HttpServerParams } from "../types";
 export declare function initDefaultHook(hub: Hub, serverParams: HttpServerParams): {
-    readonly beforeSendResponse: ({ currentResponse, next }: import("../route").RouteHookParamsAfter<import("..").Request>) => import("../route").RouteHookNext;
+    readonly beforeSendResponse: ({ currentResponse, next }: import("../route").RouteHookParamsAfter) => import("../route").RouteHookNext;
 };

package/dist/core/functionsBuilders/index.cjs

@@ -2,4 +2,5 @@
 
 require('./route/index.cjs');
 require('./steps/index.cjs');
+require('./router/index.cjs');
 

package/dist/core/functionsBuilders/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./route";
 export * from "./steps";
+export * from "./router";

package/dist/core/functionsBuilders/index.mjs

@@ -1,2 +1,3 @@
 import './route/index.mjs';
 import './steps/index.mjs';
+import './router/index.mjs';

package/dist/core/functionsBuilders/route/build.d.ts

@@ -1,10 +1,13 @@
-import { type BuildStepFunctionParams } from "../steps";
+import { type createStepFunctionBuilder } from "../steps";
 import { type BuildRouteNotSupportEither, type createRouteFunctionBuilder } from "./create";
 import { type HookRouteLifeCycle, type Route } from "../../route";
 import { type ResponseContract } from "../../response";
-export interface BuildRouteFunctionParams extends BuildStepFunctionParams {
+import { type Environment } from "../../types";
+export interface BuildRouteFunctionParams {
     readonly routeFunctionBuilders: readonly ReturnType<typeof createRouteFunctionBuilder>[];
     readonly globalHooksRouteLifeCycle: readonly HookRouteLifeCycle[];
+    readonly stepFunctionBuilders: readonly ReturnType<typeof createStepFunctionBuilder>[];
+    readonly environment: Environment;
     readonly defaultExtractContract: ResponseContract.Contract;
 }
 export declare function buildRouteFunction(route: Route, params: BuildRouteFunctionParams): Promise<import("..").BuildStepNotSupportEither | import("./create").BuildRouteSuccessEither | BuildRouteNotSupportEither>;

package/dist/core/functionsBuilders/route/create.d.ts

@@ -1,18 +1,16 @@
 import { E, type MaybePromise } from "@duplojs/utils";
-import { type HookRouteLifeCycle, type Route } from "../../route";
-import { type Request } from "../../request";
+import { type BuildedRoute, type HookRouteLifeCycle, type Route } from "../../route";
 import { type Environment } from "../../types";
 import { type BuildStepSuccessEither, type BuildStepNotSupportEither } from "../steps";
 import { type Steps } from "../../steps";
 import { type ResponseContract } from "../../response";
-export type BuildedRouteFunction = (request: Request) => Promise<void>;
-export type BuildRouteSuccessEither = E.Right<"buildSuccess", BuildedRouteFunction>;
+export type BuildRouteSuccessEither = E.Right<"buildSuccess", BuildedRoute>;
 export type BuildRouteNotSupportEither = E.Left<"routeNotSupport", Route>;
 export interface RouteFunctionBuilderParams {
     readonly globalHooksRouteLifeCycle: readonly HookRouteLifeCycle[];
     readonly environment: Environment;
     buildStep(element: Steps): Promise<BuildStepSuccessEither | BuildStepNotSupportEither>;
-    success(result: BuildedRouteFunction): BuildRouteSuccessEither;
+    success(result: BuildedRoute): BuildRouteSuccessEither;
     readonly defaultExtractContract: ResponseContract.Contract;
 }
 export declare function createRouteFunctionBuilder(support: (route: Route) => boolean, builder: (route: Route, params: RouteFunctionBuilderParams) => MaybePromise<BuildRouteSuccessEither | BuildStepNotSupportEither>): (route: Route, params: RouteFunctionBuilderParams) => MaybePromise<BuildRouteNotSupportEither | BuildRouteSuccessEither | BuildStepNotSupportEither>;

package/dist/core/functionsBuilders/route/{hook.cjs → default/hook.cjs}

@@ -1,9 +1,9 @@
 'use strict';
 
-require('../../response/index.cjs');
-require('../../route/index.cjs');
-var hooks = require('../../route/hooks.cjs');
-var hook = require('../../response/hook.cjs');
+require('../../../response/index.cjs');
+require('../../../route/index.cjs');
+var hooks = require('../../../route/hooks.cjs');
+var hook = require('../../../response/hook.cjs');
 
 /* eslint-disable @typescript-eslint/prefer-for-of */
 const hookExit = hooks.hookRouteExitKind.setTo({});
@@ -20,7 +20,10 @@ function buildHookBefore(hooks$1) {
     }
     return async (params) => {
         for (let index = 0; index < hooks$1.length; index++) {
-            const result = await hooks$1[index](params);
+            let result = hooks$1[index](params);
+            if (result instanceof Promise) {
+                result = await result;
+            }
             if (hooks.hookRouteExitKind.has(result)
                 || result instanceof hook.HookResponse) {
                 return result;
@@ -35,7 +38,10 @@ function buildHookErrorBefore(hooks$1) {
     }
     return async (params) => {
         for (let index = 0; index < hooks$1.length; index++) {
-            const result = await hooks$1[index](params);
+            let result = hooks$1[index](params);
+            if (result instanceof Promise) {
+                result = await result;
+            }
             if (hooks.hookRouteExitKind.has(result)
                 || result instanceof hook.HookResponse) {
                 return result;
@@ -50,7 +56,10 @@ function buildHookAfter(hooks$1) {
     }
     return async (params) => {
         for (let index = 0; index < hooks$1.length; index++) {
-            const result = await hooks$1[index](params);
+            let result = hooks$1[index](params);
+            if (result instanceof Promise) {
+                result = await result;
+            }
             if (hooks.hookRouteExitKind.has(result)) {
                 return result;
             }

package/dist/core/functionsBuilders/route/{hook.d.ts → default/hook.d.ts}

@@ -1,8 +1,8 @@
-import { HookResponse } from "../../response";
-import { type HookAfterSendResponse, type HookBeforeRouteExecution, type HookBeforeSendResponse, type HookError, type HookRouteLifeCycle, type HookSendResponse, type RouteHookErrorParams, type RouteHookParams, type RouteHookParamsAfter } from "../../route";
+import { HookResponse } from "../../../response";
+import { type HookAfterSendResponse, type HookBeforeRouteExecution, type HookBeforeSendResponse, type HookError, type HookRouteLifeCycle, type HookSendResponse, type RouteHookErrorParams, type RouteHookParams, type RouteHookParamsAfter } from "../../../route";
 export declare function exitHookFunction(): import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-exit", unknown>, unknown>;
 export declare function nextHookFunction(): import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown>;
-export declare function buildHookBefore(hooks: (HookBeforeRouteExecution)[]): typeof exitHookFunction | ((params: RouteHookParams) => Promise<import("../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown> | HookResponse<import("../../response").ResponseCode, string, unknown>>);
-export declare function buildHookErrorBefore(hooks: HookError[]): typeof exitHookFunction | ((params: RouteHookErrorParams) => Promise<import("../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown> | HookResponse<import("../../response").ResponseCode, string, unknown>>);
-export declare function buildHookAfter(hooks: (HookBeforeSendResponse | HookSendResponse | HookAfterSendResponse)[]): typeof exitHookFunction | ((params: RouteHookParamsAfter) => Promise<import("../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown>>);
+export declare function buildHookBefore(hooks: (HookBeforeRouteExecution)[]): typeof exitHookFunction | ((params: RouteHookParams) => Promise<import("../../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown> | HookResponse<import("../../../response").ResponseCode, string, unknown>>);
+export declare function buildHookErrorBefore(hooks: HookError[]): typeof exitHookFunction | ((params: RouteHookErrorParams) => Promise<import("../../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown> | HookResponse<import("../../../response").ResponseCode, string, unknown>>);
+export declare function buildHookAfter(hooks: (HookBeforeSendResponse | HookSendResponse | HookAfterSendResponse)[]): typeof exitHookFunction | ((params: RouteHookParamsAfter) => Promise<import("../../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown>>);
 export declare function createHookResponse(from: keyof HookRouteLifeCycle): RouteHookParams["response"];

package/dist/core/functionsBuilders/route/{hook.mjs → default/hook.mjs}

@@ -1,7 +1,7 @@
-import '../../response/index.mjs';
-import '../../route/index.mjs';
-import { hookRouteExitKind, hookRouteNextKind } from '../../route/hooks.mjs';
-import { HookResponse } from '../../response/hook.mjs';
+import '../../../response/index.mjs';
+import '../../../route/index.mjs';
+import { hookRouteExitKind, hookRouteNextKind } from '../../../route/hooks.mjs';
+import { HookResponse } from '../../../response/hook.mjs';
 
 /* eslint-disable @typescript-eslint/prefer-for-of */
 const hookExit = hookRouteExitKind.setTo({});
@@ -18,7 +18,10 @@ function buildHookBefore(hooks) {
     }
     return async (params) => {
         for (let index = 0; index < hooks.length; index++) {
-            const result = await hooks[index](params);
+            let result = hooks[index](params);
+            if (result instanceof Promise) {
+                result = await result;
+            }
             if (hookRouteExitKind.has(result)
                 || result instanceof HookResponse) {
                 return result;
@@ -33,7 +36,10 @@ function buildHookErrorBefore(hooks) {
     }
     return async (params) => {
         for (let index = 0; index < hooks.length; index++) {
-            const result = await hooks[index](params);
+            let result = hooks[index](params);
+            if (result instanceof Promise) {
+                result = await result;
+            }
             if (hookRouteExitKind.has(result)
                 || result instanceof HookResponse) {
                 return result;
@@ -48,7 +54,10 @@ function buildHookAfter(hooks) {
     }
     return async (params) => {
         for (let index = 0; index < hooks.length; index++) {
-            const result = await hooks[index](params);
+            let result = hooks[index](params);
+            if (result instanceof Promise) {
+                result = await result;
+            }
             if (hookRouteExitKind.has(result)) {
                 return result;
             }