@duplojs/lang 0.0.0 → 0.0.1-beta.10

package/dist/dataStructure/structure/defaults/lazy.d.ts

@@ -7,6 +7,6 @@ export declare const lazyStructureKind: DKind.Handler<DKind.Definition<"@Duplojs
 export interface LazyStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
     readonly getter: DCommon.Memoized<Structure>;
 }
-export interface LazyStructure<GenericValue extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<Structure<GenericValue, LazyStructureDefinition<GenericConstraints>> & DKind.Kind<typeof lazyStructureKind>> {
+export interface LazyStructure<out GenericValue extends unknown = unknown, out GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, LazyStructureDefinition<GenericConstraints>> & DKind.Kind<typeof lazyStructureKind>> {
 }
-export declare const LazyStructure: <GenericStructure extends Structure, const GenericConstraints extends readonly Constraint<StructureValue<GenericStructure>>[]>(getStructure: () => GenericStructure, constraints: GenericConstraints) => LazyStructure<StructureValue<GenericStructure>, readonly [...GenericConstraints]>;
+export declare const LazyStructure: <GenericStructure extends Structure, const GenericConstraints extends readonly Constraint<StructureValue<GenericStructure>>[]>(getStructure: () => GenericStructure, constraints: GenericConstraints) => NoInfer<LazyStructure<StructureValue<GenericStructure>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/structure/defaults/lazy.mjs

@@ -1,15 +1,22 @@
+import { callThen } from "../../../common/callThen.mjs";
 import { memo } from "../../../common/memo.mjs";
 import { createKind } from "../../kind.mjs";
+import { ErrorSymbol } from "../../common/resultSymbol.mjs";
 import { createStructure } from "../base.mjs";
+import { structureIdentifier } from "../identifier.mjs";
 //#region scripts/dataStructure/structure/defaults/lazy.ts
 const lazyStructureKind = createKind("lazy-structure");
 const LazyStructure = createStructure(lazyStructureKind, ({ init }) => (getStructure, constraints) => init({
-	getter: memo(getStructure),
+	getter: memo(() => {
+		const dataStructure = getStructure();
+		if (structureIdentifier(dataStructure, lazyStructureKind)) return dataStructure.definition.getter.value;
+		return dataStructure;
+	}),
 	constraints
 }, {
 	executeCheck: (self, data, errorHandler) => self.definition.getter.value.executeCheck(data, errorHandler),
-	executeEncode: (self, codecContext, data, errorHandler) => self.definition.getter.value.executeEncode(codecContext, data, errorHandler),
-	executeDecode: (self, codecContext, data, errorHandler) => self.definition.getter.value.executeDecode(codecContext, data, errorHandler),
+	executeEncode: (self, codecContext, data, errorHandler) => callThen(self.definition.getter.value.executeEncode(codecContext, data, errorHandler), (encodedData) => encodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : encodedData)),
+	executeDecode: (self, codecContext, data, errorHandler) => callThen(self.definition.getter.value.executeDecode(codecContext, data, errorHandler), (decodedData) => decodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(decodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : decodedData)),
 	isAsynchronous: (self) => self.definition.getter.value.isAsynchronous()
 }));
 //#endregion

package/dist/dataStructure/structure/defaults/nonEncodableString.cjs

@@ -0,0 +1,17 @@
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+const require_base = require("../base.cjs");
+//#region scripts/dataStructure/structure/defaults/nonEncodableString.ts
+const nonEncodableStringStructureKind = require_kind.createKind("non-encodable-string-structure");
+const NonEncodableStringStructure = require_base.createStructure(nonEncodableStringStructureKind, ({ init }) => (value) => init({
+	value,
+	constraints: []
+}, {
+	executeCheck: (self, data, errorHandler) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeEncode: (self, codecContext, data, errorHandler) => data === self.definition.value ? data : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeDecode: (self, codecContext, data, errorHandler) => data === self.definition.value ? data : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.NonEncodableStringStructure = NonEncodableStringStructure;
+exports.nonEncodableStringStructureKind = nonEncodableStringStructureKind;

package/dist/dataStructure/structure/defaults/nonEncodableString.d.ts

@@ -0,0 +1,10 @@
+import { Structure, StructureDefinition } from '../base';
+import type * as DKind from '../../../kind';
+import type * as DCommon from '../../../common';
+export declare const nonEncodableStringStructureKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/non-encodable-string-structure", unknown>>;
+export interface NonEncodableStringStructureDefinition extends StructureDefinition<readonly []> {
+    readonly value: string;
+}
+export interface NonEncodableStringStructure extends DCommon.Forward<Structure<String, NonEncodableStringStructureDefinition> & DKind.Kind<typeof nonEncodableStringStructureKind>> {
+}
+export declare const NonEncodableStringStructure: (value: string) => NoInfer<NonEncodableStringStructure>;

package/dist/dataStructure/structure/defaults/nonEncodableString.mjs

@@ -0,0 +1,16 @@
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+import { createStructure } from "../base.mjs";
+//#region scripts/dataStructure/structure/defaults/nonEncodableString.ts
+const nonEncodableStringStructureKind = createKind("non-encodable-string-structure");
+const NonEncodableStringStructure = createStructure(nonEncodableStringStructureKind, ({ init }) => (value) => init({
+	value,
+	constraints: []
+}, {
+	executeCheck: (self, data, errorHandler) => data === self.definition.value ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeEncode: (self, codecContext, data, errorHandler) => data === self.definition.value ? data : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeDecode: (self, codecContext, data, errorHandler) => data === self.definition.value ? data : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { NonEncodableStringStructure, nonEncodableStringStructureKind };

package/dist/dataStructure/structure/defaults/object.d.ts

@@ -25,6 +25,6 @@ export interface ObjectStructureDefinition<GenericConstraints extends readonly C
     readonly shape: DCommon.Memoized<readonly EntryShapeObjectStructure[]>;
     readonly keys: readonly string[];
 }
-export interface ObjectStructure<GenericValue extends Record<string, unknown> = Record<string, unknown>, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<Structure<GenericValue, ObjectStructureDefinition<GenericConstraints>> & DKind.Kind<typeof objectStructureKind>> {
+export interface ObjectStructure<out GenericValue extends Record<string, unknown> = Record<string, unknown>, out GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, ObjectStructureDefinition<GenericConstraints>> & DKind.Kind<typeof objectStructureKind>> {
 }
-export declare const ObjectStructure: <GenericShape extends ShapeObjectStructure, const GenericConstraints extends readonly Constraint<ShapeObjectStructureValue<GenericShape>>[]>(shape: GenericShape, constraints: GenericConstraints) => ObjectStructure<ShapeObjectStructureValue<GenericShape>, readonly [...GenericConstraints]>;
+export declare const ObjectStructure: <GenericShape extends ShapeObjectStructure, const GenericConstraints extends readonly Constraint<ShapeObjectStructureValue<GenericShape>>[]>(shape: GenericShape, constraints: GenericConstraints) => NoInfer<ObjectStructure<ShapeObjectStructureValue<GenericShape>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/structure/defaults/object.mjs

@@ -18,7 +18,8 @@ const ObjectStructure = createStructure(objectStructureKind, ({ init }) => (shap
 		if (!isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		if (Object.keys(data).some((value) => !self.definition.keys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		return callThen(self.definition.shape.value.reduce((accumulator, entry) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? callThen(entry.value.executeCheck(data[entry.key], errorHandler), (result) => result === ErrorSymbol || awaitedAccumulator === ErrorSymbol ? ErrorSymbol : SuccessSymbol)), SuccessSymbol), (awaitedResult) => {
+		const result = self.definition.shape.value.reduce((accumulator, entry) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? callThen(entry.value.executeCheck(data[entry.key], errorHandler), (result) => result === ErrorSymbol || awaitedAccumulator === ErrorSymbol ? ErrorSymbol : SuccessSymbol)), SuccessSymbol);
+		return callThen(result, (awaitedResult) => {
 			pathStage?.close();
 			return awaitedResult;
 		});
@@ -27,21 +28,23 @@ const ObjectStructure = createStructure(objectStructureKind, ({ init }) => (shap
 		if (!isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		if (Object.keys(data).some((value) => !self.definition.keys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		return callThen(self.definition.shape.value.reduce((accumulator, entry) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? callThen(entry.value.executeEncode(codecContext, data[entry.key], errorHandler), (encodedData) => {
+		const encodedData = self.definition.shape.value.reduce((accumulator, entry) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? callThen(entry.value.executeEncode(codecContext, data[entry.key], errorHandler), (encodedData) => {
 			if (encodedData === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
 			awaitedAccumulator[entry.key] = encodedData;
 			return awaitedAccumulator;
-		})), {}), (awaitedEncodedData) => pathStage?.close() ?? (awaitedEncodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedEncodedData)));
+		})), {});
+		return callThen(encodedData, (awaitedEncodedData) => pathStage?.close() ?? (awaitedEncodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedEncodedData)));
 	},
 	executeDecode: (self, codecContext, data, errorHandler) => {
 		if (!isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		if (Object.keys(data).some((value) => !self.definition.keys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		return callThen(self.definition.shape.value.reduce((accumulator, entry) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? callThen(entry.value.executeDecode(codecContext, data[entry.key], errorHandler), (decodedData) => {
+		const decodedData = self.definition.shape.value.reduce((accumulator, entry) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? callThen(entry.value.executeDecode(codecContext, data[entry.key], errorHandler), (decodedData) => {
 			if (decodedData === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
 			awaitedAccumulator[entry.key] = decodedData;
 			return awaitedAccumulator;
-		})), {}), (awaitedDecodedData) => pathStage?.close() ?? (awaitedDecodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedDecodedData)));
+		})), {});
+		return callThen(decodedData, (awaitedDecodedData) => pathStage?.close() ?? (awaitedDecodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedDecodedData)));
 	},
 	isAsynchronous: (self) => self.definition.shape.value.some((entry) => entry.value.isAsynchronous())
 }));

package/dist/dataStructure/structure/defaults/record.cjs

@@ -1,6 +1,6 @@
 const require_callThen = require("../../../common/callThen.cjs");
 const require_isType = require("../../../common/isType.cjs");
-const require_justExec = require("../../../common/justExec.cjs");
+const require_memo = require("../../../common/memo.cjs");
 const require_kind = require("../../kind.cjs");
 const require_resultSymbol = require("../../common/resultSymbol.cjs");
 const require_base = require("../base.cjs");
@@ -16,10 +16,10 @@ const RecordStructure = require_base.createStructure(recordStructureKind, ({ ini
 	key,
 	value,
 	constraints,
-	requiredKeys: require_justExec.justExec(() => {
+	requiredKeys: require_memo.memo(() => {
 		if (require_identifier.structureIdentifier(key, require_union.unionStructureKind)) {
-			if (key.definition.values.some((value) => require_identifier.structureIdentifier(value, require_type.typeStructureKind) && require_identifier$1.typeIdentifier(value.definition.type, require_string.stringTypeKind))) return null;
-			return key.definition.values.map((value) => require_identifier.structureIdentifier(value, require_type.typeStructureKind) && require_identifier$1.typeIdentifier(value.definition.type, require_stringLiteral.stringLiteralTypeKind) ? value.definition.type.definition.value : null).filter(require_isType.isType("string"));
+			if (key.definition.values.value.some((value) => require_identifier.structureIdentifier(value, require_type.typeStructureKind) && require_identifier$1.typeIdentifier(value.definition.type, require_string.stringTypeKind))) return null;
+			return key.definition.values.value.map((value) => require_identifier.structureIdentifier(value, require_type.typeStructureKind) && require_identifier$1.typeIdentifier(value.definition.type, require_stringLiteral.stringLiteralTypeKind) ? value.definition.type.definition.value : null).filter(require_isType.isType("string"));
 		}
 		if (require_identifier.structureIdentifier(key, require_type.typeStructureKind) && require_identifier$1.typeIdentifier(key.definition.type, require_stringLiteral.stringLiteralTypeKind)) return [key.definition.type.definition.value];
 		return null;
@@ -28,7 +28,7 @@ const RecordStructure = require_base.createStructure(recordStructureKind, ({ ini
 	executeCheck: (self, data, errorHandler) => {
 		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const keyData = Object.keys(data);
-		const requiredKeys = self.definition.requiredKeys;
+		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
 		const result = (requiredKeys ?? keyData).reduce((accumulator, key) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? require_callThen.callThen(self.definition.key.executeCheck(key, errorHandler), (resultKey) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? require_callThen.callThen(self.definition.value.executeCheck(data[key], errorHandler), (resultValue) => resultValue === require_resultSymbol.ErrorSymbol || resultKey === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_resultSymbol.SuccessSymbol))), require_resultSymbol.SuccessSymbol);
@@ -40,7 +40,7 @@ const RecordStructure = require_base.createStructure(recordStructureKind, ({ ini
 	executeEncode: (self, codecContext, data, errorHandler) => {
 		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const keyData = Object.keys(data);
-		const requiredKeys = self.definition.requiredKeys;
+		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
 		const encodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? require_callThen.callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? require_callThen.callThen(self.definition.value.executeEncode(codecContext, data[key], errorHandler), (encodedValue) => {
@@ -53,7 +53,7 @@ const RecordStructure = require_base.createStructure(recordStructureKind, ({ ini
 	executeDecode: (self, codecContext, data, errorHandler) => {
 		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const keyData = Object.keys(data);
-		const requiredKeys = self.definition.requiredKeys;
+		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
 		const decodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? require_callThen.callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? require_callThen.callThen(self.definition.value.executeDecode(codecContext, data[key], errorHandler), (decodedValue) => {

package/dist/dataStructure/structure/defaults/record.d.ts

@@ -12,8 +12,8 @@ export declare const recordStructureKind: DKind.Handler<DKind.Definition<"@Duplo
 export interface RecordStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
     readonly key: UnionStructure<string> | TypeStructure<string>;
     readonly value: Structure;
-    readonly requiredKeys: string[] | null;
+    readonly requiredKeys: DCommon.Memoized<string[] | null>;
 }
-export interface RecordStructure<GenericValue extends Record<string, unknown> = Record<string, unknown>, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<Structure<GenericValue, RecordStructureDefinition<GenericConstraints>> & DKind.Kind<typeof recordStructureKind>> {
+export interface RecordStructure<out GenericValue extends Record<string, unknown> = Record<string, unknown>, out GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, RecordStructureDefinition<GenericConstraints>> & DKind.Kind<typeof recordStructureKind>> {
 }
-export declare const RecordStructure: <GenericKey extends (UnionStructure<string> | TypeStructure<string>), GenericValueStructure extends Structure, const GenericConstraints extends readonly Constraint<RecordStructureValue<GenericKey, GenericValueStructure>>[]>(key: GenericKey, value: GenericValueStructure, constraints: GenericConstraints) => RecordStructure<RecordStructureValue<GenericKey, GenericValueStructure>, readonly [...GenericConstraints]>;
+export declare const RecordStructure: <GenericKey extends (UnionStructure<string> | TypeStructure<string>), GenericValueStructure extends Structure, const GenericConstraints extends readonly Constraint<RecordStructureValue<GenericKey, GenericValueStructure>>[]>(key: GenericKey, value: GenericValueStructure, constraints: GenericConstraints) => NoInfer<RecordStructure<RecordStructureValue<GenericKey, GenericValueStructure>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/structure/defaults/record.mjs

@@ -1,6 +1,6 @@
 import { callThen } from "../../../common/callThen.mjs";
 import { isType } from "../../../common/isType.mjs";
-import { justExec } from "../../../common/justExec.mjs";
+import { memo } from "../../../common/memo.mjs";
 import { createKind } from "../../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
 import { createStructure } from "../base.mjs";
@@ -16,10 +16,10 @@ const RecordStructure = createStructure(recordStructureKind, ({ init }) => (key,
 	key,
 	value,
 	constraints,
-	requiredKeys: justExec(() => {
+	requiredKeys: memo(() => {
 		if (structureIdentifier(key, unionStructureKind)) {
-			if (key.definition.values.some((value) => structureIdentifier(value, typeStructureKind) && typeIdentifier(value.definition.type, stringTypeKind))) return null;
-			return key.definition.values.map((value) => structureIdentifier(value, typeStructureKind) && typeIdentifier(value.definition.type, stringLiteralTypeKind) ? value.definition.type.definition.value : null).filter(isType("string"));
+			if (key.definition.values.value.some((value) => structureIdentifier(value, typeStructureKind) && typeIdentifier(value.definition.type, stringTypeKind))) return null;
+			return key.definition.values.value.map((value) => structureIdentifier(value, typeStructureKind) && typeIdentifier(value.definition.type, stringLiteralTypeKind) ? value.definition.type.definition.value : null).filter(isType("string"));
 		}
 		if (structureIdentifier(key, typeStructureKind) && typeIdentifier(key.definition.type, stringLiteralTypeKind)) return [key.definition.type.definition.value];
 		return null;
@@ -28,10 +28,11 @@ const RecordStructure = createStructure(recordStructureKind, ({ init }) => (key,
 	executeCheck: (self, data, errorHandler) => {
 		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const keyData = Object.keys(data);
-		const requiredKeys = self.definition.requiredKeys;
+		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		return callThen((requiredKeys ?? keyData).reduce((accumulator, key) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? callThen(self.definition.key.executeCheck(key, errorHandler), (resultKey) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? callThen(self.definition.value.executeCheck(data[key], errorHandler), (resultValue) => resultValue === ErrorSymbol || resultKey === ErrorSymbol || awaitedAccumulator === ErrorSymbol ? ErrorSymbol : SuccessSymbol))), SuccessSymbol), (awaitedResult) => {
+		const result = (requiredKeys ?? keyData).reduce((accumulator, key) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? callThen(self.definition.key.executeCheck(key, errorHandler), (resultKey) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? callThen(self.definition.value.executeCheck(data[key], errorHandler), (resultValue) => resultValue === ErrorSymbol || resultKey === ErrorSymbol || awaitedAccumulator === ErrorSymbol ? ErrorSymbol : SuccessSymbol))), SuccessSymbol);
+		return callThen(result, (awaitedResult) => {
 			pathStage?.close();
 			return awaitedResult;
 		});
@@ -39,26 +40,28 @@ const RecordStructure = createStructure(recordStructureKind, ({ init }) => (key,
 	executeEncode: (self, codecContext, data, errorHandler) => {
 		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const keyData = Object.keys(data);
-		const requiredKeys = self.definition.requiredKeys;
+		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		return callThen((requiredKeys ?? keyData).reduce((accumulator, key) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? callThen(self.definition.value.executeEncode(codecContext, data[key], errorHandler), (encodedValue) => {
+		const encodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? callThen(self.definition.value.executeEncode(codecContext, data[key], errorHandler), (encodedValue) => {
 			if (keyResult === ErrorSymbol || encodedValue === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
 			awaitedAccumulator[key] = encodedValue;
 			return awaitedAccumulator;
-		}))), {}), (awaitedEncodedData) => pathStage?.close() ?? (awaitedEncodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedEncodedData)));
+		}))), {});
+		return callThen(encodedData, (awaitedEncodedData) => pathStage?.close() ?? (awaitedEncodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedEncodedData)));
 	},
 	executeDecode: (self, codecContext, data, errorHandler) => {
 		if (typeof data !== "object" || data === null || data.constructor !== void 0 && data.constructor.name !== "Object" || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const keyData = Object.keys(data);
-		const requiredKeys = self.definition.requiredKeys;
+		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		return callThen((requiredKeys ?? keyData).reduce((accumulator, key) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? callThen(self.definition.value.executeDecode(codecContext, data[key], errorHandler), (decodedValue) => {
+		const decodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`{record key: ${key}}`) ?? callThen(self.definition.key.executeCheck(key, errorHandler), (keyResult) => pathStage?.setCurrentPath(`{record value: ${key}}`) ?? callThen(self.definition.value.executeDecode(codecContext, data[key], errorHandler), (decodedValue) => {
 			if (keyResult === ErrorSymbol || decodedValue === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
 			awaitedAccumulator[key] = decodedValue;
 			return awaitedAccumulator;
-		}))), {}), (awaitedDecodedData) => pathStage?.close() ?? (awaitedDecodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedDecodedData)));
+		}))), {});
+		return callThen(decodedData, (awaitedDecodedData) => pathStage?.close() ?? (awaitedDecodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedDecodedData)));
 	},
 	isAsynchronous: (self) => self.definition.key.isAsynchronous() || self.definition.value.isAsynchronous()
 }));

package/dist/dataStructure/structure/defaults/type.cjs

@@ -8,7 +8,7 @@ const TypeStructure = require_base.createStructure(typeStructureKind, ({ init })
 	type,
 	constraints
 }, {
-	executeCheck: (self, data, errorHandler) => self.definition.type.executeCheck(data, errorHandler),
+	executeCheck: (self, data, errorHandler) => require_callThen.callThen(self.definition.type.executeCheck(data), (result) => result === require_resultSymbol.ErrorSymbol ? errorHandler?.().addIssue(self, data, self.definition.type) ?? require_resultSymbol.ErrorSymbol : require_resultSymbol.SuccessSymbol),
 	executeEncode: (self, codecContext, data, errorHandler) => require_callThen.callThen(self.executeCheck(data, errorHandler), (result) => {
 		if (result === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
 		const codec = codecContext.get(self.definition.type.fundamentalType);

package/dist/dataStructure/structure/defaults/type.d.ts

@@ -7,6 +7,6 @@ export declare const typeStructureKind: DKind.Handler<DKind.Definition<"@Duplojs
 export interface TypeStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
     readonly type: Type;
 }
-export interface TypeStructure<GenericType extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericType>[] = readonly Constraint<GenericType>[]> extends DCommon.UnionToIntersection<Structure<GenericType, TypeStructureDefinition<GenericConstraints>> & DKind.Kind<typeof typeStructureKind>> {
+export interface TypeStructure<out GenericType extends unknown = unknown, out GenericConstraints extends readonly Constraint<GenericType>[] = readonly Constraint<GenericType>[]> extends DCommon.Forward<Structure<GenericType, TypeStructureDefinition<GenericConstraints>> & DKind.Kind<typeof typeStructureKind>> {
 }
-export declare const TypeStructure: <GenericType extends Type, const GenericConstraints extends readonly Constraint<TypeValue<GenericType>>[]>(type: GenericType, constraints: GenericConstraints) => TypeStructure<TypeValue<GenericType>, readonly [...GenericConstraints]>;
+export declare const TypeStructure: <GenericType extends Type, const GenericConstraints extends readonly Constraint<TypeValue<GenericType>>[]>(type: GenericType, constraints: GenericConstraints) => NoInfer<TypeStructure<TypeValue<GenericType>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/structure/defaults/type.mjs

@@ -1,6 +1,6 @@
 import { callThen } from "../../../common/callThen.mjs";
 import { createKind } from "../../kind.mjs";
-import { ErrorSymbol } from "../../common/resultSymbol.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
 import { createStructure } from "../base.mjs";
 //#region scripts/dataStructure/structure/defaults/type.ts
 const typeStructureKind = createKind("type-structure");
@@ -8,7 +8,7 @@ const TypeStructure = createStructure(typeStructureKind, ({ init }) => (type, co
 	type,
 	constraints
 }, {
-	executeCheck: (self, data, errorHandler) => self.definition.type.executeCheck(data, errorHandler),
+	executeCheck: (self, data, errorHandler) => callThen(self.definition.type.executeCheck(data), (result) => result === ErrorSymbol ? errorHandler?.().addIssue(self, data, self.definition.type) ?? ErrorSymbol : SuccessSymbol),
 	executeEncode: (self, codecContext, data, errorHandler) => callThen(self.executeCheck(data, errorHandler), (result) => {
 		if (result === ErrorSymbol) return ErrorSymbol;
 		const codec = codecContext.get(self.definition.type.fundamentalType);

package/dist/dataStructure/structure/defaults/union.cjs

@@ -1,22 +1,27 @@
 const require_callThen = require("../../../common/callThen.cjs");
+const require_memo = require("../../../common/memo.cjs");
 const require_kind = require("../../kind.cjs");
 const require_resultSymbol = require("../../common/resultSymbol.cjs");
-const require_error = require("../../common/error.cjs");
-const require_base = require("../base.cjs");
+const require_base = require("../../common/error/base.cjs");
+const require_base$1 = require("../base.cjs");
 const require_identifier = require("../identifier.cjs");
+const require_lazy = require("./lazy.cjs");
 //#region scripts/dataStructure/structure/defaults/union.ts
 const unionStructureKind = require_kind.createKind("union-structure");
-const UnionStructure = require_base.createStructure(unionStructureKind, ({ init }) => (values, constraints) => init({
-	values: values.flatMap((value) => require_identifier.structureIdentifier(value, unionStructureKind) ? value.definition.values : value),
+const UnionStructure = require_base$1.createStructure(unionStructureKind, ({ init }) => (values, constraints) => init({
+	values: require_memo.memo(() => values.flatMap((value) => (function flatUnion(structure) {
+		if (require_identifier.structureIdentifier(structure, unionStructureKind)) return structure.definition.values.value.flatMap(flatUnion);
+		if (require_identifier.structureIdentifier(structure, require_lazy.lazyStructureKind)) return flatUnion(structure.definition.getter.value);
+		return structure;
+	})(value))),
 	constraints
 }, {
 	executeCheck: (self, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		const result = self.definition.values.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
+		const result = self.definition.values.value.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator === require_resultSymbol.SuccessSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler();
-			if (errorHandler && errorHandlers && subErrorHandler) {
-				subErrorHandler().usePath(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : require_base.createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
 			}
@@ -25,6 +30,7 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		return require_callThen.callThen(result, (awaitedResult) => {
 			if (awaitedResult === require_resultSymbol.ErrorSymbol) {
 				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
 				return require_resultSymbol.ErrorSymbol;
 			}
 			return require_resultSymbol.SuccessSymbol;
@@ -32,11 +38,10 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 	},
 	executeEncode: (self, codec, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		const encodedData = self.definition.values.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
+		const encodedData = self.definition.values.value.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator !== require_resultSymbol.ErrorSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler();
-			if (errorHandler && errorHandlers && subErrorHandler) {
-				subErrorHandler().usePath(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : require_base.createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
 			}
@@ -45,6 +50,7 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		return require_callThen.callThen(encodedData, (awaitedEncodedData) => {
 			if (awaitedEncodedData === require_resultSymbol.ErrorSymbol) {
 				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
 				return require_resultSymbol.ErrorSymbol;
 			}
 			return require_callThen.callThen(self.executeConstraints(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedEncodedData);
@@ -52,11 +58,10 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 	},
 	executeDecode: (self, codec, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		const decodedData = self.definition.values.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
+		const decodedData = self.definition.values.value.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator !== require_resultSymbol.ErrorSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler();
-			if (errorHandler && errorHandlers && subErrorHandler) {
-				subErrorHandler().usePath(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : require_base.createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
 			}
@@ -65,12 +70,13 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		return require_callThen.callThen(decodedData, (awaitedDecodedData) => {
 			if (awaitedDecodedData === require_resultSymbol.ErrorSymbol) {
 				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
 				return require_resultSymbol.ErrorSymbol;
 			}
 			return require_callThen.callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedDecodedData);
 		});
 	},
-	isAsynchronous: (self) => self.definition.values.some((value) => value.isAsynchronous())
+	isAsynchronous: (self) => self.definition.values.value.some((value) => value.isAsynchronous())
 }));
 //#endregion
 exports.UnionStructure = UnionStructure;

package/dist/dataStructure/structure/defaults/union.d.ts

@@ -5,8 +5,8 @@ import type * as DKind from '../../../kind';
 import * as DCommon from '../../../common';
 export declare const unionStructureKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/union-structure", unknown>>;
 export interface UnionStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
-    readonly values: DCommon.AnyTuple<Structure>;
+    readonly values: DCommon.Memoized<DCommon.AnyTuple<Structure>>;
 }
-export interface UnionStructure<GenericValue extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<Structure<GenericValue, UnionStructureDefinition<GenericConstraints>> & DKind.Kind<typeof unionStructureKind>> {
+export interface UnionStructure<out GenericValue extends unknown = unknown, out GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, UnionStructureDefinition<GenericConstraints>> & DKind.Kind<typeof unionStructureKind>> {
 }
-export declare const UnionStructure: <GenericValues extends DCommon.AnyTuple<Structure>, const GenericConstraints extends readonly Constraint<StructureValue<GenericValues[number]>>[]>(values: GenericValues, constraints: GenericConstraints) => UnionStructure<StructureValue<GenericValues[number]>, readonly [...GenericConstraints]>;
+export declare const UnionStructure: <GenericValues extends DCommon.AnyTuple<Structure>, const GenericConstraints extends readonly Constraint<StructureValue<GenericValues[number]>>[]>(values: GenericValues, constraints: GenericConstraints) => NoInfer<UnionStructure<StructureValue<GenericValues[number]>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/structure/defaults/union.mjs

@@ -1,29 +1,36 @@
 import { callThen } from "../../../common/callThen.mjs";
+import { memo } from "../../../common/memo.mjs";
 import { createKind } from "../../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
-import { createGetErrorHandler } from "../../common/error.mjs";
+import { createGetErrorHandler } from "../../common/error/base.mjs";
 import { createStructure } from "../base.mjs";
 import { structureIdentifier } from "../identifier.mjs";
+import { lazyStructureKind } from "./lazy.mjs";
 //#region scripts/dataStructure/structure/defaults/union.ts
 const unionStructureKind = createKind("union-structure");
 const UnionStructure = createStructure(unionStructureKind, ({ init }) => (values, constraints) => init({
-	values: values.flatMap((value) => structureIdentifier(value, unionStructureKind) ? value.definition.values : value),
+	values: memo(() => values.flatMap((value) => (function flatUnion(structure) {
+		if (structureIdentifier(structure, unionStructureKind)) return structure.definition.values.value.flatMap(flatUnion);
+		if (structureIdentifier(structure, lazyStructureKind)) return flatUnion(structure.definition.getter.value);
+		return structure;
+	})(value))),
 	constraints
 }, {
 	executeCheck: (self, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		return callThen(self.definition.values.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
+		const result = self.definition.values.value.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator === SuccessSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler();
-			if (errorHandler && errorHandlers && subErrorHandler) {
-				subErrorHandler().usePath(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
 			}
 			return value.executeCheck(data, subErrorHandler);
-		}), ErrorSymbol), (awaitedResult) => {
+		}), ErrorSymbol);
+		return callThen(result, (awaitedResult) => {
 			if (awaitedResult === ErrorSymbol) {
 				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
 				return ErrorSymbol;
 			}
 			return SuccessSymbol;
@@ -31,18 +38,19 @@ const UnionStructure = createStructure(unionStructureKind, ({ init }) => (values
 	},
 	executeEncode: (self, codec, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		return callThen(self.definition.values.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
+		const encodedData = self.definition.values.value.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator !== ErrorSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler();
-			if (errorHandler && errorHandlers && subErrorHandler) {
-				subErrorHandler().usePath(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
 			}
 			return value.executeEncode(codec, data, subErrorHandler);
-		}), ErrorSymbol), (awaitedEncodedData) => {
+		}), ErrorSymbol);
+		return callThen(encodedData, (awaitedEncodedData) => {
 			if (awaitedEncodedData === ErrorSymbol) {
 				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
 				return ErrorSymbol;
 			}
 			return callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedEncodedData);
@@ -50,24 +58,25 @@ const UnionStructure = createStructure(unionStructureKind, ({ init }) => (values
 	},
 	executeDecode: (self, codec, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		return callThen(self.definition.values.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
+		const decodedData = self.definition.values.value.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator !== ErrorSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler();
-			if (errorHandler && errorHandlers && subErrorHandler) {
-				subErrorHandler().usePath(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
 			}
 			return value.executeDecode(codec, data, subErrorHandler);
-		}), ErrorSymbol), (awaitedDecodedData) => {
+		}), ErrorSymbol);
+		return callThen(decodedData, (awaitedDecodedData) => {
 			if (awaitedDecodedData === ErrorSymbol) {
 				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
 				return ErrorSymbol;
 			}
 			return callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedDecodedData);
 		});
 	},
-	isAsynchronous: (self) => self.definition.values.some((value) => value.isAsynchronous())
+	isAsynchronous: (self) => self.definition.values.value.some((value) => value.isAsynchronous())
 }));
 //#endregion
 export { UnionStructure, unionStructureKind };

package/dist/dataStructure/structure/identifier.d.ts

@@ -1,5 +1,4 @@
 import { Structure } from './base';
-export declare const structureIdentifier: {
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/array-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/lazy-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/object-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/entity-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/record-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/union-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/new-type-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/entity-name-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", Record<string, unknown>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", readonly unknown[]>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').Entity<string> & Record<string, unknown>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').NewType<string, never>>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import('../..').UnionContain<GenericInput, Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>>> extends true ? Extract<Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>>, GenericGroupedKind> | Extract<import('..').ObjectStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').ArrayStructure<readonly unknown[], readonly import('..').Constraint<readonly unknown[], readonly unknown[], import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').TypeStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('../../modeling').EntityStructure<string, Record<string, unknown>>, GenericGroupedKind> | Extract<import('..').LazyStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').RecordStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').UnionStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('../../modeling').NewTypeStructure<string, unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('../../modeling').EntityNameStructure, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/array-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/lazy-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/object-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/entity-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/record-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/union-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/new-type-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangModeling/entity-name-structure", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", Record<string, unknown>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", readonly unknown[]>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').Entity<string> & Record<string, unknown>>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/structure", import('../../modeling').NewType<string, never>>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import('../..').UnionContain<GenericInput, Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>>> extends true ? Extract<Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>>, GenericGroupedKind> | Extract<import('..').ObjectStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').ArrayStructure<readonly unknown[], readonly import('..').Constraint<readonly unknown[], readonly unknown[], import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').TypeStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('../../modeling').EntityStructure<string, Record<string, unknown>>, GenericGroupedKind> | Extract<import('..').LazyStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').RecordStructure<Record<string, unknown>, readonly import('..').Constraint<Record<string, unknown>, Record<string, unknown>, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('..').UnionStructure<unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('../../modeling').NewTypeStructure<string, unknown, readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>, GenericGroupedKind> | Extract<import('../../modeling').EntityNameStructure, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-};
+import { Structures } from './types';
+import * as DKind from '../../kind';
+export declare const structureIdentifier: DKind.KindIdentifier<Structure<unknown, import('..').StructureDefinition<readonly import('..').Constraint<unknown, unknown, import('..').ConstraintDefinition>[]>>, Structures>;

package/dist/dataStructure/structure/types/constraintsValue.d.ts

@@ -1,6 +1,6 @@
 import { ConstraintValue, Constraint } from '../../constraint';
 import type * as DCommon from '../../../common';
-export type StructureConstraintsValue<GenericConstraints extends Constraint> = DCommon.NeverCoalescing<Extract<DCommon.UnionToIntersection<GenericConstraints extends Constraint ? {
+export type StructureConstraintsValue<GenericConstraints extends Constraint> = DCommon.IsNever<GenericConstraints> extends true ? unknown : DCommon.NeverCoalescing<Extract<DCommon.UnionToIntersection<GenericConstraints extends Constraint ? {
     value: ConstraintValue<GenericConstraints>;
 } : never>, {
     value: unknown;

package/dist/dataStructure/structure/types/structures.d.ts

@@ -1,5 +1,5 @@
 import { Structure } from '../base';
-import { ObjectStructure, ArrayStructure, LazyStructure, RecordStructure, UnionStructure, TypeStructure } from '../defaults';
+import { ObjectStructure, ArrayStructure, LazyStructure, RecordStructure, UnionStructure, TypeStructure, NonEncodableStringStructure } from '../defaults';
 export interface StructuresStore {
     base: Structure;
     array: ArrayStructure;
@@ -8,5 +8,6 @@ export interface StructuresStore {
     record: RecordStructure;
     union: UnionStructure;
     type: TypeStructure;
+    nonEncodableString: NonEncodableStringStructure;
 }
 export type Structures = Extract<StructuresStore[keyof StructuresStore], Structure>;