@duplojs/http 0.4.0 → 0.5.1

package/dist/core/builders/preflight/builder.cjs

@@ -8,6 +8,7 @@ function usePreflightBuilder(options) {
     return preflightBuilder.use({
         preflightSteps: [],
         hooks: options?.hooks ?? [],
+        metadata: options?.metadata ?? [],
     });
 }
 

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

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

package/dist/core/builders/preflight/builder.mjs

@@ -6,6 +6,7 @@ function usePreflightBuilder(options) {
     return preflightBuilder.use({
         preflightSteps: [],
         hooks: options?.hooks ?? [],
+        metadata: options?.metadata ?? [],
     });
 }
 

package/dist/core/builders/preflight/process.cjs

@@ -4,13 +4,14 @@ require('../../steps/index.cjs');
 var builder = require('./builder.cjs');
 var process = require('../../steps/process.cjs');
 
-builder.preflightBuilder.set("exec", ({ args: [process$1, params,], accumulator, next, }) => next({
+builder.preflightBuilder.set("exec", ({ args: [process$1, params, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     preflightSteps: [
         ...accumulator.preflightSteps,
         process.createProcessStep({
             ...params,
             process: process$1,
+            metadata,
         }),
     ],
 }));

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

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

package/dist/core/builders/preflight/process.mjs

@@ -2,13 +2,14 @@ import '../../steps/index.mjs';
 import { preflightBuilder } from './builder.mjs';
 import { createProcessStep } from '../../steps/process.mjs';
 
-preflightBuilder.set("exec", ({ args: [process, params,], accumulator, next, }) => next({
+preflightBuilder.set("exec", ({ args: [process, params, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     preflightSteps: [
         ...accumulator.preflightSteps,
         createProcessStep({
             ...params,
             process,
+            metadata,
         }),
     ],
 }));

package/dist/core/builders/preflight/route.cjs

@@ -14,4 +14,8 @@ builder.preflightBuilder.set("useRouteBuilder", ({ args: [method, paths, options
         ...(options?.hooks ?? []),
         ...accumulator.hooks,
     ],
+    metadata: [
+        ...(options?.metadata ?? []),
+        ...accumulator.metadata,
+    ],
 }));

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

@@ -3,18 +3,24 @@ import { type RequestMethods, type Request } from "../../request";
 import { type MakeRequestFromHooks, type HookRouteLifeCycle, type RoutePath } from "../../route";
 import { type RouteBuilder } from "../route";
 import { type NeverCoalescing } from "@duplojs/utils";
+import { type Metadata } from "../../metadata";
 declare module "./builder" {
     interface PreflightBuilder<GenericDefinition extends PreflightBuilderDefinition = PreflightBuilderDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        useRouteBuilder<GenericMethod extends RequestMethods, const GenericPaths extends RoutePath | readonly [RoutePath, ...RoutePath[]], const GenericHooks extends readonly HookRouteLifeCycle[] = readonly []>(method: GenericMethod, path: GenericPaths, options?: {
+        useRouteBuilder<GenericMethod extends RequestMethods, const GenericPaths extends RoutePath | readonly [RoutePath, ...RoutePath[]], const GenericHooks extends readonly HookRouteLifeCycle[] = readonly [], const GenericMetadata extends readonly Metadata[] = readonly []>(method: GenericMethod, path: GenericPaths, options?: {
             hooks?: GenericHooks | readonly HookRouteLifeCycle[];
+            metadata?: GenericMetadata;
         }): RouteBuilder<{
             readonly method: GenericMethod;
             readonly paths: GenericPaths extends string ? readonly [GenericPaths] : GenericPaths;
             readonly preflightSteps: GenericDefinition["preflightSteps"];
             readonly steps: readonly [];
             readonly hooks: readonly [
-                ...GenericHooks,
-                ...GenericDefinition["hooks"]
+                ...GenericDefinition["hooks"],
+                ...GenericHooks
+            ];
+            readonly metadata: readonly [
+                ...GenericDefinition["metadata"],
+                ...GenericMetadata
             ];
         }, GenericFloor, (GenericRequest & NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>)>;
     }

package/dist/core/builders/preflight/route.mjs

@@ -12,4 +12,8 @@ preflightBuilder.set("useRouteBuilder", ({ args: [method, paths, options,], accu
         ...(options?.hooks ?? []),
         ...accumulator.hooks,
     ],
+    metadata: [
+        ...(options?.metadata ?? []),
+        ...accumulator.metadata,
+    ],
 }));

package/dist/core/builders/process/builder.cjs

@@ -10,6 +10,7 @@ function useProcessBuilder(params) {
         ...params,
         steps: [],
         hooks: params?.hooks ?? [],
+        metadata: params?.metadata ?? [],
     });
 }
 

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

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

package/dist/core/builders/process/builder.mjs

@@ -8,6 +8,7 @@ function useProcessBuilder(params) {
         ...params,
         steps: [],
         hooks: params?.hooks ?? [],
+        metadata: params?.metadata ?? [],
     });
 }
 

package/dist/core/builders/process/checker.cjs

@@ -4,7 +4,7 @@ require('../../steps/index.cjs');
 var builder = require('./builder.cjs');
 var checker = require('../../steps/checker.cjs');
 
-builder.processBuilder.set("check", ({ args: [checker$1, { otherwise: responseContract, ...params },], accumulator, next, }) => next({
+builder.processBuilder.set("check", ({ args: [checker$1, { otherwise: responseContract, ...params }, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
@@ -12,6 +12,7 @@ builder.processBuilder.set("check", ({ args: [checker$1, { otherwise: responseCo
             ...params,
             responseContract,
             checker: checker$1,
+            metadata,
         }),
     ],
 }));

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

@@ -5,15 +5,16 @@ import { type GetCheckerResult, type Checker, type GetCheckerInput, type GetChec
 import { type ClientErrorResponseCode, type ResponseContract } from "../../response";
 import { type ProcessDefinition } from "../../process";
 import { type Request } from "../../request";
+import { type Metadata } from "../../metadata";
 declare module "./builder" {
     interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        check<GenericChecker extends Checker, GenericResultInformation extends MaybeArray<Awaited<GetCheckerResult<GenericChecker>>["information"]>, GenericInput extends GetCheckerInput<GenericChecker>, GenericResponseContract extends ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>, GenericIndex extends string = never, GenericOptions extends (GetCheckerOptions<GenericChecker> | ((floor: GenericFloor) => Exclude<GetCheckerOptions<GenericChecker>, undefined>)) = never>(checker: GenericChecker, params: {
+        check<GenericChecker extends Checker, GenericResultInformation extends MaybeArray<Awaited<GetCheckerResult<GenericChecker>>["information"]>, GenericInput extends GetCheckerInput<GenericChecker>, GenericResponseContract extends ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>, GenericIndex extends string = never, GenericOptions extends (GetCheckerOptions<GenericChecker> | ((floor: GenericFloor) => Exclude<GetCheckerOptions<GenericChecker>, undefined>)) = never, const GenericMetadata extends readonly Metadata[] = readonly []>(checker: GenericChecker, params: {
             input(floor: GenericFloor): GenericInput;
             readonly result: GenericResultInformation;
             readonly indexing?: GenericIndex;
             readonly options?: FixDeepFunctionInfer<GenericChecker["definition"]["options"] | ((floor: GenericFloor) => GenericChecker["definition"]["options"]), GenericOptions>;
             readonly otherwise: GenericResponseContract;
-        }): ProcessBuilder<O.AssignObjects<GenericDefinition, {
+        }, ...metadata: GenericMetadata): ProcessBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 CheckerStep<{
@@ -23,6 +24,7 @@ declare module "./builder" {
                     input(floor: GenericFloor): GenericInput;
                     readonly options: NeverCoalescing<Adaptor<GenericOptions, AnyFunction | GenericChecker["definition"]["options"]>, undefined>;
                     readonly responseContract: GenericResponseContract;
+                    readonly metadata: GenericMetadata;
                 }>
             ];
         }>, O.AssignObjects<GenericFloor, {

package/dist/core/builders/process/checker.mjs

@@ -2,7 +2,7 @@ import '../../steps/index.mjs';
 import { processBuilder } from './builder.mjs';
 import { createCheckerStep } from '../../steps/checker.mjs';
 
-processBuilder.set("check", ({ args: [checker, { otherwise: responseContract, ...params },], accumulator, next, }) => next({
+processBuilder.set("check", ({ args: [checker, { otherwise: responseContract, ...params }, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
@@ -10,6 +10,7 @@ processBuilder.set("check", ({ args: [checker, { otherwise: responseContract, ..
             ...params,
             responseContract,
             checker,
+            metadata,
         }),
     ],
 }));

package/dist/core/builders/process/cut.cjs

@@ -4,13 +4,14 @@ require('../../steps/index.cjs');
 var builder = require('./builder.cjs');
 var cut = require('../../steps/cut.cjs');
 
-builder.processBuilder.set("cut", ({ args: [responseContract, theFunction], accumulator, next, }) => next({
+builder.processBuilder.set("cut", ({ args: [responseContract, theFunction, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         cut.createCutStep({
             responseContract,
             theFunction,
+            metadata,
         }),
     ],
 }));

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

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

package/dist/core/builders/process/cut.mjs

@@ -2,13 +2,14 @@ import '../../steps/index.mjs';
 import { processBuilder } from './builder.mjs';
 import { createCutStep } from '../../steps/cut.mjs';
 
-processBuilder.set("cut", ({ args: [responseContract, theFunction], accumulator, next, }) => next({
+processBuilder.set("cut", ({ args: [responseContract, theFunction, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         createCutStep({
             responseContract,
             theFunction,
+            metadata,
         }),
     ],
 }));

package/dist/core/builders/process/extract.cjs

@@ -4,13 +4,14 @@ require('../../steps/index.cjs');
 var builder = require('./builder.cjs');
 var extract = require('../../steps/extract.cjs');
 
-builder.processBuilder.set("extract", ({ args: [shape, responseContract], accumulator, next, }) => next({
+builder.processBuilder.set("extract", ({ args: [shape, responseContract, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         extract.createExtractStep({
             shape,
             responseContract,
+            metadata,
         }),
     ],
 }));

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

@@ -4,14 +4,16 @@ import { type DP, type ObjectEntry, type O, type SimplifyTopLevel, type NeverCoa
 import { type ClientErrorResponseCode, type ResponseContract } from "../../response";
 import { type ProcessDefinition } from "../../process";
 import { type Request } from "../../request";
+import { type Metadata } from "../../metadata";
 declare module "./builder" {
     interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        extract<GenericShape extends ExtractShape, GenericResponseContract extends (ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>) = never>(shape: GenericShape, responseContract?: GenericResponseContract): ProcessBuilder<O.AssignObjects<GenericDefinition, {
+        extract<GenericShape extends ExtractShape, GenericResponseContract extends (ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty> | undefined) = never, const GenericMetadata extends readonly Metadata[] = readonly []>(shape: GenericShape, responseContract?: GenericResponseContract, ...metadata: GenericMetadata): ProcessBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 ExtractStep<{
                     readonly shape: GenericShape;
                     readonly responseContract: NeverCoalescing<GenericResponseContract, undefined>;
+                    readonly metadata: GenericMetadata;
                 }>
             ];
         }>, O.AssignObjects<GenericFloor, {

package/dist/core/builders/process/extract.mjs

@@ -2,13 +2,14 @@ import '../../steps/index.mjs';
 import { processBuilder } from './builder.mjs';
 import { createExtractStep } from '../../steps/extract.mjs';
 
-processBuilder.set("extract", ({ args: [shape, responseContract], accumulator, next, }) => next({
+processBuilder.set("extract", ({ args: [shape, responseContract, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         createExtractStep({
             shape,
             responseContract,
+            metadata,
         }),
     ],
 }));

package/dist/core/builders/process/index.cjs

@@ -5,7 +5,7 @@ require('./cut.cjs');
 require('./extract.cjs');
 require('./checker.cjs');
 require('./process.cjs');
-require('./export.cjs');
+require('./exports.cjs');
 require('./presetChecker.cjs');
 
 

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

@@ -3,5 +3,5 @@ export * from "./cut";
 export * from "./extract";
 export * from "./checker";
 export * from "./process";
-export * from "./export";
+export * from "./exports";
 export * from "./presetChecker";

package/dist/core/builders/process/index.mjs

@@ -3,5 +3,5 @@ import './cut.mjs';
 import './extract.mjs';
 import './checker.mjs';
 import './process.mjs';
-import './export.mjs';
+import './exports.mjs';
 import './presetChecker.mjs';

package/dist/core/builders/process/presetChecker.cjs

@@ -4,13 +4,14 @@ require('../../steps/index.cjs');
 var builder = require('./builder.cjs');
 var presetChecker = require('../../steps/presetChecker.cjs');
 
-builder.processBuilder.set("presetCheck", ({ args: [presetChecker$1, input,], accumulator, next, }) => next({
+builder.processBuilder.set("presetCheck", ({ args: [presetChecker$1, input, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         presetChecker.createPresetCheckerStep({
             presetChecker: presetChecker$1,
             input,
+            metadata,
         }),
     ],
 }));

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

@@ -4,14 +4,16 @@ import { type O, type A } from "@duplojs/utils";
 import { type Request } from "../../request";
 import { type GetPresetCheckerIndex, type GetPresetCheckerInformation, type GetPresetCheckerResult, type GetPresetCheckerInput, type PresetChecker } from "../../presetChecker";
 import { type ProcessDefinition } from "../../process";
+import { type Metadata } from "../../metadata";
 declare module "./builder" {
     interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        presetCheck<GenericPresetChecker extends PresetChecker, GenericInput extends GetPresetCheckerInput<GenericPresetChecker>>(presetChecker: GenericPresetChecker, input: (floor: GenericFloor) => GenericInput): ProcessBuilder<O.AssignObjects<GenericDefinition, {
+        presetCheck<GenericPresetChecker extends PresetChecker, GenericInput extends GetPresetCheckerInput<GenericPresetChecker>, const GenericMetadata extends readonly Metadata[] = readonly []>(presetChecker: GenericPresetChecker, input: (floor: GenericFloor) => GenericInput, ...metadata: GenericMetadata): ProcessBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 PresetCheckerStep<{
                     readonly presetChecker: GenericPresetChecker;
                     input(floor: GenericFloor): GenericInput;
+                    readonly metadata: GenericMetadata;
                 }>
             ];
         }>, O.AssignObjects<GenericFloor, {

package/dist/core/builders/process/presetChecker.mjs

@@ -2,13 +2,14 @@ import '../../steps/index.mjs';
 import { processBuilder } from './builder.mjs';
 import { createPresetCheckerStep } from '../../steps/presetChecker.mjs';
 
-processBuilder.set("presetCheck", ({ args: [presetChecker, input,], accumulator, next, }) => next({
+processBuilder.set("presetCheck", ({ args: [presetChecker, input, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         createPresetCheckerStep({
             presetChecker,
             input,
+            metadata,
         }),
     ],
 }));

package/dist/core/builders/process/process.cjs

@@ -4,13 +4,14 @@ require('../../steps/index.cjs');
 var builder = require('./builder.cjs');
 var process = require('../../steps/process.cjs');
 
-builder.processBuilder.set("exec", ({ args: [process$1, params,], accumulator, next, }) => next({
+builder.processBuilder.set("exec", ({ args: [process$1, params, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         process.createProcessStep({
             ...params,
             process: process$1,
+            metadata,
         }),
     ],
 }));

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

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

package/dist/core/builders/process/process.mjs

@@ -2,13 +2,14 @@ import '../../steps/index.mjs';
 import { processBuilder } from './builder.mjs';
 import { createProcessStep } from '../../steps/process.mjs';
 
-processBuilder.set("exec", ({ args: [process, params,], accumulator, next, }) => next({
+processBuilder.set("exec", ({ args: [process, params, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
         createProcessStep({
             ...params,
             process,
+            metadata,
         }),
     ],
 }));

package/dist/core/builders/route/builder.cjs

@@ -11,6 +11,7 @@ function useRouteBuilder(method, path, options) {
         preflightSteps: [],
         steps: [],
         hooks: options?.hooks ?? [],
+        metadata: options?.metadata ?? [],
     });
 }
 

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

@@ -2,15 +2,18 @@ import { type MakeRequestFromHooks, type HookRouteLifeCycle, type RouteDefinitio
 import { type Floor } from "../../floor";
 import { type RequestMethods, type Request } from "../../request";
 import { type Builder, type NeverCoalescing } from "@duplojs/utils";
+import { type Metadata } from "../../metadata";
 export interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> extends Builder<RouteDefinition> {
 }
 export declare const routeBuilderHandler: import("@duplojs/utils").BuilderHandler<RouteBuilder<RouteDefinition, {}, Request>>;
-export declare function useRouteBuilder<GenericMethod extends RequestMethods, const GenericPaths extends RoutePath | readonly [RoutePath, ...RoutePath[]], const GenericHooks extends readonly HookRouteLifeCycle[] = readonly []>(method: GenericMethod, path: GenericPaths, options?: {
+export declare function useRouteBuilder<GenericMethod extends RequestMethods, const GenericPaths extends RoutePath | readonly [RoutePath, ...RoutePath[]], const GenericHooks extends readonly HookRouteLifeCycle[] = readonly [], const GenericMetadata extends readonly Metadata[] = readonly []>(method: GenericMethod, path: GenericPaths, options?: {
     hooks?: GenericHooks | readonly HookRouteLifeCycle[];
+    metadata?: GenericMetadata;
 }): RouteBuilder<{
     readonly method: GenericMethod;
     readonly paths: GenericPaths extends string ? readonly [GenericPaths] : GenericPaths;
     readonly preflightSteps: readonly [];
     readonly steps: readonly [];
     readonly hooks: GenericHooks;
+    readonly metadata: GenericMetadata;
 }, {}, NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>>;

package/dist/core/builders/route/builder.mjs

@@ -9,6 +9,7 @@ function useRouteBuilder(method, path, options) {
         preflightSteps: [],
         steps: [],
         hooks: options?.hooks ?? [],
+        metadata: options?.metadata ?? [],
     });
 }
 

package/dist/core/builders/route/checker.cjs

@@ -4,7 +4,7 @@ require('../../steps/index.cjs');
 var builder = require('./builder.cjs');
 var checker = require('../../steps/checker.cjs');
 
-builder.routeBuilderHandler.set("check", ({ args: [checker$1, { otherwise: responseContract, ...params },], accumulator, next, }) => next({
+builder.routeBuilderHandler.set("check", ({ args: [checker$1, { otherwise: responseContract, ...params }, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
@@ -12,6 +12,7 @@ builder.routeBuilderHandler.set("check", ({ args: [checker$1, { otherwise: respo
             ...params,
             responseContract,
             checker: checker$1,
+            metadata,
         }),
     ],
 }));

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

@@ -5,15 +5,16 @@ import { type O, type MaybeArray, type NeverCoalescing, type FixDeepFunctionInfe
 import { type GetCheckerInput, type Checker, type GetCheckerResult, type GetCheckerOptions } from "../../checker";
 import { type ClientErrorResponseCode, type ResponseContract } from "../../response";
 import { type Request } from "../../request";
+import { type Metadata } from "../../metadata";
 declare module "./builder" {
     interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        check<GenericChecker extends Checker, GenericResultInformation extends MaybeArray<Awaited<GetCheckerResult<GenericChecker>>["information"]>, GenericInput extends GetCheckerInput<GenericChecker>, GenericResponseContract extends ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>, GenericIndex extends string = never, GenericOptions extends (GetCheckerOptions<GenericChecker> | ((floor: GenericFloor) => Exclude<GetCheckerOptions<GenericChecker>, undefined>)) = never>(checker: GenericChecker, params: {
+        check<GenericChecker extends Checker, GenericResultInformation extends MaybeArray<Awaited<GetCheckerResult<GenericChecker>>["information"]>, GenericInput extends GetCheckerInput<GenericChecker>, GenericResponseContract extends ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>, GenericIndex extends string = never, GenericOptions extends (GetCheckerOptions<GenericChecker> | ((floor: GenericFloor) => Exclude<GetCheckerOptions<GenericChecker>, undefined>)) = never, const GenericMetadata extends readonly Metadata[] = readonly []>(checker: GenericChecker, params: {
             input(floor: GenericFloor): GenericInput;
             readonly result: GenericResultInformation;
             readonly indexing?: GenericIndex;
             readonly options?: FixDeepFunctionInfer<GenericChecker["definition"]["options"] | ((floor: GenericFloor) => GenericChecker["definition"]["options"]), GenericOptions>;
             readonly otherwise: GenericResponseContract;
-        }): RouteBuilder<O.AssignObjects<GenericDefinition, {
+        }, ...metadata: GenericMetadata): RouteBuilder<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 CheckerStep<{
@@ -23,6 +24,7 @@ declare module "./builder" {
                     input(floor: GenericFloor): GenericInput;
                     readonly options: NeverCoalescing<Adaptor<GenericOptions, AnyFunction | GenericChecker["definition"]["options"]>, undefined>;
                     readonly responseContract: GenericResponseContract;
+                    readonly metadata: GenericMetadata;
                 }>
             ];
         }>, O.AssignObjects<GenericFloor, {

package/dist/core/builders/route/checker.mjs

@@ -2,7 +2,7 @@ import '../../steps/index.mjs';
 import { routeBuilderHandler } from './builder.mjs';
 import { createCheckerStep } from '../../steps/checker.mjs';
 
-routeBuilderHandler.set("check", ({ args: [checker, { otherwise: responseContract, ...params },], accumulator, next, }) => next({
+routeBuilderHandler.set("check", ({ args: [checker, { otherwise: responseContract, ...params }, ...metadata], accumulator, next, }) => next({
     ...accumulator,
     steps: [
         ...accumulator.steps,
@@ -10,6 +10,7 @@ routeBuilderHandler.set("check", ({ args: [checker, { otherwise: responseContrac
             ...params,
             responseContract,
             checker,
+            metadata,
         }),
     ],
 }));