@duplojs/http 0.2.0 → 0.4.0

package/dist/client/unexpectedResponseError.mjs

@@ -0,0 +1,39 @@
+import { kindHeritage } from '@duplojs/utils';
+import { createClientKind } from './kind.mjs';
+
+class UnexpectedInformationResponseError extends kindHeritage("unexpected-information-response-error", createClientKind("unexpected-information-response-error"), Error) {
+    information;
+    response;
+    constructor(information, response) {
+        super({}, ["Unexpected information response."]);
+        this.information = information;
+        this.response = response;
+    }
+}
+class UnexpectedCodeResponseError extends kindHeritage("unexpected-code-response-error", createClientKind("unexpected-code-response-error"), Error) {
+    code;
+    response;
+    constructor(code, response) {
+        super({}, ["Unexpected code response."]);
+        this.code = code;
+        this.response = response;
+    }
+}
+class UnexpectedResponseTypeError extends kindHeritage("unexpected-response-type-error", createClientKind("unexpected-response-type-error"), Error) {
+    expectType;
+    response;
+    constructor(expectType, response) {
+        super({}, ["Unexpected response type."]);
+        this.expectType = expectType;
+        this.response = response;
+    }
+}
+class UnexpectedResponseError extends kindHeritage("unexpected-response-error", createClientKind("unexpected-response-error"), Error) {
+    response;
+    constructor(response) {
+        super({}, ["Unexpected response."]);
+        this.response = response;
+    }
+}
+
+export { UnexpectedCodeResponseError, UnexpectedInformationResponseError, UnexpectedResponseError, UnexpectedResponseTypeError };

package/dist/core/functionsBuilders/route/default.cjs

@@ -2,12 +2,13 @@
 
 var index = require('../../route/index.cjs');
 var utils = require('@duplojs/utils');
-var index$1 = require('../../response/index.cjs');
+require('../../response/index.cjs');
 var hook = require('./hook.cjs');
 var create = require('./create.cjs');
 require('../steps/index.cjs');
 var processStep = require('../steps/defaults/processStep.cjs');
-var response = require('../../route/hooks/response.cjs');
+var base = require('../../response/base.cjs');
+var hook$1 = require('../../response/hook.cjs');
 
 /* eslint-disable @typescript-eslint/prefer-for-of */
 const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.routeKind.has, async (route, { success, buildStep, globalHooksRouteLifeCycle, }) => {
@@ -63,13 +64,13 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
                 next: hook.nextHookFunction,
                 response: hook.createHookResponse("beforeRouteExecution"),
             });
-            if (beforeRouteExecutionResult instanceof index$1.Response) {
+            if (beforeRouteExecutionResult instanceof base.Response) {
                 return beforeRouteExecutionResult;
             }
             let floor = {};
             for (let index = 0; index < buildedPreFlightSteps.length; index++) {
                 const result = await buildedPreFlightSteps[index].buildedFunction(request, floor);
-                if (result instanceof index$1.Response) {
+                if (result instanceof base.Response) {
                     return result;
                 }
                 floor = result;
@@ -80,17 +81,17 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
                 next: hook.nextHookFunction,
                 response: hook.createHookResponse("parseBody"),
             });
-            if (parseBodyResult instanceof index$1.Response) {
+            if (parseBodyResult instanceof base.Response) {
                 return parseBodyResult;
             }
             for (let index = 0; index < buildedSteps.length; index++) {
                 const result = await buildedSteps[index].buildedFunction(request, floor);
-                if (result instanceof index$1.Response) {
+                if (result instanceof base.Response) {
                     return result;
                 }
                 floor = result;
             }
-            return new index$1.Response("500", "missing-response", undefined);
+            return new base.Response("500", "missing-response", undefined);
         }
         catch (error) {
             const errorResult = await hooks.error({
@@ -100,10 +101,10 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
                 next: hook.nextHookFunction,
                 response: hook.createHookResponse("error"),
             });
-            if (errorResult instanceof response.HookResponse) {
+            if (errorResult instanceof hook$1.HookResponse) {
                 return errorResult;
             }
-            return new index$1.Response("500", "server-error", error);
+            return new base.Response("500", "server-error", error);
         }
     }
     return success(async (request) => {

package/dist/core/functionsBuilders/route/default.mjs

@@ -1,11 +1,12 @@
 import { routeKind } from '../../route/index.mjs';
 import { E, A, pipe, isType, forward } from '@duplojs/utils';
-import { Response } from '../../response/index.mjs';
+import '../../response/index.mjs';
 import { buildHookAfter, buildHookErrorBefore, buildHookBefore, createHookResponse, nextHookFunction, exitHookFunction } from './hook.mjs';
 import { createRouteFunctionBuilder } from './create.mjs';
 import '../steps/index.mjs';
 import { buildStepsFunction } from '../steps/defaults/processStep.mjs';
-import { HookResponse } from '../../route/hooks/response.mjs';
+import { Response } from '../../response/base.mjs';
+import { HookResponse } from '../../response/hook.mjs';
 
 /* eslint-disable @typescript-eslint/prefer-for-of */
 const defaultRouteFunctionBuilder = createRouteFunctionBuilder(routeKind.has, async (route, { success, buildStep, globalHooksRouteLifeCycle, }) => {

package/dist/core/functionsBuilders/route/hook.cjs

@@ -1,56 +1,56 @@
 'use strict';
 
 require('../../route/index.cjs');
-var index = require('../../route/hooks/index.cjs');
-var response = require('../../route/hooks/response.cjs');
+var hooks = require('../../route/hooks.cjs');
+var hook = require('../../response/hook.cjs');
 
 /* eslint-disable @typescript-eslint/prefer-for-of */
-const hookExit = index.hookRouteExitKind.setTo({});
-const hookNext = index.hookRouteNextKind.setTo({});
+const hookExit = hooks.hookRouteExitKind.setTo({});
+const hookNext = hooks.hookRouteNextKind.setTo({});
 function exitHookFunction() {
     return hookExit;
 }
 function nextHookFunction() {
     return hookNext;
 }
-function buildHookBefore(hooks) {
-    if (!hooks.length) {
+function buildHookBefore(hooks$1) {
+    if (!hooks$1.length) {
         return exitHookFunction;
     }
     return async (params) => {
-        for (let index$1 = 0; index$1 < hooks.length; index$1++) {
-            const result = await hooks[index$1](params);
-            if (index.hookRouteExitKind.has(result)
-                || result instanceof response.HookResponse) {
+        for (let index = 0; index < hooks$1.length; index++) {
+            const result = await hooks$1[index](params);
+            if (hooks.hookRouteExitKind.has(result)
+                || result instanceof hook.HookResponse) {
                 return result;
             }
         }
         return hookNext;
     };
 }
-function buildHookErrorBefore(hooks) {
-    if (!hooks.length) {
+function buildHookErrorBefore(hooks$1) {
+    if (!hooks$1.length) {
         return exitHookFunction;
     }
     return async (params) => {
-        for (let index$1 = 0; index$1 < hooks.length; index$1++) {
-            const result = await hooks[index$1](params);
-            if (index.hookRouteExitKind.has(result)
-                || result instanceof response.HookResponse) {
+        for (let index = 0; index < hooks$1.length; index++) {
+            const result = await hooks$1[index](params);
+            if (hooks.hookRouteExitKind.has(result)
+                || result instanceof hook.HookResponse) {
                 return result;
             }
         }
         return hookNext;
     };
 }
-function buildHookAfter(hooks) {
-    if (!hooks.length) {
+function buildHookAfter(hooks$1) {
+    if (!hooks$1.length) {
         return exitHookFunction;
     }
     return async (params) => {
-        for (let index$1 = 0; index$1 < hooks.length; index$1++) {
-            const result = await hooks[index$1](params);
-            if (index.hookRouteExitKind.has(result)) {
+        for (let index = 0; index < hooks$1.length; index++) {
+            const result = await hooks$1[index](params);
+            if (hooks.hookRouteExitKind.has(result)) {
                 return result;
             }
         }
@@ -58,7 +58,7 @@ function buildHookAfter(hooks) {
     };
 }
 function createHookResponse(from) {
-    return (code, information, body) => new response.HookResponse(from, code, information, body);
+    return (code, information, body) => new hook.HookResponse(from, code, information, body);
 }
 
 exports.buildHookAfter = buildHookAfter;

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

@@ -1,7 +1,7 @@
 import { type HookAfterSendResponse, type HookBeforeRouteExecution, type HookBeforeSendResponse, type HookError, type HookParseBody, HookResponse, 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 | HookParseBody)[]): typeof exitHookFunction | ((params: RouteHookParams) => Promise<import("../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown> | HookResponse<import("../..").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("../..").ResponseCode, string, unknown>>);
+export declare function buildHookBefore(hooks: (HookBeforeRouteExecution | HookParseBody)[]): typeof exitHookFunction | ((params: RouteHookParams) => Promise<import("../../route").RouteHookExit | import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>, unknown> | HookResponse<import("../../route").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("../../route").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

@@ -1,6 +1,6 @@
 import '../../route/index.mjs';
-import { hookRouteExitKind, hookRouteNextKind } from '../../route/hooks/index.mjs';
-import { HookResponse } from '../../route/hooks/response.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({});

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

@@ -3,9 +3,9 @@ import { type Steps } from "../../steps/types";
 import { type Floor } from "../../floor";
 import { type HookRouteLifeCycle } from "../../route";
 import { type Request } from "../../request";
-import { type ResponseContract, type Response } from "../../response";
+import { type ResponseContract, type PredictedResponse } from "../../response";
 import { type Environment } from "../../types";
-export type BuildedStepFunction = (request: Request, floor: Floor) => MaybePromise<Floor | Response>;
+export type BuildedStepFunction = (request: Request, floor: Floor) => MaybePromise<Floor | PredictedResponse>;
 export interface BuildStepResult {
     readonly buildedFunction: BuildedStepFunction;
     readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];

package/dist/core/functionsBuilders/steps/defaults/checkerStep.cjs

@@ -4,9 +4,10 @@ var checker$1 = require('../../../checker.cjs');
 var create = require('../create.cjs');
 require('../../../steps/index.cjs');
 var utils = require('@duplojs/utils');
-var index = require('../../../response/index.cjs');
+require('../../../response/index.cjs');
 var checker = require('../../../steps/checker.cjs');
 var presetChecker = require('../../../steps/presetChecker.cjs');
+var predicted = require('../../../response/predicted.cjs');
 
 const defaultCheckerStepFunctionBuilder = create.createStepFunctionBuilder((element) => checker.checkerStepKind.has(element) || presetChecker.presetCheckerStepKind.has(element), (step, { success }) => {
     const { checkerOptions, checkerFunction, input, responseContract, stepResult, indexing, stepOptions, } = utils.pipe(step, utils.P.when(checker.checkerStepKind.has, ({ definition }) => ({
@@ -36,7 +37,7 @@ const defaultCheckerStepFunctionBuilder = create.createStepFunctionBuilder((elem
     });
     const expectedResult = utils.pipe(stepResult, utils.P.when(utils.isType("string"), (expectedInformation) => ((information) => information === expectedInformation)), utils.P.otherwise((expectedInformation) => ((information) => expectedInformation.includes(information))));
     function getResponse() {
-        return new index.Response(responseContract.code, responseContract.information, undefined);
+        return new predicted.PredictedResponse(responseContract.code, responseContract.information, undefined);
     }
     function treatResult(output, floor) {
         if (!expectedResult(output.information)) {

package/dist/core/functionsBuilders/steps/defaults/checkerStep.mjs

@@ -2,9 +2,10 @@ import { checkerOutputKind } from '../../../checker.mjs';
 import { createStepFunctionBuilder } from '../create.mjs';
 import '../../../steps/index.mjs';
 import { pipe, P, or, isType, forward } from '@duplojs/utils';
-import { Response } from '../../../response/index.mjs';
+import '../../../response/index.mjs';
 import { checkerStepKind } from '../../../steps/checker.mjs';
 import { presetCheckerStepKind } from '../../../steps/presetChecker.mjs';
+import { PredictedResponse } from '../../../response/predicted.mjs';
 
 const defaultCheckerStepFunctionBuilder = createStepFunctionBuilder((element) => checkerStepKind.has(element) || presetCheckerStepKind.has(element), (step, { success }) => {
     const { checkerOptions, checkerFunction, input, responseContract, stepResult, indexing, stepOptions, } = pipe(step, P.when(checkerStepKind.has, ({ definition }) => ({
@@ -34,7 +35,7 @@ const defaultCheckerStepFunctionBuilder = createStepFunctionBuilder((element) =>
     });
     const expectedResult = pipe(stepResult, P.when(isType("string"), (expectedInformation) => ((information) => information === expectedInformation)), P.otherwise((expectedInformation) => ((information) => expectedInformation.includes(information))));
     function getResponse() {
-        return new Response(responseContract.code, responseContract.information, undefined);
+        return new PredictedResponse(responseContract.code, responseContract.information, undefined);
     }
     function treatResult(output, floor) {
         if (!expectedResult(output.information)) {

package/dist/core/functionsBuilders/steps/defaults/cutStep.cjs

@@ -3,9 +3,10 @@
 require('../../../steps/index.cjs');
 var create = require('../create.cjs');
 var utils = require('@duplojs/utils');
-var index = require('../../../response/index.cjs');
+require('../../../response/index.cjs');
 var cut = require('../../../steps/cut.cjs');
 var contract = require('../../../response/contract.cjs');
+var predicted = require('../../../response/predicted.cjs');
 
 const defaultCutStepFunctionBuilder = create.createStepFunctionBuilder(cut.cutStepKind.has, (step, { success }) => {
     const { responseContract, theFunction: cutFunction, } = step.definition;
@@ -22,7 +23,7 @@ const defaultCutStepFunctionBuilder = create.createStepFunctionBuilder(cut.cutSt
         if (utils.E.isLeft(result)) {
             throw new contract.ResponseContract.Error(information, utils.unwrap(result));
         }
-        return new index.Response(currentContract.code, currentContract.information, body);
+        return new predicted.PredictedResponse(currentContract.code, currentContract.information, body);
     };
     function treatResult(result, floor) {
         if (cut.cutStepOutputKind.has(result)) {

package/dist/core/functionsBuilders/steps/defaults/cutStep.mjs

@@ -1,9 +1,10 @@
 import '../../../steps/index.mjs';
 import { createStepFunctionBuilder } from '../create.mjs';
 import { wrapValue, A, E, unwrap } from '@duplojs/utils';
-import { Response } from '../../../response/index.mjs';
+import '../../../response/index.mjs';
 import { cutStepKind, cutStepOutputKind } from '../../../steps/cut.mjs';
 import { ResponseContract } from '../../../response/contract.mjs';
+import { PredictedResponse } from '../../../response/predicted.mjs';
 
 const defaultCutStepFunctionBuilder = createStepFunctionBuilder(cutStepKind.has, (step, { success }) => {
     const { responseContract, theFunction: cutFunction, } = step.definition;
@@ -20,7 +21,7 @@ const defaultCutStepFunctionBuilder = createStepFunctionBuilder(cutStepKind.has,
         if (E.isLeft(result)) {
             throw new ResponseContract.Error(information, unwrap(result));
         }
-        return new Response(currentContract.code, currentContract.information, body);
+        return new PredictedResponse(currentContract.code, currentContract.information, body);
     };
     function treatResult(result, floor) {
         if (cutStepOutputKind.has(result)) {

package/dist/core/functionsBuilders/steps/defaults/extractStep.cjs

@@ -2,15 +2,16 @@
 
 require('../../../steps/index.cjs');
 var utils = require('@duplojs/utils');
-var index = require('../../../response/index.cjs');
+require('../../../response/index.cjs');
 var create = require('../create.cjs');
 var extract = require('../../../steps/extract.cjs');
+var predicted = require('../../../response/predicted.cjs');
 
 const defaultExtractStepFunctionBuilder = create.createStepFunctionBuilder(extract.extractStepKind.has, (step, { success, environment, defaultExtractContract }) => {
     const { shape, responseContract: stepResponseContract, } = step.definition;
     const responseContract = stepResponseContract ?? defaultExtractContract;
     function getResponse(result, key, subKey) {
-        const response = new index.Response(responseContract.code, responseContract.information, environment === "DEV"
+        const response = new predicted.PredictedResponse(responseContract.code, responseContract.information, environment === "DEV"
             ? utils.unwrap(result)
             : undefined);
         return subKey === undefined
@@ -33,9 +34,9 @@ const defaultExtractStepFunctionBuilder = create.createStepFunctionBuilder(extra
         buildedFunction: (request, floor) => {
             let newFloor = floor;
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
-            for (let index$1 = 0; index$1 < extractors.length; index$1++) {
-                const result = extractors[index$1](request, newFloor);
-                if (result instanceof index.Response) {
+            for (let index = 0; index < extractors.length; index++) {
+                const result = extractors[index](request, newFloor);
+                if (result instanceof predicted.PredictedResponse) {
                     return result;
                 }
                 newFloor = result;

package/dist/core/functionsBuilders/steps/defaults/extractStep.mjs

@@ -1,14 +1,15 @@
 import '../../../steps/index.mjs';
 import { unwrap, E, A, O, DP, pipe, P, isType, justReturn, innerPipe } from '@duplojs/utils';
-import { Response } from '../../../response/index.mjs';
+import '../../../response/index.mjs';
 import { createStepFunctionBuilder } from '../create.mjs';
 import { extractStepKind } from '../../../steps/extract.mjs';
+import { PredictedResponse } from '../../../response/predicted.mjs';
 
 const defaultExtractStepFunctionBuilder = createStepFunctionBuilder(extractStepKind.has, (step, { success, environment, defaultExtractContract }) => {
     const { shape, responseContract: stepResponseContract, } = step.definition;
     const responseContract = stepResponseContract ?? defaultExtractContract;
     function getResponse(result, key, subKey) {
-        const response = new Response(responseContract.code, responseContract.information, environment === "DEV"
+        const response = new PredictedResponse(responseContract.code, responseContract.information, environment === "DEV"
             ? unwrap(result)
             : undefined);
         return subKey === undefined
@@ -33,7 +34,7 @@ const defaultExtractStepFunctionBuilder = createStepFunctionBuilder(extractStepK
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
             for (let index = 0; index < extractors.length; index++) {
                 const result = extractors[index](request, newFloor);
-                if (result instanceof Response) {
+                if (result instanceof PredictedResponse) {
                     return result;
                 }
                 newFloor = result;

package/dist/core/functionsBuilders/steps/defaults/handlerStep.cjs

@@ -3,9 +3,10 @@
 require('../../../steps/index.cjs');
 var create = require('../create.cjs');
 var utils = require('@duplojs/utils');
-var index = require('../../../response/index.cjs');
+require('../../../response/index.cjs');
 var handler = require('../../../steps/handler.cjs');
 var contract = require('../../../response/contract.cjs');
+var predicted = require('../../../response/predicted.cjs');
 
 const defaultHandlerStepFunctionBuilder = create.createStepFunctionBuilder(handler.handlerStepKind.has, (step, { success }) => {
     const { responseContract, theFunction: handlerFunction, } = step.definition;
@@ -21,7 +22,7 @@ const defaultHandlerStepFunctionBuilder = create.createStepFunctionBuilder(handl
         if (utils.E.isLeft(result)) {
             throw new contract.ResponseContract.Error(information, utils.unwrap(result));
         }
-        return new index.Response(currentContract.code, currentContract.information, body);
+        return new predicted.PredictedResponse(currentContract.code, currentContract.information, body);
     };
     return success({
         buildedFunction: (request, floor) => handlerFunction(floor, {

package/dist/core/functionsBuilders/steps/defaults/handlerStep.mjs

@@ -1,9 +1,10 @@
 import '../../../steps/index.mjs';
 import { createStepFunctionBuilder } from '../create.mjs';
 import { A, E, unwrap } from '@duplojs/utils';
-import { Response } from '../../../response/index.mjs';
+import '../../../response/index.mjs';
 import { handlerStepKind } from '../../../steps/handler.mjs';
 import { ResponseContract } from '../../../response/contract.mjs';
+import { PredictedResponse } from '../../../response/predicted.mjs';
 
 const defaultHandlerStepFunctionBuilder = createStepFunctionBuilder(handlerStepKind.has, (step, { success }) => {
     const { responseContract, theFunction: handlerFunction, } = step.definition;
@@ -19,7 +20,7 @@ const defaultHandlerStepFunctionBuilder = createStepFunctionBuilder(handlerStepK
         if (E.isLeft(result)) {
             throw new ResponseContract.Error(information, unwrap(result));
         }
-        return new Response(currentContract.code, currentContract.information, body);
+        return new PredictedResponse(currentContract.code, currentContract.information, body);
     };
     return success({
         buildedFunction: (request, floor) => handlerFunction(floor, {

package/dist/core/functionsBuilders/steps/defaults/processStep.cjs

@@ -1,10 +1,11 @@
 'use strict';
 
 require('../../../steps/index.cjs');
-var index = require('../../../response/index.cjs');
+require('../../../response/index.cjs');
 var create = require('../create.cjs');
 var utils = require('@duplojs/utils');
 var process = require('../../../steps/process.cjs');
+var predicted = require('../../../response/predicted.cjs');
 
 function buildStepsFunction(steps, buildStep) {
     return utils.G.asyncReduce(steps, utils.G.reduceFrom([]), async ({ lastValue, element: step, next, exit }) => {
@@ -31,9 +32,9 @@ const defaultProcessStepFunctionBuilder = create.createStepFunctionBuilder(proce
         buildedFunction: async (request, floor) => {
             let processFloor = { options: getOptions(floor) };
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
-            for (let index$1 = 0; index$1 < buildedSteps.length; index$1++) {
-                const result = await buildedSteps[index$1].buildedFunction(request, floor);
-                if (result instanceof index.Response) {
+            for (let index = 0; index < buildedSteps.length; index++) {
+                const result = await buildedSteps[index].buildedFunction(request, floor);
+                if (result instanceof predicted.PredictedResponse) {
                     return result;
                 }
                 processFloor = result;

package/dist/core/functionsBuilders/steps/defaults/processStep.mjs

@@ -1,8 +1,9 @@
 import '../../../steps/index.mjs';
-import { Response } from '../../../response/index.mjs';
+import '../../../response/index.mjs';
 import { createStepFunctionBuilder } from '../create.mjs';
 import { G, E, A, unwrap, pipe, P, or, isType, forward } from '@duplojs/utils';
 import { processStepKind } from '../../../steps/process.mjs';
+import { PredictedResponse } from '../../../response/predicted.mjs';
 
 function buildStepsFunction(steps, buildStep) {
     return G.asyncReduce(steps, G.reduceFrom([]), async ({ lastValue, element: step, next, exit }) => {
@@ -31,7 +32,7 @@ const defaultProcessStepFunctionBuilder = createStepFunctionBuilder(processStepK
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
             for (let index = 0; index < buildedSteps.length; index++) {
                 const result = await buildedSteps[index].buildedFunction(request, floor);
-                if (result instanceof Response) {
+                if (result instanceof PredictedResponse) {
                     return result;
                 }
                 processFloor = result;

package/dist/core/hub/defaultNotfoundHandler.d.ts

@@ -6,5 +6,5 @@ export declare const defaultNotfoundHandler: import("../steps").HandlerStep<{
         readonly coerce: boolean;
         readonly checkers: readonly [];
     }>>>;
-    theFunction: (floor: import("..").Floor, { request, response }: import("../steps").HandlerStepFunctionParams<import("..").Request, import("../response").Response<import("../response").ResponseCode, string, unknown>>) => never;
+    theFunction: (floor: import("..").Floor, { request, response }: import("../steps").HandlerStepFunctionParams<import("..").Request, import("../response").PredictedResponse<import("../response").ResponseCode, string, unknown>>) => never;
 }>;

package/dist/core/hub/index.cjs

@@ -59,7 +59,7 @@ function createHub(config) {
         register(route) {
             return {
                 ...this,
-                routes: utils.A.concat(this.routes, utils.pipe(route, utils.P.when(index.routeKind.has, utils.A.coalescing), utils.P.when(utils.isType("iterable"), utils.A.from), utils.P.otherwise(utils.O.values))),
+                routes: utils.A.concat(this.routes, utils.pipe(route, utils.P.when(index.routeKind.has, utils.A.coalescing), utils.P.when(utils.isType("iterable"), utils.A.from), utils.P.otherwise(utils.O.values), utils.A.filter((route) => !utils.A.includes(this.routes, route)))),
             };
         },
         setDefaultExtractContract(defaultExtractContract) {

package/dist/core/hub/index.mjs

@@ -57,7 +57,7 @@ function createHub(config) {
         register(route) {
             return {
                 ...this,
-                routes: A.concat(this.routes, pipe(route, P.when(routeKind.has, A.coalescing), P.when(isType("iterable"), A.from), P.otherwise(O.values))),
+                routes: A.concat(this.routes, pipe(route, P.when(routeKind.has, A.coalescing), P.when(isType("iterable"), A.from), P.otherwise(O.values), A.filter((route) => !A.includes(this.routes, route)))),
             };
         },
         setDefaultExtractContract(defaultExtractContract) {