@duplojs/http 0.2.0 → 0.5.0

package/dist/core/response/index.cjs

@@ -1,45 +1,16 @@
 'use strict';
 
-var utils = require('@duplojs/utils');
-var kind = require('../kind.cjs');
+var base = require('./base.cjs');
 var contract = require('./contract.cjs');
+var hook = require('./hook.cjs');
+var predicted = require('./predicted.cjs');
 
-class Response extends utils.kindHeritage("response", kind.createCoreLibKind("response")) {
-    code;
-    information;
-    body;
-    headers = undefined;
-    constructor(code, information, body) {
-        super();
-        this.code = code;
-        this.information = information;
-        this.body = body;
-    }
-    setHeaders(headers) {
-        this.headers = utils.O.override(this.headers ?? {}, headers);
-        return this;
-    }
-    setHeader(key, header) {
-        if (!this.headers) {
-            this.headers = {};
-        }
-        if (typeof header !== "undefined") {
-            this.headers[key] = header;
-        }
-        return this;
-    }
-    deleteHeader(key) {
-        if (!this.headers) {
-            return this;
-        }
-        const { [key]: deleteHeader, ...rest } = this.headers;
-        this.headers = rest;
-        return this;
-    }
-}
 
+
+exports.Response = base.Response;
 Object.defineProperty(exports, "ResponseContract", {
-    enumerable: true,
-    get: function () { return contract.ResponseContract; }
+	enumerable: true,
+	get: function () { return contract.ResponseContract; }
 });
-exports.Response = Response;
+exports.HookResponse = hook.HookResponse;
+exports.PredictedResponse = predicted.PredictedResponse;

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

@@ -1,21 +1,4 @@
-import { type S } from "@duplojs/utils";
+export * from "./base";
 export * from "./contract";
-export type InformationResponseCode = `1${S.Digit}${S.Digit}`;
-export type SuccessResponseCode = `2${S.Digit}${S.Digit}`;
-export type RedirectionResponseCode = `3${S.Digit}${S.Digit}`;
-export type ClientErrorResponseCode = `4${S.Digit}${S.Digit}`;
-export type ServerErrorResponseCode = `5${S.Digit}${S.Digit}`;
-export type ResponseCode = (InformationResponseCode | SuccessResponseCode | RedirectionResponseCode | ClientErrorResponseCode | ServerErrorResponseCode);
-declare const Response_base: new (params?: {
-    "@DuplojsHttpCore/response"?: unknown;
-} | undefined) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"response", unknown>, unknown>;
-export declare class Response<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends Response_base {
-    code: GenericCode;
-    information: GenericInformation;
-    body: GenericBody;
-    headers: Record<string, string | string[]> | undefined;
-    constructor(code: GenericCode, information: GenericInformation, body: GenericBody);
-    setHeaders(headers: Partial<Record<string, string | string[]>>): this;
-    setHeader(key: string, header?: string | string[]): this;
-    deleteHeader(key: string): this;
-}
+export * from "./hook";
+export * from "./predicted";

package/dist/core/response/index.mjs

@@ -1,39 +1,4 @@
-import { kindHeritage, O } from '@duplojs/utils';
-import { createCoreLibKind } from '../kind.mjs';
+export { Response } from './base.mjs';
 export { ResponseContract } from './contract.mjs';
-
-class Response extends kindHeritage("response", createCoreLibKind("response")) {
-    code;
-    information;
-    body;
-    headers = undefined;
-    constructor(code, information, body) {
-        super();
-        this.code = code;
-        this.information = information;
-        this.body = body;
-    }
-    setHeaders(headers) {
-        this.headers = O.override(this.headers ?? {}, headers);
-        return this;
-    }
-    setHeader(key, header) {
-        if (!this.headers) {
-            this.headers = {};
-        }
-        if (typeof header !== "undefined") {
-            this.headers[key] = header;
-        }
-        return this;
-    }
-    deleteHeader(key) {
-        if (!this.headers) {
-            return this;
-        }
-        const { [key]: deleteHeader, ...rest } = this.headers;
-        this.headers = rest;
-        return this;
-    }
-}
-
-export { Response };
+export { HookResponse } from './hook.mjs';
+export { PredictedResponse } from './predicted.mjs';

package/dist/core/response/predicted.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+require('./index.cjs');
+var utils = require('@duplojs/utils');
+var base = require('./base.cjs');
+
+const defaultParamsParent = [undefined, undefined, undefined];
+const defaultParams = {};
+class PredictedResponse extends utils.kindHeritage("predicted-response", kind.createCoreLibKind("predicted-response"), base.Response) {
+    code;
+    information;
+    body;
+    constructor(code, information, body) {
+        super(defaultParams, defaultParamsParent);
+        this.code = code;
+        this.information = information;
+        this.body = body;
+    }
+}
+
+exports.PredictedResponse = PredictedResponse;

package/dist/core/response/predicted.d.ts

@@ -0,0 +1,11 @@
+import { type ResponseCode, Response } from "../response";
+declare const PredictedResponse_base: new (params: {
+    "@DuplojsHttpCore/predicted-response"?: unknown;
+}, parentParams: [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/predicted-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"predicted-response", unknown>, unknown>;
+export declare class PredictedResponse<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends PredictedResponse_base {
+    code: GenericCode;
+    information: GenericInformation;
+    body: GenericBody;
+    constructor(code: GenericCode, information: GenericInformation, body: GenericBody);
+}
+export {};

package/dist/core/response/predicted.mjs

@@ -0,0 +1,20 @@
+import { createCoreLibKind } from '../kind.mjs';
+import './index.mjs';
+import { kindHeritage } from '@duplojs/utils';
+import { Response } from './base.mjs';
+
+const defaultParamsParent = [undefined, undefined, undefined];
+const defaultParams = {};
+class PredictedResponse extends kindHeritage("predicted-response", createCoreLibKind("predicted-response"), Response) {
+    code;
+    information;
+    body;
+    constructor(code, information, body) {
+        super(defaultParams, defaultParamsParent);
+        this.code = code;
+        this.information = information;
+        this.body = body;
+    }
+}
+
+export { PredictedResponse };

package/dist/core/route/{hooks/index.cjs → hooks.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var kind = require('../../kind.cjs');
-var response = require('./response.cjs');
+var kind = require('../kind.cjs');
+require('../response/index.cjs');
 
 const hookRouteExitKind = kind.createCoreLibKind("route-hook-exit");
 const hookRouteNextKind = kind.createCoreLibKind("route-hook-next");
@@ -15,7 +15,6 @@ function createHookRouteLifeCycle(...args) {
     };
 }
 
-exports.HookResponse = response.HookResponse;
 exports.createHookRouteLifeCycle = createHookRouteLifeCycle;
 exports.hookRouteExitKind = hookRouteExitKind;
 exports.hookRouteNextKind = hookRouteNextKind;

package/dist/core/route/{hooks/index.d.ts → hooks.d.ts}

@@ -1,8 +1,8 @@
-import { type Request } from "../../request";
+import { type Request } from "../request";
 import { type UnionToIntersection, type AnyFunction, type Kind, type MaybePromise, type SimplifyTopLevel, type IsEqual } from "@duplojs/utils";
-import { type HookResponse } from "./response";
-import { type ResponseCode, type Response } from "../../response";
-export * from "./response";
+import { type HookResponse } from "../response";
+import { type ResponseCode, type Response } from "../response";
+export * from "../response";
 export interface HookParamsOnConstructRequest {
     request: Request;
     addRequestProperties<GenericNewProperties extends Record<string, unknown>>(newProperties: GenericNewProperties): Request & GenericNewProperties;

package/dist/core/route/{hooks/index.mjs → hooks.mjs}

@@ -1,5 +1,5 @@
-import { createCoreLibKind } from '../../kind.mjs';
-export { HookResponse } from './response.mjs';
+import { createCoreLibKind } from '../kind.mjs';
+import '../response/index.mjs';
 
 const hookRouteExitKind = createCoreLibKind("route-hook-exit");
 const hookRouteNextKind = createCoreLibKind("route-hook-next");

package/dist/core/route/index.cjs

@@ -3,15 +3,15 @@
 var utils = require('@duplojs/utils');
 var kind = require('../kind.cjs');
 require('./types/index.cjs');
-var index = require('./hooks/index.cjs');
+var hooks = require('./hooks.cjs');
 
 const routeKind = kind.createCoreLibKind("route");
 function createRoute(definition) {
     return utils.pipe({ definition }, routeKind.setTo);
 }
 
-exports.createHookRouteLifeCycle = index.createHookRouteLifeCycle;
-exports.hookRouteExitKind = index.hookRouteExitKind;
-exports.hookRouteNextKind = index.hookRouteNextKind;
+exports.createHookRouteLifeCycle = hooks.createHookRouteLifeCycle;
+exports.hookRouteExitKind = hooks.hookRouteExitKind;
+exports.hookRouteNextKind = hooks.hookRouteNextKind;
 exports.createRoute = createRoute;
 exports.routeKind = routeKind;

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

@@ -2,6 +2,7 @@ import { type O, type Kind } from "@duplojs/utils";
 import { type RequestMethods } from "../request";
 import { type ExtractStep, type CheckerStep, type CutStep, type HandlerStep, type ProcessStep, type stepKind, type PresetCheckerStep } from "../steps";
 import { type HookRouteLifeCycle } from "./hooks";
+import { type Metadata } from "../metadata";
 export * from "./types";
 export * from "./hooks";
 export interface RouteStepsCustom {
@@ -17,6 +18,7 @@ export interface RouteDefinition {
     readonly preflightSteps: readonly RoutePreFlightSteps[];
     readonly steps: readonly RouteSteps[];
     readonly hooks: readonly HookRouteLifeCycle[];
+    readonly metadata: readonly Metadata[];
 }
 export declare const routeKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route", unknown>>;
 export interface Route<GenericDefinition extends RouteDefinition = RouteDefinition> extends Kind<typeof routeKind.definition> {

package/dist/core/route/index.mjs

@@ -1,7 +1,7 @@
 import { pipe } from '@duplojs/utils';
 import { createCoreLibKind } from '../kind.mjs';
 import './types/index.mjs';
-export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind } from './hooks/index.mjs';
+export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind } from './hooks.mjs';
 
 const routeKind = createCoreLibKind("route");
 function createRoute(definition) {

package/dist/core/router/index.cjs

@@ -58,6 +58,7 @@ async function buildRouter(inputHub) {
         hooks: [],
         preflightSteps: [],
         steps: [hub.notfoundHandler],
+        metadata: [],
     }), async (route) => {
         const result = await build.buildRouteFunction(route, buildParams);
         return utils.E.whenIsLeft(result, (element) => {

package/dist/core/router/index.mjs

@@ -57,6 +57,7 @@ async function buildRouter(inputHub) {
         hooks: [],
         preflightSteps: [],
         steps: [hub.notfoundHandler],
+        metadata: [],
     }), async (route) => {
         const result = await buildRouteFunction(route, buildParams);
         return E.whenIsLeft(result, (element) => {

package/dist/core/steps/checker.d.ts

@@ -3,6 +3,7 @@ import { type StepKind } from "./kind";
 import { type Checker } from "../checker";
 import { type Floor } from "../floor";
 import { type ClientErrorResponseCode, type ResponseContract } from "../response";
+import { type Metadata } from "../metadata";
 export interface CheckerStepDefinition {
     readonly checker: Checker;
     readonly result: string | readonly string[];
@@ -10,6 +11,7 @@ export interface CheckerStepDefinition {
     input(input: Floor): unknown;
     readonly options?: Record<string, unknown> | ((input: any) => Record<string, unknown>);
     readonly responseContract: ResponseContract.Contract<ClientErrorResponseCode>;
+    readonly metadata: readonly Metadata[];
 }
 export declare const checkerStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>>;
 export type _CheckerStep = (Kind<typeof checkerStepKind.definition> & StepKind);

package/dist/core/steps/cut.d.ts

@@ -2,17 +2,19 @@ import { type WrappedValue, type Kind, type MaybePromise, type NeverCoalescing }
 import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
 import { type StepFunctionParams } from "./types";
-import { type Response, type ResponseContract } from "../response";
+import { type PredictedResponse, type ResponseContract } from "../response";
 import { type Request } from "../request";
+import { type Metadata } from "../metadata";
 export declare const cutStepOutputKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-output", unknown>>;
 export interface CutStepFunctionOutput<GenericData extends Record<string, unknown> = Record<string, unknown>> extends Kind<typeof cutStepOutputKind.definition>, WrappedValue<GenericData> {
 }
-export interface CutStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends Response = Response> extends StepFunctionParams<GenericRequest, GenericResponse> {
+export interface CutStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> extends StepFunctionParams<GenericRequest, GenericResponse> {
     output<GenericData extends Record<string, unknown> = never>(data?: GenericData): CutStepFunctionOutput<NeverCoalescing<GenericData, {}>>;
 }
 export interface CutStepDefinition {
-    theFunction(floor: Floor, params: CutStepFunctionParams): MaybePromise<CutStepFunctionOutput | Response>;
+    theFunction(floor: Floor, params: CutStepFunctionParams): MaybePromise<CutStepFunctionOutput | PredictedResponse>;
     readonly responseContract: ResponseContract.Contract | readonly ResponseContract.Contract[];
+    readonly metadata: readonly Metadata[];
 }
 export declare const cutStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>>;
 export type _CutStep = (Kind<typeof cutStepKind.definition> & StepKind);

package/dist/core/steps/extract.d.ts

@@ -2,6 +2,7 @@ import { type DP, type Kind, type O, type AnyFunction } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Request } from "../request";
 import { type ClientErrorResponseCode, type ResponseContract } from "../response";
+import { type Metadata } from "../metadata";
 export interface DisabledExtractKeysCustom {
 }
 export type DisabledExtractKeys = O.GetPropsWithValue<DisabledExtractKeysCustom, true>;
@@ -9,6 +10,7 @@ export type ExtractShape<GenericRequest extends Request = Request> = Partial<Rec
 export interface ExtractStepDefinition {
     readonly shape: ExtractShape;
     readonly responseContract?: ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>;
+    readonly metadata: readonly Metadata[];
 }
 export declare const extractStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>>;
 export type _ExtractStep = (Kind<typeof extractStepKind.definition> & StepKind);

package/dist/core/steps/handler.d.ts

@@ -1,14 +1,16 @@
 import { type MaybePromise, type Kind } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
-import { type Response, type ResponseContract } from "../response";
+import { type PredictedResponse, type ResponseContract } from "../response";
 import { type Request } from "../request";
 import { type StepFunctionParams } from "./types";
-export interface HandlerStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends Response = Response> extends StepFunctionParams<GenericRequest, GenericResponse> {
+import { type Metadata } from "../metadata";
+export interface HandlerStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> extends StepFunctionParams<GenericRequest, GenericResponse> {
 }
 export interface HandlerStepDefinition {
-    theFunction(floor: Floor, params: HandlerStepFunctionParams): MaybePromise<Response>;
+    theFunction(floor: Floor, params: HandlerStepFunctionParams): MaybePromise<PredictedResponse>;
     readonly responseContract: ResponseContract.Contract | readonly ResponseContract.Contract[];
+    readonly metadata: readonly Metadata[];
 }
 export declare const handlerStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>>;
 type _HandlerStep = (Kind<typeof handlerStepKind.definition> & StepKind);

package/dist/core/steps/identifier.d.ts

@@ -1,5 +1,5 @@
 import { type Kind } from "@duplojs/utils";
 export declare const stepIdentifier: {
-    <GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>, GenericInput extends Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>, GenericGroupedKind extends import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import("@duplojs/utils").IsEqual<import("@duplojs/utils").IsEqual<false | (GenericInput extends any ? import("@duplojs/utils").IsEqual<GenericInput, Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>> : never), boolean>, true> extends true ? Extract<import("./checker").CheckerStep<import("./checker").CheckerStepDefinition>, GenericGroupedKind> | Extract<import("./cut").CutStep<import("./cut").CutStepDefinition>, GenericGroupedKind> | Extract<import("./extract").ExtractStep<import("./extract").ExtractStepDefinition>, GenericGroupedKind> | Extract<import("./handler").HandlerStep<import("./handler").HandlerStepDefinition>, GenericGroupedKind> | Extract<import("./presetChecker").PresetCheckerStep<import("./presetChecker").PresetCheckerStepDefinition>, GenericGroupedKind> | Extract<import("./process").ProcessStep<import("./process").ProcessStepDefinition>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-    <GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>, GenericInput extends Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>, GenericGroupedKind extends import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import("@duplojs/utils").IsEqual<import("@duplojs/utils").IsEqual<false | (GenericInput extends any ? import("@duplojs/utils").IsEqual<GenericInput, Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>> : never), boolean>, true> extends true ? Extract<import("./checker").CheckerStep<import("./checker").CheckerStepDefinition>, GenericGroupedKind> | Extract<import("./cut").CutStep<import("./cut").CutStepDefinition>, GenericGroupedKind> | Extract<import("./extract").ExtractStep<import("./extract").ExtractStepDefinition>, GenericGroupedKind> | Extract<import("./handler").HandlerStep<import("./handler").HandlerStepDefinition>, GenericGroupedKind> | Extract<import("./presetChecker").PresetCheckerStep<import("./presetChecker").PresetCheckerStepDefinition>, GenericGroupedKind> | Extract<import("./process").ProcessStep<import("./process").ProcessStepDefinition>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>, GenericInput extends unknown, GenericGroupedKind extends import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import("@duplojs/utils").IsEqual<import("@duplojs/utils").IsEqual<false | (GenericInput extends any ? import("@duplojs/utils").IsEqual<GenericInput, Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>> : never), boolean>, true> extends true ? Extract<import("./checker").CheckerStep<import("./checker").CheckerStepDefinition>, GenericGroupedKind> | Extract<import("./cut").CutStep<import("./cut").CutStepDefinition>, GenericGroupedKind> | Extract<import("./extract").ExtractStep<import("./extract").ExtractStepDefinition>, GenericGroupedKind> | Extract<import("./handler").HandlerStep<import("./handler").HandlerStepDefinition>, GenericGroupedKind> | Extract<import("./presetChecker").PresetCheckerStep<import("./presetChecker").PresetCheckerStepDefinition>, GenericGroupedKind> | Extract<import("./process").ProcessStep<import("./process").ProcessStepDefinition>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>, GenericInput extends unknown, GenericGroupedKind extends import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import("@duplojs/utils").IsEqual<import("@duplojs/utils").IsEqual<false | (GenericInput extends any ? import("@duplojs/utils").IsEqual<GenericInput, Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>> : never), boolean>, true> extends true ? Extract<import("./checker").CheckerStep<import("./checker").CheckerStepDefinition>, GenericGroupedKind> | Extract<import("./cut").CutStep<import("./cut").CutStepDefinition>, GenericGroupedKind> | Extract<import("./extract").ExtractStep<import("./extract").ExtractStepDefinition>, GenericGroupedKind> | Extract<import("./handler").HandlerStep<import("./handler").HandlerStepDefinition>, GenericGroupedKind> | Extract<import("./presetChecker").PresetCheckerStep<import("./presetChecker").PresetCheckerStepDefinition>, GenericGroupedKind> | Extract<import("./process").ProcessStep<import("./process").ProcessStepDefinition>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
 };

package/dist/core/steps/presetChecker.d.ts

@@ -2,9 +2,11 @@ import { type Kind } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
 import { type PresetChecker } from "../presetChecker";
+import { type Metadata } from "../metadata";
 export interface PresetCheckerStepDefinition {
     readonly presetChecker: PresetChecker;
     input(input: Floor): unknown;
+    readonly metadata: readonly Metadata[];
 }
 export declare const presetCheckerStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>>;
 export type _PresetCheckerStep = (Kind<typeof presetCheckerStepKind.definition> & StepKind);

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

@@ -1,10 +1,12 @@
 import { type Kind } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Process } from "../process";
+import { type Metadata } from "../metadata";
 export interface ProcessStepDefinition {
     readonly process: Process;
     readonly options?: Record<string, unknown> | ((input: any) => Record<string, unknown>);
     readonly imports?: readonly string[];
+    readonly metadata: readonly Metadata[];
 }
 export declare const processStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>;
 export type _ProcessStep = (Kind<typeof processStepKind.definition> & StepKind);

package/dist/core/steps/types/stepFunctionParams.d.ts

@@ -1,7 +1,7 @@
 import { type Request } from "../../request";
-import { type Response } from "../../response";
+import { type PredictedResponse } from "../../response";
 import { type IsEqual, type Or } from "@duplojs/utils";
-export interface StepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends Response = Response> {
+export interface StepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> {
     request: GenericRequest;
     response<GenericInformation extends GenericResponse["information"], GenericFilteredResponse extends Extract<GenericResponse, {
         information: GenericInformation;

package/dist/core/types/forbiddenBigintDataParser.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/types/forbiddenBigintDataParser.d.ts

@@ -0,0 +1,6 @@
+import { type DP } from "@duplojs/utils";
+declare const SymbolForbiddenBigintDataParser: unique symbol;
+export type ForbiddenBigintDataParser<GenericDataParser extends DP.DataParser> = DP.Contain<GenericDataParser, DP.DataParserBigInt<any>> extends true ? {
+    [SymbolForbiddenBigintDataParser]: "Bigint dataParser is not supported.";
+} : unknown;
+export {};

package/dist/core/types/forbiddenBigintDataParser.mjs

@@ -0,0 +1 @@
+

package/dist/core/types/index.cjs

@@ -1,4 +1,5 @@
 'use strict';
 
 require('./environment.cjs');
+require('./forbiddenBigintDataParser.cjs');
 

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

@@ -1 +1,2 @@
 export * from "./environment";
+export * from "./forbiddenBigintDataParser";

package/dist/core/types/index.mjs

@@ -1 +1,2 @@
 import './environment.mjs';
+import './forbiddenBigintDataParser.mjs';

package/dist/interfaces/node/createHttpServer.cjs

@@ -13,6 +13,7 @@ async function createHttpServer(inputHub, params) {
         ...params,
         maxBodySize: "50mb",
         informationHeaderKey: "information",
+        predictedHeaderKey: "predicted",
         fromHookHeaderKey: "from-hook",
         interface: "node",
     };

package/dist/interfaces/node/createHttpServer.d.ts

@@ -10,6 +10,7 @@ declare module "../../core/hub" {
         readonly port: number;
         readonly maxBodySize: BytesInString | number;
         readonly informationHeaderKey: string;
+        readonly predictedHeaderKey: string;
         readonly fromHookHeaderKey: string;
         readonly http?: http.ServerOptions;
         readonly https?: https.ServerOptions;
@@ -19,5 +20,5 @@ declare module "../../core/hub" {
         readonly serverResponse: http.ServerResponse;
     }
 }
-export type CreateHttpServerParams = O.PartialKeys<Omit<HttpServerParams, "interface">, "maxBodySize" | "informationHeaderKey" | "fromHookHeaderKey">;
+export type CreateHttpServerParams = O.PartialKeys<Omit<HttpServerParams, "interface">, "maxBodySize" | "informationHeaderKey" | "predictedHeaderKey" | "fromHookHeaderKey">;
 export declare function createHttpServer(inputHub: Hub, params: CreateHttpServerParams): Promise<https.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>>;

package/dist/interfaces/node/createHttpServer.mjs

@@ -11,6 +11,7 @@ async function createHttpServer(inputHub, params) {
         ...params,
         maxBodySize: "50mb",
         informationHeaderKey: "information",
+        predictedHeaderKey: "predicted",
         fromHookHeaderKey: "from-hook",
         interface: "node",
     };

package/dist/interfaces/node/hooks.cjs

@@ -3,18 +3,20 @@
 require('../../core/route/index.cjs');
 var utils = require('@duplojs/utils');
 require('./error/index.cjs');
-var index = require('../../core/route/hooks/index.cjs');
-var response = require('../../core/route/hooks/response.cjs');
+var hooks = require('../../core/route/hooks.cjs');
+var predicted = require('../../core/response/predicted.cjs');
+var hook = require('../../core/response/hook.cjs');
 var bodySizeExceedsLimitError = require('./error/bodySizeExceedsLimitError.cjs');
 var bodyParseWrongChunkReceived = require('./error/bodyParseWrongChunkReceived.cjs');
 var bodyParseUnknownError = require('./error/bodyParseUnknownError.cjs');
 
 function makeNodeHook(hub, serverParams) {
     const informationHeaderKey = serverParams.informationHeaderKey;
+    const predictedHeaderKey = serverParams.predictedHeaderKey;
     const fromHookHeaderKey = serverParams.fromHookHeaderKey;
     const isDev = hub.config.environment === "DEV";
     const maxBodySize = utils.stringToBytes(serverParams.maxBodySize);
-    return index.createHookRouteLifeCycle({
+    return hooks.createHookRouteLifeCycle({
         async parseBody({ request, exit }) {
             const contentType = request.headers["content-type"] instanceof Array
                 ? request.headers["content-type"].join(", ")
@@ -79,17 +81,20 @@ function makeNodeHook(hub, serverParams) {
         },
         beforeSendResponse({ request, currentResponse, exit }) {
             const body = currentResponse.body;
-            if (typeof body === "number"
-                || typeof body === "string"
-                || body === null
+            if (typeof body === "string"
                 || body instanceof Error) {
                 currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
             }
-            else if (typeof body === "object") {
+            else if (typeof body === "object"
+                || typeof body === "number"
+                || typeof body === "boolean") {
                 currentResponse.setHeader("content-type", "application/json; charset=utf-8");
             }
             currentResponse.setHeader(informationHeaderKey, currentResponse.information);
-            if (currentResponse instanceof response.HookResponse) {
+            if (currentResponse instanceof predicted.PredictedResponse) {
+                currentResponse.setHeader(predictedHeaderKey, "1");
+            }
+            else if (currentResponse instanceof hook.HookResponse) {
                 currentResponse.setHeader(fromHookHeaderKey, currentResponse.fromHook);
             }
             request.raw.response.writeHead(Number(currentResponse.code), currentResponse.headers);
@@ -101,16 +106,14 @@ function makeNodeHook(hub, serverParams) {
             if (body instanceof Error) {
                 rawResponse.write(body.toString());
             }
-            else if (typeof body === "object") {
+            else if (typeof body === "object"
+                || typeof body === "number"
+                || typeof body === "boolean") {
                 rawResponse.write(JSON.stringify(body));
             }
             else if (typeof body === "string") {
                 rawResponse.write(body);
             }
-            else if (typeof body === "number"
-                || typeof body === "bigint") {
-                rawResponse.write(body.toString());
-            }
             rawResponse.end();
             return exit();
         },