@duplojs/lang 0.0.0 → 0.0.1-beta.10

package/dist/index.mjs

@@ -14,6 +14,8 @@ import { callThen } from "./common/callThen.mjs";
 import { object_exports } from "./object/index.mjs";
 import { clone } from "./common/clone.mjs";
 import { cast, shameOnYou } from "./common/constraint/cast/index.mjs";
+import { infer } from "./common/constraint/infer/index.mjs";
+import { removeConstraint } from "./common/constraint/remove.mjs";
 import { detachObjectMethod } from "./common/detachObjectMethod.mjs";
 import { createEnum } from "./common/enum.mjs";
 import { equal } from "./common/equal.mjs";
@@ -59,12 +61,12 @@ import { when } from "./common/when.mjs";
 import { whenElse } from "./common/whenElse.mjs";
 import { whenNot } from "./common/whenNot.mjs";
 import { common_exports } from "./common/index.mjs";
+import { path_exports } from "./path/index.mjs";
 import { number_exports } from "./number/index.mjs";
 import { dataStructure_exports } from "./dataStructure/index.mjs";
 import { tuple_exports } from "./tuple/index.mjs";
 import { modeling_exports } from "./modeling/index.mjs";
 import { pattern_exports } from "./pattern/index.mjs";
 import { invocation_exports } from "./invocation/index.mjs";
-import { path_exports } from "./path/index.mjs";
 import { printer_exports } from "./printer/index.mjs";
-export { array_exports as A, AssertsError, chrono_exports as C, array_exports as DArray, chrono_exports as DChrono, common_exports as DCommon, dataStructure_exports as DDataStructure, either_exports as DEither, generator_exports as DGenerator, invocation_exports as DInvocation, kind_exports as DKind, modeling_exports as DModeling, number_exports as DNumber, object_exports as DObject, path_exports as DPath, pattern_exports as DPattern, printer_exports as DPrinter, dataStructure_exports as DS, string_exports as DString, tuple_exports as DTuple, either_exports as E, generator_exports as G, invocation_exports as I, InvalidBytesInStringError, InvalidMillisecondInStringError, modeling_exports as M, MissingBuilderMethodsError, number_exports as N, object_exports as O, pattern_exports as P, string_exports as S, tuple_exports as T, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };
+export { array_exports as A, AssertsError, chrono_exports as C, array_exports as DArray, chrono_exports as DChrono, common_exports as DCommon, dataStructure_exports as DDataStructure, either_exports as DEither, generator_exports as DGenerator, invocation_exports as DInvocation, kind_exports as DKind, modeling_exports as DModeling, number_exports as DNumber, object_exports as DObject, path_exports as DPath, pattern_exports as DPattern, printer_exports as DPrinter, dataStructure_exports as DS, string_exports as DString, tuple_exports as DTuple, either_exports as E, generator_exports as G, invocation_exports as I, InvalidBytesInStringError, InvalidMillisecondInStringError, modeling_exports as M, MissingBuilderMethodsError, number_exports as N, object_exports as O, pattern_exports as P, string_exports as S, tuple_exports as T, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, infer, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, removeConstraint, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };

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

@@ -1,12 +1,17 @@
-import { FlowControllerExit, FlowControllerResult, flowControllerExitKind, FlowControllerPreviousFunctionResult } from './controller';
-import { DKind } from '../../index.ts';
+import { FlowControllerExit, FlowControllerResult, flowControllerExitKind, FlowControllerPreviousFunctionResult, UnwrapFlowControllerResult } from './controller';
 import * as DCommon from '../../common';
+import type * as DKind from '../../kind';
 type ComputeLastUsableValue<GenericAccumulator extends DCommon.AnyTuple> = GenericAccumulator extends [
     ...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 ComputeTypeOutput<GenericAccumulator extends DCommon.AnyTuple> = Extract<(ComputeLastUsableValue<GenericAccumulator> | (GenericAccumulator[number] extends infer InferredPipeResult ? InferredPipeResult extends FlowControllerResult<infer InferredResult> ? InferredResult extends FlowControllerExit ? DKind.GetValue<typeof flowControllerExitKind, InferredResult> : InferredResult extends Promise<infer InferredExit extends FlowControllerExit> ? Promise<DKind.GetValue<typeof flowControllerExitKind, InferredExit>> : never : never : never)) extends infer InferredResult ? DCommon.ContainExtends<InferredResult, Promise<any>> extends true ? Promise<Awaited<InferredResult>> : InferredResult : never, any>;
+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;
+type ComputeTypeOutput<GenericAccumulator extends DCommon.AnyTuple> = Extract<(ComputeLastUsableValue<GenericAccumulator> | (UnwrapFlowControllerResult<GenericAccumulator[number]> extends infer InferredResult ? InferredResult extends FlowControllerExit ? DKind.GetValue<typeof flowControllerExitKind, InferredResult> : InferredResult extends Promise<infer InferredExit extends FlowControllerExit> ? Promise<DKind.GetValue<typeof flowControllerExitKind, InferredExit>> : InferredResult extends Promise<unknown> ? Promise<never> : never : never)) extends infer InferredResult ? DCommon.Or<[
+    DCommon.ContainExtends<InferredResult, Promise<any>>
+]> extends true ? IsMaybePromise<GenericAccumulator> extends true ? DCommon.MaybePromise<Awaited<InferredResult>> : Promise<Awaited<InferredResult>> : InferredResult : never, any>;
 export declare function flow<const GenericInput extends unknown, const GenericOutput1 extends unknown>(pipe1: Pipe<[
     GenericInput
 ], GenericOutput1>): (input: GenericInput) => DCommon.BreakGenericLink<Extract<ComputeTypeOutput<[

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

@@ -11,6 +11,7 @@ export type FlowControllerPreviousFunctionResult = DCommon.MaybePromise<(DCommon
 export interface FlowControllerResult<GenericResult extends unknown> {
     readonly [FlowControllerResultSymbol]: GenericResult;
 }
+export type UnwrapFlowControllerResult<GenericValue extends unknown> = GenericValue extends FlowControllerResult<infer InferredResult> ? InferredResult : GenericValue;
 export interface FlowController<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DKind.Kind<typeof flowControllerKind> {
     (this: never, input: GenericInput): FlowControllerResult<GenericOutput>;
     exec(previousFunction: () => FlowControllerPreviousFunctionResult): (FlowControllerPreviousFunctionResult | GenericOutput | DCommon.MergePromise<FlowControllerPreviousFunctionResult | GenericOutput>);

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

@@ -0,0 +1,38 @@
+const require_parentClass = require("../../../../kind/parentClass.cjs");
+const require_create = require("../../../../either/left/create.cjs");
+const require_stringToMillisecond = require("../../../../common/stringToMillisecond.cjs");
+const require_kind = require("../../../kind.cjs");
+const require_base = require("../base.cjs");
+//#region scripts/invocation/flow/controller/defaults/aborter.ts
+const flowControllerAborterKind = require_kind.createKind("flow-controller-aborter");
+var AbortErrorFlowController = class extends require_parentClass.parentClass(require_kind.createKind("abort-error-flow-controller"), Error) {
+	abortController;
+	constructor(abortController) {
+		super(null, "Flow is aborted by FlowControllerAborter.");
+		this.abortController = abortController;
+	}
+};
+const aborter = require_base.createFlowController(flowControllerAborterKind, ({ init, exitFlow }) => (theFunction, params) => {
+	let aborter = void 0;
+	const formattedTimeout = params?.timeout === void 0 ? void 0 : require_stringToMillisecond.stringToMillisecond(params.timeout);
+	return init(async (previousFunction) => {
+		const result = previousFunction();
+		if (require_base.flowControllerExitKind.has(result)) return result;
+		aborter?.abort(new AbortErrorFlowController(aborter));
+		const currentAborter = new AbortController();
+		aborter = currentAborter;
+		if (formattedTimeout !== void 0) setTimeout(() => void currentAborter.abort(new AbortErrorFlowController(currentAborter)), formattedTimeout);
+		try {
+			const abortResult = await theFunction(result, currentAborter);
+			if (currentAborter.signal.aborted === true) return exitFlow(require_create.left("signal-aborted", currentAborter.signal.reason));
+			return abortResult;
+		} catch (error) {
+			if (error instanceof AbortErrorFlowController) return exitFlow(require_create.left("signal-aborted", currentAborter.signal.reason));
+			throw error;
+		}
+	});
+});
+//#endregion
+exports.AbortErrorFlowController = AbortErrorFlowController;
+exports.aborter = aborter;
+exports.flowControllerAborterKind = flowControllerAborterKind;

package/dist/invocation/flow/controller/defaults/aborter.d.ts

@@ -0,0 +1,17 @@
+import { FlowController } from '../base';
+import * as DCommon from '../../../../common';
+import * as DKind from '../../../../kind';
+import * as DEither from '../../../../either';
+export declare const flowControllerAborterKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-aborter", unknown>>;
+export interface FlowControllerAborter<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<Awaited<GenericOutput> | DEither.Left<"signal-aborted", AbortErrorFlowController>>> & DKind.Kind<typeof flowControllerAborterKind>> {
+}
+declare const AbortErrorFlowController_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/abort-error-flow-controller", unknown>>, ErrorConstructor>;
+export declare class AbortErrorFlowController extends AbortErrorFlowController_base {
+    abortController: AbortController;
+    constructor(abortController: AbortController);
+}
+export interface FlowControllerAborterParams {
+    timeout?: DCommon.TimeInString;
+}
+export declare const aborter: <GenericInput extends unknown, GenericOutput extends unknown>(theFunction: (input: GenericInput, aborter: AbortController) => GenericOutput, params?: FlowControllerAborterParams) => FlowControllerAborter<GenericInput, GenericOutput>;
+export {};

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

@@ -0,0 +1,36 @@
+import { parentClass } from "../../../../kind/parentClass.mjs";
+import { left } from "../../../../either/left/create.mjs";
+import { stringToMillisecond } from "../../../../common/stringToMillisecond.mjs";
+import { createKind } from "../../../kind.mjs";
+import { createFlowController, flowControllerExitKind } from "../base.mjs";
+//#region scripts/invocation/flow/controller/defaults/aborter.ts
+const flowControllerAborterKind = createKind("flow-controller-aborter");
+var AbortErrorFlowController = class extends parentClass(createKind("abort-error-flow-controller"), Error) {
+	abortController;
+	constructor(abortController) {
+		super(null, "Flow is aborted by FlowControllerAborter.");
+		this.abortController = abortController;
+	}
+};
+const aborter = createFlowController(flowControllerAborterKind, ({ init, exitFlow }) => (theFunction, params) => {
+	let aborter = void 0;
+	const formattedTimeout = params?.timeout === void 0 ? void 0 : stringToMillisecond(params.timeout);
+	return init(async (previousFunction) => {
+		const result = previousFunction();
+		if (flowControllerExitKind.has(result)) return result;
+		aborter?.abort(new AbortErrorFlowController(aborter));
+		const currentAborter = new AbortController();
+		aborter = currentAborter;
+		if (formattedTimeout !== void 0) setTimeout(() => void currentAborter.abort(new AbortErrorFlowController(currentAborter)), formattedTimeout);
+		try {
+			const abortResult = await theFunction(result, currentAborter);
+			if (currentAborter.signal.aborted === true) return exitFlow(left("signal-aborted", currentAborter.signal.reason));
+			return abortResult;
+		} catch (error) {
+			if (error instanceof AbortErrorFlowController) return exitFlow(left("signal-aborted", currentAborter.signal.reason));
+			throw error;
+		}
+	});
+});
+//#endregion
+export { AbortErrorFlowController, aborter, flowControllerAborterKind };

package/dist/invocation/flow/controller/defaults/debounce.d.ts

@@ -3,6 +3,6 @@ import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 import * as DEither from '../../../../either';
 export declare const flowControllerDebounceKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-debounce", unknown>>;
-export interface FlowControllerDebounce<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<FlowControllerExit<DEither.Left<"debounce-reject">>>> & DKind.Kind<typeof flowControllerDebounceKind>> {
+export interface FlowControllerDebounce<GenericInput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<FlowControllerExit<DEither.Left<"debounce-reject">>>> & DKind.Kind<typeof flowControllerDebounceKind>> {
 }
 export declare const debounce: <GenericInput extends unknown = unknown>(debounce: DCommon.TimeInString) => FlowControllerDebounce<GenericInput>;

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

@@ -7,9 +7,11 @@ const require_base = require("../base.cjs");
 const flowControllerFilterKind = require_kind.createKind("flow-controller-filter");
 const filter = require_base.createFlowController(flowControllerFilterKind, ({ init, exitFlow }) => (filterFunction) => init((previousFunction) => require_callThen.callThen(previousFunction(), (result) => {
 	if (require_base.flowControllerExitKind.has(result)) return result;
-	const filterResult = require_unwrap.unwrapRight(filterFunction(result));
-	if (require_is.isLeft(filterResult)) return exitFlow(filterResult);
-	return filterResult;
+	return require_callThen.callThen(filterFunction(result), (filterResult) => {
+		const result = require_unwrap.unwrapRight(filterResult);
+		if (require_is.isLeft(result)) return exitFlow(result);
+		return result;
+	});
 })));
 //#endregion
 exports.filter = filter;

package/dist/invocation/flow/controller/defaults/filter.d.ts

@@ -3,6 +3,6 @@ import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 import * as DEither from '../../../../either';
 export declare const flowControllerFilterKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-filter", unknown>>;
-export interface FlowControllerFilter<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, GenericOutput extends DEither.Left ? FlowControllerExit<GenericOutput> : GenericOutput extends DEither.Right ? DEither.GetValue<GenericOutput> : GenericOutput> & DKind.Kind<typeof flowControllerFilterKind>> {
+export interface FlowControllerFilter<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, DCommon.SplitPromise<GenericOutput> extends infer InferredOutput ? InferredOutput extends unknown ? Awaited<InferredOutput> extends infer InferredAwaited ? (InferredAwaited extends DEither.Left ? FlowControllerExit<InferredAwaited> : InferredAwaited extends DEither.Right ? DEither.GetValue<InferredAwaited> : InferredAwaited) extends infer InferredResult ? InferredOutput extends Promise<unknown> ? Promise<InferredResult> : InferredResult : never : never : never : never> & DKind.Kind<typeof flowControllerFilterKind>> {
 }
 export declare const filter: <GenericInput extends unknown, GenericOutput extends unknown>(filterFunction: (input: GenericInput) => GenericOutput) => FlowControllerFilter<GenericInput, GenericOutput>;

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

@@ -7,9 +7,11 @@ import { createFlowController, flowControllerExitKind } from "../base.mjs";
 const flowControllerFilterKind = createKind("flow-controller-filter");
 const filter = createFlowController(flowControllerFilterKind, ({ init, exitFlow }) => (filterFunction) => init((previousFunction) => callThen(previousFunction(), (result) => {
 	if (flowControllerExitKind.has(result)) return result;
-	const filterResult = unwrapRight(filterFunction(result));
-	if (isLeft(filterResult)) return exitFlow(filterResult);
-	return filterResult;
+	return callThen(filterFunction(result), (filterResult) => {
+		const result = unwrapRight(filterResult);
+		if (isLeft(result)) return exitFlow(result);
+		return result;
+	});
 })));
 //#endregion
 export { filter, flowControllerFilterKind };

package/dist/invocation/flow/controller/defaults/index.d.ts

@@ -1,3 +1,4 @@
+export * from './aborter';
 export * from './debounce';
 export * from './filter';
 export * from './retry';

package/dist/invocation/flow/controller/defaults/retry.d.ts

@@ -2,7 +2,7 @@ import { FlowController } from '../base';
 import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 export declare const flowControllerRetryKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-retry", unknown>>;
-export interface FlowControllerRetry<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<never>> & DKind.Kind<typeof flowControllerRetryKind>> {
+export interface FlowControllerRetry<GenericInput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<never>> & DKind.Kind<typeof flowControllerRetryKind>> {
 }
 export interface RetryParams {
     times?: number;

package/dist/invocation/flow/controller/defaults/throttling.d.ts

@@ -3,6 +3,6 @@ import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 import * as DEither from '../../../../either';
 export declare const flowControllerThrottlingKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-throttling", unknown>>;
-export interface FlowControllerThrottling<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<FlowControllerExit<DEither.Left<"throttling-reject">>>> & DKind.Kind<typeof flowControllerThrottlingKind>> {
+export interface FlowControllerThrottling<GenericInput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<FlowControllerExit<DEither.Left<"throttling-reject">>>> & DKind.Kind<typeof flowControllerThrottlingKind>> {
 }
 export declare const throttling: <GenericInput extends unknown = unknown>(throttling: DCommon.TimeInString) => FlowControllerThrottling<GenericInput>;

package/dist/invocation/flow/controller/defaults/timeout.d.ts

@@ -2,6 +2,6 @@ import { FlowController } from '../base';
 import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 export declare const flowControllerTimeoutKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-timeout", unknown>>;
-export interface FlowControllerTimeout<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<never>> & DKind.Kind<typeof flowControllerTimeoutKind>> {
+export interface FlowControllerTimeout<GenericInput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<never>> & DKind.Kind<typeof flowControllerTimeoutKind>> {
 }
 export declare const timeout: <GenericInput extends unknown = unknown>(timeout: DCommon.TimeInString) => FlowControllerTimeout<GenericInput>;

package/dist/invocation/index.cjs

@@ -2,6 +2,7 @@ const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_evidence = require("./evidence.cjs");
 const require_kind = require("./kind.cjs");
 const require_base = require("./flow/controller/base.cjs");
+const require_aborter = require("./flow/controller/defaults/aborter.cjs");
 const require_debounce = require("./flow/controller/defaults/debounce.cjs");
 const require_filter = require("./flow/controller/defaults/filter.cjs");
 const require_retry = require("./flow/controller/defaults/retry.cjs");
@@ -9,18 +10,21 @@ 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");
 //#region scripts/invocation/index.ts
 var invocation_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	AbortErrorFlowController: () => require_aborter.AbortErrorFlowController,
+	aborter: () => require_aborter.aborter,
 	appendEvidence: () => require_evidence.appendEvidence,
 	createFlowController: () => require_base.createFlowController,
 	createKind: () => require_kind.createKind,
 	createPort: () => require_port.createPort,
-	createUseCase: () => require_useCase.createUseCase,
+	createReader: () => require_reader.createReader,
 	debounce: () => require_debounce.debounce,
 	evidenceResult: () => require_evidence.evidenceResult,
 	filter: () => require_filter.filter,
 	flow: () => require_base$1.flow,
+	flowControllerAborterKind: () => require_aborter.flowControllerAborterKind,
 	flowControllerDebounceKind: () => require_debounce.flowControllerDebounceKind,
 	flowControllerExitKind: () => require_base.flowControllerExitKind,
 	flowControllerFilterKind: () => require_filter.flowControllerFilterKind,
@@ -29,22 +33,25 @@ 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,
 	retry: () => require_retry.retry,
 	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;
+exports.aborter = require_aborter.aborter;
 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.debounce = require_debounce.debounce;
 exports.evidenceResult = require_evidence.evidenceResult;
 exports.filter = require_filter.filter;
 exports.flow = require_base$1.flow;
+exports.flowControllerAborterKind = require_aborter.flowControllerAborterKind;
 exports.flowControllerDebounceKind = require_debounce.flowControllerDebounceKind;
 exports.flowControllerExitKind = require_base.flowControllerExitKind;
 exports.flowControllerFilterKind = require_filter.flowControllerFilterKind;
@@ -59,8 +66,8 @@ Object.defineProperty(exports, "invocation_exports", {
 	}
 });
 exports.portHandlerKind = require_port.portHandlerKind;
+exports.readerKind = require_reader.readerKind;
+exports.resolveReaders = require_reader.resolveReaders;
 exports.retry = require_retry.retry;
 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,4 @@ export * from './evidence';
 export * from './flow';
 export * from './kind';
 export * from './port';
-export * from './useCase';
+export * from './reader';

package/dist/invocation/index.mjs

@@ -2,6 +2,7 @@ import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { appendEvidence, evidenceResult } from "./evidence.mjs";
 import { createKind } from "./kind.mjs";
 import { createFlowController, flowControllerExitKind, flowControllerKind } from "./flow/controller/base.mjs";
+import { AbortErrorFlowController, aborter, flowControllerAborterKind } from "./flow/controller/defaults/aborter.mjs";
 import { debounce, flowControllerDebounceKind } from "./flow/controller/defaults/debounce.mjs";
 import { filter, flowControllerFilterKind } from "./flow/controller/defaults/filter.mjs";
 import { flowControllerRetryKind, retry } from "./flow/controller/defaults/retry.mjs";
@@ -9,18 +10,21 @@ 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";
 //#region scripts/invocation/index.ts
 var invocation_exports = /* @__PURE__ */ __exportAll({
+	AbortErrorFlowController: () => AbortErrorFlowController,
+	aborter: () => aborter,
 	appendEvidence: () => appendEvidence,
 	createFlowController: () => createFlowController,
 	createKind: () => createKind,
 	createPort: () => createPort,
-	createUseCase: () => createUseCase,
+	createReader: () => createReader,
 	debounce: () => debounce,
 	evidenceResult: () => evidenceResult,
 	filter: () => filter,
 	flow: () => flow,
+	flowControllerAborterKind: () => flowControllerAborterKind,
 	flowControllerDebounceKind: () => flowControllerDebounceKind,
 	flowControllerExitKind: () => flowControllerExitKind,
 	flowControllerFilterKind: () => flowControllerFilterKind,
@@ -29,11 +33,11 @@ var invocation_exports = /* @__PURE__ */ __exportAll({
 	flowControllerThrottlingKind: () => flowControllerThrottlingKind,
 	flowControllerTimeoutKind: () => flowControllerTimeoutKind,
 	portHandlerKind: () => portHandlerKind,
+	readerKind: () => readerKind,
+	resolveReaders: () => resolveReaders,
 	retry: () => retry,
 	throttling: () => throttling,
-	timeout: () => timeout,
-	useCaseHandlerKind: () => useCaseHandlerKind,
-	wireUseCases: () => wireUseCases
+	timeout: () => timeout
 });
 //#endregion
-export { appendEvidence, createFlowController, createKind, createPort, createUseCase, debounce, evidenceResult, filter, flow, flowControllerDebounceKind, flowControllerExitKind, flowControllerFilterKind, flowControllerKind, flowControllerRetryKind, flowControllerThrottlingKind, flowControllerTimeoutKind, invocation_exports, portHandlerKind, retry, throttling, timeout, useCaseHandlerKind, wireUseCases };
+export { AbortErrorFlowController, aborter, appendEvidence, createFlowController, createKind, createPort, createReader, debounce, evidenceResult, filter, flow, flowControllerAborterKind, flowControllerDebounceKind, flowControllerExitKind, flowControllerFilterKind, flowControllerKind, flowControllerRetryKind, flowControllerThrottlingKind, flowControllerTimeoutKind, invocation_exports, portHandlerKind, readerKind, resolveReaders, retry, throttling, timeout };

package/dist/invocation/reader.cjs

@@ -0,0 +1,26 @@
+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_uncapitalize = require("../string/uncapitalize.cjs");
+//#region scripts/invocation/reader.ts
+const readerKind = require("./kind.cjs").createKind("reader");
+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 = require_uncapitalize.uncapitalize(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,28 @@
+import { PortHandler } from './port';
+import * as DCommon from '../common';
+import type * as DKind from '../kind';
+export type ReaderDependencies = Record<string, Reader | PortHandler>;
+export type ReaderDependenciesValue<GenericDependencies extends ReaderDependencies> = DCommon.SimplifyTopLevel<{
+    [Prop in keyof GenericDependencies as 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 ? [
+        Uncapitalize<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 = any, 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>;

package/dist/invocation/reader.mjs

@@ -0,0 +1,25 @@
+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 { uncapitalize } from "../string/uncapitalize.mjs";
+import { createKind } from "./kind.mjs";
+//#region scripts/invocation/reader.ts
+const readerKind = createKind("reader");
+function createReader(dependencies, read) {
+	return {
+		dependencies,
+		run: (injectedDependencies) => read(pipe(forward(dependencies), entries, map(([key, value]) => {
+			const formattedKey = uncapitalize(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/kind/createIdentifier.d.ts

@@ -1,7 +1,11 @@
 import { Kind, Handler } from './base';
 import { GetHandler } from './types';
 import type * as DCommon from '../common';
-export declare function createKindIdentifier<GenericParent extends Kind<Handler>, GenericChildren extends GenericParent>(): {
-    <GenericKindHandler extends GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetHandler<InferredChildren> : never : never, GenericInput extends unknown, GenericGroupedKind extends DCommon.UnionToIntersection<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is ((DCommon.UnionContain<GenericInput, GenericParent> extends true ? Extract<GenericChildren, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>);
-    <GenericKindHandler extends GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetHandler<InferredChildren> : never : never, GenericInput extends unknown, GenericGroupedKind extends DCommon.UnionToIntersection<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is ((DCommon.UnionContain<GenericInput, GenericParent> extends true ? Extract<GenericChildren, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>);
-};
+type KindIdentifierHandlers<GenericParent extends Kind<Handler>, GenericChildren extends GenericParent> = GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetHandler<InferredChildren> : never : never;
+type KindIdentifierResult<GenericParent extends Kind<Handler>, GenericChildren extends GenericParent, GenericInput extends unknown, GenericGroupedKind extends unknown> = ((GenericInput extends GenericParent ? GenericChildren extends GenericInput ? GenericChildren extends GenericGroupedKind ? GenericChildren : never : never : never) | Extract<GenericInput, GenericGroupedKind>);
+export interface KindIdentifier<GenericParent extends Kind<Handler>, GenericChildren extends GenericParent> {
+    <GenericKindHandler extends KindIdentifierHandlers<GenericParent, GenericChildren>, GenericInput extends unknown, GenericGroupedKind extends DCommon.Forward<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is KindIdentifierResult<GenericParent, GenericChildren, GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends KindIdentifierHandlers<GenericParent, GenericChildren>, GenericInput extends unknown, GenericGroupedKind extends DCommon.Forward<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is KindIdentifierResult<GenericParent, GenericChildren, GenericInput, GenericGroupedKind>;
+}
+export declare function createKindIdentifier<GenericParent extends Kind<Handler>, GenericChildren extends GenericParent>(): KindIdentifier<GenericParent, GenericChildren>;
+export {};

package/dist/kind/types/getName.d.ts

@@ -0,0 +1,2 @@
+import { Definition, Handler, Kind } from '../base';
+export type GetName<GenericValue extends Kind<Handler>> = GenericValue extends Kind<Handler<Definition<infer InferredKindName>>> ? InferredKindName : never;

package/dist/kind/types/getNamespaceName.d.ts

@@ -0,0 +1,3 @@
+import { Definition, Handler } from '../base';
+import { createNamespace } from '../namespace';
+export type GetNamespaceName<GenericKindConstructor extends ReturnType<typeof createNamespace>> = ReturnType<GenericKindConstructor> extends Handler<Definition<`@${infer InferredName}/${string}`>> ? InferredName : never;

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

@@ -1,3 +1,5 @@
 export type * from './getHandler';
+export type * from './getName';
+export type * from './getNamespaceName';
 export type * from './getValue';
 export type * from './remove';

package/dist/kind/types/remove.d.ts

@@ -1,2 +1,2 @@
-import { KeySymbol, Kind } from '../base';
-export type Remove<GenericObject extends Kind<any>> = Omit<GenericObject, KeySymbol>;
+import { Kind, KeySymbol } from '../base';
+export type Remove<GenericObject extends object> = GenericObject extends Kind<any> ? Omit<GenericObject, KeySymbol> : GenericObject;

package/dist/modeling/entity/base.cjs

@@ -1,21 +1,34 @@
+const require_parentClass = require("../../kind/parentClass.cjs");
 const require_isSimple = require("../../object/isSimple.cjs");
+const require_override = require("../../object/override.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");
+const require_unwrap = require("../../either/left/unwrap.cjs");
+const require_unwrap$1 = require("../../either/right/unwrap.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");
-const require_entityName = require("./entityName.cjs");
+const require_base$2 = require("../taggedObject/base.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({
+var EncodeEntityError = class extends require_parentClass.parentClass(require_kind.createKind("encode-entity-error"), Error) {
+	error;
+	constructor(error) {
+		super(void 0, "An error occurred while encoding an Entity. This can only happen if you are bypassing the type system.");
+		this.error = error;
+	}
+};
+const EntityStructure = require_base$1.createStructure(entityStructureKind, ({ init }) => (name, shape) => init({
 	inner: require_memo.memo(() => require_object.ObjectStructure({
 		...shape(),
-		[entityKind.runTimeKey]: require_entityName.EntityNameStructure(name)
+		[entityKind.runTimeKey]: require_nonEncodableString.NonEncodableStringStructure(name)
 	}, [])),
 	constraints: []
 }, {
@@ -34,7 +47,7 @@ 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,
@@ -45,7 +58,7 @@ const EntityStructure = require_base.createStructure(entityStructureKind, ({ ini
 		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
@@ -61,7 +74,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,17 +84,31 @@ 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);
-	})
+	},
+	encodeEntity: async (self, codecs, data) => {
+		const result = await self.asyncEncode(codecs, data);
+		if (require_is.isLeft(result)) throw new EncodeEntityError(require_unwrap.unwrapLeft(result));
+		return require_unwrap$1.unwrapRight(result);
+	},
+	update: (self, ...args) => {
+		if (args.length === 1) {
+			const [update] = args;
+			return (input) => self.update(input, update);
+		}
+		const [input, { [require_base$2.objectTagKind.runTimeKey]: __, ...update }] = args;
+		return require_override.override(input, update);
+	}
 }));
 //#endregion
+exports.EncodeEntityError = EncodeEntityError;
 exports.EntityStructure = EntityStructure;
 exports.entityKind = entityKind;
 exports.entityStructureKind = entityStructureKind;