@duplojs/lang 0.0.1-beta.1 → 0.0.1-beta.11

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;

package/dist/modeling/entity/base.d.ts

@@ -1,5 +1,5 @@
 import { NewType, NewTypeMap } from '../newType';
-import type * as DKind from '../../kind';
+import * as DKind from '../../kind';
 import * as DCommon from '../../common';
 import * as DDataStructure from '../../dataStructure';
 import * as DEither from '../../either';
@@ -7,6 +7,8 @@ declare module '../../dataStructure' {
     interface StructuresStore {
         entity: EntityStructure;
     }
+}
+declare module '../../dataStructure/common' {
     interface EncodeStructure<GenericValue extends unknown, GenericCodecs extends DDataStructure.Codecs> {
         entity: GenericValue extends Entity<infer InferredName> ? (Entity<InferredName> & {
             [Prop in Exclude<keyof GenericValue, DKind.KeySymbol>]: DDataStructure.EncodedValue<GenericValue[Prop], GenericCodecs>;
@@ -17,6 +19,7 @@ export declare const entityKind: DKind.Handler<DKind.Definition<"@DuplojsLangMod
 export interface Entity<GenericName extends string = string> extends DKind.Kind<typeof entityKind, GenericName> {
 }
 export type GetEntityName<GenericEntity extends Entity> = GenericEntity extends Entity<infer InferredName> ? InferredName : never;
+export type ExtractByEntityName<GenericValue extends unknown, GenericEntityName extends string> = GenericValue extends Entity<GenericEntityName> ? GenericValue : never;
 export declare const entityStructureKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/entity-structure", unknown>>;
 export interface EntityStructureDefinition extends DDataStructure.StructureDefinition<readonly []> {
     readonly inner: DCommon.Memoized<DDataStructure.ObjectStructure>;
@@ -28,16 +31,28 @@ export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.Re
         DCommon.Not<DCommon.IsExtends<DCommon.AnyFunction, GenericRawValue[keyof GenericRawValue]>>
     ]>
 ]> extends true ? {
-    [Prop in keyof GenericRawValue]: NewTypeMap<GenericRawValue[Prop]>;
-} : GenericRawValue extends Entity ? EntityMap<DKind.Remove<GenericRawValue>> : GenericRawValue : GenericRawValue;
-export interface EntityStructure<GenericName extends string = string, GenericProperties extends Record<string, unknown> = Record<string, unknown>> extends DCommon.UnionToIntersection<DDataStructure.Structure<Entity<GenericName> & GenericProperties, EntityStructureDefinition> & DKind.Kind<typeof entityStructureKind>> {
+    [Prop in keyof GenericRawValue]: EntityMap<GenericRawValue[Prop]>;
+} : GenericRawValue : GenericRawValue;
+export type EntityUpdate<GenericEntity extends Entity, GenericNewProperties extends object> = Extract<(Entity<GetEntityName<GenericEntity>> & DCommon.SimplifyTopLevel<DKind.Remove<GenericEntity> extends infer InferredProperties ? {
+    [Prop in keyof InferredProperties]: Prop extends keyof GenericNewProperties ? GenericNewProperties[Prop] extends infer InferredNewValue ? InferredNewValue extends undefined ? InferredProperties[Prop] : InferredNewValue : never : InferredProperties[Prop];
+} : never>), any>;
+export interface EntityStructure<out GenericName extends string = string, out GenericProperties extends Record<string, unknown> = Record<string, unknown>> extends DCommon.Forward<DDataStructure.Structure<Entity<GenericName> & GenericProperties, EntityStructureDefinition> & DKind.Kind<typeof entityStructureKind>> {
     readonly name: GenericName;
     "new"<GenericNewProperties extends GenericProperties>(properties: GenericNewProperties): (Entity<GenericName> & GenericNewProperties);
-    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<EntityMap<DDataStructure.StructureValue<this>>, GenericCodecs>) => (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
-    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<EntityMap<DDataStructure.StructureValue<this>>, GenericCodecs>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
-    map(data: EntityMap<DDataStructure.StructureValue<this>>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
-    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<EntityMap<DDataStructure.StructureValue<this>>, GenericCodecs>) => Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<EntityMap<DDataStructure.StructureValue<this>>, GenericCodecs>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    asyncMap(data: EntityMap<DDataStructure.StructureValue<this>>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>) => (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
+    map(data: EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>) => Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncMap(data: EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    encodeEntity<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.StructureValue<this>): Promise<DDataStructure.EncodedValue<EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>>;
+    update<GenericInputEntity extends (Entity<GenericName> & GenericProperties), const GenericPayload extends Partial<GenericProperties>>(update: GenericPayload): (input: GenericInputEntity) => EntityUpdate<GenericInputEntity, GenericPayload>;
+    update<GenericInputEntity extends (Entity<GenericName> & GenericProperties), const GenericPayload extends Partial<GenericProperties>>(input: GenericInputEntity, update: GenericPayload): EntityUpdate<GenericInputEntity, GenericPayload>;
+}
+declare const EncodeEntityError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangModeling/encode-entity-error", unknown>>, ErrorConstructor>;
+export declare class EncodeEntityError extends EncodeEntityError_base {
+    error: DDataStructure.Error;
+    constructor(error: DDataStructure.Error);
 }
 export declare const EntityStructure: <GenericName extends string, GenericShape extends DDataStructure.ShapeObjectStructure, const GenericProperties extends DDataStructure.ShapeObjectStructureValue<GenericShape>>(name: GenericName, shape: () => GenericShape) => EntityStructure<GenericName, GenericProperties>;
+export {};