@duplojs/http 0.2.0 → 0.5.0

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.cjs

@@ -9,6 +9,7 @@ var contract = require('../response/contract.cjs');
 const defaultNotfoundHandler = handler.createHandlerStep({
     responseContract: contract.ResponseContract.notFound("notfound-route", utils.DP.string()),
     theFunction: (floor, { request, response }) => response("notfound-route", `${request.method}:${request.path}`),
+    metadata: [],
 });
 
 exports.defaultNotfoundHandler = defaultNotfoundHandler;

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

@@ -6,5 +6,6 @@ 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;
+    metadata: never[];
 }>;

package/dist/core/hub/defaultNotfoundHandler.mjs

@@ -7,6 +7,7 @@ import { ResponseContract } from '../response/contract.mjs';
 const defaultNotfoundHandler = createHandlerStep({
     responseContract: ResponseContract.notFound("notfound-route", DP.string()),
     theFunction: (floor, { request, response }) => response("notfound-route", `${request.method}:${request.path}`),
+    metadata: [],
 });
 
 export { defaultNotfoundHandler };

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) {
@@ -74,6 +74,7 @@ function createHub(config) {
                 notfoundHandler: handler.createHandlerStep({
                     responseContract,
                     theFunction: (floor, params) => theFunction(params),
+                    metadata: [],
                 }),
             };
         },

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) {
@@ -72,6 +72,7 @@ function createHub(config) {
                 notfoundHandler: createHandlerStep({
                     responseContract,
                     theFunction: (floor, params) => theFunction(params),
+                    metadata: [],
                 }),
             };
         },

package/dist/core/index.cjs

@@ -2,27 +2,30 @@
 
 require('./types/index.cjs');
 require('./builders/index.cjs');
-var index = require('./response/index.cjs');
-var index$1 = require('./route/index.cjs');
+require('./response/index.cjs');
+var index = require('./route/index.cjs');
 require('./steps/index.cjs');
 var checker$2 = require('./checker.cjs');
 require('./floor.cjs');
 var kind$1 = require('./kind.cjs');
-var index$3 = require('./process/index.cjs');
+var index$1 = require('./process/index.cjs');
 var request = require('./request.cjs');
 var presetChecker$1 = require('./presetChecker.cjs');
-var index$4 = require('./hub/index.cjs');
+var index$2 = require('./hub/index.cjs');
 require('./functionsBuilders/index.cjs');
-var index$5 = require('./router/index.cjs');
+var index$3 = require('./router/index.cjs');
 var stringIdentifier = require('./stringIdentifier.cjs');
+require('./metadata/index.cjs');
 var checker = require('./builders/checker.cjs');
 var builder = require('./builders/route/builder.cjs');
 var store = require('./builders/route/store.cjs');
 var builder$1 = require('./builders/process/builder.cjs');
 var builder$2 = require('./builders/preflight/builder.cjs');
+var base = require('./response/base.cjs');
 var contract = require('./response/contract.cjs');
-var response = require('./route/hooks/response.cjs');
-var index$2 = require('./route/hooks/index.cjs');
+var hook = require('./response/hook.cjs');
+var predicted = require('./response/predicted.cjs');
+var hooks = require('./route/hooks.cjs');
 var kind = require('./steps/kind.cjs');
 var identifier = require('./steps/identifier.cjs');
 var checker$1 = require('./steps/checker.cjs');
@@ -31,13 +34,13 @@ var cut = require('./steps/cut.cjs');
 var handler = require('./steps/handler.cjs');
 var process = require('./steps/process.cjs');
 var presetChecker = require('./steps/presetChecker.cjs');
-var hooks = require('./hub/hooks.cjs');
+var hooks$1 = require('./hub/hooks.cjs');
 var defaultNotfoundHandler = require('./hub/defaultNotfoundHandler.cjs');
 var defaultExtractContract = require('./hub/defaultExtractContract.cjs');
 var build = require('./functionsBuilders/route/build.cjs');
 var create = require('./functionsBuilders/route/create.cjs');
 var _default = require('./functionsBuilders/route/default.cjs');
-var hook = require('./functionsBuilders/route/hook.cjs');
+var hook$1 = require('./functionsBuilders/route/hook.cjs');
 var create$1 = require('./functionsBuilders/steps/create.cjs');
 var checkerStep = require('./functionsBuilders/steps/defaults/checkerStep.cjs');
 var cutStep = require('./functionsBuilders/steps/defaults/cutStep.cjs');
@@ -48,24 +51,25 @@ var build$1 = require('./functionsBuilders/steps/build.cjs');
 var pathToRegExp = require('./router/pathToRegExp.cjs');
 var buildError = require('./router/buildError.cjs');
 var decodeUrl = require('./router/decodeUrl.cjs');
+var base$1 = require('./metadata/base.cjs');
+var ignoreByRouteStore = require('./metadata/ignoreByRouteStore.cjs');
 
 
 
-exports.Response = index.Response;
-exports.createRoute = index$1.createRoute;
-exports.routeKind = index$1.routeKind;
+exports.createRoute = index.createRoute;
+exports.routeKind = index.routeKind;
 exports.checkerKind = checker$2.checkerKind;
 exports.checkerOutputKind = checker$2.checkerOutputKind;
 exports.createChecker = checker$2.createChecker;
 exports.createCoreLibKind = kind$1.createCoreLibKind;
-exports.createProcess = index$3.createProcess;
-exports.processKind = index$3.processKind;
+exports.createProcess = index$1.createProcess;
+exports.processKind = index$1.processKind;
 exports.Request = request.Request;
 exports.createPresetChecker = presetChecker$1.createPresetChecker;
 exports.presetCheckerKind = presetChecker$1.presetCheckerKind;
-exports.createHub = index$4.createHub;
-exports.hubKind = index$4.hubKind;
-exports.buildRouter = index$5.buildRouter;
+exports.createHub = index$2.createHub;
+exports.hubKind = index$2.hubKind;
+exports.buildRouter = index$3.buildRouter;
 exports.createCoreLibStringIdentifier = stringIdentifier.createCoreLibStringIdentifier;
 exports.checkerBuilder = checker.checkerBuilder;
 exports.useCheckerBuilder = checker.useCheckerBuilder;
@@ -76,14 +80,16 @@ exports.processBuilder = builder$1.processBuilder;
 exports.useProcessBuilder = builder$1.useProcessBuilder;
 exports.preflightBuilder = builder$2.preflightBuilder;
 exports.usePreflightBuilder = builder$2.usePreflightBuilder;
+exports.Response = base.Response;
 Object.defineProperty(exports, "ResponseContract", {
 	enumerable: true,
 	get: function () { return contract.ResponseContract; }
 });
-exports.HookResponse = response.HookResponse;
-exports.createHookRouteLifeCycle = index$2.createHookRouteLifeCycle;
-exports.hookRouteExitKind = index$2.hookRouteExitKind;
-exports.hookRouteNextKind = index$2.hookRouteNextKind;
+exports.HookResponse = hook.HookResponse;
+exports.PredictedResponse = predicted.PredictedResponse;
+exports.createHookRouteLifeCycle = hooks.createHookRouteLifeCycle;
+exports.hookRouteExitKind = hooks.hookRouteExitKind;
+exports.hookRouteNextKind = hooks.hookRouteNextKind;
 exports.stepKind = kind.stepKind;
 exports.stepIdentifier = identifier.stepIdentifier;
 exports.checkerStepKind = checker$1.checkerStepKind;
@@ -99,24 +105,24 @@ exports.createProcessStep = process.createProcessStep;
 exports.processStepKind = process.processStepKind;
 exports.createPresetCheckerStep = presetChecker.createPresetCheckerStep;
 exports.presetCheckerStepKind = presetChecker.presetCheckerStepKind;
-exports.hookServerExitKind = hooks.hookServerExitKind;
-exports.hookServerNextKind = hooks.hookServerNextKind;
-exports.launchHookBeforeBuildRoute = hooks.launchHookBeforeBuildRoute;
-exports.launchHookServer = hooks.launchHookServer;
-exports.launchHookServerError = hooks.launchHookServerError;
-exports.serverErrorExitHookFunction = hooks.serverErrorExitHookFunction;
-exports.serverErrorNextHookFunction = hooks.serverErrorNextHookFunction;
+exports.hookServerExitKind = hooks$1.hookServerExitKind;
+exports.hookServerNextKind = hooks$1.hookServerNextKind;
+exports.launchHookBeforeBuildRoute = hooks$1.launchHookBeforeBuildRoute;
+exports.launchHookServer = hooks$1.launchHookServer;
+exports.launchHookServerError = hooks$1.launchHookServerError;
+exports.serverErrorExitHookFunction = hooks$1.serverErrorExitHookFunction;
+exports.serverErrorNextHookFunction = hooks$1.serverErrorNextHookFunction;
 exports.defaultNotfoundHandler = defaultNotfoundHandler.defaultNotfoundHandler;
 exports.defaultExtractContract = defaultExtractContract.defaultExtractContract;
 exports.buildRouteFunction = build.buildRouteFunction;
 exports.createRouteFunctionBuilder = create.createRouteFunctionBuilder;
 exports.defaultRouteFunctionBuilder = _default.defaultRouteFunctionBuilder;
-exports.buildHookAfter = hook.buildHookAfter;
-exports.buildHookBefore = hook.buildHookBefore;
-exports.buildHookErrorBefore = hook.buildHookErrorBefore;
-exports.createHookResponse = hook.createHookResponse;
-exports.exitHookFunction = hook.exitHookFunction;
-exports.nextHookFunction = hook.nextHookFunction;
+exports.buildHookAfter = hook$1.buildHookAfter;
+exports.buildHookBefore = hook$1.buildHookBefore;
+exports.buildHookErrorBefore = hook$1.buildHookErrorBefore;
+exports.createHookResponse = hook$1.createHookResponse;
+exports.exitHookFunction = hook$1.exitHookFunction;
+exports.nextHookFunction = hook$1.nextHookFunction;
 exports.createStepFunctionBuilder = create$1.createStepFunctionBuilder;
 exports.defaultCheckerStepFunctionBuilder = checkerStep.defaultCheckerStepFunctionBuilder;
 exports.defaultCutStepFunctionBuilder = cutStep.defaultCutStepFunctionBuilder;
@@ -130,3 +136,6 @@ exports.RouterBuildError = buildError.RouterBuildError;
 exports.decodeUrl = decodeUrl.decodeUrl;
 exports.regexQueryAnalyser = decodeUrl.regexQueryAnalyser;
 exports.regexUrlAnalyser = decodeUrl.regexUrlAnalyser;
+exports.createMetadata = base$1.createMetadata;
+exports.metadataKind = base$1.metadataKind;
+exports.IgnoreByRouteStoreMetadata = ignoreByRouteStore.IgnoreByRouteStoreMetadata;

package/dist/core/index.d.ts

@@ -13,3 +13,4 @@ export * from "./hub";
 export * from "./functionsBuilders";
 export * from "./router";
 export * from "./stringIdentifier";
+export * from "./metadata";

package/dist/core/index.mjs

@@ -1,6 +1,6 @@
 import './types/index.mjs';
 import './builders/index.mjs';
-export { Response } from './response/index.mjs';
+import './response/index.mjs';
 export { createRoute, routeKind } from './route/index.mjs';
 import './steps/index.mjs';
 export { checkerKind, checkerOutputKind, createChecker } from './checker.mjs';
@@ -13,14 +13,17 @@ export { createHub, hubKind } from './hub/index.mjs';
 import './functionsBuilders/index.mjs';
 export { buildRouter } from './router/index.mjs';
 export { createCoreLibStringIdentifier } from './stringIdentifier.mjs';
+import './metadata/index.mjs';
 export { checkerBuilder, useCheckerBuilder } from './builders/checker.mjs';
 export { routeBuilderHandler, useRouteBuilder } from './builders/route/builder.mjs';
 export { routeStore } from './builders/route/store.mjs';
 export { processBuilder, useProcessBuilder } from './builders/process/builder.mjs';
 export { preflightBuilder, usePreflightBuilder } from './builders/preflight/builder.mjs';
+export { Response } from './response/base.mjs';
 export { ResponseContract } from './response/contract.mjs';
-export { HookResponse } from './route/hooks/response.mjs';
-export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind } from './route/hooks/index.mjs';
+export { HookResponse } from './response/hook.mjs';
+export { PredictedResponse } from './response/predicted.mjs';
+export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind } from './route/hooks.mjs';
 export { stepKind } from './steps/kind.mjs';
 export { stepIdentifier } from './steps/identifier.mjs';
 export { checkerStepKind, createCheckerStep } from './steps/checker.mjs';
@@ -46,3 +49,5 @@ export { buildStepFunction } from './functionsBuilders/steps/build.mjs';
 export { pathToRegExp } from './router/pathToRegExp.mjs';
 export { RouterBuildError } from './router/buildError.mjs';
 export { decodeUrl, regexQueryAnalyser, regexUrlAnalyser } from './router/decodeUrl.mjs';
+export { createMetadata, metadataKind } from './metadata/base.mjs';
+export { IgnoreByRouteStoreMetadata } from './metadata/ignoreByRouteStore.mjs';

package/dist/core/metadata/base.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
+
+const metadataKind = kind.createCoreLibKind("metadata");
+function createMetadata(name) {
+    function metadataHandler(value) {
+        return metadataKind.setTo(utils.wrapValue(value), name);
+    }
+    metadataHandler.dataName = name;
+    metadataHandler.is = function (input) {
+        return metadataKind.has(input)
+            && metadataKind.getValue(input) === name;
+    };
+    return metadataHandler;
+}
+
+exports.createMetadata = createMetadata;
+exports.metadataKind = metadataKind;

package/dist/core/metadata/base.d.ts

@@ -0,0 +1,14 @@
+import { type WrappedValue, type Kind, type IsEqual, type Or, type IsExtends } from "@duplojs/utils";
+export declare const metadataKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/metadata", string>>;
+export interface Metadata<GenericName extends string = string, GenericValue extends unknown = unknown> extends Kind<typeof metadataKind.definition, GenericName>, WrappedValue<GenericValue> {
+}
+export interface MetadataHandler<GenericName extends string, GenericValue extends unknown> {
+    dataName: GenericName;
+    <GenericMetadataValue extends GenericValue>(...args: Or<[
+        IsEqual<GenericValue, unknown>,
+        IsEqual<GenericValue, never>,
+        IsExtends<undefined, GenericValue>
+    ]> extends true ? [value?: GenericMetadataValue] : [value: GenericMetadataValue]): Metadata<GenericName, GenericMetadataValue>;
+    is(input: unknown): input is Metadata<GenericName, any>;
+}
+export declare function createMetadata<GenericName extends string, GenericValue extends unknown = unknown>(name: GenericName): MetadataHandler<GenericName, GenericValue>;

package/dist/core/metadata/base.mjs

@@ -0,0 +1,17 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { wrapValue } from '@duplojs/utils';
+
+const metadataKind = createCoreLibKind("metadata");
+function createMetadata(name) {
+    function metadataHandler(value) {
+        return metadataKind.setTo(wrapValue(value), name);
+    }
+    metadataHandler.dataName = name;
+    metadataHandler.is = function (input) {
+        return metadataKind.has(input)
+            && metadataKind.getValue(input) === name;
+    };
+    return metadataHandler;
+}
+
+export { createMetadata, metadataKind };

package/dist/core/metadata/ignoreByRouteStore.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var base = require('./base.cjs');
+
+const IgnoreByRouteStoreMetadata = base.createMetadata("ignore-by-route-store");
+
+exports.IgnoreByRouteStoreMetadata = IgnoreByRouteStoreMetadata;

package/dist/core/metadata/ignoreByRouteStore.d.ts

@@ -0,0 +1 @@
+export declare const IgnoreByRouteStoreMetadata: import("./base").MetadataHandler<"ignore-by-route-store", unknown>;

package/dist/core/metadata/ignoreByRouteStore.mjs

@@ -0,0 +1,5 @@
+import { createMetadata } from './base.mjs';
+
+const IgnoreByRouteStoreMetadata = createMetadata("ignore-by-route-store");
+
+export { IgnoreByRouteStoreMetadata };

package/dist/core/metadata/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var base = require('./base.cjs');
+var ignoreByRouteStore = require('./ignoreByRouteStore.cjs');
+
+
+
+exports.createMetadata = base.createMetadata;
+exports.metadataKind = base.metadataKind;
+exports.IgnoreByRouteStoreMetadata = ignoreByRouteStore.IgnoreByRouteStoreMetadata;

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

@@ -0,0 +1,2 @@
+export * from "./base";
+export * from "./ignoreByRouteStore";

package/dist/core/metadata/index.mjs

@@ -0,0 +1,2 @@
+export { createMetadata, metadataKind } from './base.mjs';
+export { IgnoreByRouteStoreMetadata } from './ignoreByRouteStore.mjs';

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

@@ -3,6 +3,7 @@ import { type ProcessStep, type CheckerStep, type CutStep, type ExtractStep, typ
 import { type Floor } from "../floor";
 import { type HookRouteLifeCycle } from "../route";
 import { type Request } from "../request";
+import { type Metadata } from "../metadata";
 export * from "./types";
 export interface ProcessStepsCustom {
 }
@@ -13,6 +14,7 @@ export interface ProcessDefinition {
     steps: readonly ProcessSteps[];
     options?: Record<string, unknown>;
     readonly hooks: readonly HookRouteLifeCycle[];
+    readonly metadata: readonly Metadata[];
     [SymbolProcessExportValue]?: Floor;
     [SymbolProcessRequest]?: Request;
 }
@@ -28,4 +30,4 @@ export declare const processKind: import("@duplojs/utils").KindHandler<import("@
 export interface Process<GenericDefinition extends ProcessDefinition = ProcessDefinition> extends Kind<typeof processKind.definition> {
     definition: GenericDefinition;
 }
-export declare function createProcess<GenericDefinition extends Pick<ProcessDefinition, "steps" | "options" | "hooks">>(definition: GenericDefinition): Process<GenericDefinition>;
+export declare function createProcess<GenericDefinition extends Pick<ProcessDefinition, "steps" | "options" | "hooks" | "metadata">>(definition: GenericDefinition): Process<GenericDefinition>;

package/dist/core/response/base.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('../kind.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 = Response;

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

@@ -0,0 +1,21 @@
+import { type S } from "@duplojs/utils";
+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 {};