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

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");
@@ -12,6 +13,8 @@ const require_port = require("./port.cjs");
 const require_useCase = require("./useCase.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,
@@ -21,6 +24,7 @@ var invocation_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	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,
@@ -36,6 +40,8 @@ var invocation_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	wireUseCases: () => require_useCase.wireUseCases
 });
 //#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;
@@ -45,6 +51,7 @@ 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;

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";
@@ -12,6 +13,8 @@ import { createPort, portHandlerKind } from "./port.mjs";
 import { createUseCase, useCaseHandlerKind, wireUseCases } from "./useCase.mjs";
 //#region scripts/invocation/index.ts
 var invocation_exports = /* @__PURE__ */ __exportAll({
+	AbortErrorFlowController: () => AbortErrorFlowController,
+	aborter: () => aborter,
 	appendEvidence: () => appendEvidence,
 	createFlowController: () => createFlowController,
 	createKind: () => createKind,
@@ -21,6 +24,7 @@ var invocation_exports = /* @__PURE__ */ __exportAll({
 	evidenceResult: () => evidenceResult,
 	filter: () => filter,
 	flow: () => flow,
+	flowControllerAborterKind: () => flowControllerAborterKind,
 	flowControllerDebounceKind: () => flowControllerDebounceKind,
 	flowControllerExitKind: () => flowControllerExitKind,
 	flowControllerFilterKind: () => flowControllerFilterKind,
@@ -36,4 +40,4 @@ var invocation_exports = /* @__PURE__ */ __exportAll({
 	wireUseCases: () => wireUseCases
 });
 //#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, createUseCase, debounce, evidenceResult, filter, flow, flowControllerAborterKind, flowControllerDebounceKind, flowControllerExitKind, flowControllerFilterKind, flowControllerKind, flowControllerRetryKind, flowControllerThrottlingKind, flowControllerTimeoutKind, invocation_exports, portHandlerKind, retry, throttling, timeout, useCaseHandlerKind, wireUseCases };

package/dist/kind/createIdentifier.d.ts

@@ -2,6 +2,6 @@ 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>);
+    <GenericKindHandler extends GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetHandler<InferredChildren> : never : never, GenericInput extends unknown, GenericGroupedKind extends DCommon.Forward<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is ((GenericInput extends GenericParent ? GenericChildren extends GenericInput ? GenericChildren extends GenericGroupedKind ? GenericChildren : never : never : never) | Extract<GenericInput, GenericGroupedKind>);
+    <GenericKindHandler extends GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetHandler<InferredChildren> : never : never, GenericInput extends unknown, GenericGroupedKind extends DCommon.Forward<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is ((GenericInput extends GenericParent ? GenericChildren extends GenericInput ? GenericChildren extends GenericGroupedKind ? GenericChildren : never : never : never) | Extract<GenericInput, GenericGroupedKind>);
 };

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

@@ -6,16 +6,16 @@ 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_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");
 //#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({
 	inner: require_memo.memo(() => require_object.ObjectStructure({
 		...shape(),
-		[entityKind.runTimeKey]: require_entityName.EntityNameStructure(name)
+		[entityKind.runTimeKey]: require_nonEncodableString.NonEncodableStringStructure(name)
 	}, [])),
 	constraints: []
 }, {

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

@@ -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,11 +19,12 @@ 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>;
 }
-export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.RemoveConstraint<GenericValue>> = GenericRawValue extends NewType ? NewTypeMap<GenericRawValue> : GenericRawValue extends object ? DCommon.Or<[
+export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.RemoveConstraint<GenericValue>> = GenericRawValue extends NewType ? NewTypeMap<GenericRawValue> : GenericRawValue extends Entity ? GenericRawValue : GenericRawValue extends object ? DCommon.Or<[
     DCommon.IsExtends<GenericRawValue, readonly any[]>,
     DCommon.And<[
         DCommon.IsExtends<keyof GenericRawValue, string>,
@@ -29,15 +32,15 @@ export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.Re
     ]>
 ]> 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>> {
+} : GenericRawValue : GenericRawValue;
+export interface EntityStructure<GenericName extends string = string, 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>>;
 }
 export declare const EntityStructure: <GenericName extends string, GenericShape extends DDataStructure.ShapeObjectStructure, const GenericProperties extends DDataStructure.ShapeObjectStructureValue<GenericShape>>(name: GenericName, shape: () => GenericShape) => EntityStructure<GenericName, GenericProperties>;

package/dist/modeling/entity/base.mjs

@@ -6,16 +6,16 @@ import { memo } from "../../common/memo.mjs";
 import { ErrorSymbol } from "../../dataStructure/common/resultSymbol.mjs";
 import { createGetErrorHandler } from "../../dataStructure/common/error.mjs";
 import { createStructure } from "../../dataStructure/structure/base.mjs";
+import { NonEncodableStringStructure } from "../../dataStructure/structure/defaults/nonEncodableString.mjs";
 import { ObjectStructure } from "../../dataStructure/structure/defaults/object.mjs";
 import { createKind } from "../kind.mjs";
-import { EntityNameStructure } from "./entityName.mjs";
 //#region scripts/modeling/entity/base.ts
 const entityKind = createKind("entity");
 const entityStructureKind = createKind("entity-structure");
 const EntityStructure = createStructure(entityStructureKind, ({ init }) => (name, shape) => init({
 	inner: memo(() => ObjectStructure({
 		...shape(),
-		[entityKind.runTimeKey]: EntityNameStructure(name)
+		[entityKind.runTimeKey]: NonEncodableStringStructure(name)
 	}, [])),
 	constraints: []
 }, {

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

@@ -1,4 +1,3 @@
 export * from './base';
-export * from './entityName';
 export * from './helper';
 export * from './namespace';

package/dist/modeling/index.cjs

@@ -1,42 +1,50 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_kind = require("./kind.cjs");
-const require_entityName = require("./entity/entityName.cjs");
 const require_base = require("./entity/base.cjs");
 const require_helper = require("./entity/helper.cjs");
 const require_base$1 = require("./newType/base.cjs");
 const require_helper$1 = require("./newType/helper.cjs");
 const require_base$2 = require("./flag/base.cjs");
 const require_namespace = require("./entity/namespace.cjs");
+const require_base$3 = require("./taggedObject/base.cjs");
+const require_helper$2 = require("./taggedObject/helper.cjs");
 //#region scripts/modeling/index.ts
 var modeling_exports = /* @__PURE__ */ require_runtime.__exportAll({
-	EntityNameStructure: () => require_entityName.EntityNameStructure,
 	EntityStructure: () => require_base.EntityStructure,
 	NewTypeStructure: () => require_base$1.NewTypeStructure,
+	TaggedObjectStructure: () => require_base$3.TaggedObjectStructure,
 	createEntity: () => require_helper.createEntity,
 	createEntityNamespace: () => require_namespace.createEntityNamespace,
 	createFlag: () => require_base$2.createFlag,
 	createKind: () => require_kind.createKind,
 	createNewEntity: () => require_helper$1.createNewEntity,
+	createTaggedObject: () => require_helper$2.createTaggedObject,
 	entityKind: () => require_base.entityKind,
-	entityNameStructureKind: () => require_entityName.entityNameStructureKind,
 	entityStructureKind: () => require_base.entityStructureKind,
 	flagKind: () => require_base$2.flagKind,
+	getTagValue: () => require_helper$2.getTagValue,
+	hasTagValue: () => require_helper$2.hasTagValue,
 	namespaceKind: () => require_namespace.namespaceKind,
-	newTypeStructureKind: () => require_base$1.newTypeStructureKind
+	newTypeStructureKind: () => require_base$1.newTypeStructureKind,
+	objectTagKind: () => require_base$3.objectTagKind,
+	taggedObject: () => require_helper$2.taggedObject,
+	taggedObjectStructureKind: () => require_base$3.taggedObjectStructureKind
 });
 //#endregion
-exports.EntityNameStructure = require_entityName.EntityNameStructure;
 exports.EntityStructure = require_base.EntityStructure;
 exports.NewTypeStructure = require_base$1.NewTypeStructure;
+exports.TaggedObjectStructure = require_base$3.TaggedObjectStructure;
 exports.createEntity = require_helper.createEntity;
 exports.createEntityNamespace = require_namespace.createEntityNamespace;
 exports.createFlag = require_base$2.createFlag;
 exports.createKind = require_kind.createKind;
 exports.createNewEntity = require_helper$1.createNewEntity;
+exports.createTaggedObject = require_helper$2.createTaggedObject;
 exports.entityKind = require_base.entityKind;
-exports.entityNameStructureKind = require_entityName.entityNameStructureKind;
 exports.entityStructureKind = require_base.entityStructureKind;
 exports.flagKind = require_base$2.flagKind;
+exports.getTagValue = require_helper$2.getTagValue;
+exports.hasTagValue = require_helper$2.hasTagValue;
 Object.defineProperty(exports, "modeling_exports", {
 	enumerable: true,
 	get: function() {
@@ -45,3 +53,6 @@ Object.defineProperty(exports, "modeling_exports", {
 });
 exports.namespaceKind = require_namespace.namespaceKind;
 exports.newTypeStructureKind = require_base$1.newTypeStructureKind;
+exports.objectTagKind = require_base$3.objectTagKind;
+exports.taggedObject = require_helper$2.taggedObject;
+exports.taggedObjectStructureKind = require_base$3.taggedObjectStructureKind;

package/dist/modeling/index.d.ts

@@ -2,3 +2,4 @@ export * from './entity';
 export * from './flag';
 export * from './kind';
 export * from './newType';
+export * from './taggedObject';

package/dist/modeling/index.mjs

@@ -1,28 +1,34 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { createKind } from "./kind.mjs";
-import { EntityNameStructure, entityNameStructureKind } from "./entity/entityName.mjs";
 import { EntityStructure, entityKind, entityStructureKind } from "./entity/base.mjs";
 import { createEntity } from "./entity/helper.mjs";
 import { NewTypeStructure, newTypeStructureKind } from "./newType/base.mjs";
 import { createNewEntity } from "./newType/helper.mjs";
 import { createFlag, flagKind } from "./flag/base.mjs";
 import { createEntityNamespace, namespaceKind } from "./entity/namespace.mjs";
+import { TaggedObjectStructure, objectTagKind, taggedObjectStructureKind } from "./taggedObject/base.mjs";
+import { createTaggedObject, getTagValue, hasTagValue, taggedObject } from "./taggedObject/helper.mjs";
 //#region scripts/modeling/index.ts
 var modeling_exports = /* @__PURE__ */ __exportAll({
-	EntityNameStructure: () => EntityNameStructure,
 	EntityStructure: () => EntityStructure,
 	NewTypeStructure: () => NewTypeStructure,
+	TaggedObjectStructure: () => TaggedObjectStructure,
 	createEntity: () => createEntity,
 	createEntityNamespace: () => createEntityNamespace,
 	createFlag: () => createFlag,
 	createKind: () => createKind,
 	createNewEntity: () => createNewEntity,
+	createTaggedObject: () => createTaggedObject,
 	entityKind: () => entityKind,
-	entityNameStructureKind: () => entityNameStructureKind,
 	entityStructureKind: () => entityStructureKind,
 	flagKind: () => flagKind,
+	getTagValue: () => getTagValue,
+	hasTagValue: () => hasTagValue,
 	namespaceKind: () => namespaceKind,
-	newTypeStructureKind: () => newTypeStructureKind
+	newTypeStructureKind: () => newTypeStructureKind,
+	objectTagKind: () => objectTagKind,
+	taggedObject: () => taggedObject,
+	taggedObjectStructureKind: () => taggedObjectStructureKind
 });
 //#endregion
-export { EntityNameStructure, EntityStructure, NewTypeStructure, createEntity, createEntityNamespace, createFlag, createKind, createNewEntity, entityKind, entityNameStructureKind, entityStructureKind, flagKind, modeling_exports, namespaceKind, newTypeStructureKind };
+export { EntityStructure, NewTypeStructure, TaggedObjectStructure, createEntity, createEntityNamespace, createFlag, createKind, createNewEntity, createTaggedObject, entityKind, entityStructureKind, flagKind, getTagValue, hasTagValue, modeling_exports, namespaceKind, newTypeStructureKind, objectTagKind, taggedObject, taggedObjectStructureKind };

package/dist/modeling/newType/base.cjs

@@ -7,14 +7,17 @@ const require_error = require("../../dataStructure/common/error.cjs");
 const require_base = require("../../dataStructure/structure/base.cjs");
 //#region scripts/modeling/newType/base.ts
 const newTypeStructureKind = require("../kind.cjs").createKind("new-type-structure");
+function executeNewTypeConstraints(structure, data, errorHandler) {
+	return structure.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(constraint.executeCheck(data), (constraintResult) => constraintResult === require_resultSymbol.ErrorSymbol ? errorHandler?.().addIssue(structure, data, constraint) ?? require_resultSymbol.ErrorSymbol : require_resultSymbol.SuccessSymbol)), require_resultSymbol.SuccessSymbol);
+}
 const NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ init }) => (name, structure, newTypeConstraints) => init({
 	constraints: [],
 	newTypeConstraints,
 	inner: structure
 }, {
-	executeCheck: (self, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : self.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : constraint.executeCheck(data, errorHandler)), require_resultSymbol.SuccessSymbol)),
-	executeEncode: (self, codec, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeEncode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : constraint.executeCheck(data, errorHandler)), require_resultSymbol.SuccessSymbol), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
-	executeDecode: (self, codec, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeDecode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : constraint.executeCheck(awaitedInnerResult, errorHandler)), require_resultSymbol.SuccessSymbol), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
+	executeCheck: (self, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : executeNewTypeConstraints(self, data, errorHandler)),
+	executeEncode: (self, codec, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeEncode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(executeNewTypeConstraints(self, data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
+	executeDecode: (self, codec, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeDecode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(executeNewTypeConstraints(self, awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous() || self.definition.newTypeConstraints.some((value) => value.isAsynchronous())
 }, {
 	name,

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

@@ -25,7 +25,7 @@ export interface NewTypeStructureDefinition<GenericNewTypeConstraint extends rea
     readonly newTypeConstraints: GenericNewTypeConstraint;
 }
 export type ComputeNewType<GenericName extends string, GenericValue extends unknown, GenericNewTypeConstraint extends readonly DDataStructure.Constraint<GenericValue>[], GenericIntersectionConstraintValue = DDataStructure.ConstraintValue<DArray.Unwrap<GenericNewTypeConstraint>>, GenericClearValue = DCommon.NeverCoalescing<DCommon.RemoveConstraint<GenericIntersectionConstraintValue>, unknown>> = (GenericValue & GenericClearValue & NewType<GenericName, GenericIntersectionConstraintValue extends (GenericClearValue & infer InferredConstraint extends DCommon.BaseConstraint) ? InferredConstraint : never>);
-export interface NewTypeStructure<GenericName extends string = string, GenericValue extends unknown = unknown, GenericNewTypeConstraint extends readonly DDataStructure.Constraint<GenericValue>[] = readonly DDataStructure.Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<DDataStructure.Structure<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>, NewTypeStructureDefinition<GenericNewTypeConstraint>> & DKind.Kind<typeof newTypeStructureKind>> {
+export interface NewTypeStructure<GenericName extends string = string, GenericValue extends unknown = unknown, GenericNewTypeConstraint extends readonly DDataStructure.Constraint<GenericValue>[] = readonly DDataStructure.Constraint<GenericValue>[]> extends DCommon.Forward<DDataStructure.Structure<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>, NewTypeStructureDefinition<GenericNewTypeConstraint>> & DKind.Kind<typeof newTypeStructureKind>> {
     readonly name: GenericName;
     decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<NewTypeMap<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<NewTypeMap<DDataStructure.StructureValue<this>>, GenericCodecs>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);

package/dist/modeling/newType/base.mjs

@@ -8,14 +8,17 @@ import { createStructure } from "../../dataStructure/structure/base.mjs";
 import { createKind } from "../kind.mjs";
 //#region scripts/modeling/newType/base.ts
 const newTypeStructureKind = createKind("new-type-structure");
+function executeNewTypeConstraints(structure, data, errorHandler) {
+	return structure.definition.newTypeConstraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : callThen(constraint.executeCheck(data), (constraintResult) => constraintResult === ErrorSymbol ? errorHandler?.().addIssue(structure, data, constraint) ?? ErrorSymbol : SuccessSymbol)), SuccessSymbol);
+}
 const NewTypeStructure = createStructure(newTypeStructureKind, ({ init }) => (name, structure, newTypeConstraints) => init({
 	constraints: [],
 	newTypeConstraints,
 	inner: structure
 }, {
-	executeCheck: (self, data, errorHandler) => callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : self.definition.newTypeConstraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : constraint.executeCheck(data, errorHandler)), SuccessSymbol)),
-	executeEncode: (self, codec, data, errorHandler) => callThen(self.definition.inner.executeEncode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(self.definition.newTypeConstraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : constraint.executeCheck(data, errorHandler)), SuccessSymbol), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
-	executeDecode: (self, codec, data, errorHandler) => callThen(self.definition.inner.executeDecode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(self.definition.newTypeConstraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : constraint.executeCheck(awaitedInnerResult, errorHandler)), SuccessSymbol), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
+	executeCheck: (self, data, errorHandler) => callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : executeNewTypeConstraints(self, data, errorHandler)),
+	executeEncode: (self, codec, data, errorHandler) => callThen(self.definition.inner.executeEncode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(executeNewTypeConstraints(self, data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
+	executeDecode: (self, codec, data, errorHandler) => callThen(self.definition.inner.executeDecode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(executeNewTypeConstraints(self, awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous() || self.definition.newTypeConstraints.some((value) => value.isAsynchronous())
 }, {
 	name,

package/dist/modeling/taggedObject/base.cjs

@@ -0,0 +1,23 @@
+const require_base = 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/taggedObject/base.ts
+const objectTagKind = require_kind.createKind("object-tag");
+const taggedObjectStructureKind = require_kind.createKind("tagged-object-structure");
+const TaggedObjectStructure = require_base.createStructure(taggedObjectStructureKind, ({ init }) => (name, shape) => init({
+	inner: require_object.ObjectStructure({
+		...shape,
+		[objectTagKind.runTimeKey]: require_nonEncodableString.NonEncodableStringStructure(name)
+	}, []),
+	constraints: []
+}, {
+	executeCheck: (self, data, errorHandler) => self.definition.inner.executeCheck(data, errorHandler),
+	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.executeEncode(codecContext, data, errorHandler),
+	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.executeDecode(codecContext, data, errorHandler),
+	isAsynchronous: (self) => self.definition.inner.isAsynchronous()
+}, { name }));
+//#endregion
+exports.TaggedObjectStructure = TaggedObjectStructure;
+exports.objectTagKind = objectTagKind;
+exports.taggedObjectStructureKind = taggedObjectStructureKind;