@duplojs/lang 0.0.1-beta.8 → 0.1.0-beta.1

package/dist/either/unwrapOtherwise.cjs

@@ -0,0 +1,14 @@
+const require_kind = require("./kind.cjs");
+const require_is = require("./right/is.cjs");
+//#region scripts/either/unwrapOtherwise.ts
+function unwrapOtherwise(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (input) => unwrapOtherwise(input, value);
+	}
+	const [input, value] = args;
+	if (require_is.isRight(input)) return require_kind.valueKind.getValue(input);
+	return value();
+}
+//#endregion
+exports.unwrapOtherwise = unwrapOtherwise;

package/dist/either/unwrapOtherwise.d.ts

@@ -0,0 +1,8 @@
+import { Left } from './left';
+import { Right } from './right';
+import { GetValue } from './types';
+import type * as DCommon from '../common';
+type Either = Right | Left;
+export declare function unwrapOtherwise<GenericInput extends Either | DCommon.AnyValue, const GenericValue extends unknown>(input: GenericInput, value: () => GenericValue): (GetValue<Extract<GenericInput, Right>> | GenericValue);
+export declare function unwrapOtherwise<GenericInput extends Either | DCommon.AnyValue, const GenericValue extends unknown>(value: () => GenericValue): (input: GenericInput) => (GetValue<Extract<GenericInput, Right>> | GenericValue);
+export {};

package/dist/either/unwrapOtherwise.mjs

@@ -0,0 +1,14 @@
+import { valueKind } from "./kind.mjs";
+import { isRight } from "./right/is.mjs";
+//#region scripts/either/unwrapOtherwise.ts
+function unwrapOtherwise(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (input) => unwrapOtherwise(input, value);
+	}
+	const [input, value] = args;
+	if (isRight(input)) return valueKind.getValue(input);
+	return value();
+}
+//#endregion
+export { unwrapOtherwise };

package/dist/generator/reduce.cjs

@@ -1,6 +1,7 @@
+const require_kind = require("./kind.cjs");
 const require_reduce = require("../array/reduce.cjs");
 //#region scripts/generator/reduce.ts
-const reduceKind = require("./kind.cjs").createKind("reduce");
+const reduceKind = require_kind.createKind("reduce");
 function reduceFrom(value) {
 	return { [reduceKind.runTimeKey]: value };
 }

package/dist/generator/reduce.mjs

@@ -1,5 +1,5 @@
-import { reduceTools } from "../array/reduce.mjs";
 import { createKind } from "./kind.mjs";
+import { reduceTools } from "../array/reduce.mjs";
 //#region scripts/generator/reduce.ts
 const reduceKind = createKind("reduce");
 function reduceFrom(value) {

package/dist/invocation/evidence.d.ts

@@ -14,5 +14,5 @@ export interface EvidenceResult<GenericInformation extends string, GenericValue
  */
 export declare function evidenceResult<GenericInformation extends string, GenericValue extends object>(information: GenericInformation): (value: GenericValue) => EvidenceResult<GenericInformation, GenericValue>;
 export declare function evidenceResult<GenericInformation extends string, GenericValue extends object>(information: GenericInformation, value: GenericValue): EvidenceResult<GenericInformation, GenericValue>;
-export type FindEvidence<GenericValue extends unknown> = (GenericValue extends Evidence ? GenericValue : GenericValue extends Promise<unknown> ? FindEvidence<Awaited<GenericValue>> : GenericValue extends DEither.Right | DEither.Left ? FindEvidence<DEither.GetValue<GenericValue>> : never) extends infer InferredResult extends Evidence ? InferredResult : never;
+export type FindEvidence<GenericValue extends unknown> = (GenericValue extends Evidence ? GenericValue : GenericValue extends Promise<unknown> ? FindEvidence<Awaited<GenericValue>> : GenericValue extends DEither.Right | DEither.Left ? FindEvidence<DEither.GetValue<GenericValue>> : GenericValue extends Generator<infer InferredYeldValue, infer InferredResult> ? (FindEvidence<InferredYeldValue> | FindEvidence<InferredResult>) : GenericValue extends AsyncGenerator<infer InferredYeldValue, infer InferredResult> ? (FindEvidence<InferredYeldValue> | FindEvidence<InferredResult>) : never) extends infer InferredResult extends Evidence ? InferredResult : never;
 export type GetEvidenceResult<GenericFunction extends DCommon.AnyFunction, EvidenceName extends Extract<keyof FindEvidence<ReturnType<GenericFunction>>[DCommon.ConstraintSymbol]["evidence"], string>> = Extract<FindEvidence<ReturnType<GenericFunction>>, EvidenceName extends unknown ? Evidence<EvidenceName> : never>;

package/dist/invocation/flow/base.cjs

@@ -4,14 +4,14 @@ const require_base = require("./controller/base.cjs");
 //#region scripts/invocation/flow/base.ts
 function flow(...args) {
 	const accumulateFunction = args.reduce((accumulator, currentValue) => {
-		if (require_base.flowControllerKind.has(currentValue)) return (arg) => currentValue.exec(() => accumulator(arg));
+		if (require_base.flowControllerKind.has(currentValue)) return (input, argument) => currentValue.exec(() => accumulator(input, argument));
 		else {
-			const preparedResultTreatment = (result) => require_base.flowControllerExitKind.has(result) ? result : currentValue(result);
-			return (arg) => require_callThen.callThen(accumulator(arg), preparedResultTreatment);
+			const preparedResultTreatment = (result, argument) => require_base.flowControllerExitKind.has(result) ? result : currentValue(result, argument);
+			return (input, argument) => require_callThen.callThen(accumulator(input, argument), (result) => preparedResultTreatment(result, argument));
 		}
 	}, require_forward.forward);
 	const preparedResultTreatment = (result) => require_base.flowControllerExitKind.has(result) ? require_base.flowControllerExitKind.getValue(result) : result;
-	return (arg) => require_callThen.callThen(accumulateFunction(arg), preparedResultTreatment);
+	return (input) => require_callThen.callThen(accumulateFunction(input, input), preparedResultTreatment);
 }
 //#endregion
 exports.flow = flow;

package/dist/invocation/flow/base.d.ts

@@ -5,7 +5,7 @@ type ComputeLastUsableValue<GenericAccumulator extends DCommon.AnyTuple> = Gener
     ...infer InferredRest,
     infer InferredLast
 ] ? InferredLast extends FlowControllerResult<infer InferredFlowControllerResult> ? Exclude<Awaited<InferredFlowControllerResult>, FlowControllerPreviousFunctionResult | FlowControllerExit> extends infer InferredOutputValue ? DCommon.HasSomething<InferredOutputValue> extends true ? InferredOutputValue : InferredRest extends DCommon.AnyTuple ? ComputeLastUsableValue<InferredRest> : never : never : InferredLast : never;
-type Pipe<GenericAccumulator extends DCommon.AnyTuple, GenericOutput extends unknown> = (this: never, input: Awaited<ComputeLastUsableValue<GenericAccumulator>>) => GenericOutput;
+type Pipe<GenericAccumulator extends DCommon.AnyTuple, GenericOutput extends unknown> = (this: never, input: Awaited<ComputeLastUsableValue<GenericAccumulator>>, argument: GenericAccumulator[0]) => GenericOutput;
 type IsMaybePromise<GenericAccumulator extends DCommon.AnyTuple> = {
     [Index in keyof GenericAccumulator]: UnwrapFlowControllerResult<GenericAccumulator[Index]> extends infer InferredResult ? DCommon.IsExtends<InferredResult, Promise<unknown>> extends true ? false : DCommon.ContainExtends<InferredResult, Promise<any>> : never;
 }[number] extends false ? false : true;

package/dist/invocation/flow/base.mjs

@@ -4,14 +4,14 @@ import { flowControllerExitKind, flowControllerKind } from "./controller/base.mj
 //#region scripts/invocation/flow/base.ts
 function flow(...args) {
 	const accumulateFunction = args.reduce((accumulator, currentValue) => {
-		if (flowControllerKind.has(currentValue)) return (arg) => currentValue.exec(() => accumulator(arg));
+		if (flowControllerKind.has(currentValue)) return (input, argument) => currentValue.exec(() => accumulator(input, argument));
 		else {
-			const preparedResultTreatment = (result) => flowControllerExitKind.has(result) ? result : currentValue(result);
-			return (arg) => callThen(accumulator(arg), preparedResultTreatment);
+			const preparedResultTreatment = (result, argument) => flowControllerExitKind.has(result) ? result : currentValue(result, argument);
+			return (input, argument) => callThen(accumulator(input, argument), (result) => preparedResultTreatment(result, argument));
 		}
 	}, forward);
 	const preparedResultTreatment = (result) => flowControllerExitKind.has(result) ? flowControllerExitKind.getValue(result) : result;
-	return (arg) => callThen(accumulateFunction(arg), preparedResultTreatment);
+	return (input) => callThen(accumulateFunction(input, input), preparedResultTreatment);
 }
 //#endregion
 export { flow };

package/dist/invocation/flow/controller/defaults/debounce.cjs

@@ -16,7 +16,7 @@ const debounce = require_base.createFlowController(flowControllerDebounceKind, (
 		lastEvent?.resolve(false);
 		lastEvent = require_externalPromise.createExternalPromise();
 		lastTimeout = setTimeout(() => lastEvent?.resolve(true), formattedDebounceTime);
-		if (!await lastEvent.promise) return exitFlow(require_create.left("debounce-reject"));
+		if (!await lastEvent.promise) return exitFlow(require_create.left("debounce-reject", void 0));
 		return result;
 	});
 });

package/dist/invocation/flow/controller/defaults/debounce.mjs

@@ -16,7 +16,7 @@ const debounce = createFlowController(flowControllerDebounceKind, ({ init, exitF
 		lastEvent?.resolve(false);
 		lastEvent = createExternalPromise();
 		lastTimeout = setTimeout(() => lastEvent?.resolve(true), formattedDebounceTime);
-		if (!await lastEvent.promise) return exitFlow(left("debounce-reject"));
+		if (!await lastEvent.promise) return exitFlow(left("debounce-reject", void 0));
 		return result;
 	});
 });

package/dist/invocation/flow/controller/defaults/throttling.cjs

@@ -15,7 +15,7 @@ const throttling = require_base.createFlowController(flowControllerThrottlingKin
 		if (Date.now() - lastTime < formattedThrottlingTime) {
 			lastEvent?.resolve(false);
 			lastEvent = require_externalPromise.createExternalPromise();
-			if (!await lastEvent.promise) return exitFlow(require_create.left("throttling-reject"));
+			if (!await lastEvent.promise) return exitFlow(require_create.left("throttling-reject", void 0));
 		}
 		setTimeout(() => lastEvent?.resolve(true), formattedThrottlingTime);
 		lastTime = Date.now();

package/dist/invocation/flow/controller/defaults/throttling.mjs

@@ -15,7 +15,7 @@ const throttling = createFlowController(flowControllerThrottlingKind, ({ init, e
 		if (Date.now() - lastTime < formattedThrottlingTime) {
 			lastEvent?.resolve(false);
 			lastEvent = createExternalPromise();
-			if (!await lastEvent.promise) return exitFlow(left("throttling-reject"));
+			if (!await lastEvent.promise) return exitFlow(left("throttling-reject", void 0));
 		}
 		setTimeout(() => lastEvent?.resolve(true), formattedThrottlingTime);
 		lastTime = Date.now();

package/dist/invocation/index.cjs

@@ -10,7 +10,9 @@ const require_throttling = require("./flow/controller/defaults/throttling.cjs");
 const require_timeout = require("./flow/controller/defaults/timeout.cjs");
 const require_base$1 = require("./flow/base.cjs");
 const require_port = require("./port.cjs");
-const require_useCase = require("./useCase.cjs");
+const require_reader = require("./reader.cjs");
+const require_resolver = require("./resolver.cjs");
+const require_signature = require("./signature.cjs");
 //#region scripts/invocation/index.ts
 var invocation_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	AbortErrorFlowController: () => require_aborter.AbortErrorFlowController,
@@ -19,7 +21,8 @@ var invocation_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	createFlowController: () => require_base.createFlowController,
 	createKind: () => require_kind.createKind,
 	createPort: () => require_port.createPort,
-	createUseCase: () => require_useCase.createUseCase,
+	createReader: () => require_reader.createReader,
+	createResolver: () => require_resolver.createResolver,
 	debounce: () => require_debounce.debounce,
 	evidenceResult: () => require_evidence.evidenceResult,
 	filter: () => require_filter.filter,
@@ -33,11 +36,14 @@ var invocation_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	flowControllerThrottlingKind: () => require_throttling.flowControllerThrottlingKind,
 	flowControllerTimeoutKind: () => require_timeout.flowControllerTimeoutKind,
 	portHandlerKind: () => require_port.portHandlerKind,
+	readerKind: () => require_reader.readerKind,
+	resolveReaders: () => require_reader.resolveReaders,
+	resolverKind: () => require_resolver.resolverKind,
 	retry: () => require_retry.retry,
+	signatureKind: () => require_signature.signatureKind,
+	signedFunction: () => require_signature.signedFunction,
 	throttling: () => require_throttling.throttling,
-	timeout: () => require_timeout.timeout,
-	useCaseHandlerKind: () => require_useCase.useCaseHandlerKind,
-	wireUseCases: () => require_useCase.wireUseCases
+	timeout: () => require_timeout.timeout
 });
 //#endregion
 exports.AbortErrorFlowController = require_aborter.AbortErrorFlowController;
@@ -46,7 +52,8 @@ exports.appendEvidence = require_evidence.appendEvidence;
 exports.createFlowController = require_base.createFlowController;
 exports.createKind = require_kind.createKind;
 exports.createPort = require_port.createPort;
-exports.createUseCase = require_useCase.createUseCase;
+exports.createReader = require_reader.createReader;
+exports.createResolver = require_resolver.createResolver;
 exports.debounce = require_debounce.debounce;
 exports.evidenceResult = require_evidence.evidenceResult;
 exports.filter = require_filter.filter;
@@ -66,8 +73,11 @@ Object.defineProperty(exports, "invocation_exports", {
 	}
 });
 exports.portHandlerKind = require_port.portHandlerKind;
+exports.readerKind = require_reader.readerKind;
+exports.resolveReaders = require_reader.resolveReaders;
+exports.resolverKind = require_resolver.resolverKind;
 exports.retry = require_retry.retry;
+exports.signatureKind = require_signature.signatureKind;
+exports.signedFunction = require_signature.signedFunction;
 exports.throttling = require_throttling.throttling;
 exports.timeout = require_timeout.timeout;
-exports.useCaseHandlerKind = require_useCase.useCaseHandlerKind;
-exports.wireUseCases = require_useCase.wireUseCases;

package/dist/invocation/index.d.ts

@@ -2,4 +2,6 @@ export * from './evidence';
 export * from './flow';
 export * from './kind';
 export * from './port';
-export * from './useCase';
+export * from './reader';
+export * from './resolver';
+export * from './signature';

package/dist/invocation/index.mjs

@@ -10,7 +10,9 @@ import { flowControllerThrottlingKind, throttling } from "./flow/controller/defa
 import { flowControllerTimeoutKind, timeout } from "./flow/controller/defaults/timeout.mjs";
 import { flow } from "./flow/base.mjs";
 import { createPort, portHandlerKind } from "./port.mjs";
-import { createUseCase, useCaseHandlerKind, wireUseCases } from "./useCase.mjs";
+import { createReader, readerKind, resolveReaders } from "./reader.mjs";
+import { createResolver, resolverKind } from "./resolver.mjs";
+import { signatureKind, signedFunction } from "./signature.mjs";
 //#region scripts/invocation/index.ts
 var invocation_exports = /* @__PURE__ */ __exportAll({
 	AbortErrorFlowController: () => AbortErrorFlowController,
@@ -19,7 +21,8 @@ var invocation_exports = /* @__PURE__ */ __exportAll({
 	createFlowController: () => createFlowController,
 	createKind: () => createKind,
 	createPort: () => createPort,
-	createUseCase: () => createUseCase,
+	createReader: () => createReader,
+	createResolver: () => createResolver,
 	debounce: () => debounce,
 	evidenceResult: () => evidenceResult,
 	filter: () => filter,
@@ -33,11 +36,14 @@ var invocation_exports = /* @__PURE__ */ __exportAll({
 	flowControllerThrottlingKind: () => flowControllerThrottlingKind,
 	flowControllerTimeoutKind: () => flowControllerTimeoutKind,
 	portHandlerKind: () => portHandlerKind,
+	readerKind: () => readerKind,
+	resolveReaders: () => resolveReaders,
+	resolverKind: () => resolverKind,
 	retry: () => retry,
+	signatureKind: () => signatureKind,
+	signedFunction: () => signedFunction,
 	throttling: () => throttling,
-	timeout: () => timeout,
-	useCaseHandlerKind: () => useCaseHandlerKind,
-	wireUseCases: () => wireUseCases
+	timeout: () => timeout
 });
 //#endregion
-export { AbortErrorFlowController, aborter, appendEvidence, createFlowController, createKind, createPort, createUseCase, debounce, evidenceResult, filter, flow, flowControllerAborterKind, flowControllerDebounceKind, flowControllerExitKind, flowControllerFilterKind, flowControllerKind, flowControllerRetryKind, flowControllerThrottlingKind, flowControllerTimeoutKind, invocation_exports, portHandlerKind, retry, throttling, timeout, useCaseHandlerKind, wireUseCases };
+export { AbortErrorFlowController, aborter, appendEvidence, createFlowController, createKind, createPort, createReader, createResolver, debounce, evidenceResult, filter, flow, flowControllerAborterKind, flowControllerDebounceKind, flowControllerExitKind, flowControllerFilterKind, flowControllerKind, flowControllerRetryKind, flowControllerThrottlingKind, flowControllerTimeoutKind, invocation_exports, portHandlerKind, readerKind, resolveReaders, resolverKind, retry, signatureKind, signedFunction, throttling, timeout };

package/dist/invocation/reader.cjs

@@ -0,0 +1,30 @@
+const require_entries = require("../object/entries.cjs");
+const require_entry = require("../object/entry.cjs");
+const require_fromEntries = require("../object/fromEntries.cjs");
+const require_map = require("../array/map.cjs");
+const require_forward = require("../common/forward.cjs");
+const require_pipe = require("../common/pipe.cjs");
+const require_replace = require("../string/replace.cjs");
+const require_uncapitalize = require("../string/uncapitalize.cjs");
+//#region scripts/invocation/reader.ts
+const readerKind = require("./kind.cjs").createKind("reader");
+function formatPortName(value) {
+	return require_pipe.pipe(value, require_uncapitalize.uncapitalize, require_replace.replace(/Port$/, ""));
+}
+function createReader(dependencies, read) {
+	return {
+		dependencies,
+		run: (injectedDependencies) => read(require_pipe.pipe(require_forward.forward(dependencies), require_entries.entries, require_map.map(([key, value]) => {
+			const formattedKey = readerKind.has(value) ? require_uncapitalize.uncapitalize(key) : formatPortName(key);
+			return require_entry.entry(formattedKey, readerKind.has(value) && !injectedDependencies[formattedKey] ? value.run(injectedDependencies) : injectedDependencies[formattedKey]);
+		}), require_fromEntries.fromEntries)),
+		[readerKind.runTimeKey]: null
+	};
+}
+function resolveReaders(readers, ports) {
+	return require_pipe.pipe(readers, require_entries.entries, require_map.map(([key, reader]) => require_entry.entry(require_uncapitalize.uncapitalize(key), reader.run(ports))), require_fromEntries.fromEntries);
+}
+//#endregion
+exports.createReader = createReader;
+exports.readerKind = readerKind;
+exports.resolveReaders = resolveReaders;

package/dist/invocation/reader.d.ts

@@ -0,0 +1,30 @@
+import { PortHandler } from './port';
+import * as DCommon from '../common';
+import type * as DKind from '../kind';
+type FormatPortName<GenericValue extends string> = Uncapitalize<GenericValue> extends infer InferredResult extends string ? InferredResult extends `${infer InferredName}Port` ? InferredName : InferredResult : never;
+export type ReaderDependencies = Record<string, Reader | PortHandler>;
+export type ReaderDependenciesValue<GenericDependencies extends ReaderDependencies> = DCommon.SimplifyTopLevel<{
+    [Prop in keyof GenericDependencies as (GenericDependencies[Prop] extends PortHandler ? FormatPortName<Extract<Prop, string>> : Uncapitalize<Extract<Prop, string>>)]: GenericDependencies[Prop] extends PortHandler ? ReturnType<GenericDependencies[Prop]["createImplementation"]> : GenericDependencies[Prop] extends Reader ? ReturnType<GenericDependencies[Prop]["run"]> : never;
+}>;
+export type GetAllPorts<GenericDependenciesValue extends ReaderDependencies> = GenericDependenciesValue extends any ? ({
+    [Prop in keyof GenericDependenciesValue]: (GenericDependenciesValue[Prop] extends PortHandler ? [
+        FormatPortName<Extract<Prop, string>>,
+        ReturnType<GenericDependenciesValue[Prop]["createImplementation"]>
+    ] : GenericDependenciesValue[Prop] extends Reader ? GetAllPorts<GenericDependenciesValue[Prop]["dependencies"]> : never);
+})[keyof GenericDependenciesValue] : never;
+export declare const readerKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/reader", unknown>>;
+export interface Reader<GenericDependencies extends ReaderDependencies = ReaderDependencies, GenericOutput extends unknown = unknown> extends DKind.Kind<typeof readerKind> {
+    dependencies: GenericDependencies;
+    run(ports: DCommon.SimplifyTopLevel<(GetAllPorts<GenericDependencies> extends infer InferredEntriesDependenciesValue extends DCommon.ObjectEntry ? {
+        [Entry in InferredEntriesDependenciesValue as Entry[0]]: Entry[1];
+    } : never) & ({
+        [Prop in keyof GenericDependencies as GenericDependencies[Prop] extends Reader ? Uncapitalize<Extract<Prop, string>> : never]?: GenericDependencies[Prop] extends Reader ? ReturnType<GenericDependencies[Prop]["run"]> : never;
+    })>): GenericOutput;
+}
+export declare function createReader<const GenericDependencies extends ReaderDependencies, GenericOutput extends unknown>(dependencies: GenericDependencies, read: (dependenciesValue: ReaderDependenciesValue<GenericDependencies>) => GenericOutput): Reader<GenericDependencies, GenericOutput>;
+export declare function resolveReaders<GenericReaders extends Record<string, Reader>>(readers: GenericReaders, ports: DCommon.SimplifyTopLevel<DCommon.UnionToIntersection<{
+    [Prop in keyof GenericReaders]: GetAllPorts<GenericReaders[Prop]["dependencies"]> extends infer InferredEntriesDependenciesValue extends DCommon.ObjectEntry ? {
+        [Entry in InferredEntriesDependenciesValue as Entry[0]]: Entry[1];
+    } : never;
+}[keyof GenericReaders]>>): ReaderDependenciesValue<GenericReaders>;
+export {};

package/dist/invocation/reader.mjs

@@ -0,0 +1,29 @@
+import { entries } from "../object/entries.mjs";
+import { entry } from "../object/entry.mjs";
+import { fromEntries } from "../object/fromEntries.mjs";
+import { map } from "../array/map.mjs";
+import { forward } from "../common/forward.mjs";
+import { pipe } from "../common/pipe.mjs";
+import { replace } from "../string/replace.mjs";
+import { uncapitalize } from "../string/uncapitalize.mjs";
+import { createKind } from "./kind.mjs";
+//#region scripts/invocation/reader.ts
+const readerKind = createKind("reader");
+function formatPortName(value) {
+	return pipe(value, uncapitalize, replace(/Port$/, ""));
+}
+function createReader(dependencies, read) {
+	return {
+		dependencies,
+		run: (injectedDependencies) => read(pipe(forward(dependencies), entries, map(([key, value]) => {
+			const formattedKey = readerKind.has(value) ? uncapitalize(key) : formatPortName(key);
+			return entry(formattedKey, readerKind.has(value) && !injectedDependencies[formattedKey] ? value.run(injectedDependencies) : injectedDependencies[formattedKey]);
+		}), fromEntries)),
+		[readerKind.runTimeKey]: null
+	};
+}
+function resolveReaders(readers, ports) {
+	return pipe(readers, entries, map(([key, reader]) => entry(uncapitalize(key), reader.run(ports))), fromEntries);
+}
+//#endregion
+export { createReader, readerKind, resolveReaders };

package/dist/invocation/resolver.cjs

@@ -0,0 +1,31 @@
+const require_callThen = require("../common/callThen.cjs");
+const require_create = require("../either/left/create.cjs");
+const require_is = require("../either/left/is.cjs");
+const require_create$1 = require("../either/right/create.cjs");
+//#region scripts/invocation/resolver.ts
+const resolverKind = require("./kind.cjs").createKind("resolver");
+function createResolver(value) {
+	function resolve(subscribers, whenError) {
+		return Promise.resolve().then(() => Object.values(subscribers).reduce((accumulator, element) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
+			if (require_is.isLeft(awaitedAccumulator)) return awaitedAccumulator;
+			return element(value);
+		}), null)).then((result) => {
+			if (require_is.isLeft(result)) return require_callThen.callThen(whenError(result, value), (output) => require_create.left("resolve-error", output));
+			return require_create$1.right("resolve-success", value);
+		});
+	}
+	function runAndResolve(theFunction, subscribers, whenError) {
+		return Promise.resolve().then(() => theFunction(value)).then((result) => {
+			if (require_is.isLeft(result)) return require_callThen.callThen(whenError(result, value), (output) => require_create.left("resolve-error", output));
+			return resolve(subscribers, whenError);
+		});
+	}
+	return () => ({
+		resolve,
+		runAndResolve,
+		[resolverKind.runTimeKey]: null
+	});
+}
+//#endregion
+exports.createResolver = createResolver;
+exports.resolverKind = resolverKind;

package/dist/invocation/resolver.d.ts

@@ -0,0 +1,14 @@
+import * as DCommon from '../common';
+import type * as DKind from '../kind';
+import type * as DObject from '../object';
+import * as DEither from '../either';
+export declare const resolverKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/resolver", unknown>>;
+export interface Resolver<GenericValue extends unknown = unknown, GenericSubscribers extends Record<string, (value: GenericValue) => unknown> = Record<string, (value: GenericValue) => unknown>> extends DKind.Kind<typeof resolverKind> {
+    runAndResolve<GenericOutput extends DCommon.MaybePromise<DEither.Right | DEither.Left | undefined | DCommon.EscapeVoid>, const GenericWrapperSubscribers extends GenericSubscribers, GenericOutputHandlerLeft extends unknown = never>(theFunction: (value: GenericValue) => GenericOutput, subscribers: GenericWrapperSubscribers, ...args: (DCommon.ContainExtends<Extract<Awaited<GenericOutput> | Awaited<ReturnType<DObject.Values<GenericWrapperSubscribers>>>, DEither.Left>, DEither.Left> extends true ? [
+        whenLeft: (result: Extract<Awaited<GenericOutput> | Awaited<ReturnType<DObject.Values<GenericWrapperSubscribers>>>, DEither.Left>, value: GenericValue) => GenericOutputHandlerLeft
+    ] : [])): Promise<(DCommon.IsNever<GenericOutputHandlerLeft> extends true ? never : DEither.Left<"resolve-error", Awaited<GenericOutputHandlerLeft>>) | DEither.Right<"resolve-success", GenericValue>>;
+    resolve<const GenericWrapperSubscribers extends GenericSubscribers, GenericOutputHandlerLeft extends unknown = never>(subscribers: GenericWrapperSubscribers, ...args: (DCommon.ContainExtends<Extract<Awaited<ReturnType<DObject.Values<GenericWrapperSubscribers>>>, DEither.Left>, DEither.Left> extends true ? [
+        whenLeft: (result: Extract<Awaited<ReturnType<DObject.Values<GenericWrapperSubscribers>>>, DEither.Left>, value: GenericValue) => GenericOutputHandlerLeft
+    ] : [])): Promise<(DCommon.IsNever<GenericOutputHandlerLeft> extends true ? never : DEither.Left<"resolve-error", Awaited<GenericOutputHandlerLeft>>) | DEither.Right<"resolve-success", GenericValue>>;
+}
+export declare function createResolver<const GenericValue extends unknown>(value: GenericValue): <GenericSubscribers extends (Record<string, (value: GenericValue) => unknown> | DCommon.AnyTuple<string>)>() => Resolver<GenericValue, GenericSubscribers extends readonly string[] ? Record<GenericSubscribers[number], (value: GenericValue) => unknown> : GenericSubscribers>;

package/dist/invocation/resolver.mjs

@@ -0,0 +1,31 @@
+import { callThen } from "../common/callThen.mjs";
+import { left } from "../either/left/create.mjs";
+import { isLeft } from "../either/left/is.mjs";
+import { right } from "../either/right/create.mjs";
+import { createKind } from "./kind.mjs";
+//#region scripts/invocation/resolver.ts
+const resolverKind = createKind("resolver");
+function createResolver(value) {
+	function resolve(subscribers, whenError) {
+		return Promise.resolve().then(() => Object.values(subscribers).reduce((accumulator, element) => callThen(accumulator, (awaitedAccumulator) => {
+			if (isLeft(awaitedAccumulator)) return awaitedAccumulator;
+			return element(value);
+		}), null)).then((result) => {
+			if (isLeft(result)) return callThen(whenError(result, value), (output) => left("resolve-error", output));
+			return right("resolve-success", value);
+		});
+	}
+	function runAndResolve(theFunction, subscribers, whenError) {
+		return Promise.resolve().then(() => theFunction(value)).then((result) => {
+			if (isLeft(result)) return callThen(whenError(result, value), (output) => left("resolve-error", output));
+			return resolve(subscribers, whenError);
+		});
+	}
+	return () => ({
+		resolve,
+		runAndResolve,
+		[resolverKind.runTimeKey]: null
+	});
+}
+//#endregion
+export { createResolver, resolverKind };

package/dist/invocation/signature.cjs

@@ -0,0 +1,8 @@
+//#region scripts/invocation/signature.ts
+const signatureKind = require("./kind.cjs").createKind("signature");
+function signedFunction(name, theFunction) {
+	return signatureKind.setTo(theFunction, name);
+}
+//#endregion
+exports.signatureKind = signatureKind;
+exports.signedFunction = signedFunction;

package/dist/invocation/signature.d.ts

@@ -0,0 +1,7 @@
+import type * as DCommon from '../common';
+import type * as DKind from '../kind';
+export declare const signatureKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/signature", string>>;
+export interface Signature<GenericName extends string = string> extends DKind.Kind<typeof signatureKind, GenericName> {
+}
+export type SignedFunction<GenericName extends string = string, GenericFunction extends DCommon.AnyFunction = DCommon.AnyFunction> = (Signature<GenericName> & GenericFunction);
+export declare function signedFunction<GenericName extends string, GenericFunction extends DCommon.AnyFunction>(name: NoInfer<GenericName>, theFunction: NoInfer<GenericFunction>): SignedFunction<GenericName, GenericFunction>;

package/dist/invocation/signature.mjs

@@ -0,0 +1,8 @@
+import { createKind } from "./kind.mjs";
+//#region scripts/invocation/signature.ts
+const signatureKind = createKind("signature");
+function signedFunction(name, theFunction) {
+	return signatureKind.setTo(theFunction, name);
+}
+//#endregion
+export { signatureKind, signedFunction };

package/dist/modeling/entity/base.cjs

@@ -4,15 +4,15 @@ const require_create$1 = require("../../either/right/create.cjs");
 const require_justExec = require("../../common/justExec.cjs");
 const require_memo = require("../../common/memo.cjs");
 const require_resultSymbol = require("../../dataStructure/common/resultSymbol.cjs");
-const require_error = require("../../dataStructure/common/error.cjs");
-const require_base = require("../../dataStructure/structure/base.cjs");
+const require_base = require("../../dataStructure/common/error/base.cjs");
+const require_base$1 = require("../../dataStructure/structure/base.cjs");
 const require_nonEncodableString = require("../../dataStructure/structure/defaults/nonEncodableString.cjs");
 const require_object = require("../../dataStructure/structure/defaults/object.cjs");
 const require_kind = require("../kind.cjs");
 //#region scripts/modeling/entity/base.ts
 const entityKind = require_kind.createKind("entity");
 const entityStructureKind = require_kind.createKind("entity-structure");
-const EntityStructure = require_base.createStructure(entityStructureKind, ({ init }) => (name, shape) => init({
+const EntityStructure = require_base$1.createStructure(entityStructureKind, ({ init }) => (name, shape) => init({
 	inner: require_memo.memo(() => require_object.ObjectStructure({
 		...shape(),
 		[entityKind.runTimeKey]: require_nonEncodableString.NonEncodableStringStructure(name)
@@ -22,6 +22,7 @@ const EntityStructure = require_base.createStructure(entityStructureKind, ({ ini
 	executeCheck: (self, data, errorHandler) => self.definition.inner.value.executeCheck(data, errorHandler),
 	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeEncode(codecContext, data, errorHandler),
 	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeDecode(codecContext, data, errorHandler),
+	executeParse: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeParse(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.inner.value.isAsynchronous()
 }, {
 	name,
@@ -34,24 +35,24 @@ const EntityStructure = require_base.createStructure(entityStructureKind, ({ ini
 			const [codecs] = args;
 			return (value) => self.decodeMap(codecs, value);
 		}
-		const errorHandler = require_error.createGetErrorHandler();
+		const errorHandler = require_base.createGetErrorHandler();
 		const [codecs, data] = args;
 		const result = self.executeDecode(codecs.context.value, require_isSimple.isSimple(data) ? {
 			...data,
 			[entityKind.runTimeKey]: name
 		} : data, errorHandler);
-		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result instanceof Promise) return require_create.left("async-error", new require_base.ErrorPromise());
 		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 		return require_create$1.right("map-success", result);
 	},
 	map: (self, data) => {
-		const errorHandler = require_error.createGetErrorHandler();
+		const errorHandler = require_base.createGetErrorHandler();
 		const formattedData = require_isSimple.isSimple(data) ? {
 			...data,
 			[entityKind.runTimeKey]: name
 		} : data;
 		const result = self.executeCheck(formattedData, errorHandler);
-		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result instanceof Promise) return require_create.left("async-error", new require_base.ErrorPromise());
 		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 		return require_create$1.right("map-success", formattedData);
 	},
@@ -61,7 +62,7 @@ const EntityStructure = require_base.createStructure(entityStructureKind, ({ ini
 			return (value) => self.asyncDecodeMap(codecs, value);
 		}
 		return require_justExec.justExec(async () => {
-			const errorHandler = require_error.createGetErrorHandler();
+			const errorHandler = require_base.createGetErrorHandler();
 			const [codecs, data] = args;
 			const result = await self.executeDecode(codecs.context.value, require_isSimple.isSimple(data) ? {
 				...data,
@@ -71,15 +72,25 @@ const EntityStructure = require_base.createStructure(entityStructureKind, ({ ini
 			return require_create$1.right("map-success", result);
 		});
 	},
-	asyncMap: (self, data) => require_justExec.justExec(async () => {
-		const errorHandler = require_error.createGetErrorHandler();
+	asyncMap: async (self, data) => {
+		const errorHandler = require_base.createGetErrorHandler();
 		const formattedData = require_isSimple.isSimple(data) ? {
 			...data,
 			[entityKind.runTimeKey]: name
 		} : data;
 		if (await self.executeCheck(formattedData, errorHandler) === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 		return require_create$1.right("map-success", formattedData);
-	})
+	},
+	update: (self, ...args) => {
+		if (args.length === 1) {
+			const [update] = args;
+			return (input) => self.update(input, update);
+		}
+		const [input, update] = args;
+		const updatedEntity = { [entityKind.runTimeKey]: name };
+		for (const key of self.definition.inner.value.definition.keys) updatedEntity[key] = update[key] === void 0 ? input[key] : update[key];
+		return updatedEntity;
+	}
 }));
 //#endregion
 exports.EntityStructure = EntityStructure;