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

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

@@ -1,18 +1,18 @@
 import { EntityStructure, Entity } from '../entity';
-import type * as DCommon from '../../common';
 import type * as DKind from '../../kind';
 import type * as DDataStructure from '../../dataStructure';
 export declare const flagKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/flag", Record<string, unknown>>>;
-export interface Flag<GenericName extends string = string, GenericValue extends unknown = never> extends DKind.Kind<typeof flagKind, Record<GenericName, GenericValue>> {
+export interface Flag<GenericName extends Capitalize<string> = Capitalize<string>, GenericPayload extends unknown = unknown> extends DKind.Kind<typeof flagKind, Record<GenericName, GenericPayload>> {
 }
+export type GetFlagName<GenericFlag extends Flag> = GenericFlag extends Flag<infer InferredName extends Capitalize<string>> ? InferredName : never;
+export type GetFlagPayload<GenericFlag extends Flag> = GenericFlag extends Flag<any, infer InferredPayload> ? InferredPayload : never;
 declare const flagHandlerKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/flag-handler", unknown>>;
-export interface FlagHandler<GenericName extends string = string, GenericEntity extends Entity = Entity, GenericValue extends unknown = unknown> extends DKind.Kind<typeof flagHandlerKind> {
+export interface FlagHandler<GenericName extends Capitalize<string> = Capitalize<string>, GenericEntity extends Entity = Entity, GenericPayload extends unknown = unknown> extends DKind.Kind<typeof flagHandlerKind> {
     readonly name: GenericName;
-    append<GenericInputEntity extends GenericEntity, const GenericInputValue extends GenericValue>(value: GenericInputValue): (entity: GenericInputEntity) => (GenericInputEntity & Flag<GenericName, GenericInputValue>);
-    append<GenericInputEntity extends GenericEntity, const GenericInputValue extends GenericValue>(entity: GenericInputEntity, value: GenericInputValue): (GenericInputEntity & Flag<GenericName, GenericInputValue>);
-    getValue<GenericInputEntity extends GenericEntity & Flag<GenericName, GenericValue>>(entity: GenericInputEntity): DKind.GetValue<typeof flagKind, GenericInputEntity>[GenericName];
+    append<GenericInputEntity extends GenericEntity, const GenericInputPayload extends GenericPayload>(value: GenericInputPayload): (entity: GenericInputEntity) => (GenericInputEntity & Flag<GenericName, GenericInputPayload>);
+    append<GenericInputEntity extends GenericEntity, const GenericInputPayload extends GenericPayload>(entity: GenericInputEntity, value: GenericInputPayload): (GenericInputEntity & Flag<GenericName, GenericInputPayload>);
+    getPayload<GenericInputEntity extends GenericEntity & Flag<GenericName, GenericPayload>>(entity: GenericInputEntity): DKind.GetValue<typeof flagKind, GenericInputEntity>[GenericName];
     has<GenericInputEntity extends GenericEntity>(entity: GenericInputEntity): entity is Extract<GenericInputEntity, Flag<GenericName, any>>;
 }
-export declare function createFlag<GenericName extends Capitalize<string>, GenericEntityStructure extends EntityStructure, GenericPayload extends unknown = {}>(name: DCommon.IsEqual<GenericName, Capitalize<string>> extends true ? never : NoInfer<GenericName>): FlagHandler<GenericName, DDataStructure.StructureValue<GenericEntityStructure>, GenericPayload>;
-export type GetFlag<GenericHandler extends FlagHandler<any, any, any>> = GenericHandler extends FlagHandler<infer InferredName, any, infer InferredValue> ? Flag<InferredName, InferredValue> : never;
+export declare function createFlag<GenericFLag extends Flag, GenericEntityStructure extends EntityStructure>(name: GetFlagName<GenericFLag>): FlagHandler<GetFlagName<GenericFLag>, DDataStructure.StructureValue<GenericEntityStructure>, GetFlagPayload<GenericFLag>>;
 export {};

package/dist/modeling/flag/base.mjs

@@ -18,7 +18,7 @@ function createFlag(name) {
 	return {
 		name,
 		append,
-		getValue(entity) {
+		getPayload(entity) {
 			return flagKind.getValue(entity)[name];
 		},
 		has(entity) {

package/dist/modeling/index.cjs

@@ -4,51 +4,50 @@ const require_base = require("./entity/base.cjs");
 const require_helper = require("./entity/helper.cjs");
 const require_base$1 = require("./newType/base.cjs");
 const require_helper$1 = require("./newType/helper.cjs");
-const require_base$2 = require("./flag/base.cjs");
 const require_namespace = require("./entity/namespace.cjs");
-const require_base$3 = require("./taggedObject/base.cjs");
+const require_base$2 = require("./fact/base.cjs");
+const require_base$3 = require("./flag/base.cjs");
+const require_base$4 = require("./taggedObject/base.cjs");
 const require_helper$2 = require("./taggedObject/helper.cjs");
 //#region scripts/modeling/index.ts
 var modeling_exports = /* @__PURE__ */ require_runtime.__exportAll({
-	EncodeEntityError: () => require_base.EncodeEntityError,
-	EncodeNewTypeError: () => require_base$1.EncodeNewTypeError,
-	EncodeTaggedObjectError: () => require_base$3.EncodeTaggedObjectError,
 	EntityStructure: () => require_base.EntityStructure,
 	NewTypeStructure: () => require_base$1.NewTypeStructure,
-	TaggedObjectStructure: () => require_base$3.TaggedObjectStructure,
+	TaggedObjectStructure: () => require_base$4.TaggedObjectStructure,
 	createEntity: () => require_helper.createEntity,
 	createEntityNamespace: () => require_namespace.createEntityNamespace,
-	createFlag: () => require_base$2.createFlag,
+	createFact: () => require_base$2.createFact,
+	createFlag: () => require_base$3.createFlag,
 	createKind: () => require_kind.createKind,
 	createNewType: () => require_helper$1.createNewType,
 	createTaggedObject: () => require_helper$2.createTaggedObject,
 	entityKind: () => require_base.entityKind,
 	entityStructureKind: () => require_base.entityStructureKind,
-	flagKind: () => require_base$2.flagKind,
+	factKind: () => require_base$2.factKind,
+	flagKind: () => require_base$3.flagKind,
 	getTagValue: () => require_helper$2.getTagValue,
 	hasTagValue: () => require_helper$2.hasTagValue,
 	namespaceKind: () => require_namespace.namespaceKind,
 	newTypeStructureKind: () => require_base$1.newTypeStructureKind,
-	objectTagKind: () => require_base$3.objectTagKind,
+	objectTagKind: () => require_base$4.objectTagKind,
 	taggedObject: () => require_helper$2.taggedObject,
-	taggedObjectStructureKind: () => require_base$3.taggedObjectStructureKind
+	taggedObjectStructureKind: () => require_base$4.taggedObjectStructureKind
 });
 //#endregion
-exports.EncodeEntityError = require_base.EncodeEntityError;
-exports.EncodeNewTypeError = require_base$1.EncodeNewTypeError;
-exports.EncodeTaggedObjectError = require_base$3.EncodeTaggedObjectError;
 exports.EntityStructure = require_base.EntityStructure;
 exports.NewTypeStructure = require_base$1.NewTypeStructure;
-exports.TaggedObjectStructure = require_base$3.TaggedObjectStructure;
+exports.TaggedObjectStructure = require_base$4.TaggedObjectStructure;
 exports.createEntity = require_helper.createEntity;
 exports.createEntityNamespace = require_namespace.createEntityNamespace;
-exports.createFlag = require_base$2.createFlag;
+exports.createFact = require_base$2.createFact;
+exports.createFlag = require_base$3.createFlag;
 exports.createKind = require_kind.createKind;
 exports.createNewType = require_helper$1.createNewType;
 exports.createTaggedObject = require_helper$2.createTaggedObject;
 exports.entityKind = require_base.entityKind;
 exports.entityStructureKind = require_base.entityStructureKind;
-exports.flagKind = require_base$2.flagKind;
+exports.factKind = require_base$2.factKind;
+exports.flagKind = require_base$3.flagKind;
 exports.getTagValue = require_helper$2.getTagValue;
 exports.hasTagValue = require_helper$2.hasTagValue;
 Object.defineProperty(exports, "modeling_exports", {
@@ -59,6 +58,6 @@ Object.defineProperty(exports, "modeling_exports", {
 });
 exports.namespaceKind = require_namespace.namespaceKind;
 exports.newTypeStructureKind = require_base$1.newTypeStructureKind;
-exports.objectTagKind = require_base$3.objectTagKind;
+exports.objectTagKind = require_base$4.objectTagKind;
 exports.taggedObject = require_helper$2.taggedObject;
-exports.taggedObjectStructureKind = require_base$3.taggedObjectStructureKind;
+exports.taggedObjectStructureKind = require_base$4.taggedObjectStructureKind;

package/dist/modeling/index.d.ts

@@ -1,4 +1,5 @@
 export * from './entity';
+export * from './fact';
 export * from './flag';
 export * from './kind';
 export * from './newType';

package/dist/modeling/index.mjs

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

package/dist/modeling/newType/base.cjs

@@ -1,28 +1,16 @@
-const require_parentClass = require("../../kind/parentClass.cjs");
 const require_callThen = require("../../common/callThen.cjs");
 const require_create = require("../../either/left/create.cjs");
-const require_is = require("../../either/left/is.cjs");
 const require_create$1 = require("../../either/right/create.cjs");
-const require_unwrap = require("../../either/left/unwrap.cjs");
-const require_unwrap$1 = require("../../either/right/unwrap.cjs");
 const require_justExec = require("../../common/justExec.cjs");
 const require_resultSymbol = require("../../dataStructure/common/resultSymbol.cjs");
-const require_error = require("../../dataStructure/common/error.cjs");
-const require_base = require("../../dataStructure/structure/base.cjs");
-const require_kind = require("../kind.cjs");
+const require_base = require("../../dataStructure/common/error/base.cjs");
+const require_base$1 = require("../../dataStructure/structure/base.cjs");
 //#region scripts/modeling/newType/base.ts
-const newTypeStructureKind = require_kind.createKind("new-type-structure");
-var EncodeNewTypeError = class extends require_parentClass.parentClass(require_kind.createKind("encode-new-type-error"), Error) {
-	error;
-	constructor(error) {
-		super(void 0, "An error occurred while encoding a NewType. This can only happen if you are bypassing the type system.");
-		this.error = error;
-	}
-};
+const newTypeStructureKind = require("../kind.cjs").createKind("new-type-structure");
 function executeNewTypeConstraints(structure, data, errorHandler) {
 	return structure.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(constraint.executeCheck(data), (constraintResult) => constraintResult === require_resultSymbol.ErrorSymbol ? errorHandler?.().addIssue(structure, data, constraint) ?? require_resultSymbol.ErrorSymbol : require_resultSymbol.SuccessSymbol)), require_resultSymbol.SuccessSymbol);
 }
-const NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ init }) => (name, structure, newTypeConstraints) => init({
+const NewTypeStructure = require_base$1.createStructure(newTypeStructureKind, ({ init }) => (name, structure, newTypeConstraints) => init({
 	constraints: [],
 	newTypeConstraints,
 	inner: structure
@@ -30,6 +18,7 @@ const NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ i
 	executeCheck: (self, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : executeNewTypeConstraints(self, data, errorHandler)),
 	executeEncode: (self, codec, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeEncode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(executeNewTypeConstraints(self, data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
 	executeDecode: (self, codec, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeDecode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(executeNewTypeConstraints(self, awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
+	executeParse: (self, codecContext, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeParse(codecContext, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(executeNewTypeConstraints(self, awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous() || self.definition.newTypeConstraints.some((value) => value.isAsynchronous())
 }, {
 	name,
@@ -38,17 +27,17 @@ const NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ i
 			const [codecs] = args;
 			return (value) => self.decodeMap(codecs, value);
 		}
-		const errorHandler = require_error.createGetErrorHandler();
+		const errorHandler = require_base.createGetErrorHandler();
 		const [codecs, data] = args;
 		const result = self.executeDecode(codecs.context.value, data, errorHandler);
-		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result instanceof Promise) return require_create.left("async-error", new require_base.ErrorPromise());
 		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 		return require_create$1.right("map-success", result);
 	},
 	map: (self, data) => {
-		const errorHandler = require_error.createGetErrorHandler();
+		const errorHandler = require_base.createGetErrorHandler();
 		const result = self.executeCheck(data, errorHandler);
-		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result instanceof Promise) return require_create.left("async-error", new require_base.ErrorPromise());
 		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 		return require_create$1.right("map-success", data);
 	},
@@ -58,7 +47,7 @@ const NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ i
 			return (value) => self.asyncDecodeMap(codecs, value);
 		}
 		return require_justExec.justExec(async () => {
-			const errorHandler = require_error.createGetErrorHandler();
+			const errorHandler = require_base.createGetErrorHandler();
 			const [codecs, data] = args;
 			const result = await self.executeDecode(codecs.context.value, data, errorHandler);
 			if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
@@ -66,17 +55,11 @@ const NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ i
 		});
 	},
 	asyncMap: async (self, data) => {
-		const errorHandler = require_error.createGetErrorHandler();
+		const errorHandler = require_base.createGetErrorHandler();
 		if (await self.executeCheck(data, errorHandler) === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 		return require_create$1.right("map-success", data);
-	},
-	encodeNewType: async (self, codec, data) => {
-		const result = await self.asyncEncode(codec, data);
-		if (require_is.isLeft(result)) throw new EncodeNewTypeError(require_unwrap.unwrapLeft(result));
-		return require_unwrap$1.unwrapRight(result);
 	}
 }));
 //#endregion
-exports.EncodeNewTypeError = EncodeNewTypeError;
 exports.NewTypeStructure = NewTypeStructure;
 exports.newTypeStructureKind = newTypeStructureKind;

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

@@ -1,4 +1,4 @@
-import * as DKind from '../../kind';
+import type * as DKind from '../../kind';
 import * as DCommon from '../../common';
 import type * as DArray from '../../array';
 import * as DEither from '../../either';
@@ -24,21 +24,14 @@ export interface NewTypeStructureDefinition<GenericNewTypeConstraint extends rea
     readonly inner: DDataStructure.Structure;
     readonly newTypeConstraints: GenericNewTypeConstraint;
 }
-export type ComputeNewType<GenericName extends string, GenericValue extends unknown, GenericNewTypeConstraint extends readonly DDataStructure.Constraint<GenericValue>[], GenericIntersectionConstraintValue = DDataStructure.ConstraintValue<DArray.Unwrap<GenericNewTypeConstraint>>, GenericClearValue = DCommon.NeverCoalescing<DCommon.RemoveConstraint<GenericIntersectionConstraintValue>, unknown>> = (GenericValue & GenericClearValue & NewType<GenericName, GenericIntersectionConstraintValue extends (GenericClearValue & infer InferredConstraint extends DCommon.BaseConstraint) ? InferredConstraint : never>);
+export type ComputeNewType<GenericName extends string, GenericValue extends unknown, GenericNewTypeConstraint extends readonly DDataStructure.Constraint<GenericValue>[], GenericIntersectionConstraintValue = DDataStructure.ConstraintValue<DArray.Unwrap<GenericNewTypeConstraint>>, GenericClearValue = DCommon.NeverCoalescing<DCommon.RemoveConstraint<GenericIntersectionConstraintValue>, unknown>> = Extract<GenericValue & GenericClearValue & NewType<GenericName, GenericIntersectionConstraintValue extends (GenericClearValue & infer InferredConstraint extends DCommon.BaseConstraint) ? InferredConstraint : never>, any>;
 export interface NewTypeStructure<out GenericName extends string = string, out GenericValue extends unknown = unknown, out GenericNewTypeConstraint extends readonly DDataStructure.Constraint<GenericValue>[] = readonly DDataStructure.Constraint<GenericValue>[]> extends DCommon.Forward<DDataStructure.Structure<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>, NewTypeStructureDefinition<GenericNewTypeConstraint>> & DKind.Kind<typeof newTypeStructureKind>> {
     readonly name: GenericName;
-    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<NewTypeMap<DDataStructure.StructureValue<this>>, GenericCodecs>) => (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
-    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<NewTypeMap<DDataStructure.StructureValue<this>>, GenericCodecs>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
-    map(data: NewTypeMap<DDataStructure.StructureValue<this>>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
-    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<NewTypeMap<DDataStructure.StructureValue<this>>, GenericCodecs>) => Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<NewTypeMap<DDataStructure.StructureValue<this>>, GenericCodecs>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    asyncMap(data: NewTypeMap<DDataStructure.StructureValue<this>>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    encodeNewType<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.StructureValue<this>): Promise<DDataStructure.EncodedValue<NewTypeMap<DDataStructure.StructureValue<this>>, GenericCodecs>>;
-}
-declare const EncodeNewTypeError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangModeling/encode-new-type-error", unknown>>, ErrorConstructor>;
-export declare class EncodeNewTypeError extends EncodeNewTypeError_base {
-    error: DDataStructure.Error;
-    constructor(error: DDataStructure.Error);
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<NewTypeMap<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>>, GenericCodecs>) => (DEither.Right<"map-success", ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<NewTypeMap<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>>, GenericCodecs>): (DEither.Right<"map-success", ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    map(data: NewTypeMap<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>>): (DEither.Right<"map-success", ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<NewTypeMap<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>>, GenericCodecs>) => Promise<DEither.Right<"map-success", ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<NewTypeMap<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>>, GenericCodecs>): Promise<DEither.Right<"map-success", ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncMap(data: NewTypeMap<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>>): Promise<DEither.Right<"map-success", ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>> | DEither.Left<"map-error", DDataStructure.Error>>;
 }
 export declare const NewTypeStructure: <GenericName extends string, GenericStructure extends DDataStructure.Structure, const GenericNewTypeConstraint extends readonly DDataStructure.Constraint<DDataStructure.StructureValue<GenericStructure>>[]>(name: GenericName, structure: GenericStructure, newTypeConstraints: GenericNewTypeConstraint) => NewTypeStructure<GenericName, DDataStructure.StructureValue<GenericStructure>, GenericNewTypeConstraint>;
-export {};

package/dist/modeling/newType/base.mjs

@@ -1,24 +1,13 @@
-import { parentClass } from "../../kind/parentClass.mjs";
 import { callThen } from "../../common/callThen.mjs";
 import { left } from "../../either/left/create.mjs";
-import { isLeft } from "../../either/left/is.mjs";
 import { right } from "../../either/right/create.mjs";
-import { unwrapLeft } from "../../either/left/unwrap.mjs";
-import { unwrapRight } from "../../either/right/unwrap.mjs";
 import { justExec } from "../../common/justExec.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../dataStructure/common/resultSymbol.mjs";
-import { createGetErrorHandler } from "../../dataStructure/common/error.mjs";
+import { ErrorPromise, createGetErrorHandler } from "../../dataStructure/common/error/base.mjs";
 import { createStructure } from "../../dataStructure/structure/base.mjs";
 import { createKind } from "../kind.mjs";
 //#region scripts/modeling/newType/base.ts
 const newTypeStructureKind = createKind("new-type-structure");
-var EncodeNewTypeError = class extends parentClass(createKind("encode-new-type-error"), Error) {
-	error;
-	constructor(error) {
-		super(void 0, "An error occurred while encoding a NewType. This can only happen if you are bypassing the type system.");
-		this.error = error;
-	}
-};
 function executeNewTypeConstraints(structure, data, errorHandler) {
 	return structure.definition.newTypeConstraints.reduce((accumulator, constraint) => callThen(accumulator, (result) => result === ErrorSymbol ? ErrorSymbol : callThen(constraint.executeCheck(data), (constraintResult) => constraintResult === ErrorSymbol ? errorHandler?.().addIssue(structure, data, constraint) ?? ErrorSymbol : SuccessSymbol)), SuccessSymbol);
 }
@@ -30,6 +19,7 @@ const NewTypeStructure = createStructure(newTypeStructureKind, ({ init }) => (na
 	executeCheck: (self, data, errorHandler) => callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : executeNewTypeConstraints(self, data, errorHandler)),
 	executeEncode: (self, codec, data, errorHandler) => callThen(self.definition.inner.executeEncode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(executeNewTypeConstraints(self, data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(data, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
 	executeDecode: (self, codec, data, errorHandler) => callThen(self.definition.inner.executeDecode(codec, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(executeNewTypeConstraints(self, awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
+	executeParse: (self, codecContext, data, errorHandler) => callThen(self.definition.inner.executeParse(codecContext, data, errorHandler), (awaitedInnerResult) => awaitedInnerResult === ErrorSymbol ? ErrorSymbol : callThen(executeNewTypeConstraints(self, awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === ErrorSymbol ? ErrorSymbol : awaitedInnerResult))),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous() || self.definition.newTypeConstraints.some((value) => value.isAsynchronous())
 }, {
 	name,
@@ -41,14 +31,14 @@ const NewTypeStructure = createStructure(newTypeStructureKind, ({ init }) => (na
 		const errorHandler = createGetErrorHandler();
 		const [codecs, data] = args;
 		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("map-error", errorHandler().createError());
 		return right("map-success", result);
 	},
 	map: (self, 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("map-error", errorHandler().createError());
 		return right("map-success", data);
 	},
@@ -69,12 +59,7 @@ const NewTypeStructure = createStructure(newTypeStructureKind, ({ init }) => (na
 		const errorHandler = createGetErrorHandler();
 		if (await self.executeCheck(data, errorHandler) === ErrorSymbol) return left("map-error", errorHandler().createError());
 		return right("map-success", data);
-	},
-	encodeNewType: async (self, codec, data) => {
-		const result = await self.asyncEncode(codec, data);
-		if (isLeft(result)) throw new EncodeNewTypeError(unwrapLeft(result));
-		return unwrapRight(result);
 	}
 }));
 //#endregion
-export { EncodeNewTypeError, NewTypeStructure, newTypeStructureKind };
+export { NewTypeStructure, newTypeStructureKind };

package/dist/modeling/taggedObject/base.cjs

@@ -1,28 +1,17 @@
-const require_parentClass = require("../../kind/parentClass.cjs");
 const require_isSimple = require("../../object/isSimple.cjs");
 const require_create = require("../../either/left/create.cjs");
-const require_is = require("../../either/left/is.cjs");
 const require_create$1 = require("../../either/right/create.cjs");
-const require_unwrap = require("../../either/left/unwrap.cjs");
-const require_unwrap$1 = require("../../either/right/unwrap.cjs");
 const require_justExec = require("../../common/justExec.cjs");
 const require_resultSymbol = require("../../dataStructure/common/resultSymbol.cjs");
-const require_error = require("../../dataStructure/common/error.cjs");
-const require_base = require("../../dataStructure/structure/base.cjs");
+const require_base = require("../../dataStructure/common/error/base.cjs");
+const require_base$1 = require("../../dataStructure/structure/base.cjs");
 const require_nonEncodableString = require("../../dataStructure/structure/defaults/nonEncodableString.cjs");
 const require_object = require("../../dataStructure/structure/defaults/object.cjs");
 const require_kind = require("../kind.cjs");
 //#region scripts/modeling/taggedObject/base.ts
 const objectTagKind = require_kind.createKind("object-tag");
 const taggedObjectStructureKind = require_kind.createKind("tagged-object-structure");
-var EncodeTaggedObjectError = class extends require_parentClass.parentClass(require_kind.createKind("encode-tagged-object-error"), Error) {
-	error;
-	constructor(error) {
-		super(void 0, "An error occurred while encoding a TaggedObject. This can only happen if you are bypassing the type system.");
-		this.error = error;
-	}
-};
-const TaggedObjectStructure = require_base.createStructure(taggedObjectStructureKind, ({ init }) => (name, shape) => init({
+const TaggedObjectStructure = require_base$1.createStructure(taggedObjectStructureKind, ({ init }) => (name, shape) => init({
 	inner: require_object.ObjectStructure({
 		...shape,
 		[objectTagKind.runTimeKey]: require_nonEncodableString.NonEncodableStringStructure(name)
@@ -32,6 +21,7 @@ const TaggedObjectStructure = require_base.createStructure(taggedObjectStructure
 	executeCheck: (self, data, errorHandler) => self.definition.inner.executeCheck(data, errorHandler),
 	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.executeEncode(codecContext, data, errorHandler),
 	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.executeDecode(codecContext, data, errorHandler),
+	executeParse: (self, codecContext, data, errorHandler) => self.definition.inner.executeParse(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous()
 }, {
 	name,
@@ -44,24 +34,24 @@ const TaggedObjectStructure = require_base.createStructure(taggedObjectStructure
 			const [codecs] = args;
 			return (value) => self.decodeMap(codecs, value);
 		}
-		const errorHandler = require_error.createGetErrorHandler();
+		const errorHandler = require_base.createGetErrorHandler();
 		const [codecs, data] = args;
 		const result = self.executeDecode(codecs.context.value, require_isSimple.isSimple(data) ? {
 			...data,
 			[objectTagKind.runTimeKey]: name
 		} : data, errorHandler);
-		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result instanceof Promise) return require_create.left("async-error", new require_base.ErrorPromise());
 		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 		return require_create$1.right("map-success", result);
 	},
 	map: (self, data) => {
-		const errorHandler = require_error.createGetErrorHandler();
+		const errorHandler = require_base.createGetErrorHandler();
 		const formattedData = require_isSimple.isSimple(data) ? {
 			...data,
 			[objectTagKind.runTimeKey]: name
 		} : data;
 		const result = self.executeCheck(formattedData, errorHandler);
-		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result instanceof Promise) return require_create.left("async-error", new require_base.ErrorPromise());
 		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 		return require_create$1.right("map-success", formattedData);
 	},
@@ -71,7 +61,7 @@ const TaggedObjectStructure = require_base.createStructure(taggedObjectStructure
 			return (value) => self.asyncDecodeMap(codecs, value);
 		}
 		return require_justExec.justExec(async () => {
-			const errorHandler = require_error.createGetErrorHandler();
+			const errorHandler = require_base.createGetErrorHandler();
 			const [codecs, data] = args;
 			const result = await self.executeDecode(codecs.context.value, require_isSimple.isSimple(data) ? {
 				...data,
@@ -82,7 +72,7 @@ const TaggedObjectStructure = require_base.createStructure(taggedObjectStructure
 		});
 	},
 	asyncMap: async (self, data) => {
-		const errorHandler = require_error.createGetErrorHandler();
+		const errorHandler = require_base.createGetErrorHandler();
 		const formattedData = require_isSimple.isSimple(data) ? {
 			...data,
 			[objectTagKind.runTimeKey]: name
@@ -90,14 +80,18 @@ const TaggedObjectStructure = require_base.createStructure(taggedObjectStructure
 		if (await self.executeCheck(formattedData, errorHandler) === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 		return require_create$1.right("map-success", formattedData);
 	},
-	encodeTaggedObject: async (self, codecs, data) => {
-		const result = await self.asyncEncode(codecs, data);
-		if (require_is.isLeft(result)) throw new EncodeTaggedObjectError(require_unwrap.unwrapLeft(result));
-		return require_unwrap$1.unwrapRight(result);
+	update: (self, ...args) => {
+		if (args.length === 1) {
+			const [update] = args;
+			return (input) => self.update(input, update);
+		}
+		const [input, update] = args;
+		const updatedTaggedObject = { [objectTagKind.runTimeKey]: name };
+		for (const key of self.definition.inner.definition.keys) updatedTaggedObject[key] = update[key] === void 0 ? input[key] : update[key];
+		return updatedTaggedObject;
 	}
 }));
 //#endregion
-exports.EncodeTaggedObjectError = EncodeTaggedObjectError;
 exports.TaggedObjectStructure = TaggedObjectStructure;
 exports.objectTagKind = objectTagKind;
 exports.taggedObjectStructureKind = taggedObjectStructureKind;

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

@@ -1,5 +1,5 @@
 import { NewType, NewTypeMap } from '../newType';
-import * as DKind from '../../kind';
+import type * as DKind from '../../kind';
 import * as DCommon from '../../common';
 import * as DEither from '../../either';
 import * as DDataStructure from '../../dataStructure';
@@ -36,21 +36,19 @@ export type TaggedObjectMap<GenericValue extends unknown, GenericRawValue = DCom
 ]> extends true ? {
     [Prop in keyof GenericRawValue]: TaggedObjectMap<GenericRawValue[Prop]>;
 } : GenericRawValue : GenericRawValue;
+export type TaggedObjectUpdate<GenericTaggedObject extends ObjectTag, GenericNewProperties extends object> = Extract<(ObjectTag<GetTagValue<GenericTaggedObject>> & DCommon.SimplifyTopLevel<DKind.Remove<GenericTaggedObject> extends infer InferredProperties ? {
+    [Prop in keyof InferredProperties]: Prop extends keyof GenericNewProperties ? GenericNewProperties[Prop] extends infer InferredNewValue ? InferredNewValue extends undefined ? InferredProperties[Prop] : InferredNewValue : never : InferredProperties[Prop];
+} : never>), any>;
 export interface TaggedObjectStructure<out GenericTaggedObject extends ObjectTag = ObjectTag> extends DCommon.Forward<DDataStructure.Structure<GenericTaggedObject, TaggedObjectStructureDefinition> & DKind.Kind<typeof taggedObjectStructureKind>> {
     readonly name: GetTagValue<GenericTaggedObject>;
     "new"(properties: DCommon.SimplifyTopLevel<DKind.Remove<GenericTaggedObject>>): GenericTaggedObject;
-    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>) => (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
-    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
-    map(data: TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
-    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>) => Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    asyncMap(data: TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    encodeTaggedObject<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.StructureValue<this>): Promise<DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>>;
-}
-declare const EncodeTaggedObjectError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangModeling/encode-tagged-object-error", unknown>>, ErrorConstructor>;
-export declare class EncodeTaggedObjectError extends EncodeTaggedObjectError_base {
-    error: DDataStructure.Error;
-    constructor(error: DDataStructure.Error);
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<GenericTaggedObject>>, GenericCodecs>) => (DEither.Right<"map-success", GenericTaggedObject> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<GenericTaggedObject>>, GenericCodecs>): (DEither.Right<"map-success", GenericTaggedObject> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    map(data: TaggedObjectMap<DKind.Remove<GenericTaggedObject>>): (DEither.Right<"map-success", GenericTaggedObject> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<GenericTaggedObject>>, GenericCodecs>) => Promise<DEither.Right<"map-success", GenericTaggedObject> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<GenericTaggedObject>>, GenericCodecs>): Promise<DEither.Right<"map-success", GenericTaggedObject> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncMap(data: TaggedObjectMap<DKind.Remove<GenericTaggedObject>>): Promise<DEither.Right<"map-success", GenericTaggedObject> | DEither.Left<"map-error", DDataStructure.Error>>;
+    update<GenericInput extends GenericTaggedObject, const GenericPayload extends Partial<DKind.Remove<GenericTaggedObject>>>(update: GenericPayload): (input: GenericInput) => TaggedObjectUpdate<GenericInput, GenericPayload>;
+    update<GenericInput extends GenericTaggedObject, const GenericPayload extends Partial<DKind.Remove<GenericTaggedObject>>>(input: GenericInput, update: GenericPayload): TaggedObjectUpdate<GenericInput, GenericPayload>;
 }
 export declare const TaggedObjectStructure: <GenericTaggedObject extends ObjectTag, GenericName extends string = never, GenericShape extends DDataStructure.ShapeObjectStructure = never>(name: GetTagValue<GenericTaggedObject> | GenericName, shape: ShapeTaggedObjectStructure<GenericTaggedObject> | GenericShape) => TaggedObjectStructure<ObjectTag extends GenericTaggedObject ? (ObjectTag<GenericName> & DDataStructure.ShapeObjectStructureValue<GenericShape>) : GenericTaggedObject>;
-export {};

package/dist/modeling/taggedObject/base.mjs

@@ -1,13 +1,9 @@
-import { parentClass } from "../../kind/parentClass.mjs";
 import { isSimple } from "../../object/isSimple.mjs";
 import { left } from "../../either/left/create.mjs";
-import { isLeft } from "../../either/left/is.mjs";
 import { right } from "../../either/right/create.mjs";
-import { unwrapLeft } from "../../either/left/unwrap.mjs";
-import { unwrapRight } from "../../either/right/unwrap.mjs";
 import { justExec } from "../../common/justExec.mjs";
 import { ErrorSymbol } from "../../dataStructure/common/resultSymbol.mjs";
-import { createGetErrorHandler } from "../../dataStructure/common/error.mjs";
+import { ErrorPromise, createGetErrorHandler } from "../../dataStructure/common/error/base.mjs";
 import { createStructure } from "../../dataStructure/structure/base.mjs";
 import { NonEncodableStringStructure } from "../../dataStructure/structure/defaults/nonEncodableString.mjs";
 import { ObjectStructure } from "../../dataStructure/structure/defaults/object.mjs";
@@ -15,13 +11,6 @@ import { createKind } from "../kind.mjs";
 //#region scripts/modeling/taggedObject/base.ts
 const objectTagKind = createKind("object-tag");
 const taggedObjectStructureKind = createKind("tagged-object-structure");
-var EncodeTaggedObjectError = class extends parentClass(createKind("encode-tagged-object-error"), Error) {
-	error;
-	constructor(error) {
-		super(void 0, "An error occurred while encoding a TaggedObject. This can only happen if you are bypassing the type system.");
-		this.error = error;
-	}
-};
 const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init }) => (name, shape) => init({
 	inner: ObjectStructure({
 		...shape,
@@ -32,6 +21,7 @@ const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init
 	executeCheck: (self, data, errorHandler) => self.definition.inner.executeCheck(data, errorHandler),
 	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.executeEncode(codecContext, data, errorHandler),
 	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.executeDecode(codecContext, data, errorHandler),
+	executeParse: (self, codecContext, data, errorHandler) => self.definition.inner.executeParse(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous()
 }, {
 	name,
@@ -50,7 +40,7 @@ const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init
 			...data,
 			[objectTagKind.runTimeKey]: name
 		} : 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("map-error", errorHandler().createError());
 		return right("map-success", result);
 	},
@@ -61,7 +51,7 @@ const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init
 			[objectTagKind.runTimeKey]: name
 		} : data;
 		const result = self.executeCheck(formattedData, 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("map-error", errorHandler().createError());
 		return right("map-success", formattedData);
 	},
@@ -90,11 +80,16 @@ const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init
 		if (await self.executeCheck(formattedData, errorHandler) === ErrorSymbol) return left("map-error", errorHandler().createError());
 		return right("map-success", formattedData);
 	},
-	encodeTaggedObject: async (self, codecs, data) => {
-		const result = await self.asyncEncode(codecs, data);
-		if (isLeft(result)) throw new EncodeTaggedObjectError(unwrapLeft(result));
-		return unwrapRight(result);
+	update: (self, ...args) => {
+		if (args.length === 1) {
+			const [update] = args;
+			return (input) => self.update(input, update);
+		}
+		const [input, update] = args;
+		const updatedTaggedObject = { [objectTagKind.runTimeKey]: name };
+		for (const key of self.definition.inner.definition.keys) updatedTaggedObject[key] = update[key] === void 0 ? input[key] : update[key];
+		return updatedTaggedObject;
 	}
 }));
 //#endregion
-export { EncodeTaggedObjectError, TaggedObjectStructure, objectTagKind, taggedObjectStructureKind };
+export { TaggedObjectStructure, objectTagKind, taggedObjectStructureKind };