@duplojs/lang 0.0.1-beta.8 → 0.1.0-beta.1

package/dist/dataStructure/structure/base.mjs

@@ -5,7 +5,7 @@ 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";
+import { ErrorPromise, createGetErrorHandler } from "../common/error/base.mjs";
 //#region scripts/dataStructure/structure/base.ts
 var StructureClass = class StructureClass {
 	constructor() {}
@@ -23,7 +23,7 @@ var StructureClass = class StructureClass {
 };
 const structureKind = createKind("structure");
 function createStructure(kindHandler, createConstructor) {
-	const init = (definition, { executeCheck, executeEncode, executeDecode, isAsynchronous }, ...rest) => {
+	const init = (definition, { executeCheck, executeEncode, executeDecode, executeParse, isAsynchronous }, ...rest) => {
 		let cachedIsAsynchronous = void 0;
 		const self = StructureClass.init({
 			...Object.fromEntries(Object.entries(rest[0] ?? {}).map(([key, prop]) => typeof prop === "function" ? [key, (...args) => prop(self, ...args)] : [key, prop])),
@@ -35,12 +35,14 @@ function createStructure(kindHandler, createConstructor) {
 				executeCheck,
 				executeEncode,
 				executeDecode,
+				executeParse,
 				isAsynchronous
 			}, ...rest),
 			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),
+			executeParse: (codecContext, data, errorHandler) => executeParse(self, codecContext, data, errorHandler),
 			isAsynchronous: () => {
 				if (cachedIsAsynchronous !== void 0) return cachedIsAsynchronous;
 				cachedIsAsynchronous = false;
@@ -52,7 +54,7 @@ function createStructure(kindHandler, createConstructor) {
 			check: (data) => {
 				const errorHandler = createGetErrorHandler();
 				const result = self.executeCheck(data, errorHandler);
-				if (result instanceof Promise) return left("async-error", void 0);
+				if (result instanceof Promise) return left("async-error", new ErrorPromise());
 				if (result === ErrorSymbol) return left("check-error", errorHandler().createError());
 				return right("check-success", data);
 			},
@@ -66,41 +68,51 @@ function createStructure(kindHandler, createConstructor) {
 				if (result instanceof Promise || result === ErrorSymbol) return false;
 				return true;
 			},
-			encode: (codecs, data) => self.unsafeEncode(codecs, data),
-			asyncEncode: (codecs, data) => self.asyncUnsafeEncode(codecs, data),
-			unsafeEncode: (codecs, data) => {
+			encode: (codecs, data) => {
 				const errorHandler = createGetErrorHandler();
 				const result = self.executeEncode(codecs.context.value, data, errorHandler);
-				if (result instanceof Promise) return left("async-error", void 0);
+				if (result instanceof Promise) return left("async-error", new ErrorPromise());
 				if (result === ErrorSymbol) return left("encode-error", errorHandler().createError());
 				return right("encode-success", result);
 			},
-			asyncUnsafeEncode: async (codecs, data) => {
+			asyncEncode: async (codecs, data) => {
 				const errorHandler = createGetErrorHandler();
 				const result = await self.executeEncode(codecs.context.value, data, errorHandler);
 				if (result === ErrorSymbol) return left("encode-error", errorHandler().createError());
 				return right("encode-success", result);
 			},
-			decode: (codecs, data) => self.unsafeDecode(codecs, data),
-			asyncDecode: (codecs, data) => self.asyncUnsafeDecode(codecs, data),
-			unsafeDecode: (codecs, data) => {
+			decode: (codecs, data) => {
 				const errorHandler = createGetErrorHandler();
 				const result = self.executeDecode(codecs.context.value, data, errorHandler);
-				if (result instanceof Promise) return left("async-error", void 0);
+				if (result instanceof Promise) return left("async-error", new ErrorPromise());
 				if (result === ErrorSymbol) return left("decode-error", errorHandler().createError());
 				return right("decode-success", result);
 			},
-			asyncUnsafeDecode: async (codecs, data) => {
+			asyncDecode: async (codecs, data) => {
 				const errorHandler = createGetErrorHandler();
 				const result = await self.executeDecode(codecs.context.value, data, errorHandler);
 				if (result === ErrorSymbol) return left("decode-error", errorHandler().createError());
 				return right("decode-success", result);
 			},
+			parse: (data, codecs) => {
+				const errorHandler = createGetErrorHandler();
+				const result = self.executeParse(codecs?.context.value ?? /* @__PURE__ */ new Map(), data, errorHandler);
+				if (result instanceof Promise) return left("async-error", new ErrorPromise());
+				if (result === ErrorSymbol) return left("parse-error", errorHandler().createError());
+				return right("parse-success", result);
+			},
+			asyncParse: async (data, codecs) => {
+				const errorHandler = createGetErrorHandler();
+				const result = await self.executeParse(codecs?.context.value ?? /* @__PURE__ */ new Map(), data, errorHandler);
+				if (result === ErrorSymbol) return left("parse-error", errorHandler().createError());
+				return right("parse-success", result);
+			},
 			contract: () => self,
 			clone: () => init(simpleClone(definition), {
 				executeCheck,
 				executeEncode,
 				executeDecode,
+				executeParse,
 				isAsynchronous
 			}, ...rest),
 			setMessage: (message) => {

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

@@ -37,6 +37,16 @@ const ArrayStructure = require_base.createStructure(arrayStructureKind, ({ init
 		})), []);
 		return require_callThen.callThen(decodedData, (awaitedDecodedData) => pathStage?.close() ?? (awaitedDecodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedDecodedData)));
 	},
+	executeParse: (self, codecContext, data, errorHandler) => {
+		if (!Array.isArray(data)) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
+		const pathStage = errorHandler?.().createPathStage();
+		const parsedData = data.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`[array: ${index}]`) ?? require_callThen.callThen(self.definition.element.executeParse(codecContext, value, errorHandler), (parsedData) => {
+			if (parsedData === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
+			awaitedAccumulator[index] = parsedData;
+			return awaitedAccumulator;
+		})), []);
+		return require_callThen.callThen(parsedData, (awaitedParsedData) => pathStage?.close() ?? (awaitedParsedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedParsedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedParsedData)));
+	},
 	isAsynchronous: (self) => self.definition.element.isAsynchronous()
 }));
 //#endregion

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

@@ -13,6 +13,6 @@ export declare const arrayStructureKind: DKind.Handler<DKind.Definition<"@Duploj
 export interface ArrayStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
     readonly element: Structure;
 }
-export interface ArrayStructure<GenericValue extends readonly unknown[] = readonly unknown[], GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, ArrayStructureDefinition<GenericConstraints>> & DKind.Kind<typeof arrayStructureKind>> {
+export interface ArrayStructure<out GenericValue extends readonly unknown[] = readonly unknown[], out GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<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) => NoInfer<ArrayStructure<readonly StructureValue<GenericElement>[], readonly [...GenericConstraints]>>;

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

@@ -37,6 +37,16 @@ const ArrayStructure = createStructure(arrayStructureKind, ({ init }) => (elemen
 		})), []);
 		return callThen(decodedData, (awaitedDecodedData) => pathStage?.close() ?? (awaitedDecodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedDecodedData)));
 	},
+	executeParse: (self, codecContext, data, errorHandler) => {
+		if (!Array.isArray(data)) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
+		const pathStage = errorHandler?.().createPathStage();
+		const parsedData = data.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(`[array: ${index}]`) ?? callThen(self.definition.element.executeParse(codecContext, value, errorHandler), (parsedData) => {
+			if (parsedData === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
+			awaitedAccumulator[index] = parsedData;
+			return awaitedAccumulator;
+		})), []);
+		return callThen(parsedData, (awaitedParsedData) => pathStage?.close() ?? (awaitedParsedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedParsedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedParsedData)));
+	},
 	isAsynchronous: (self) => self.definition.element.isAsynchronous()
 }));
 //#endregion

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

@@ -17,6 +17,7 @@ const LazyStructure = require_base.createStructure(lazyStructureKind, ({ init })
 	executeCheck: (self, data, errorHandler) => self.definition.getter.value.executeCheck(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)),
+	executeParse: (self, codecContext, data, errorHandler) => require_callThen.callThen(self.definition.getter.value.executeParse(codecContext, data, errorHandler), (parsedData) => parsedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(parsedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : parsedData)),
 	isAsynchronous: (self) => self.definition.getter.value.isAsynchronous()
 }));
 //#endregion

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.Forward<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) => NoInfer<LazyStructure<StructureValue<GenericStructure>, readonly [...GenericConstraints]>>;

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

@@ -17,6 +17,7 @@ const LazyStructure = createStructure(lazyStructureKind, ({ init }) => (getStruc
 	executeCheck: (self, data, errorHandler) => self.definition.getter.value.executeCheck(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)),
+	executeParse: (self, codecContext, data, errorHandler) => callThen(self.definition.getter.value.executeParse(codecContext, data, errorHandler), (parsedData) => parsedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(parsedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : parsedData)),
 	isAsynchronous: (self) => self.definition.getter.value.isAsynchronous()
 }));
 //#endregion

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

@@ -10,6 +10,7 @@ const NonEncodableStringStructure = require_base.createStructure(nonEncodableStr
 	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,
+	executeParse: (self, codecContext, data, errorHandler) => self.executeDecode(codecContext, data, errorHandler),
 	isAsynchronous: () => false
 }));
 //#endregion

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

@@ -10,6 +10,7 @@ const NonEncodableStringStructure = createStructure(nonEncodableStringStructureK
 	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,
+	executeParse: (self, codecContext, data, errorHandler) => self.executeDecode(codecContext, data, errorHandler),
 	isAsynchronous: () => false
 }));
 //#endregion

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

@@ -7,10 +7,11 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/structure/defaults/object.ts
 const objectStructureKind = require_kind.createKind("object-structure");
 const ObjectStructure = require_base.createStructure(objectStructureKind, ({ init }) => (shape, constraints) => init({
-	shape: require_memo.memo(() => Object.entries(shape).map(([key, value]) => ({
+	optimizedShape: require_memo.memo(() => Object.entries(shape).map(([key, value]) => ({
 		key,
 		value
 	}))),
+	shape,
 	keys: Object.keys(shape),
 	constraints
 }, {
@@ -18,7 +19,7 @@ const ObjectStructure = require_base.createStructure(objectStructureKind, ({ ini
 		if (!require_isSimple.isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		if (Object.keys(data).some((value) => !self.definition.keys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		const result = self.definition.shape.value.reduce((accumulator, entry) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? require_callThen.callThen(entry.value.executeCheck(data[entry.key], errorHandler), (result) => result === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_resultSymbol.SuccessSymbol)), require_resultSymbol.SuccessSymbol);
+		const result = self.definition.optimizedShape.value.reduce((accumulator, entry) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? require_callThen.callThen(entry.value.executeCheck(data[entry.key], errorHandler), (result) => result === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_resultSymbol.SuccessSymbol)), require_resultSymbol.SuccessSymbol);
 		return require_callThen.callThen(result, (awaitedResult) => {
 			pathStage?.close();
 			return awaitedResult;
@@ -28,9 +29,9 @@ const ObjectStructure = require_base.createStructure(objectStructureKind, ({ ini
 		if (!require_isSimple.isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		if (Object.keys(data).some((value) => !self.definition.keys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		const encodedData = self.definition.shape.value.reduce((accumulator, entry) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? require_callThen.callThen(entry.value.executeEncode(codecContext, data[entry.key], errorHandler), (encodedData) => {
+		const encodedData = self.definition.optimizedShape.value.reduce((accumulator, entry) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? require_callThen.callThen(entry.value.executeEncode(codecContext, data[entry.key], errorHandler), (encodedData) => {
 			if (encodedData === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
-			awaitedAccumulator[entry.key] = encodedData;
+			if (encodedData !== void 0) awaitedAccumulator[entry.key] = encodedData;
 			return awaitedAccumulator;
 		})), {});
 		return require_callThen.callThen(encodedData, (awaitedEncodedData) => pathStage?.close() ?? (awaitedEncodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedEncodedData)));
@@ -39,14 +40,24 @@ const ObjectStructure = require_base.createStructure(objectStructureKind, ({ ini
 		if (!require_isSimple.isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		if (Object.keys(data).some((value) => !self.definition.keys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		const decodedData = self.definition.shape.value.reduce((accumulator, entry) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? require_callThen.callThen(entry.value.executeDecode(codecContext, data[entry.key], errorHandler), (decodedData) => {
+		const decodedData = self.definition.optimizedShape.value.reduce((accumulator, entry) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? require_callThen.callThen(entry.value.executeDecode(codecContext, data[entry.key], errorHandler), (decodedData) => {
 			if (decodedData === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
-			awaitedAccumulator[entry.key] = decodedData;
+			if (decodedData !== void 0) awaitedAccumulator[entry.key] = decodedData;
 			return awaitedAccumulator;
 		})), {});
 		return require_callThen.callThen(decodedData, (awaitedDecodedData) => pathStage?.close() ?? (awaitedDecodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedDecodedData)));
 	},
-	isAsynchronous: (self) => self.definition.shape.value.some((entry) => entry.value.isAsynchronous())
+	executeParse: (self, codecContext, data, errorHandler) => {
+		if (!require_isSimple.isSimple(data)) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
+		const pathStage = errorHandler?.().createPathStage();
+		const parsedData = self.definition.optimizedShape.value.reduce((accumulator, entry) => require_callThen.callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? require_callThen.callThen(entry.value.executeParse(codecContext, data[entry.key], errorHandler), (parsedData) => {
+			if (parsedData === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
+			if (parsedData !== void 0) awaitedAccumulator[entry.key] = parsedData;
+			return awaitedAccumulator;
+		})), {});
+		return require_callThen.callThen(parsedData, (awaitedParsedData) => pathStage?.close() ?? (awaitedParsedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedParsedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedParsedData)));
+	},
+	isAsynchronous: (self) => self.definition.optimizedShape.value.some((entry) => entry.value.isAsynchronous())
 }));
 //#endregion
 exports.ObjectStructure = ObjectStructure;

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

@@ -22,9 +22,10 @@ export type ShapeObjectStructureValue<GenericShape extends ShapeObjectStructure>
 } extends infer InferredResult extends Record<string, unknown> ? DObject.PartialKeys<InferredResult, DObject.GetPropsWithValueExtends<InferredResult, undefined>> : never;
 export declare const objectStructureKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/object-structure", unknown>>;
 export interface ObjectStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
-    readonly shape: DCommon.Memoized<readonly EntryShapeObjectStructure[]>;
+    readonly optimizedShape: DCommon.Memoized<readonly EntryShapeObjectStructure[]>;
+    readonly shape: Readonly<Record<string, Structure>>;
     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.Forward<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) => NoInfer<ObjectStructure<ShapeObjectStructureValue<GenericShape>, readonly [...GenericConstraints]>>;

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

@@ -7,10 +7,11 @@ import { createStructure } from "../base.mjs";
 //#region scripts/dataStructure/structure/defaults/object.ts
 const objectStructureKind = createKind("object-structure");
 const ObjectStructure = createStructure(objectStructureKind, ({ init }) => (shape, constraints) => init({
-	shape: memo(() => Object.entries(shape).map(([key, value]) => ({
+	optimizedShape: memo(() => Object.entries(shape).map(([key, value]) => ({
 		key,
 		value
 	}))),
+	shape,
 	keys: Object.keys(shape),
 	constraints
 }, {
@@ -18,7 +19,7 @@ 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();
-		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);
+		const result = self.definition.optimizedShape.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;
@@ -28,9 +29,9 @@ 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();
-		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) => {
+		const encodedData = self.definition.optimizedShape.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;
+			if (encodedData !== void 0) awaitedAccumulator[entry.key] = encodedData;
 			return awaitedAccumulator;
 		})), {});
 		return callThen(encodedData, (awaitedEncodedData) => pathStage?.close() ?? (awaitedEncodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedEncodedData)));
@@ -39,14 +40,24 @@ 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();
-		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) => {
+		const decodedData = self.definition.optimizedShape.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;
+			if (decodedData !== void 0) awaitedAccumulator[entry.key] = decodedData;
 			return awaitedAccumulator;
 		})), {});
 		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())
+	executeParse: (self, codecContext, data, errorHandler) => {
+		if (!isSimple(data)) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
+		const pathStage = errorHandler?.().createPathStage();
+		const parsedData = self.definition.optimizedShape.value.reduce((accumulator, entry) => callThen(accumulator, (awaitedAccumulator) => pathStage?.setCurrentPath(entry.key) ?? callThen(entry.value.executeParse(codecContext, data[entry.key], errorHandler), (parsedData) => {
+			if (parsedData === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
+			if (parsedData !== void 0) awaitedAccumulator[entry.key] = parsedData;
+			return awaitedAccumulator;
+		})), {});
+		return callThen(parsedData, (awaitedParsedData) => pathStage?.close() ?? (awaitedParsedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedParsedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedParsedData)));
+	},
+	isAsynchronous: (self) => self.definition.optimizedShape.value.some((entry) => entry.value.isAsynchronous())
 }));
 //#endregion
 export { ObjectStructure, objectStructureKind };

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

@@ -1,4 +1,5 @@
 const require_callThen = require("../../../common/callThen.cjs");
+const require_isSimple = require("../../../object/isSimple.cjs");
 const require_isType = require("../../../common/isType.cjs");
 const require_memo = require("../../../common/memo.cjs");
 const require_kind = require("../../kind.cjs");
@@ -26,7 +27,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;
+		if (!require_isSimple.isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const keyData = Object.keys(data);
 		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
@@ -38,31 +39,43 @@ 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;
+		if (!require_isSimple.isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const keyData = Object.keys(data);
 		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) => {
+		const encodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => key === "__proto__" ? accumulator : 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) => {
 			if (keyResult === require_resultSymbol.ErrorSymbol || encodedValue === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
-			awaitedAccumulator[key] = encodedValue;
+			if (encodedValue !== void 0) awaitedAccumulator[key] = encodedValue;
 			return awaitedAccumulator;
 		}))), {});
 		return require_callThen.callThen(encodedData, (awaitedEncodedData) => pathStage?.close() ?? (awaitedEncodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.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) ?? require_resultSymbol.ErrorSymbol;
+		if (!require_isSimple.isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
 		const keyData = Object.keys(data);
 		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) => {
+		const decodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => key === "__proto__" ? accumulator : 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) => {
 			if (keyResult === require_resultSymbol.ErrorSymbol || decodedValue === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
-			awaitedAccumulator[key] = decodedValue;
+			if (decodedValue !== void 0) awaitedAccumulator[key] = decodedValue;
 			return awaitedAccumulator;
 		}))), {});
 		return require_callThen.callThen(decodedData, (awaitedDecodedData) => pathStage?.close() ?? (awaitedDecodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedDecodedData)));
 	},
+	executeParse: (self, codecContext, data, errorHandler) => {
+		if (!require_isSimple.isSimple(data)) return errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol;
+		const keyData = Object.keys(data);
+		const requiredKeys = self.definition.requiredKeys.value;
+		const pathStage = errorHandler?.().createPathStage();
+		const parsedData = (requiredKeys ?? keyData).reduce((accumulator, key) => key === "__proto__" ? accumulator : 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.executeParse(codecContext, data[key], errorHandler), (parsedValue) => {
+			if (keyResult === require_resultSymbol.ErrorSymbol || parsedValue === require_resultSymbol.ErrorSymbol || awaitedAccumulator === require_resultSymbol.ErrorSymbol) return require_resultSymbol.ErrorSymbol;
+			if (parsedValue !== void 0) awaitedAccumulator[key] = parsedValue;
+			return awaitedAccumulator;
+		}))), {});
+		return require_callThen.callThen(parsedData, (awaitedParsedData) => pathStage?.close() ?? (awaitedParsedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedParsedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedParsedData)));
+	},
 	isAsynchronous: (self) => self.definition.key.isAsynchronous() || self.definition.value.isAsynchronous()
 }));
 //#endregion

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

@@ -14,6 +14,6 @@ export interface RecordStructureDefinition<GenericConstraints extends readonly C
     readonly value: Structure;
     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.Forward<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) => NoInfer<RecordStructure<RecordStructureValue<GenericKey, GenericValueStructure>, readonly [...GenericConstraints]>>;

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

@@ -1,4 +1,5 @@
 import { callThen } from "../../../common/callThen.mjs";
+import { isSimple } from "../../../object/isSimple.mjs";
 import { isType } from "../../../common/isType.mjs";
 import { memo } from "../../../common/memo.mjs";
 import { createKind } from "../../kind.mjs";
@@ -26,7 +27,7 @@ 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;
+		if (!isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const keyData = Object.keys(data);
 		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
@@ -38,31 +39,43 @@ 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;
+		if (!isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const keyData = Object.keys(data);
 		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		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) => {
+		const encodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => key === "__proto__" ? accumulator : 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;
+			if (encodedValue !== void 0) awaitedAccumulator[key] = encodedValue;
 			return awaitedAccumulator;
 		}))), {});
 		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;
+		if (!isSimple(data) || Object.getOwnPropertySymbols(data).length !== 0) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const keyData = Object.keys(data);
 		const requiredKeys = self.definition.requiredKeys.value;
 		if (requiredKeys && keyData.some((value) => !requiredKeys.includes(value))) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
 		const pathStage = errorHandler?.().createPathStage();
-		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) => {
+		const decodedData = (requiredKeys ?? keyData).reduce((accumulator, key) => key === "__proto__" ? accumulator : 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;
+			if (decodedValue !== void 0) awaitedAccumulator[key] = decodedValue;
 			return awaitedAccumulator;
 		}))), {});
 		return callThen(decodedData, (awaitedDecodedData) => pathStage?.close() ?? (awaitedDecodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedDecodedData)));
 	},
+	executeParse: (self, codecContext, data, errorHandler) => {
+		if (!isSimple(data)) return errorHandler?.().addIssue(self, data) ?? ErrorSymbol;
+		const keyData = Object.keys(data);
+		const requiredKeys = self.definition.requiredKeys.value;
+		const pathStage = errorHandler?.().createPathStage();
+		const parsedData = (requiredKeys ?? keyData).reduce((accumulator, key) => key === "__proto__" ? accumulator : 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.executeParse(codecContext, data[key], errorHandler), (parsedValue) => {
+			if (keyResult === ErrorSymbol || parsedValue === ErrorSymbol || awaitedAccumulator === ErrorSymbol) return ErrorSymbol;
+			if (parsedValue !== void 0) awaitedAccumulator[key] = parsedValue;
+			return awaitedAccumulator;
+		}))), {});
+		return callThen(parsedData, (awaitedParsedData) => pathStage?.close() ?? (awaitedParsedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedParsedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedParsedData)));
+	},
 	isAsynchronous: (self) => self.definition.key.isAsynchronous() || self.definition.value.isAsynchronous()
 }));
 //#endregion

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

@@ -18,6 +18,7 @@ const TypeStructure = require_base.createStructure(typeStructureKind, ({ init })
 		const codec = codecContext.get(self.definition.type.fundamentalType);
 		return require_callThen.callThen(codec ? codec.decode(data, errorHandler) : data, (decodedData) => decodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeCheck(decodedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : decodedData));
 	},
+	executeParse: (self, codecContext, data, errorHandler) => self.executeDecode(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.type.isAsynchronous()
 }));
 //#endregion

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.Forward<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) => NoInfer<TypeStructure<TypeValue<GenericType>, readonly [...GenericConstraints]>>;

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

@@ -18,6 +18,7 @@ const TypeStructure = createStructure(typeStructureKind, ({ init }) => (type, co
 		const codec = codecContext.get(self.definition.type.fundamentalType);
 		return callThen(codec ? codec.decode(data, errorHandler) : data, (decodedData) => decodedData === ErrorSymbol ? ErrorSymbol : callThen(self.executeCheck(decodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : decodedData));
 	},
+	executeParse: (self, codecContext, data, errorHandler) => self.executeDecode(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.type.isAsynchronous()
 }));
 //#endregion

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

@@ -2,13 +2,13 @@ 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({
+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);
@@ -20,7 +20,7 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		const errorHandlers = errorHandler ? [] : void 0;
 		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(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);
@@ -40,7 +40,7 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		const errorHandlers = errorHandler ? [] : void 0;
 		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(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);
@@ -60,7 +60,7 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		const errorHandlers = errorHandler ? [] : void 0;
 		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(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);
@@ -76,6 +76,26 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 			return require_callThen.callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedDecodedData);
 		});
 	},
+	executeParse: (self, codecContext, data, errorHandler) => {
+		const errorHandlers = errorHandler ? [] : void 0;
+		const parsedData = 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_base.createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
+				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
+				errorHandlers.push(subErrorHandler);
+			}
+			return value.executeParse(codecContext, data, subErrorHandler);
+		}), require_resultSymbol.ErrorSymbol);
+		return require_callThen.callThen(parsedData, (awaitedParsedData) => {
+			if (awaitedParsedData === require_resultSymbol.ErrorSymbol) {
+				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
+				return require_resultSymbol.ErrorSymbol;
+			}
+			return require_callThen.callThen(self.executeConstraints(awaitedParsedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedParsedData);
+		});
+	},
 	isAsynchronous: (self) => self.definition.values.value.some((value) => value.isAsynchronous())
 }));
 //#endregion