@duplojs/lang 0.0.0 → 0.0.1-beta.2

package/dist/dataStructure/index.mjs

@@ -2,7 +2,8 @@ import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { createKind } from "./kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "./common/resultSymbol.mjs";
 import { codecKind, codecsKind, createCodec, createCodecs } from "./common/codec.mjs";
-import { createErrorHandler, createGetErrorHandler } from "./common/error.mjs";
+import { createErrorHandler, createGetErrorHandler, decodeIssueKind, encodeIssueKind, issueKind } from "./common/error.mjs";
+import { createErrorInterpreter } from "./common/errorInterpreter.mjs";
 import { constraintKind, createConstraint } from "./constraint/base.mjs";
 import { AllowedCharactersConstraint, allowedCharactersConstraintKind } from "./constraint/defaults/allowedCharacters.mjs";
 import { ArrayLengthEqualConstraint, arrayLengthEqualConstraintKind } from "./constraint/defaults/arrayLengthEqual.mjs";
@@ -30,23 +31,25 @@ import { SafeConstraint, safeConstraintKind } from "./constraint/defaults/safe.m
 import { StrictNegativeConstraint, strictNegativeConstraintKind } from "./constraint/defaults/strictNegative.mjs";
 import { StrictPositiveConstraint, strictPositiveConstraintKind } from "./constraint/defaults/strictPositive.mjs";
 import { StringLengthEqualConstraint, stringLengthEqualConstraintKind } from "./constraint/defaults/stringLengthEqual.mjs";
+import { TrimmedConstraint, trimmedConstraintKind } from "./constraint/defaults/trimmed.mjs";
 import { UrlConstraint, urlConstraintKind } from "./constraint/defaults/url.mjs";
 import { UuidConstraint, uuidConstraintKind, uuidRegex } from "./constraint/defaults/uuid.mjs";
 import { constraintIdentifier } from "./constraint/identifier.mjs";
 import { createFundamentalType, fundamentalTypeKind } from "./fundamentalType/base.mjs";
-import { TheBigint } from "./fundamentalType/defaults/bigint.mjs";
-import { TheBoolean } from "./fundamentalType/defaults/boolean.mjs";
-import { TheDate } from "./fundamentalType/defaults/date.mjs";
-import { TheNull } from "./fundamentalType/defaults/null.mjs";
-import { TheNumber } from "./fundamentalType/defaults/number.mjs";
-import { TheString } from "./fundamentalType/defaults/string.mjs";
-import { TheTime } from "./fundamentalType/defaults/time.mjs";
-import { TheUndefined } from "./fundamentalType/defaults/undefined.mjs";
+import { TheBigint, bigintFundamentalTypeKind } from "./fundamentalType/defaults/bigint.mjs";
+import { TheBoolean, booleanFundamentalTypeKind } from "./fundamentalType/defaults/boolean.mjs";
+import { TheDate, dateFundamentalTypeKind } from "./fundamentalType/defaults/date.mjs";
+import { TheNull, nullFundamentalTypeKind } from "./fundamentalType/defaults/null.mjs";
+import { TheNumber, numberFundamentalTypeKind } from "./fundamentalType/defaults/number.mjs";
+import { TheString, stringFundamentalTypeKind } from "./fundamentalType/defaults/string.mjs";
+import { TheTime, timeFundamentalTypeKind } from "./fundamentalType/defaults/time.mjs";
+import { TheUndefined, undefinedFundamentalTypeKind } from "./fundamentalType/defaults/undefined.mjs";
 import { fundamentalTypeIdentifier } from "./fundamentalType/identifier.mjs";
 import { allowedCharacters } from "./helpers/allowedCharacters.mjs";
 import { StructureClass, createStructure, structureKind } from "./structure/base.mjs";
 import { ArrayStructure, arrayStructureKind } from "./structure/defaults/array.mjs";
 import { LazyStructure, lazyStructureKind } from "./structure/defaults/lazy.mjs";
+import { NonEncodableStringStructure, nonEncodableStringStructureKind } from "./structure/defaults/nonEncodableString.mjs";
 import { ObjectStructure, objectStructureKind } from "./structure/defaults/object.mjs";
 import { structureIdentifier } from "./structure/identifier.mjs";
 import { UnionStructure, unionStructureKind } from "./structure/defaults/union.mjs";
@@ -112,6 +115,7 @@ import { strictNegative } from "./helpers/strictNegative.mjs";
 import { strictPositive } from "./helpers/strictPositive.mjs";
 import { stringLengthEqual } from "./helpers/stringLengthEqual.mjs";
 import { time } from "./helpers/time.mjs";
+import { trimmed } from "./helpers/trimmed.mjs";
 import { url } from "./helpers/url.mjs";
 import { uuid } from "./helpers/uuid.mjs";
 //#region scripts/dataStructure/index.ts
@@ -141,6 +145,7 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	MinElementsConstraint: () => MinElementsConstraint,
 	MultipleOfConstraint: () => MultipleOfConstraint,
 	NegativeConstraint: () => NegativeConstraint,
+	NonEncodableStringStructure: () => NonEncodableStringStructure,
 	NotEmptyConstraint: () => NotEmptyConstraint,
 	NotZeroConstraint: () => NotZeroConstraint,
 	NullType: () => NullType,
@@ -168,6 +173,7 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	TheTime: () => TheTime,
 	TheUndefined: () => TheUndefined,
 	TimeType: () => TimeType,
+	TrimmedConstraint: () => TrimmedConstraint,
 	TypeStructure: () => TypeStructure,
 	UndefinedType: () => UndefinedType,
 	UnionStructure: () => UnionStructure,
@@ -184,9 +190,11 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	betweenThanOrEqual: () => betweenThanOrEqual,
 	betweenThanOrEqualConstraintKind: () => betweenThanOrEqualConstraintKind,
 	bigint: () => bigint,
+	bigintFundamentalTypeKind: () => bigintFundamentalTypeKind,
 	bigintLiteralTypeKind: () => bigintLiteralTypeKind,
 	bigintTypeKind: () => bigintTypeKind,
 	boolean: () => boolean,
+	booleanFundamentalTypeKind: () => booleanFundamentalTypeKind,
 	booleanLiteralTypeKind: () => booleanLiteralTypeKind,
 	booleanTypeKind: () => booleanTypeKind,
 	codecKind: () => codecKind,
@@ -197,15 +205,19 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	createCodecs: () => createCodecs,
 	createConstraint: () => createConstraint,
 	createErrorHandler: () => createErrorHandler,
+	createErrorInterpreter: () => createErrorInterpreter,
 	createFundamentalType: () => createFundamentalType,
 	createGetErrorHandler: () => createGetErrorHandler,
 	createKind: () => createKind,
 	createStructure: () => createStructure,
 	createType: () => createType,
 	date: () => date,
+	dateFundamentalTypeKind: () => dateFundamentalTypeKind,
 	dateTypeKind: () => dateTypeKind,
+	decodeIssueKind: () => decodeIssueKind,
 	email: () => email,
 	emailConstraintKind: () => emailConstraintKind,
+	encodeIssueKind: () => encodeIssueKind,
 	even: () => even,
 	evenConstraintKind: () => evenConstraintKind,
 	extend: () => extend,
@@ -219,6 +231,7 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	integerConstraintKind: () => integerConstraintKind,
 	isNullStructure: () => isNullStructure,
 	isUndefinedStructure: () => isUndefinedStructure,
+	issueKind: () => issueKind,
 	lazy: () => lazy,
 	lazyStructureKind: () => lazyStructureKind,
 	lessThan: () => lessThan,
@@ -237,14 +250,17 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	multipleOfConstraintKind: () => multipleOfConstraintKind,
 	negative: () => negative,
 	negativeConstraintKind: () => negativeConstraintKind,
+	nonEncodableStringStructureKind: () => nonEncodableStringStructureKind,
 	notEmpty: () => notEmpty,
 	notEmptyConstraintKind: () => notEmptyConstraintKind,
 	notZero: () => notZero,
 	notZeroConstraintKind: () => notZeroConstraintKind,
 	null: () => nullHelper,
+	nullFundamentalTypeKind: () => nullFundamentalTypeKind,
 	nullTypeKind: () => nullTypeKind,
 	nullable: () => nullable,
 	number: () => number,
+	numberFundamentalTypeKind: () => numberFundamentalTypeKind,
 	numberLiteralTypeKind: () => numberLiteralTypeKind,
 	numberTypeKind: () => numberTypeKind,
 	object: () => object,
@@ -267,6 +283,7 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	strictPositive: () => strictPositive,
 	strictPositiveConstraintKind: () => strictPositiveConstraintKind,
 	string: () => string,
+	stringFundamentalTypeKind: () => stringFundamentalTypeKind,
 	stringLengthEqual: () => stringLengthEqual,
 	stringLengthEqualConstraintKind: () => stringLengthEqualConstraintKind,
 	stringLiteralTypeKind: () => stringLiteralTypeKind,
@@ -275,11 +292,15 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	structureIdentifier: () => structureIdentifier,
 	structureKind: () => structureKind,
 	time: () => time,
+	timeFundamentalTypeKind: () => timeFundamentalTypeKind,
 	timeTypeKind: () => timeTypeKind,
+	trimmed: () => trimmed,
+	trimmedConstraintKind: () => trimmedConstraintKind,
 	typeIdentifier: () => typeIdentifier,
 	typeKind: () => typeKind,
 	typeStructureKind: () => typeStructureKind,
 	undefined: () => undefinedHelper,
+	undefinedFundamentalTypeKind: () => undefinedFundamentalTypeKind,
 	undefinedTypeKind: () => undefinedTypeKind,
 	union: () => union,
 	unionStructureKind: () => unionStructureKind,
@@ -290,4 +311,4 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	uuidRegex: () => uuidRegex
 });
 //#endregion
-export { AllowedCharactersConstraint, ArrayLengthEqualConstraint, ArrayStructure, BetweenThanConstraint, BetweenThanOrEqualConstraint, BigintLiteralType, BigintType, BooleanLiteralType, BooleanType, DateType, EmailConstraint, ErrorSymbol, EvenConstraint, GreaterThanConstraint, GreaterThanOrEqualConstraint, IntegerConstraint, LazyStructure, LessThanConstraint, LessThanOrEqualConstraint, MaxCharactersConstraint, MaxElementsConstraint, MinCharactersConstraint, MinElementsConstraint, MultipleOfConstraint, NegativeConstraint, NotEmptyConstraint, NotZeroConstraint, NullType, NumberLiteralType, NumberType, ObjectStructure, OddConstraint, PositiveConstraint, RecordStructure, RefineConstraint, SafeConstraint, StrictNegativeConstraint, StrictPositiveConstraint, StringLengthEqualConstraint, StringLiteralType, StringType, StructureClass, SuccessSymbol, TheBigint, TheBoolean, TheDate, TheNull, TheNumber, TheString, TheTime, TheUndefined, TimeType, TypeStructure, UndefinedType, UnionStructure, UrlConstraint, UuidConstraint, allowedCharacters, allowedCharactersConstraintKind, array, arrayLengthEqual, arrayLengthEqualConstraintKind, arrayStructureKind, betweenThan, betweenThanConstraintKind, betweenThanOrEqual, betweenThanOrEqualConstraintKind, bigint, bigintLiteralTypeKind, bigintTypeKind, boolean, booleanLiteralTypeKind, booleanTypeKind, codecKind, codecsKind, constraintIdentifier, constraintKind, createCodec, createCodecs, createConstraint, createErrorHandler, createFundamentalType, createGetErrorHandler, createKind, createStructure, createType, dataStructure_exports, date, dateTypeKind, email, emailConstraintKind, even, evenConstraintKind, extend, fundamentalTypeIdentifier, fundamentalTypeKind, greaterThan, greaterThanConstraintKind, greaterThanOrEqual, greaterThanOrEqualConstraintKind, integer, integerConstraintKind, isNullStructure, isUndefinedStructure, lazy, lazyStructureKind, lessThan, lessThanConstraintKind, lessThanOrEqual, lessThanOrEqualConstraintKind, literal, maxCharacters, maxCharactersConstraintKind, maxElements, maxElementsConstraintKind, minCharacters, minElements, minElementsConstraintKind, multipleOf, multipleOfConstraintKind, negative, negativeConstraintKind, notEmpty, notEmptyConstraintKind, notZero, notZeroConstraintKind, nullHelper as null, nullTypeKind, nullable, number, numberLiteralTypeKind, numberTypeKind, object, objectStructureKind, odd, oddConstraintKind, optional, partial, positive, positiveConstraintKind, record, recordStructureKind, refine, refineConstraintKind, required, safe, safeConstraintKind, strictNegative, strictNegativeConstraintKind, strictPositive, strictPositiveConstraintKind, string, stringLengthEqual, stringLengthEqualConstraintKind, stringLiteralTypeKind, stringMinConstraintKind, stringTypeKind, structureIdentifier, structureKind, time, timeTypeKind, typeIdentifier, typeKind, typeStructureKind, undefinedHelper as undefined, undefinedTypeKind, union, unionStructureKind, url, urlConstraintKind, uuid, uuidConstraintKind, uuidRegex };
+export { AllowedCharactersConstraint, ArrayLengthEqualConstraint, ArrayStructure, BetweenThanConstraint, BetweenThanOrEqualConstraint, BigintLiteralType, BigintType, BooleanLiteralType, BooleanType, DateType, EmailConstraint, ErrorSymbol, EvenConstraint, GreaterThanConstraint, GreaterThanOrEqualConstraint, IntegerConstraint, LazyStructure, LessThanConstraint, LessThanOrEqualConstraint, MaxCharactersConstraint, MaxElementsConstraint, MinCharactersConstraint, MinElementsConstraint, MultipleOfConstraint, NegativeConstraint, NonEncodableStringStructure, NotEmptyConstraint, NotZeroConstraint, NullType, NumberLiteralType, NumberType, ObjectStructure, OddConstraint, PositiveConstraint, RecordStructure, RefineConstraint, SafeConstraint, StrictNegativeConstraint, StrictPositiveConstraint, StringLengthEqualConstraint, StringLiteralType, StringType, StructureClass, SuccessSymbol, TheBigint, TheBoolean, TheDate, TheNull, TheNumber, TheString, TheTime, TheUndefined, TimeType, TrimmedConstraint, TypeStructure, UndefinedType, UnionStructure, UrlConstraint, UuidConstraint, allowedCharacters, allowedCharactersConstraintKind, array, arrayLengthEqual, arrayLengthEqualConstraintKind, arrayStructureKind, betweenThan, betweenThanConstraintKind, betweenThanOrEqual, betweenThanOrEqualConstraintKind, bigint, bigintFundamentalTypeKind, bigintLiteralTypeKind, bigintTypeKind, boolean, booleanFundamentalTypeKind, booleanLiteralTypeKind, booleanTypeKind, codecKind, codecsKind, constraintIdentifier, constraintKind, createCodec, createCodecs, createConstraint, createErrorHandler, createErrorInterpreter, createFundamentalType, createGetErrorHandler, createKind, createStructure, createType, dataStructure_exports, date, dateFundamentalTypeKind, dateTypeKind, decodeIssueKind, email, emailConstraintKind, encodeIssueKind, even, evenConstraintKind, extend, fundamentalTypeIdentifier, fundamentalTypeKind, greaterThan, greaterThanConstraintKind, greaterThanOrEqual, greaterThanOrEqualConstraintKind, integer, integerConstraintKind, isNullStructure, isUndefinedStructure, issueKind, lazy, lazyStructureKind, lessThan, lessThanConstraintKind, lessThanOrEqual, lessThanOrEqualConstraintKind, literal, maxCharacters, maxCharactersConstraintKind, maxElements, maxElementsConstraintKind, minCharacters, minElements, minElementsConstraintKind, multipleOf, multipleOfConstraintKind, negative, negativeConstraintKind, nonEncodableStringStructureKind, notEmpty, notEmptyConstraintKind, notZero, notZeroConstraintKind, nullHelper as null, nullFundamentalTypeKind, nullTypeKind, nullable, number, numberFundamentalTypeKind, numberLiteralTypeKind, numberTypeKind, object, objectStructureKind, odd, oddConstraintKind, optional, partial, positive, positiveConstraintKind, record, recordStructureKind, refine, refineConstraintKind, required, safe, safeConstraintKind, strictNegative, strictNegativeConstraintKind, strictPositive, strictPositiveConstraintKind, string, stringFundamentalTypeKind, stringLengthEqual, stringLengthEqualConstraintKind, stringLiteralTypeKind, stringMinConstraintKind, stringTypeKind, structureIdentifier, structureKind, time, timeFundamentalTypeKind, timeTypeKind, trimmed, trimmedConstraintKind, typeIdentifier, typeKind, typeStructureKind, undefinedHelper as undefined, undefinedFundamentalTypeKind, undefinedTypeKind, union, unionStructureKind, url, urlConstraintKind, uuid, uuidConstraintKind, uuidRegex };

package/dist/dataStructure/structure/base.cjs

@@ -2,6 +2,7 @@ const require_bindPrototypeMethods = require("../../common/bindPrototypeMethods.
 const require_callThen = require("../../common/callThen.cjs");
 const require_create = require("../../either/left/create.cjs");
 const require_create$1 = require("../../either/right/create.cjs");
+const require_simpleClone = require("../../common/simpleClone.cjs");
 const require_kind = require("../kind.cjs");
 const require_resultSymbol = require("../common/resultSymbol.cjs");
 const require_error = require("../common/error.cjs");
@@ -15,7 +16,9 @@ var StructureClass = class StructureClass {
 		return self;
 	}
 	static addToPrototype(prop, value) {
-		StructureClass.prototype[prop] = value;
+		StructureClass.prototype[prop] = typeof value === "function" ? function(...args) {
+			return value(this, ...args);
+		} : value;
 	}
 };
 const structureKind = require_kind.createKind("structure");
@@ -34,7 +37,7 @@ function createStructure(kindHandler, createConstructor) {
 				executeDecode,
 				isAsynchronous
 			}, ...rest),
-			executeConstraints: (data, errorHandler) => definition.constraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : constraint.executeCheck(data, errorHandler)), require_resultSymbol.SuccessSymbol),
+			executeConstraints: (data, errorHandler) => definition.constraints.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(self, data, constraint) ?? require_resultSymbol.ErrorSymbol : require_resultSymbol.SuccessSymbol)), require_resultSymbol.SuccessSymbol),
 			executeCheck: (data, errorHandler) => require_callThen.callThen(executeCheck(self, data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : self.executeConstraints(data, errorHandler)),
 			executeEncode: (codecContext, data, errorHandler) => executeEncode(self, codecContext, data, errorHandler),
 			executeDecode: (codecContext, data, errorHandler) => executeDecode(self, codecContext, data, errorHandler),
@@ -58,8 +61,8 @@ function createStructure(kindHandler, createConstructor) {
 				if (await self.executeCheck(data, errorHandler) === require_resultSymbol.ErrorSymbol) return require_create.left("check-error", errorHandler().createError());
 				return require_create$1.right("check-success", data);
 			},
-			is: (data, errorHandler) => {
-				const result = self.executeCheck(data, errorHandler);
+			is: (data) => {
+				const result = self.executeCheck(data);
 				if (result instanceof Promise || result === require_resultSymbol.ErrorSymbol) return false;
 				return true;
 			},
@@ -94,12 +97,19 @@ function createStructure(kindHandler, createConstructor) {
 				return require_create$1.right("decode-success", result);
 			},
 			contract: () => self,
-			clone: () => init(definition, {
+			clone: () => init(require_simpleClone.simpleClone(definition), {
 				executeCheck,
 				executeEncode,
 				executeDecode,
 				isAsynchronous
 			}, ...rest),
+			setMessage: (message) => {
+				self.definition.message = message;
+				return self;
+			},
+			addMessage: (message) => {
+				return self.clone().setMessage(message);
+			},
 			[kindHandler.runTimeKey]: null,
 			[structureKind.runTimeKey]: null
 		});

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

@@ -7,15 +7,16 @@ import * as DCommon from '../../common';
 export declare class StructureClass {
     private constructor();
     static init(params: DKind.Remove<Structure>): Structure;
-    static addToPrototype<GenericProp extends keyof Structure>(prop: GenericProp, value: Structure[GenericProp]): void;
+    static addToPrototype<GenericProp extends keyof Structure>(prop: GenericProp, value: Structure[GenericProp] extends infer InferredValue ? InferredValue extends DCommon.AnyFunction ? (self: Structure, ...rest: Parameters<InferredValue>) => ReturnType<InferredValue> : Structure[GenericProp] : never): void;
 }
 export declare const structureKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/structure", unknown>>;
 export interface StructureDefinition<GenericConstraints extends readonly Constraint<any>[] = readonly Constraint<any>[]> {
+    readonly message?: string;
     readonly constraints: readonly [...GenericConstraints];
 }
 export interface Structure<GenericValue extends unknown = unknown, GenericDefinition extends StructureDefinition<readonly Constraint<GenericValue>[]> = StructureDefinition<readonly Constraint<GenericValue>[]>> extends DKind.Kind<typeof structureKind, (GenericValue & StructureConstraintsValue<GenericDefinition["constraints"][number]>)> {
     readonly definition: GenericDefinition;
-    addConstraint<const GenericNewConstraints extends DCommon.AnyTuple<Constraint<GenericValue>>>(...args: DCommon.FixDeepFunctionInfer<DCommon.AnyTuple<Constraint<GenericValue>>, GenericNewConstraints>): Structure<GenericValue, StructureDefinition<readonly [...this["definition"]["constraints"], ...GenericNewConstraints]>>;
+    addConstraint<const GenericNewConstraints extends DCommon.AnyTuple<Constraint<GenericValue>>>(...args: DCommon.FixDeepFunctionInfer<DCommon.AnyTuple<Constraint<GenericValue>>, GenericNewConstraints>): Structure<StructureValue<this>, StructureDefinition<readonly [...this["definition"]["constraints"], ...GenericNewConstraints]>>;
     executeConstraints(data: unknown, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     executeCheck(data: unknown, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     executeEncode(codecContext: CodecContext, data: unknown, errorHandler?: GetErrorHandler): unknown;
@@ -23,7 +24,7 @@ export interface Structure<GenericValue extends unknown = unknown, GenericDefini
     isAsynchronous(): boolean;
     check(data: unknown): (DEither.Right<"check-success", StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"check-error", Error>);
     asyncCheck(data: unknown): Promise<DEither.Right<"check-success", StructureValue<this>> | DEither.Left<"check-error", Error>>;
-    is(data: unknown, errorHandler?: GetErrorHandler): data is StructureValue<this>;
+    is(data: unknown): data is StructureValue<this>;
     encode<GenericCodecs extends Codecs>(codecs: GenericCodecs, data: StructureValue<this>): (DEither.Right<"encode-success", EncodedValue<StructureValue<this>, GenericCodecs>> | DEither.Left<"async-error", undefined> | DEither.Left<"encode-error", Error>);
     asyncEncode<GenericCodecs extends Codecs>(codecs: GenericCodecs, data: StructureValue<this>): Promise<DEither.Right<"encode-success", EncodedValue<StructureValue<this>, GenericCodecs>> | DEither.Left<"encode-error", Error>>;
     unsafeEncode<GenericCodecs extends Codecs>(codecs: GenericCodecs, data: unknown): (DEither.Right<"encode-success", EncodedValue<StructureValue<this>, GenericCodecs>> | DEither.Left<"async-error", undefined> | DEither.Left<"encode-error", Error>);
@@ -34,6 +35,8 @@ export interface Structure<GenericValue extends unknown = unknown, GenericDefini
     asyncUnsafeDecode(codecs: Codecs, data: unknown): Promise<DEither.Right<"decode-success", StructureValue<this>> | DEither.Left<"decode-error", Error>>;
     contract<GenericValue extends unknown, GenericThis extends this>(...args: DCommon.IsEqual<StructureValue<GenericThis>, GenericValue> extends true ? [] : [] & DCommon.ComputedTypeError<"Contract error.">): Structure<GenericValue>;
     clone(): this;
+    setMessage(massage: string): this;
+    addMessage(massage: string): this;
 }
 export interface CreateStructureInitParams<GenericStructure extends Structure = Structure> {
     executeCheck(self: GenericStructure, data: unknown, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
@@ -45,6 +48,6 @@ export type CreateStructureInitRest<GenericStructure extends Structure = Structu
     [Prop in Exclude<keyof GenericStructure, keyof Structure>]: GenericStructure[Prop] extends DCommon.AnyFunction ? (self: GenericStructure, ...args: Parameters<GenericStructure[Prop]>) => ReturnType<GenericStructure[Prop]> : GenericStructure[Prop];
 };
 export interface CreateStructureConstructorParams<GenericKindHandler extends DKind.Handler = DKind.Handler> {
-    init<GenericStructure extends (Structure & DKind.Kind<GenericKindHandler>)>(definition: GenericStructure["definition"], params: CreateStructureInitParams<GenericStructure>, ...args: DCommon.IsNever<Exclude<keyof GenericStructure, keyof Structure>> extends true ? [] : [rest: CreateStructureInitRest<GenericStructure>]): GenericStructure;
+    init<GenericStructure extends (Structure & DKind.Kind<GenericKindHandler>)>(definition: GenericStructure["definition"], params: CreateStructureInitParams<GenericStructure>, ...args: DCommon.IsNever<Exclude<keyof GenericStructure, keyof Structure>> extends true ? [] : [rest: CreateStructureInitRest<GenericStructure>]): NoInfer<GenericStructure>;
 }
 export declare function createStructure<GenericKindHandler extends DKind.Handler, GenericConstructor extends ((...args: any[]) => (Structure & DKind.Kind<GenericKindHandler>))>(kindHandler: GenericKindHandler, createConstructor: (params: CreateStructureConstructorParams<GenericKindHandler>) => GenericConstructor): GenericConstructor;

package/dist/dataStructure/structure/base.mjs

@@ -2,6 +2,7 @@ import { bindPrototypeMethods } from "../../common/bindPrototypeMethods.mjs";
 import { callThen } from "../../common/callThen.mjs";
 import { left } from "../../either/left/create.mjs";
 import { right } from "../../either/right/create.mjs";
+import { simpleClone } from "../../common/simpleClone.mjs";
 import { createKind } from "../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../common/resultSymbol.mjs";
 import { createGetErrorHandler } from "../common/error.mjs";
@@ -15,7 +16,9 @@ var StructureClass = class StructureClass {
 		return self;
 	}
 	static addToPrototype(prop, value) {
-		StructureClass.prototype[prop] = value;
+		StructureClass.prototype[prop] = typeof value === "function" ? function(...args) {
+			return value(this, ...args);
+		} : value;
 	}
 };
 const structureKind = createKind("structure");
@@ -34,7 +37,7 @@ function createStructure(kindHandler, createConstructor) {
 				executeDecode,
 				isAsynchronous
 			}, ...rest),
-			executeConstraints: (data, errorHandler) => definition.constraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : constraint.executeCheck(data, errorHandler)), SuccessSymbol),
+			executeConstraints: (data, errorHandler) => definition.constraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : callThen(constraint.executeCheck(data), (constraintResult) => constraintResult === ErrorSymbol ? errorHandler?.().addIssue(self, data, constraint) ?? ErrorSymbol : SuccessSymbol)), SuccessSymbol),
 			executeCheck: (data, errorHandler) => callThen(executeCheck(self, data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : self.executeConstraints(data, errorHandler)),
 			executeEncode: (codecContext, data, errorHandler) => executeEncode(self, codecContext, data, errorHandler),
 			executeDecode: (codecContext, data, errorHandler) => executeDecode(self, codecContext, data, errorHandler),
@@ -58,8 +61,8 @@ function createStructure(kindHandler, createConstructor) {
 				if (await self.executeCheck(data, errorHandler) === ErrorSymbol) return left("check-error", errorHandler().createError());
 				return right("check-success", data);
 			},
-			is: (data, errorHandler) => {
-				const result = self.executeCheck(data, errorHandler);
+			is: (data) => {
+				const result = self.executeCheck(data);
 				if (result instanceof Promise || result === ErrorSymbol) return false;
 				return true;
 			},
@@ -94,12 +97,19 @@ function createStructure(kindHandler, createConstructor) {
 				return right("decode-success", result);
 			},
 			contract: () => self,
-			clone: () => init(definition, {
+			clone: () => init(simpleClone(definition), {
 				executeCheck,
 				executeEncode,
 				executeDecode,
 				isAsynchronous
 			}, ...rest),
+			setMessage: (message) => {
+				self.definition.message = message;
+				return self;
+			},
+			addMessage: (message) => {
+				return self.clone().setMessage(message);
+			},
 			[kindHandler.runTimeKey]: null,
 			[structureKind.runTimeKey]: null
 		});

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

@@ -15,4 +15,4 @@ export interface ArrayStructureDefinition<GenericConstraints extends readonly Co
 }
 export interface ArrayStructure<GenericValue extends readonly unknown[] = readonly unknown[], GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<Structure<GenericValue, ArrayStructureDefinition<GenericConstraints>> & DKind.Kind<typeof arrayStructureKind>> {
 }
-export declare const ArrayStructure: <GenericElement extends Structure, const GenericConstraints extends readonly Constraint<readonly StructureValue<GenericElement>[]>[]>(element: GenericElement, constraints: GenericConstraints) => ArrayStructure<readonly StructureValue<GenericElement>[], readonly [...GenericConstraints]>;
+export declare const ArrayStructure: <GenericElement extends Structure, const GenericConstraints extends readonly Constraint<readonly StructureValue<GenericElement>[]>[]>(element: GenericElement, constraints: GenericConstraints) => NoInfer<ArrayStructure<readonly StructureValue<GenericElement>[], readonly [...GenericConstraints]>>;

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

@@ -11,7 +11,8 @@ const ArrayStructure = createStructure(arrayStructureKind, ({ init }) => (elemen
 	executeCheck: (self, data, errorHandler) => {
 		if (!Array.isArray(data)) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		return callThen(data.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`[array: ${index}]`) ?? callThen(self.definition.element.executeCheck(value, errorHandler), (result) => result === ErrorSymbol || awaitedAccumulator === ErrorSymbol ? ErrorSymbol : SuccessSymbol)), SuccessSymbol), (awaitedResult) => {
+		const result = data.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`[array: ${index}]`) ?? callThen(self.definition.element.executeCheck(value, errorHandler), (result) => result === ErrorSymbol || awaitedAccumulator === ErrorSymbol ? ErrorSymbol : SuccessSymbol)), SuccessSymbol);
+		return callThen(result, (awaitedResult) => {
 			pathStage?.close();
 			return awaitedResult;
 		});
@@ -19,20 +20,22 @@ const ArrayStructure = createStructure(arrayStructureKind, ({ init }) => (elemen
 	executeEncode: (self, codecContext, data, errorHandler) => {
 		if (!Array.isArray(data)) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		return callThen(data.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`[array: ${index}]`) ?? callThen(self.definition.element.executeEncode(codecContext, value, errorHandler), (encodedData) => {
+		const encodedData = data.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`[array: ${index}]`) ?? callThen(self.definition.element.executeEncode(codecContext, value, errorHandler), (encodedData) => {
 			if (encodedData === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
 			awaitedAccumulator[index] = 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 (!Array.isArray(data)) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		return callThen(data.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`[array: ${index}]`) ?? callThen(self.definition.element.executeDecode(codecContext, value, errorHandler), (decodedData) => {
+		const decodedData = data.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`[array: ${index}]`) ?? callThen(self.definition.element.executeDecode(codecContext, value, errorHandler), (decodedData) => {
 			if (decodedData === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
 			awaitedAccumulator[index] = 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.element.isAsynchronous()
 }));

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

@@ -1,5 +1,6 @@
 export * from './array';
 export * from './lazy';
+export * from './nonEncodableString';
 export * from './object';
 export * from './record';
 export * from './type';

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

@@ -1,5 +1,7 @@
+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_base = require("../base.cjs");
 //#region scripts/dataStructure/structure/defaults/lazy.ts
 const lazyStructureKind = require_kind.createKind("lazy-structure");
@@ -8,8 +10,8 @@ const LazyStructure = require_base.createStructure(lazyStructureKind, ({ init })
 	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) => require_callThen.callThen(self.definition.getter.value.executeEncode(codecContext, data, errorHandler), (encodedData) => encodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : encodedData)),
+	executeDecode: (self, codecContext, data, errorHandler) => require_callThen.callThen(self.definition.getter.value.executeDecode(codecContext, data, errorHandler), (decodedData) => decodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(decodedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : decodedData)),
 	isAsynchronous: (self) => self.definition.getter.value.isAsynchronous()
 }));
 //#endregion

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

@@ -9,4 +9,4 @@ export interface LazyStructureDefinition<GenericConstraints extends readonly Con
 }
 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 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,5 +1,7 @@
+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";
 //#region scripts/dataStructure/structure/defaults/lazy.ts
 const lazyStructureKind = createKind("lazy-structure");
@@ -8,8 +10,8 @@ const LazyStructure = createStructure(lazyStructureKind, ({ init }) => (getStruc
 	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.UnionToIntersection<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

@@ -27,4 +27,4 @@ export interface ObjectStructureDefinition<GenericConstraints extends readonly C
 }
 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 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.d.ts

@@ -16,4 +16,4 @@ export interface RecordStructureDefinition<GenericConstraints extends readonly C
 }
 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 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

@@ -31,7 +31,8 @@ const RecordStructure = createStructure(recordStructureKind, ({ init }) => (key,
 		const requiredKeys = self.definition.requiredKeys;
 		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;
 		});
@@ -42,11 +43,12 @@ const RecordStructure = createStructure(recordStructureKind, ({ init }) => (key,
 		const requiredKeys = self.definition.requiredKeys;
 		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;
@@ -54,11 +56,12 @@ const RecordStructure = createStructure(recordStructureKind, ({ init }) => (key,
 		const requiredKeys = self.definition.requiredKeys;
 		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);