@duplojs/http 0.1.0

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

@@ -0,0 +1,20 @@
+import '../../steps/kind.mjs';
+import '../../steps/identifier.mjs';
+import '../../steps/checker.mjs';
+import '../../steps/extract.mjs';
+import '../../steps/cut.mjs';
+import '../../steps/handler.mjs';
+import '../../steps/process.mjs';
+import { createPresetCheckerStep } from '../../steps/presetChecker.mjs';
+import { processBuilder } from './builder.mjs';
+
+processBuilder.set("presetCheck", ({ args: [presetChecker, input,], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        createPresetCheckerStep({
+            presetChecker,
+            input,
+        }),
+    ],
+}));

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

@@ -0,0 +1,22 @@
+'use strict';
+
+require('../../steps/kind.cjs');
+require('../../steps/identifier.cjs');
+require('../../steps/checker.cjs');
+require('../../steps/extract.cjs');
+require('../../steps/cut.cjs');
+require('../../steps/handler.cjs');
+var process = require('../../steps/process.cjs');
+require('../../steps/presetChecker.cjs');
+var builder = require('./builder.cjs');
+
+builder.processBuilder.set("exec", ({ args: [process$1, params,], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        process.createProcessStep({
+            ...params,
+            process: process$1,
+        }),
+    ],
+}));

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

@@ -0,0 +1,22 @@
+import { type Floor } from "../../floor";
+import { type ProcessStep } from "../../steps";
+import { type O, type NeverCoalescing, type FixDeepFunctionInfer, type Adaptor, type AnyFunction } from "@duplojs/utils";
+import { type ProcessDefinition, type GetProcessExportValue, type Process, type GetProcessRequest } from "../../process";
+import { type Request } from "../../request";
+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?: {
+            readonly imports?: GenericImportation;
+            readonly options?: FixDeepFunctionInfer<GenericProcess["definition"]["options"] | ((floor: GenericFloor) => GenericProcess["definition"]["options"]), GenericOptions>;
+        }): 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>;
+                }>
+            ];
+        }>, O.AssignObjects<GenericFloor, Pick<GenericProcessExportValue, GenericImportation[number]>>, GenericRequest & NeverCoalescing<GetProcessRequest<GenericProcess>, Request>>;
+    }
+}

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

@@ -0,0 +1,20 @@
+import '../../steps/kind.mjs';
+import '../../steps/identifier.mjs';
+import '../../steps/checker.mjs';
+import '../../steps/extract.mjs';
+import '../../steps/cut.mjs';
+import '../../steps/handler.mjs';
+import { createProcessStep } from '../../steps/process.mjs';
+import '../../steps/presetChecker.mjs';
+import { processBuilder } from './builder.mjs';
+
+processBuilder.set("exec", ({ args: [process, params,], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        createProcessStep({
+            ...params,
+            process,
+        }),
+    ],
+}));

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

@@ -0,0 +1,18 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var stringIdentifier = require('../../stringIdentifier.cjs');
+
+const routeBuilderHandler = utils.createBuilder(stringIdentifier.createCoreLibStringIdentifier("route"));
+function useRouteBuilder(method, path, options) {
+    return routeBuilderHandler.use({
+        method,
+        paths: utils.A.coalescing(path),
+        preflightSteps: [],
+        steps: [],
+        hooks: options?.hooks ?? [],
+    });
+}
+
+exports.routeBuilderHandler = routeBuilderHandler;
+exports.useRouteBuilder = useRouteBuilder;

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

@@ -0,0 +1,16 @@
+import { type MakeRequestFromHooks, type HookRouteLifeCycle, type RouteDefinition, type RoutePath } from "../../route";
+import { type Floor } from "../../floor";
+import { type RequestMethods, type Request } from "../../request";
+import { type Builder, type NeverCoalescing } from "@duplojs/utils";
+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?: {
+    hooks?: GenericHooks | readonly HookRouteLifeCycle[];
+}): RouteBuilder<{
+    readonly method: GenericMethod;
+    readonly paths: GenericPaths extends string ? readonly [GenericPaths] : GenericPaths;
+    readonly preflightSteps: readonly [];
+    readonly steps: readonly [];
+    readonly hooks: GenericHooks;
+}, {}, NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>>;

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

@@ -0,0 +1,15 @@
+import { createBuilder, A } from '@duplojs/utils';
+import { createCoreLibStringIdentifier } from '../../stringIdentifier.mjs';
+
+const routeBuilderHandler = createBuilder(createCoreLibStringIdentifier("route"));
+function useRouteBuilder(method, path, options) {
+    return routeBuilderHandler.use({
+        method,
+        paths: A.coalescing(path),
+        preflightSteps: [],
+        steps: [],
+        hooks: options?.hooks ?? [],
+    });
+}
+
+export { routeBuilderHandler, useRouteBuilder };

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

@@ -0,0 +1,23 @@
+'use strict';
+
+require('../../steps/kind.cjs');
+require('../../steps/identifier.cjs');
+var checker = require('../../steps/checker.cjs');
+require('../../steps/extract.cjs');
+require('../../steps/cut.cjs');
+require('../../steps/handler.cjs');
+require('../../steps/process.cjs');
+require('../../steps/presetChecker.cjs');
+var builder = require('./builder.cjs');
+
+builder.routeBuilderHandler.set("check", ({ args: [checker$1, { otherwise: responseContract, ...params },], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        checker.createCheckerStep({
+            ...params,
+            responseContract,
+            checker: checker$1,
+        }),
+    ],
+}));

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

@@ -0,0 +1,34 @@
+import { type Floor } from "../../floor";
+import { type RouteDefinition } from "../../route";
+import { type CheckerStep } from "../../steps";
+import { type O, type MaybeArray, type NeverCoalescing, type FixDeepFunctionInfer, type Adaptor, type AnyFunction, type DP, type A } from "@duplojs/utils";
+import { type GetCheckerInput, type Checker, type GetCheckerResult, type GetCheckerOptions } from "../../checker";
+import { type ClientErrorResponseCode, type ResponseContract } from "../../response";
+import { type Request } from "../../request";
+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: {
+            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, {
+            readonly steps: readonly [
+                ...GenericDefinition["steps"],
+                CheckerStep<{
+                    readonly checker: GenericChecker;
+                    readonly result: GenericResultInformation;
+                    readonly indexing: NeverCoalescing<GenericIndex, undefined>;
+                    input(floor: GenericFloor): GenericInput;
+                    readonly options: NeverCoalescing<Adaptor<GenericOptions, AnyFunction | GenericChecker["definition"]["options"]>, undefined>;
+                    readonly responseContract: GenericResponseContract;
+                }>
+            ];
+        }>, O.AssignObjects<GenericFloor, {
+            [Prop in GenericIndex]: Extract<Awaited<GetCheckerResult<GenericChecker>>, {
+                information: A.ArrayCoalescing<GenericResultInformation>[number];
+            }>["value"];
+        }>, GenericRequest>;
+    }
+}

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

@@ -0,0 +1,21 @@
+import '../../steps/kind.mjs';
+import '../../steps/identifier.mjs';
+import { createCheckerStep } from '../../steps/checker.mjs';
+import '../../steps/extract.mjs';
+import '../../steps/cut.mjs';
+import '../../steps/handler.mjs';
+import '../../steps/process.mjs';
+import '../../steps/presetChecker.mjs';
+import { routeBuilderHandler } from './builder.mjs';
+
+routeBuilderHandler.set("check", ({ args: [checker, { otherwise: responseContract, ...params },], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        createCheckerStep({
+            ...params,
+            responseContract,
+            checker,
+        }),
+    ],
+}));

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

@@ -0,0 +1,22 @@
+'use strict';
+
+require('../../steps/kind.cjs');
+require('../../steps/identifier.cjs');
+require('../../steps/checker.cjs');
+require('../../steps/extract.cjs');
+var cut = require('../../steps/cut.cjs');
+require('../../steps/handler.cjs');
+require('../../steps/process.cjs');
+require('../../steps/presetChecker.cjs');
+var builder = require('./builder.cjs');
+
+builder.routeBuilderHandler.set("cut", ({ args: [responseContract, theFunction], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        cut.createCutStep({
+            responseContract,
+            theFunction,
+        }),
+    ],
+}));

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

@@ -0,0 +1,19 @@
+import { type Floor } from "../../floor";
+import { type ResponseContract } from "../../response";
+import { type RouteDefinition } from "../../route";
+import { type CutStepFunctionOutput, type CutStep, type CutStepFunctionParams } from "../../steps";
+import { type Unwrap, type O, type MaybePromise, type IsEqual, type A } from "@duplojs/utils";
+import { type Request } from "../../request";
+declare module "./builder" {
+    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+        cut<const GenericResponseContract extends (ResponseContract.Contract | readonly ResponseContract.Contract[]), GenericResponse extends ResponseContract.Convert<A.ArrayCoalescing<GenericResponseContract>[number]>, GenericOutput extends CutStepFunctionOutput | GenericResponse>(responseContract: GenericResponseContract, theFunction: (floor: GenericFloor, param: CutStepFunctionParams<GenericRequest, GenericResponse>) => MaybePromise<GenericOutput>): RouteBuilder<O.AssignObjects<GenericDefinition, {
+            readonly steps: readonly [
+                ...GenericDefinition["steps"],
+                CutStep<{
+                    readonly responseContract: GenericResponseContract;
+                    theFunction(floor: GenericFloor, param: CutStepFunctionParams<GenericRequest, GenericResponse>): MaybePromise<GenericOutput>;
+                }>
+            ];
+        }>, 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/route/cut.mjs

@@ -0,0 +1,20 @@
+import '../../steps/kind.mjs';
+import '../../steps/identifier.mjs';
+import '../../steps/checker.mjs';
+import '../../steps/extract.mjs';
+import { createCutStep } from '../../steps/cut.mjs';
+import '../../steps/handler.mjs';
+import '../../steps/process.mjs';
+import '../../steps/presetChecker.mjs';
+import { routeBuilderHandler } from './builder.mjs';
+
+routeBuilderHandler.set("cut", ({ args: [responseContract, theFunction], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        createCutStep({
+            responseContract,
+            theFunction,
+        }),
+    ],
+}));

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

@@ -0,0 +1,22 @@
+'use strict';
+
+require('../../steps/kind.cjs');
+require('../../steps/identifier.cjs');
+require('../../steps/checker.cjs');
+var extract = require('../../steps/extract.cjs');
+require('../../steps/cut.cjs');
+require('../../steps/handler.cjs');
+require('../../steps/process.cjs');
+require('../../steps/presetChecker.cjs');
+var builder = require('./builder.cjs');
+
+builder.routeBuilderHandler.set("extract", ({ args: [shape, responseContract], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        extract.createExtractStep({
+            shape,
+            responseContract,
+        }),
+    ],
+}));

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

@@ -0,0 +1,25 @@
+import { type Floor } from "../../floor";
+import { type RouteDefinition } from "../../route";
+import { type ExtractShape, type ExtractStep } from "../../steps";
+import { type DP, type ObjectEntry, type O, type SimplifyTopLevel, type NeverCoalescing } from "@duplojs/utils";
+import { type ClientErrorResponseCode, type ResponseContract } from "../../response";
+import { type Request } from "../../request";
+declare module "./builder" {
+    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+        extract<GenericShape extends ExtractShape<GenericRequest>, GenericResponseContract extends (ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>) = never>(shape: GenericShape, responseContract?: GenericResponseContract): RouteBuilder<O.AssignObjects<GenericDefinition, {
+            readonly steps: readonly [
+                ...GenericDefinition["steps"],
+                ExtractStep<{
+                    readonly shape: GenericShape;
+                    readonly responseContract: NeverCoalescing<GenericResponseContract, undefined>;
+                }>
+            ];
+        }>, O.AssignObjects<GenericFloor, {
+            [Prop in keyof GenericShape]: GenericShape[Prop] extends DP.DataParser ? [Prop, DP.Output<GenericShape[Prop]>] : GenericShape[Prop] extends infer InferredSubShape extends Record<string, DP.DataParser> ? {
+                [Prop in keyof InferredSubShape]: [Prop, DP.Output<InferredSubShape[Prop]>];
+            }[keyof InferredSubShape] : never;
+        }[keyof GenericShape] extends infer InferredEntry extends ObjectEntry ? SimplifyTopLevel<{
+            [Entry in InferredEntry as Entry[0]]: Entry[1];
+        }> : never>, GenericRequest>;
+    }
+}

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

@@ -0,0 +1,20 @@
+import '../../steps/kind.mjs';
+import '../../steps/identifier.mjs';
+import '../../steps/checker.mjs';
+import { createExtractStep } from '../../steps/extract.mjs';
+import '../../steps/cut.mjs';
+import '../../steps/handler.mjs';
+import '../../steps/process.mjs';
+import '../../steps/presetChecker.mjs';
+import { routeBuilderHandler } from './builder.mjs';
+
+routeBuilderHandler.set("extract", ({ args: [shape, responseContract], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        createExtractStep({
+            shape,
+            responseContract,
+        }),
+    ],
+}));

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

@@ -0,0 +1,28 @@
+'use strict';
+
+var index = require('../../route/index.cjs');
+require('../../steps/kind.cjs');
+require('../../steps/identifier.cjs');
+require('../../steps/checker.cjs');
+require('../../steps/extract.cjs');
+require('../../steps/cut.cjs');
+var handler = require('../../steps/handler.cjs');
+require('../../steps/process.cjs');
+require('../../steps/presetChecker.cjs');
+var builder = require('./builder.cjs');
+var store = require('./store.cjs');
+
+builder.routeBuilderHandler.set("handler", ({ args: [responseContract, theFunction], accumulator, }) => {
+    const route = index.createRoute({
+        ...accumulator,
+        steps: [
+            ...accumulator.steps,
+            handler.createHandlerStep({
+                responseContract,
+                theFunction,
+            }),
+        ],
+    });
+    store.routeStore.add(route);
+    return route;
+});

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

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

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

@@ -0,0 +1,26 @@
+import { createRoute } from '../../route/index.mjs';
+import '../../steps/kind.mjs';
+import '../../steps/identifier.mjs';
+import '../../steps/checker.mjs';
+import '../../steps/extract.mjs';
+import '../../steps/cut.mjs';
+import { createHandlerStep } from '../../steps/handler.mjs';
+import '../../steps/process.mjs';
+import '../../steps/presetChecker.mjs';
+import { routeBuilderHandler } from './builder.mjs';
+import { routeStore } from './store.mjs';
+
+routeBuilderHandler.set("handler", ({ args: [responseContract, theFunction], accumulator, }) => {
+    const route = createRoute({
+        ...accumulator,
+        steps: [
+            ...accumulator.steps,
+            createHandlerStep({
+                responseContract,
+                theFunction,
+            }),
+        ],
+    });
+    routeStore.add(route);
+    return route;
+});

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

@@ -0,0 +1,8 @@
+export * from "./builder";
+export * from "./handler";
+export * from "./cut";
+export * from "./extract";
+export * from "./checker";
+export * from "./process";
+export * from "./presetChecker";
+export * from "./store";

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

@@ -0,0 +1,22 @@
+'use strict';
+
+require('../../steps/kind.cjs');
+require('../../steps/identifier.cjs');
+require('../../steps/checker.cjs');
+require('../../steps/extract.cjs');
+require('../../steps/cut.cjs');
+require('../../steps/handler.cjs');
+require('../../steps/process.cjs');
+var presetChecker = require('../../steps/presetChecker.cjs');
+var builder = require('./builder.cjs');
+
+builder.routeBuilderHandler.set("presetCheck", ({ args: [presetChecker$1, input,], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        presetChecker.createPresetCheckerStep({
+            presetChecker: presetChecker$1,
+            input,
+        }),
+    ],
+}));

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

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

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

@@ -0,0 +1,20 @@
+import '../../steps/kind.mjs';
+import '../../steps/identifier.mjs';
+import '../../steps/checker.mjs';
+import '../../steps/extract.mjs';
+import '../../steps/cut.mjs';
+import '../../steps/handler.mjs';
+import '../../steps/process.mjs';
+import { createPresetCheckerStep } from '../../steps/presetChecker.mjs';
+import { routeBuilderHandler } from './builder.mjs';
+
+routeBuilderHandler.set("presetCheck", ({ args: [presetChecker, input,], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        createPresetCheckerStep({
+            presetChecker,
+            input,
+        }),
+    ],
+}));

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

@@ -0,0 +1,22 @@
+'use strict';
+
+require('../../steps/kind.cjs');
+require('../../steps/identifier.cjs');
+require('../../steps/checker.cjs');
+require('../../steps/extract.cjs');
+require('../../steps/cut.cjs');
+require('../../steps/handler.cjs');
+var process = require('../../steps/process.cjs');
+require('../../steps/presetChecker.cjs');
+var builder = require('./builder.cjs');
+
+builder.routeBuilderHandler.set("exec", ({ args: [process$1, params,], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        process.createProcessStep({
+            ...params,
+            process: process$1,
+        }),
+    ],
+}));

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

@@ -0,0 +1,23 @@
+import { type Floor } from "../../floor";
+import { type RouteDefinition } from "../../route";
+import { type ProcessStep } from "../../steps";
+import { type O, type NeverCoalescing, type FixDeepFunctionInfer, type Adaptor, type AnyFunction } from "@duplojs/utils";
+import { type GetProcessRequest, type GetProcessExportValue, type Process } from "../../process";
+import { type Request } from "../../request";
+declare module "./builder" {
+    interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, 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?: {
+            readonly imports?: GenericImportation;
+            readonly options?: FixDeepFunctionInfer<GenericProcess["definition"]["options"] | ((floor: GenericFloor) => GenericProcess["definition"]["options"]), GenericOptions>;
+        }): RouteBuilder<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>;
+                }>
+            ];
+        }>, O.AssignObjects<GenericFloor, Pick<GenericProcessExportValue, GenericImportation[number]>>, GenericRequest & NeverCoalescing<GetProcessRequest<GenericProcess>, Request>>;
+    }
+}

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

@@ -0,0 +1,20 @@
+import '../../steps/kind.mjs';
+import '../../steps/identifier.mjs';
+import '../../steps/checker.mjs';
+import '../../steps/extract.mjs';
+import '../../steps/cut.mjs';
+import '../../steps/handler.mjs';
+import { createProcessStep } from '../../steps/process.mjs';
+import '../../steps/presetChecker.mjs';
+import { routeBuilderHandler } from './builder.mjs';
+
+routeBuilderHandler.set("exec", ({ args: [process, params,], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        createProcessStep({
+            ...params,
+            process,
+        }),
+    ],
+}));

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var stringIdentifier = require('../../stringIdentifier.cjs');
+var utils = require('@duplojs/utils');
+
+const SymbolRouteStore = Symbol.for(stringIdentifier.createCoreLibStringIdentifier("route-store"));
+const privateRouteStore = utils.createGlobalStore(SymbolRouteStore, new Set());
+const routeStore = {
+    add(route) {
+        privateRouteStore.value.add(route);
+    },
+    *getAll() {
+        for (const route of privateRouteStore.value) {
+            yield route;
+        }
+    },
+};
+
+exports.routeStore = routeStore;

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

@@ -0,0 +1,13 @@
+import { type Route } from "../../route";
+declare const SymbolRouteStore: unique symbol;
+declare module "@duplojs/utils" {
+    interface GlobalStore {
+        [SymbolRouteStore]: Set<Route>;
+    }
+}
+export interface RouteStore {
+    add(route: Route): void;
+    getAll(): Generator<Route>;
+}
+export declare const routeStore: RouteStore;
+export {};

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

@@ -0,0 +1,17 @@
+import { createCoreLibStringIdentifier } from '../../stringIdentifier.mjs';
+import { createGlobalStore } from '@duplojs/utils';
+
+const SymbolRouteStore = Symbol.for(createCoreLibStringIdentifier("route-store"));
+const privateRouteStore = createGlobalStore(SymbolRouteStore, new Set());
+const routeStore = {
+    add(route) {
+        privateRouteStore.value.add(route);
+    },
+    *getAll() {
+        for (const route of privateRouteStore.value) {
+            yield route;
+        }
+    },
+};
+
+export { routeStore };