@duplojs/lang 0.0.0 → 0.0.1-beta.2

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

@@ -9,4 +9,4 @@ export interface TypeStructureDefinition<GenericConstraints extends readonly Con
 }
 export interface TypeStructure<GenericType extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericType>[] = readonly Constraint<GenericType>[]> extends DCommon.UnionToIntersection<Structure<GenericType, TypeStructureDefinition<GenericConstraints>> & DKind.Kind<typeof typeStructureKind>> {
 }
-export declare const TypeStructure: <GenericType extends Type, const GenericConstraints extends readonly Constraint<TypeValue<GenericType>>[]>(type: GenericType, constraints: GenericConstraints) => TypeStructure<TypeValue<GenericType>, readonly [...GenericConstraints]>;
+export declare const TypeStructure: <GenericType extends Type, const GenericConstraints extends readonly Constraint<TypeValue<GenericType>>[]>(type: GenericType, constraints: GenericConstraints) => NoInfer<TypeStructure<TypeValue<GenericType>, readonly [...GenericConstraints]>>;

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

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

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

@@ -14,9 +14,8 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		const errorHandlers = errorHandler ? [] : void 0;
 		const result = self.definition.values.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator === require_resultSymbol.SuccessSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler();
-			if (errorHandler && errorHandlers && subErrorHandler) {
-				subErrorHandler().usePath(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
 			}
@@ -25,6 +24,7 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		return require_callThen.callThen(result, (awaitedResult) => {
 			if (awaitedResult === require_resultSymbol.ErrorSymbol) {
 				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
 				return require_resultSymbol.ErrorSymbol;
 			}
 			return require_resultSymbol.SuccessSymbol;
@@ -34,9 +34,8 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		const errorHandlers = errorHandler ? [] : void 0;
 		const encodedData = self.definition.values.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator !== require_resultSymbol.ErrorSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler();
-			if (errorHandler && errorHandlers && subErrorHandler) {
-				subErrorHandler().usePath(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
 			}
@@ -45,6 +44,7 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		return require_callThen.callThen(encodedData, (awaitedEncodedData) => {
 			if (awaitedEncodedData === require_resultSymbol.ErrorSymbol) {
 				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
 				return require_resultSymbol.ErrorSymbol;
 			}
 			return require_callThen.callThen(self.executeConstraints(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedEncodedData);
@@ -54,9 +54,8 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		const errorHandlers = errorHandler ? [] : void 0;
 		const decodedData = self.definition.values.reduce((accumulator, value, index) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator !== require_resultSymbol.ErrorSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler();
-			if (errorHandler && errorHandlers && subErrorHandler) {
-				subErrorHandler().usePath(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : require_error.createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
 			}
@@ -65,6 +64,7 @@ const UnionStructure = require_base.createStructure(unionStructureKind, ({ init
 		return require_callThen.callThen(decodedData, (awaitedDecodedData) => {
 			if (awaitedDecodedData === require_resultSymbol.ErrorSymbol) {
 				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
 				return require_resultSymbol.ErrorSymbol;
 			}
 			return require_callThen.callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedDecodedData);

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

@@ -9,4 +9,4 @@ export interface UnionStructureDefinition<GenericConstraints extends readonly Co
 }
 export interface UnionStructure<GenericValue extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<Structure<GenericValue, UnionStructureDefinition<GenericConstraints>> & DKind.Kind<typeof unionStructureKind>> {
 }
-export declare const UnionStructure: <GenericValues extends DCommon.AnyTuple<Structure>, const GenericConstraints extends readonly Constraint<StructureValue<GenericValues[number]>>[]>(values: GenericValues, constraints: GenericConstraints) => UnionStructure<StructureValue<GenericValues[number]>, readonly [...GenericConstraints]>;
+export declare const UnionStructure: <GenericValues extends DCommon.AnyTuple<Structure>, const GenericConstraints extends readonly Constraint<StructureValue<GenericValues[number]>>[]>(values: GenericValues, constraints: GenericConstraints) => NoInfer<UnionStructure<StructureValue<GenericValues[number]>, readonly [...GenericConstraints]>>;

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

@@ -12,18 +12,19 @@ const UnionStructure = createStructure(unionStructureKind, ({ init }) => (values
 }, {
 	executeCheck: (self, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		return callThen(self.definition.values.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
+		const result = self.definition.values.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator === SuccessSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler();
-			if (errorHandler && errorHandlers && subErrorHandler) {
-				subErrorHandler().usePath(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
 			}
 			return value.executeCheck(data, subErrorHandler);
-		}), ErrorSymbol), (awaitedResult) => {
+		}), ErrorSymbol);
+		return callThen(result, (awaitedResult) => {
 			if (awaitedResult === ErrorSymbol) {
 				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
 				return ErrorSymbol;
 			}
 			return SuccessSymbol;
@@ -31,18 +32,19 @@ const UnionStructure = createStructure(unionStructureKind, ({ init }) => (values
 	},
 	executeEncode: (self, codec, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		return callThen(self.definition.values.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
+		const encodedData = self.definition.values.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator !== ErrorSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler();
-			if (errorHandler && errorHandlers && subErrorHandler) {
-				subErrorHandler().usePath(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
 			}
 			return value.executeEncode(codec, data, subErrorHandler);
-		}), ErrorSymbol), (awaitedEncodedData) => {
+		}), ErrorSymbol);
+		return callThen(encodedData, (awaitedEncodedData) => {
 			if (awaitedEncodedData === ErrorSymbol) {
 				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
 				return ErrorSymbol;
 			}
 			return callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedEncodedData);
@@ -50,18 +52,19 @@ const UnionStructure = createStructure(unionStructureKind, ({ init }) => (values
 	},
 	executeDecode: (self, codec, data, errorHandler) => {
 		const errorHandlers = errorHandler ? [] : void 0;
-		return callThen(self.definition.values.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
+		const decodedData = self.definition.values.reduce((accumulator, value, index) => callThen(accumulator, (awaitedAccumulator) => {
 			if (awaitedAccumulator !== ErrorSymbol) return awaitedAccumulator;
-			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler();
-			if (errorHandler && errorHandlers && subErrorHandler) {
-				subErrorHandler().usePath(errorHandler().currentPath);
+			const subErrorHandler = errorHandler === void 0 ? void 0 : createGetErrorHandler(errorHandler().currentPath);
+			if (errorHandlers && subErrorHandler) {
 				subErrorHandler().createPathStage().setCurrentPath(`(union: ${index})`);
 				errorHandlers.push(subErrorHandler);
 			}
 			return value.executeDecode(codec, data, subErrorHandler);
-		}), ErrorSymbol), (awaitedDecodedData) => {
+		}), ErrorSymbol);
+		return callThen(decodedData, (awaitedDecodedData) => {
 			if (awaitedDecodedData === ErrorSymbol) {
 				if (errorHandlers) errorHandler?.().importIssues(errorHandlers);
+				errorHandler?.().addIssue(self, data);
 				return ErrorSymbol;
 			}
 			return callThen(self.executeConstraints(awaitedDecodedData, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedDecodedData);

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

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

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

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

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

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

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

@@ -2,4 +2,4 @@ import { structureKind, Structure } from '../base';
 import { StructureConstraintsValue } from './constraintsValue';
 import type * as DKind from '../../../kind';
 export type StructureValue<GenericStructure extends Structure> = DKind.GetValue<typeof structureKind, GenericStructure>;
-export type StructureInitialValue<GenericStructure extends Structure> = GenericStructure extends Structure<infer InferredValue> ? InferredValue extends (infer InferredInitialValue) & StructureConstraintsValue<GenericStructure["definition"]["constraints"][number]> ? InferredInitialValue : InferredValue : never;
+export type StructureInitialValue<GenericStructure extends Structure, GenericStructureValue = StructureValue<GenericStructure>> = GenericStructureValue extends unknown ? GenericStructureValue extends (infer InferredInitialValue) & StructureConstraintsValue<GenericStructure["definition"]["constraints"][number]> ? InferredInitialValue : GenericStructureValue : never;

package/dist/dataStructure/type/base.cjs

@@ -1,20 +1,33 @@
 const require_callThen = require("../../common/callThen.cjs");
+const require_simpleClone = require("../../common/simpleClone.cjs");
 const require_kind = require("../kind.cjs");
 const require_resultSymbol = require("../common/resultSymbol.cjs");
 //#region scripts/dataStructure/type/base.ts
 const typeKind = require_kind.createKind("type");
 function createType(fundamentalType, kindHandler, createConstructor) {
-	return createConstructor({ init: (definition, { executeCheck, isAsynchronous }) => {
+	const init = (definition, { executeCheck, isAsynchronous }) => {
 		const self = {
+			fundamentalType,
 			definition,
-			executeCheck: (data, errorHandler) => require_callThen.callThen(self.fundamentalType.executeCheck(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : executeCheck(self, data, errorHandler)),
+			executeCheck: (data) => require_callThen.callThen(self.fundamentalType.executeCheck(data), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : executeCheck(self, data)),
 			isAsynchronous: () => isAsynchronous(self),
-			fundamentalType,
+			clone: () => init(require_simpleClone.simpleClone(definition), {
+				executeCheck,
+				isAsynchronous
+			}),
+			setMessage: (message) => {
+				self.definition.message = message;
+				return self;
+			},
+			addMessage: (message) => {
+				return self.clone().setMessage(message);
+			},
 			[typeKind.runTimeKey]: null,
 			[kindHandler.runTimeKey]: null
 		};
 		return self;
-	} });
+	};
+	return createConstructor({ init });
 }
 //#endregion
 exports.createType = createType;

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

@@ -1,18 +1,22 @@
 import { FundamentalType, FundamentalTypeValue } from '../fundamentalType';
-import { ErrorSymbol, GetErrorHandler, SuccessSymbol } from '../common';
+import { ErrorSymbol, SuccessSymbol } from '../common';
 import type * as DKind from '../../kind';
 import * as DCommon from '../../common';
 export declare const typeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/type", unknown>>;
 export interface TypeDefinition {
+    readonly message?: string;
 }
 export interface Type<GenericFundamentalType extends FundamentalType = FundamentalType, GenericValue extends FundamentalTypeValue<GenericFundamentalType> = FundamentalTypeValue<GenericFundamentalType>, GenericDefinition extends TypeDefinition = TypeDefinition> extends DKind.Kind<typeof typeKind, GenericValue> {
     readonly fundamentalType: GenericFundamentalType;
     readonly definition: GenericDefinition;
-    executeCheck(data: unknown, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
+    executeCheck(data: unknown): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     isAsynchronous(): boolean;
+    clone(): this;
+    setMessage(massage: string): this;
+    addMessage(massage: string): this;
 }
 export interface CreateTypeInitParams<GenericType extends Type = Type, GenericFundamentalType extends FundamentalType = FundamentalType> {
-    executeCheck(self: GenericType, data: FundamentalTypeValue<GenericFundamentalType>, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
+    executeCheck(self: GenericType, data: FundamentalTypeValue<GenericFundamentalType>): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     isAsynchronous(self: GenericType): boolean;
 }
 export interface CreateTypeConstructorParams<GenericFundamentalType extends FundamentalType = FundamentalType, GenericKindHandler extends DKind.Handler = DKind.Handler> {

package/dist/dataStructure/type/base.mjs

@@ -1,20 +1,33 @@
 import { callThen } from "../../common/callThen.mjs";
+import { simpleClone } from "../../common/simpleClone.mjs";
 import { createKind } from "../kind.mjs";
 import { ErrorSymbol } from "../common/resultSymbol.mjs";
 //#region scripts/dataStructure/type/base.ts
 const typeKind = createKind("type");
 function createType(fundamentalType, kindHandler, createConstructor) {
-	return createConstructor({ init: (definition, { executeCheck, isAsynchronous }) => {
+	const init = (definition, { executeCheck, isAsynchronous }) => {
 		const self = {
+			fundamentalType,
 			definition,
-			executeCheck: (data, errorHandler) => callThen(self.fundamentalType.executeCheck(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : executeCheck(self, data, errorHandler)),
+			executeCheck: (data) => callThen(self.fundamentalType.executeCheck(data), (result) => result === ErrorSymbol ? ErrorSymbol : executeCheck(self, data)),
 			isAsynchronous: () => isAsynchronous(self),
-			fundamentalType,
+			clone: () => init(simpleClone(definition), {
+				executeCheck,
+				isAsynchronous
+			}),
+			setMessage: (message) => {
+				self.definition.message = message;
+				return self;
+			},
+			addMessage: (message) => {
+				return self.clone().setMessage(message);
+			},
 			[typeKind.runTimeKey]: null,
 			[kindHandler.runTimeKey]: null
 		};
 		return self;
-	} });
+	};
+	return createConstructor({ init });
 }
 //#endregion
 export { createType, typeKind };

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

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/type/defaults/bigintLiteral.ts
 const bigintLiteralTypeKind = require_kind.createKind("bigint-literal-type");
 const BigintLiteralType = require_base.createType(require_bigint.TheBigint, bigintLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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

@@ -5,7 +5,7 @@ import { createType } from "../base.mjs";
 //#region scripts/dataStructure/type/defaults/bigintLiteral.ts
 const bigintLiteralTypeKind = createKind("bigint-literal-type");
 const BigintLiteralType = createType(TheBigint, bigintLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/type/defaults/booleanLiteral.ts
 const booleanLiteralTypeKind = require_kind.createKind("boolean-literal-type");
 const BooleanLiteralType = require_base.createType(require_boolean.TheBoolean, booleanLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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

@@ -5,7 +5,7 @@ import { createType } from "../base.mjs";
 //#region scripts/dataStructure/type/defaults/booleanLiteral.ts
 const booleanLiteralTypeKind = createKind("boolean-literal-type");
 const BooleanLiteralType = createType(TheBoolean, booleanLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/type/defaults/numberLiteral.ts
 const numberLiteralTypeKind = require_kind.createKind("number-literal-type");
 const NumberLiteralType = require_base.createType(require_number.TheNumber, numberLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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

@@ -5,7 +5,7 @@ import { createType } from "../base.mjs";
 //#region scripts/dataStructure/type/defaults/numberLiteral.ts
 const numberLiteralTypeKind = createKind("number-literal-type");
 const NumberLiteralType = createType(TheNumber, numberLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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

@@ -5,7 +5,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/type/defaults/stringLiteral.ts
 const stringLiteralTypeKind = require_kind.createKind("string-literal-type");
 const StringLiteralType = require_base.createType(require_string.TheString, stringLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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

@@ -5,7 +5,7 @@ import { createType } from "../base.mjs";
 //#region scripts/dataStructure/type/defaults/stringLiteral.ts
 const stringLiteralTypeKind = createKind("string-literal-type");
 const StringLiteralType = createType(TheString, stringLiteralTypeKind, ({ init }) => (value) => init({ value }, {
-	executeCheck: (self, data, errorHandler) => data === self.definition.value ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => data === self.definition.value ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

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

@@ -1,5 +1,5 @@
 import { Type } from './base';
 export declare const typeIdentifier: {
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/date-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/null-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/time-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/undefined-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", bigint>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", boolean>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheDate>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", null>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", number>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", string>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheTime>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", undefined>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import('../..').UnionContain<GenericInput, Type<import('..').FundamentalType<symbol, unknown>, unknown, import('..').TypeDefinition>> extends true ? Extract<import('..').BigintType, GenericGroupedKind> | Extract<import('..').BooleanType, GenericGroupedKind> | Extract<import('..').DateType, GenericGroupedKind> | Extract<import('..').NullType, GenericGroupedKind> | Extract<import('..').NumberType, GenericGroupedKind> | Extract<import('..').StringType, GenericGroupedKind> | Extract<import('..').TimeType, GenericGroupedKind> | Extract<import('..').UndefinedType, GenericGroupedKind> | Extract<import('..').BigintLiteralType<bigint>, GenericGroupedKind> | Extract<import('..').BooleanLiteralType<boolean>, GenericGroupedKind> | Extract<import('..').NumberLiteralType<number>, GenericGroupedKind> | Extract<import('..').StringLiteralType<string>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/date-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/null-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/time-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/undefined-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", bigint>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", boolean>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheDate>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", null>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", number>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", string>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheTime>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", undefined>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import('../..').UnionContain<GenericInput, Type<import('..').FundamentalType<symbol, unknown>, unknown, import('..').TypeDefinition>> extends true ? Extract<import('..').BigintType, GenericGroupedKind> | Extract<import('..').BooleanType, GenericGroupedKind> | Extract<import('..').DateType, GenericGroupedKind> | Extract<import('..').NullType, GenericGroupedKind> | Extract<import('..').NumberType, GenericGroupedKind> | Extract<import('..').StringType, GenericGroupedKind> | Extract<import('..').TimeType, GenericGroupedKind> | Extract<import('..').UndefinedType, GenericGroupedKind> | Extract<import('..').BigintLiteralType<bigint>, GenericGroupedKind> | Extract<import('..').BooleanLiteralType<boolean>, GenericGroupedKind> | Extract<import('..').NumberLiteralType<number>, GenericGroupedKind> | Extract<import('..').StringLiteralType<string>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/date-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/null-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/time-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/undefined-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", bigint>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", boolean>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheDate>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", null>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", number>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", string>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheTime>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", undefined>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import('../..').UnionContain<GenericInput, Type<import('..').FundamentalType<unknown>, unknown, import('..').TypeDefinition>> extends true ? Extract<import('..').BigintType, GenericGroupedKind> | Extract<import('..').BooleanType, GenericGroupedKind> | Extract<import('..').DateType, GenericGroupedKind> | Extract<import('..').NullType, GenericGroupedKind> | Extract<import('..').NumberType, GenericGroupedKind> | Extract<import('..').StringType, GenericGroupedKind> | Extract<import('..').TimeType, GenericGroupedKind> | Extract<import('..').UndefinedType, GenericGroupedKind> | Extract<import('..').BigintLiteralType<bigint>, GenericGroupedKind> | Extract<import('..').BooleanLiteralType<boolean>, GenericGroupedKind> | Extract<import('..').NumberLiteralType<number>, GenericGroupedKind> | Extract<import('..').StringLiteralType<string>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/bigint-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/boolean-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/date-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/null-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/number-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/string-literal-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/time-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/undefined-type", unknown>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", bigint>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", boolean>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheDate>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", null>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", number>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", string>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", import('../../chrono').TheTime>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/type", undefined>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import('../..').UnionContain<GenericInput, Type<import('..').FundamentalType<unknown>, unknown, import('..').TypeDefinition>> extends true ? Extract<import('..').BigintType, GenericGroupedKind> | Extract<import('..').BooleanType, GenericGroupedKind> | Extract<import('..').DateType, GenericGroupedKind> | Extract<import('..').NullType, GenericGroupedKind> | Extract<import('..').NumberType, GenericGroupedKind> | Extract<import('..').StringType, GenericGroupedKind> | Extract<import('..').TimeType, GenericGroupedKind> | Extract<import('..').UndefinedType, GenericGroupedKind> | Extract<import('..').BigintLiteralType<bigint>, GenericGroupedKind> | Extract<import('..').BooleanLiteralType<boolean>, GenericGroupedKind> | Extract<import('..').NumberLiteralType<number>, GenericGroupedKind> | Extract<import('..').StringLiteralType<string>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
 };

package/dist/generator/asyncChunk.d.ts

@@ -1,2 +1,3 @@
-export declare function asyncChunk<const GenericItem extends unknown>(size: number): (iterator: AsyncIterable<GenericItem>) => AsyncGenerator<GenericItem[], unknown, unknown>;
-export declare function asyncChunk<const GenericItem extends unknown>(iterator: AsyncIterable<GenericItem>, size: number): AsyncGenerator<GenericItem[], unknown, unknown>;
+import type * as DArray from '../array';
+export declare function asyncChunk<const GenericItem extends unknown, GenericSize extends number>(size: GenericSize): (iterator: AsyncIterable<GenericItem>) => AsyncGenerator<readonly GenericItem[] & DArray.MinElements<1> & (number extends GenericSize ? unknown : DArray.MaxElements<GenericSize>), unknown, unknown>;
+export declare function asyncChunk<const GenericItem extends unknown, GenericSize extends number>(iterator: AsyncIterable<GenericItem>, size: GenericSize): AsyncGenerator<readonly GenericItem[] & DArray.MinElements<1> & (number extends GenericSize ? unknown : DArray.MaxElements<GenericSize>), unknown, unknown>;

package/dist/generator/chunk.d.ts

@@ -1,2 +1,3 @@
-export declare function chunk<const GenericItem extends unknown>(size: number): (iterator: Iterable<GenericItem>) => Generator<GenericItem[], unknown, unknown>;
-export declare function chunk<const GenericItem extends unknown>(iterator: Iterable<GenericItem>, size: number): Generator<GenericItem[], unknown, unknown>;
+import type * as DArray from '../array';
+export declare function chunk<const GenericItem extends unknown, GenericSize extends number>(size: GenericSize): (iterator: Iterable<GenericItem>) => Generator<readonly GenericItem[] & DArray.MinElements<1> & (number extends GenericSize ? unknown : DArray.MaxElements<GenericSize>), unknown, unknown>;
+export declare function chunk<const GenericItem extends unknown, GenericSize extends number>(iterator: Iterable<GenericItem>, size: GenericSize): Generator<readonly GenericItem[] & DArray.MinElements<1> & (number extends GenericSize ? unknown : DArray.MaxElements<GenericSize>), unknown, unknown>;

package/dist/generator/types/flat.d.ts

@@ -1,3 +1,3 @@
 import type * as DCommon from '../../common';
-export type FlatIterator<GenericValue extends unknown, GenericDepth extends number, GenericAcc extends never[] = []> = DCommon.IsEqual<GenericAcc["length"], GenericDepth> extends true ? GenericValue : DCommon.IsEqual<GenericAcc["length"], 250> extends true ? GenericValue : GenericValue extends Iterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue;
-export type FlatAsyncIterator<GenericValue extends unknown, GenericDepth extends number, GenericAcc extends never[] = []> = DCommon.IsEqual<GenericAcc["length"], GenericDepth> extends true ? GenericValue : DCommon.IsEqual<GenericAcc["length"], 250> extends true ? GenericValue : GenericValue extends Iterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue extends AsyncIterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue;
+export type FlatIterator<GenericValue extends unknown, GenericDepth extends number, GenericAcc extends never[] = []> = DCommon.IsEqual<GenericAcc["length"], GenericDepth> extends true ? GenericValue : DCommon.IsEqual<GenericAcc["length"], 250> extends true ? GenericValue : GenericValue extends string ? GenericValue : GenericValue extends Iterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue;
+export type FlatAsyncIterator<GenericValue extends unknown, GenericDepth extends number, GenericAcc extends never[] = []> = DCommon.IsEqual<GenericAcc["length"], GenericDepth> extends true ? GenericValue : DCommon.IsEqual<GenericAcc["length"], 250> extends true ? GenericValue : GenericValue extends string ? GenericValue : GenericValue extends Iterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue extends AsyncIterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue;

package/dist/invocation/flow/base.d.ts

@@ -1,4 +1,4 @@
-import { FlowControllerExit, FlowControllerResult, flowControllerExitKind, FlowControllerPreviousFunctionResult } from './controller';
+import { FlowControllerExit, FlowControllerResult, flowControllerExitKind, FlowControllerPreviousFunctionResult, UnwrapFlowControllerResult } from './controller';
 import { DKind } from '../../index.ts';
 import * as DCommon from '../../common';
 type ComputeLastUsableValue<GenericAccumulator extends DCommon.AnyTuple> = GenericAccumulator extends [
@@ -6,7 +6,12 @@ type ComputeLastUsableValue<GenericAccumulator extends DCommon.AnyTuple> = Gener
     infer InferredLast
 ] ? InferredLast extends FlowControllerResult<infer InferredFlowControllerResult> ? Exclude<Awaited<InferredFlowControllerResult>, FlowControllerPreviousFunctionResult | FlowControllerExit> extends infer InferredOutputValue ? DCommon.HasSomething<InferredOutputValue> extends true ? InferredOutputValue : InferredRest extends DCommon.AnyTuple ? ComputeLastUsableValue<InferredRest> : never : never : InferredLast : never;
 type Pipe<GenericAccumulator extends DCommon.AnyTuple, GenericOutput extends unknown> = (this: never, input: Awaited<ComputeLastUsableValue<GenericAccumulator>>) => GenericOutput;
-type ComputeTypeOutput<GenericAccumulator extends DCommon.AnyTuple> = Extract<(ComputeLastUsableValue<GenericAccumulator> | (GenericAccumulator[number] extends infer InferredPipeResult ? InferredPipeResult extends FlowControllerResult<infer InferredResult> ? InferredResult extends FlowControllerExit ? DKind.GetValue<typeof flowControllerExitKind, InferredResult> : InferredResult extends Promise<infer InferredExit extends FlowControllerExit> ? Promise<DKind.GetValue<typeof flowControllerExitKind, InferredExit>> : never : never : never)) extends infer InferredResult ? DCommon.ContainExtends<InferredResult, Promise<any>> extends true ? Promise<Awaited<InferredResult>> : InferredResult : never, any>;
+type IsMaybePromise<GenericAccumulator extends DCommon.AnyTuple> = {
+    [Index in keyof GenericAccumulator]: UnwrapFlowControllerResult<GenericAccumulator[Index]> extends infer InferredResult ? DCommon.IsExtends<InferredResult, Promise<unknown>> extends true ? false : DCommon.ContainExtends<InferredResult, Promise<any>> : never;
+}[number] extends false ? false : true;
+type ComputeTypeOutput<GenericAccumulator extends DCommon.AnyTuple> = Extract<(ComputeLastUsableValue<GenericAccumulator> | (UnwrapFlowControllerResult<GenericAccumulator[number]> extends infer InferredResult ? InferredResult extends FlowControllerExit ? DKind.GetValue<typeof flowControllerExitKind, InferredResult> : InferredResult extends Promise<infer InferredExit extends FlowControllerExit> ? Promise<DKind.GetValue<typeof flowControllerExitKind, InferredExit>> : InferredResult extends Promise<unknown> ? Promise<never> : never : never)) extends infer InferredResult ? DCommon.Or<[
+    DCommon.ContainExtends<InferredResult, Promise<any>>
+]> extends true ? IsMaybePromise<GenericAccumulator> extends true ? DCommon.MaybePromise<Awaited<InferredResult>> : Promise<Awaited<InferredResult>> : InferredResult : never, any>;
 export declare function flow<const GenericInput extends unknown, const GenericOutput1 extends unknown>(pipe1: Pipe<[
     GenericInput
 ], GenericOutput1>): (input: GenericInput) => DCommon.BreakGenericLink<Extract<ComputeTypeOutput<[

package/dist/invocation/flow/controller/base.d.ts

@@ -11,6 +11,7 @@ export type FlowControllerPreviousFunctionResult = DCommon.MaybePromise<(DCommon
 export interface FlowControllerResult<GenericResult extends unknown> {
     readonly [FlowControllerResultSymbol]: GenericResult;
 }
+export type UnwrapFlowControllerResult<GenericValue extends unknown> = GenericValue extends FlowControllerResult<infer InferredResult> ? InferredResult : GenericValue;
 export interface FlowController<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DKind.Kind<typeof flowControllerKind> {
     (this: never, input: GenericInput): FlowControllerResult<GenericOutput>;
     exec(previousFunction: () => FlowControllerPreviousFunctionResult): (FlowControllerPreviousFunctionResult | GenericOutput | DCommon.MergePromise<FlowControllerPreviousFunctionResult | GenericOutput>);