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

package/dist/invocation/reader.d.ts

@@ -1,18 +1,19 @@
 import { PortHandler } from './port';
 import * as DCommon from '../common';
 import type * as DKind from '../kind';
+type FormatPortName<GenericValue extends string> = Uncapitalize<GenericValue> extends infer InferredResult extends string ? InferredResult extends `${infer InferredName}Port` ? InferredName : InferredResult : never;
 export type ReaderDependencies = Record<string, Reader | PortHandler>;
 export type ReaderDependenciesValue<GenericDependencies extends ReaderDependencies> = DCommon.SimplifyTopLevel<{
-    [Prop in keyof GenericDependencies as Uncapitalize<Extract<Prop, string>>]: GenericDependencies[Prop] extends PortHandler ? ReturnType<GenericDependencies[Prop]["createImplementation"]> : GenericDependencies[Prop] extends Reader ? ReturnType<GenericDependencies[Prop]["run"]> : never;
+    [Prop in keyof GenericDependencies as (GenericDependencies[Prop] extends PortHandler ? FormatPortName<Extract<Prop, string>> : Uncapitalize<Extract<Prop, string>>)]: GenericDependencies[Prop] extends PortHandler ? ReturnType<GenericDependencies[Prop]["createImplementation"]> : GenericDependencies[Prop] extends Reader ? ReturnType<GenericDependencies[Prop]["run"]> : never;
 }>;
 export type GetAllPorts<GenericDependenciesValue extends ReaderDependencies> = GenericDependenciesValue extends any ? ({
     [Prop in keyof GenericDependenciesValue]: (GenericDependenciesValue[Prop] extends PortHandler ? [
-        Uncapitalize<Extract<Prop, string>>,
+        FormatPortName<Extract<Prop, string>>,
         ReturnType<GenericDependenciesValue[Prop]["createImplementation"]>
     ] : GenericDependenciesValue[Prop] extends Reader ? GetAllPorts<GenericDependenciesValue[Prop]["dependencies"]> : never);
 })[keyof GenericDependenciesValue] : never;
 export declare const readerKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/reader", unknown>>;
-export interface Reader<GenericDependencies extends ReaderDependencies = any, GenericOutput extends unknown = unknown> extends DKind.Kind<typeof readerKind> {
+export interface Reader<GenericDependencies extends ReaderDependencies = ReaderDependencies, GenericOutput extends unknown = unknown> extends DKind.Kind<typeof readerKind> {
     dependencies: GenericDependencies;
     run(ports: DCommon.SimplifyTopLevel<(GetAllPorts<GenericDependencies> extends infer InferredEntriesDependenciesValue extends DCommon.ObjectEntry ? {
         [Entry in InferredEntriesDependenciesValue as Entry[0]]: Entry[1];
@@ -26,3 +27,4 @@ export declare function resolveReaders<GenericReaders extends Record<string, Rea
         [Entry in InferredEntriesDependenciesValue as Entry[0]]: Entry[1];
     } : never;
 }[keyof GenericReaders]>>): ReaderDependenciesValue<GenericReaders>;
+export {};

package/dist/invocation/reader.mjs

@@ -4,15 +4,19 @@ import { fromEntries } from "../object/fromEntries.mjs";
 import { map } from "../array/map.mjs";
 import { forward } from "../common/forward.mjs";
 import { pipe } from "../common/pipe.mjs";
+import { replace } from "../string/replace.mjs";
 import { uncapitalize } from "../string/uncapitalize.mjs";
 import { createKind } from "./kind.mjs";
 //#region scripts/invocation/reader.ts
 const readerKind = createKind("reader");
+function formatPortName(value) {
+	return pipe(value, uncapitalize, replace(/Port$/, ""));
+}
 function createReader(dependencies, read) {
 	return {
 		dependencies,
 		run: (injectedDependencies) => read(pipe(forward(dependencies), entries, map(([key, value]) => {
-			const formattedKey = uncapitalize(key);
+			const formattedKey = readerKind.has(value) ? uncapitalize(key) : formatPortName(key);
 			return entry(formattedKey, readerKind.has(value) && !injectedDependencies[formattedKey] ? value.run(injectedDependencies) : injectedDependencies[formattedKey]);
 		}), fromEntries)),
 		[readerKind.runTimeKey]: null

package/dist/invocation/resolver.cjs

@@ -0,0 +1,31 @@
+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");
+//#region scripts/invocation/resolver.ts
+const resolverKind = require("./kind.cjs").createKind("resolver");
+function createResolver(value) {
+	function resolve(subscribers, whenError) {
+		return Promise.resolve().then(() => Object.values(subscribers).reduce((accumulator, element) => require_callThen.callThen(accumulator, (awaitedAccumulator) => {
+			if (require_is.isLeft(awaitedAccumulator)) return awaitedAccumulator;
+			return element(value);
+		}), null)).then((result) => {
+			if (require_is.isLeft(result)) return require_callThen.callThen(whenError(result, value), (output) => require_create.left("resolve-error", output));
+			return require_create$1.right("resolve-success", value);
+		});
+	}
+	function runAndResolve(theFunction, subscribers, whenError) {
+		return Promise.resolve().then(() => theFunction(value)).then((result) => {
+			if (require_is.isLeft(result)) return require_callThen.callThen(whenError(result, value), (output) => require_create.left("resolve-error", output));
+			return resolve(subscribers, whenError);
+		});
+	}
+	return () => ({
+		resolve,
+		runAndResolve,
+		[resolverKind.runTimeKey]: null
+	});
+}
+//#endregion
+exports.createResolver = createResolver;
+exports.resolverKind = resolverKind;

package/dist/invocation/resolver.d.ts

@@ -0,0 +1,14 @@
+import * as DCommon from '../common';
+import type * as DKind from '../kind';
+import type * as DObject from '../object';
+import * as DEither from '../either';
+export declare const resolverKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/resolver", unknown>>;
+export interface Resolver<GenericValue extends unknown = unknown, GenericSubscribers extends Record<string, (value: GenericValue) => unknown> = Record<string, (value: GenericValue) => unknown>> extends DKind.Kind<typeof resolverKind> {
+    runAndResolve<GenericOutput extends DCommon.MaybePromise<DEither.Right | DEither.Left | undefined | DCommon.EscapeVoid>, const GenericWrapperSubscribers extends GenericSubscribers, GenericOutputHandlerLeft extends unknown = never>(theFunction: (value: GenericValue) => GenericOutput, subscribers: GenericWrapperSubscribers, ...args: (DCommon.ContainExtends<Extract<Awaited<GenericOutput> | Awaited<ReturnType<DObject.Values<GenericWrapperSubscribers>>>, DEither.Left>, DEither.Left> extends true ? [
+        whenLeft: (result: Extract<Awaited<GenericOutput> | Awaited<ReturnType<DObject.Values<GenericWrapperSubscribers>>>, DEither.Left>, value: GenericValue) => GenericOutputHandlerLeft
+    ] : [])): Promise<(DCommon.IsNever<GenericOutputHandlerLeft> extends true ? never : DEither.Left<"resolve-error", Awaited<GenericOutputHandlerLeft>>) | DEither.Right<"resolve-success", GenericValue>>;
+    resolve<const GenericWrapperSubscribers extends GenericSubscribers, GenericOutputHandlerLeft extends unknown = never>(subscribers: GenericWrapperSubscribers, ...args: (DCommon.ContainExtends<Extract<Awaited<ReturnType<DObject.Values<GenericWrapperSubscribers>>>, DEither.Left>, DEither.Left> extends true ? [
+        whenLeft: (result: Extract<Awaited<ReturnType<DObject.Values<GenericWrapperSubscribers>>>, DEither.Left>, value: GenericValue) => GenericOutputHandlerLeft
+    ] : [])): Promise<(DCommon.IsNever<GenericOutputHandlerLeft> extends true ? never : DEither.Left<"resolve-error", Awaited<GenericOutputHandlerLeft>>) | DEither.Right<"resolve-success", GenericValue>>;
+}
+export declare function createResolver<const GenericValue extends unknown>(value: GenericValue): <GenericSubscribers extends (Record<string, (value: GenericValue) => unknown> | DCommon.AnyTuple<string>)>() => Resolver<GenericValue, GenericSubscribers extends readonly string[] ? Record<GenericSubscribers[number], (value: GenericValue) => unknown> : GenericSubscribers>;

package/dist/invocation/resolver.mjs

@@ -0,0 +1,31 @@
+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 { createKind } from "./kind.mjs";
+//#region scripts/invocation/resolver.ts
+const resolverKind = createKind("resolver");
+function createResolver(value) {
+	function resolve(subscribers, whenError) {
+		return Promise.resolve().then(() => Object.values(subscribers).reduce((accumulator, element) => callThen(accumulator, (awaitedAccumulator) => {
+			if (isLeft(awaitedAccumulator)) return awaitedAccumulator;
+			return element(value);
+		}), null)).then((result) => {
+			if (isLeft(result)) return callThen(whenError(result, value), (output) => left("resolve-error", output));
+			return right("resolve-success", value);
+		});
+	}
+	function runAndResolve(theFunction, subscribers, whenError) {
+		return Promise.resolve().then(() => theFunction(value)).then((result) => {
+			if (isLeft(result)) return callThen(whenError(result, value), (output) => left("resolve-error", output));
+			return resolve(subscribers, whenError);
+		});
+	}
+	return () => ({
+		resolve,
+		runAndResolve,
+		[resolverKind.runTimeKey]: null
+	});
+}
+//#endregion
+export { createResolver, resolverKind };

package/dist/invocation/signature.cjs

@@ -0,0 +1,8 @@
+//#region scripts/invocation/signature.ts
+const signatureKind = require("./kind.cjs").createKind("signature");
+function signedFunction(name, theFunction) {
+	return signatureKind.setTo(theFunction, name);
+}
+//#endregion
+exports.signatureKind = signatureKind;
+exports.signedFunction = signedFunction;

package/dist/invocation/signature.d.ts

@@ -0,0 +1,7 @@
+import type * as DCommon from '../common';
+import type * as DKind from '../kind';
+export declare const signatureKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/signature", string>>;
+export interface Signature<GenericName extends string = string> extends DKind.Kind<typeof signatureKind, GenericName> {
+}
+export type SignedFunction<GenericName extends string = string, GenericFunction extends DCommon.AnyFunction = DCommon.AnyFunction> = (Signature<GenericName> & GenericFunction);
+export declare function signedFunction<GenericName extends string, GenericFunction extends DCommon.AnyFunction>(name: NoInfer<GenericName>, theFunction: NoInfer<GenericFunction>): SignedFunction<GenericName, GenericFunction>;

package/dist/invocation/signature.mjs

@@ -0,0 +1,8 @@
+import { createKind } from "./kind.mjs";
+//#region scripts/invocation/signature.ts
+const signatureKind = createKind("signature");
+function signedFunction(name, theFunction) {
+	return signatureKind.setTo(theFunction, name);
+}
+//#endregion
+export { signatureKind, signedFunction };

package/dist/modeling/entity/base.cjs

@@ -1,29 +1,18 @@
-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_memo = require("../../common/memo.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/entity/base.ts
 const entityKind = require_kind.createKind("entity");
 const entityStructureKind = require_kind.createKind("entity-structure");
-var EncodeEntityError = class extends require_parentClass.parentClass(require_kind.createKind("encode-entity-error"), Error) {
-	error;
-	constructor(error) {
-		super(void 0, "An error occurred while encoding an Entity. This can only happen if you are bypassing the type system.");
-		this.error = error;
-	}
-};
-const EntityStructure = require_base.createStructure(entityStructureKind, ({ init }) => (name, shape) => init({
+const EntityStructure = require_base$1.createStructure(entityStructureKind, ({ init }) => (name, shape) => init({
 	inner: require_memo.memo(() => require_object.ObjectStructure({
 		...shape(),
 		[entityKind.runTimeKey]: require_nonEncodableString.NonEncodableStringStructure(name)
@@ -33,6 +22,7 @@ const EntityStructure = require_base.createStructure(entityStructureKind, ({ ini
 	executeCheck: (self, data, errorHandler) => self.definition.inner.value.executeCheck(data, errorHandler),
 	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeEncode(codecContext, data, errorHandler),
 	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeDecode(codecContext, data, errorHandler),
+	executeParse: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeParse(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.inner.value.isAsynchronous()
 }, {
 	name,
@@ -45,24 +35,24 @@ const EntityStructure = require_base.createStructure(entityStructureKind, ({ ini
 			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,
 			[entityKind.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,
 			[entityKind.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);
 	},
@@ -72,7 +62,7 @@ const EntityStructure = require_base.createStructure(entityStructureKind, ({ ini
 			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,
@@ -83,7 +73,7 @@ const EntityStructure = require_base.createStructure(entityStructureKind, ({ ini
 		});
 	},
 	asyncMap: async (self, data) => {
-		const errorHandler = require_error.createGetErrorHandler();
+		const errorHandler = require_base.createGetErrorHandler();
 		const formattedData = require_isSimple.isSimple(data) ? {
 			...data,
 			[entityKind.runTimeKey]: name
@@ -91,14 +81,18 @@ const EntityStructure = require_base.createStructure(entityStructureKind, ({ ini
 		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);
 	},
-	encodeEntity: async (self, codecs, data) => {
-		const result = await self.asyncEncode(codecs, data);
-		if (require_is.isLeft(result)) throw new EncodeEntityError(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 updatedEntity = { [entityKind.runTimeKey]: name };
+		for (const key of self.definition.inner.value.definition.keys) updatedEntity[key] = update[key] === void 0 ? input[key] : update[key];
+		return updatedEntity;
 	}
 }));
 //#endregion
-exports.EncodeEntityError = EncodeEntityError;
 exports.EntityStructure = EntityStructure;
 exports.entityKind = entityKind;
 exports.entityStructureKind = entityStructureKind;

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

@@ -1,8 +1,9 @@
 import { NewType, NewTypeMap } from '../newType';
-import * as DKind from '../../kind';
+import type * as DKind from '../../kind';
 import * as DCommon from '../../common';
 import * as DDataStructure from '../../dataStructure';
 import * as DEither from '../../either';
+import * as DObject from '../../object';
 declare module '../../dataStructure' {
     interface StructuresStore {
         entity: EntityStructure;
@@ -33,21 +34,21 @@ export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.Re
 ]> extends true ? {
     [Prop in keyof GenericRawValue]: EntityMap<GenericRawValue[Prop]>;
 } : GenericRawValue : GenericRawValue;
+export type EntityUpdate<GenericEntity extends Entity, GenericNewProperties extends object> = Extract<(Entity<GetEntityName<GenericEntity>> & DCommon.SimplifyTopLevel<DKind.Remove<GenericEntity> 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>;
+type ForbiddenMoreKey<GenericProperties extends Record<string, unknown>, GenericNewProperties extends Record<string, unknown>> = DObject.ForbiddenKey<GenericNewProperties, Extract<Exclude<keyof GenericNewProperties, keyof GenericProperties>, string>>;
 export interface EntityStructure<out GenericName extends string = string, out GenericProperties extends Record<string, unknown> = Record<string, unknown>> extends DCommon.Forward<DDataStructure.Structure<Entity<GenericName> & GenericProperties, EntityStructureDefinition> & DKind.Kind<typeof entityStructureKind>> {
     readonly name: GenericName;
-    "new"<GenericNewProperties extends GenericProperties>(properties: GenericNewProperties): (Entity<GenericName> & GenericNewProperties);
-    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<EntityMap<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<EntityMap<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: EntityMap<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<EntityMap<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<EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    asyncMap(data: EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    encodeEntity<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.StructureValue<this>): Promise<DDataStructure.EncodedValue<EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>>;
-}
-declare const EncodeEntityError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangModeling/encode-entity-error", unknown>>, ErrorConstructor>;
-export declare class EncodeEntityError extends EncodeEntityError_base {
-    error: DDataStructure.Error;
-    constructor(error: DDataStructure.Error);
+    "new"<GenericNewProperties extends GenericProperties>(properties: (GenericNewProperties & ForbiddenMoreKey<GenericProperties, GenericNewProperties>)): (Entity<GenericName> & DCommon.SimplifyTopLevel<Readonly<GenericNewProperties>>);
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<EntityMap<GenericProperties>, GenericCodecs>) => (DEither.Right<"map-success", Entity<GenericName> & GenericProperties> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<EntityMap<GenericProperties>, GenericCodecs>): (DEither.Right<"map-success", Entity<GenericName> & GenericProperties> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    map(data: EntityMap<GenericProperties>): (DEither.Right<"map-success", Entity<GenericName> & GenericProperties> | DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>);
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<EntityMap<GenericProperties>, GenericCodecs>) => Promise<DEither.Right<"map-success", Entity<GenericName> & GenericProperties> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<EntityMap<GenericProperties>, GenericCodecs>): Promise<DEither.Right<"map-success", Entity<GenericName> & GenericProperties> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncMap(data: EntityMap<GenericProperties>): Promise<DEither.Right<"map-success", Entity<GenericName> & GenericProperties> | DEither.Left<"map-error", DDataStructure.Error>>;
+    update<GenericInputEntity extends (Entity<GenericName> & GenericProperties), const GenericPayload extends Partial<GenericProperties>>(update: GenericPayload): (input: GenericInputEntity) => EntityUpdate<GenericInputEntity, GenericPayload>;
+    update<GenericInputEntity extends (Entity<GenericName> & GenericProperties), const GenericPayload extends Partial<GenericProperties>>(input: GenericInputEntity, update: GenericPayload): EntityUpdate<GenericInputEntity, GenericPayload>;
 }
 export declare const EntityStructure: <GenericName extends string, GenericShape extends DDataStructure.ShapeObjectStructure, const GenericProperties extends DDataStructure.ShapeObjectStructureValue<GenericShape>>(name: GenericName, shape: () => GenericShape) => EntityStructure<GenericName, GenericProperties>;
 export {};

package/dist/modeling/entity/base.mjs

@@ -1,14 +1,10 @@
-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 { memo } from "../../common/memo.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";
@@ -16,13 +12,6 @@ import { createKind } from "../kind.mjs";
 //#region scripts/modeling/entity/base.ts
 const entityKind = createKind("entity");
 const entityStructureKind = createKind("entity-structure");
-var EncodeEntityError = class extends parentClass(createKind("encode-entity-error"), Error) {
-	error;
-	constructor(error) {
-		super(void 0, "An error occurred while encoding an Entity. This can only happen if you are bypassing the type system.");
-		this.error = error;
-	}
-};
 const EntityStructure = createStructure(entityStructureKind, ({ init }) => (name, shape) => init({
 	inner: memo(() => ObjectStructure({
 		...shape(),
@@ -33,6 +22,7 @@ const EntityStructure = createStructure(entityStructureKind, ({ init }) => (name
 	executeCheck: (self, data, errorHandler) => self.definition.inner.value.executeCheck(data, errorHandler),
 	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeEncode(codecContext, data, errorHandler),
 	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeDecode(codecContext, data, errorHandler),
+	executeParse: (self, codecContext, data, errorHandler) => self.definition.inner.value.executeParse(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.inner.value.isAsynchronous()
 }, {
 	name,
@@ -51,7 +41,7 @@ const EntityStructure = createStructure(entityStructureKind, ({ init }) => (name
 			...data,
 			[entityKind.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);
 	},
@@ -62,7 +52,7 @@ const EntityStructure = createStructure(entityStructureKind, ({ init }) => (name
 			[entityKind.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);
 	},
@@ -91,11 +81,16 @@ const EntityStructure = createStructure(entityStructureKind, ({ init }) => (name
 		if (await self.executeCheck(formattedData, errorHandler) === ErrorSymbol) return left("map-error", errorHandler().createError());
 		return right("map-success", formattedData);
 	},
-	encodeEntity: async (self, codecs, data) => {
-		const result = await self.asyncEncode(codecs, data);
-		if (isLeft(result)) throw new EncodeEntityError(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 updatedEntity = { [entityKind.runTimeKey]: name };
+		for (const key of self.definition.inner.value.definition.keys) updatedEntity[key] = update[key] === void 0 ? input[key] : update[key];
+		return updatedEntity;
 	}
 }));
 //#endregion
-export { EncodeEntityError, EntityStructure, entityKind, entityStructureKind };
+export { EntityStructure, entityKind, entityStructureKind };

package/dist/modeling/entity/helper.d.ts

@@ -1,15 +1,13 @@
 import { Entity, EntityStructure } from './base';
 import { NewType } from '../newType';
+import { ObjectTag } from '../taggedObject';
 import type * as DCommon from '../../common';
 import type * as DDataStructure from '../../dataStructure';
 import type * as DString from '../../string';
-export type ForbiddenMissingNewTypeInEntityShape<GenericValue extends unknown, GenericPath extends readonly string[] = readonly []> = GenericValue extends NewType ? never : GenericValue extends object ? DCommon.Or<[
-    DCommon.IsExtends<GenericValue, readonly any[]>,
-    DCommon.And<[
-        DCommon.IsExtends<keyof GenericValue, string>,
-        DCommon.Not<DCommon.IsExtends<DCommon.AnyFunction, GenericValue[keyof GenericValue]>>
-    ]>
+export type ForbiddenMissingNewTypeInEntityShape<GenericValue extends unknown, GenericPath extends readonly string[] = readonly []> = GenericValue extends (ObjectTag | NewType | null | undefined | Entity) ? never : GenericValue extends readonly (infer InferredElement)[] ? ForbiddenMissingNewTypeInEntityShape<InferredElement, readonly [...GenericPath, "[number]"]> : GenericValue extends object ? DCommon.And<[
+    DCommon.IsExtends<keyof GenericValue, string>,
+    DCommon.Not<DCommon.IsExtends<DCommon.AnyFunction, GenericValue[keyof GenericValue]>>
 ]> extends true ? {
-    [Prop in keyof GenericValue]: ForbiddenMissingNewTypeInEntityShape<GenericValue[Prop], readonly [...GenericPath, `${Extract<Prop, string | number>}`]>;
-}[keyof GenericValue] : GenericValue extends Entity ? never : DCommon.ComputedTypeError<`Value at '${DString.Join<GenericPath>}' is not a NewType.`> : DCommon.ComputedTypeError<`Value at '${DString.Join<GenericPath>}' is not a NewType.`>;
+    [Prop in keyof GenericValue]-?: ForbiddenMissingNewTypeInEntityShape<GenericValue[Prop], readonly [...GenericPath, `${Extract<Prop, string | number>}`]>;
+}[keyof GenericValue] : DCommon.ComputedTypeError<`Value at '${DString.Join<GenericPath, ".">}' is not a NewType.`> : DCommon.ComputedTypeError<`Value at '${DString.Join<GenericPath, ".">}' is not a NewType.`>;
 export declare function createEntity<GenericName extends Capitalize<string>, GenericShape extends DDataStructure.ShapeObjectStructure>(name: GenericName, shape: () => (GenericShape & DCommon.NeverCoalescing<ForbiddenMissingNewTypeInEntityShape<DDataStructure.ShapeObjectStructureValue<GenericShape>>, unknown>)): EntityStructure<GenericName, DDataStructure.ShapeObjectStructureValue<GenericShape & DCommon.NeverCoalescing<ForbiddenMissingNewTypeInEntityShape<DDataStructure.ShapeObjectStructureValue<GenericShape>, readonly []>, unknown>>>;

package/dist/modeling/entity/namespace.cjs

@@ -1,7 +1,6 @@
 const require_kind = require("../kind.cjs");
 const require_helper = require("./helper.cjs");
 const require_helper$1 = require("../newType/helper.cjs");
-const require_base = require("../flag/base.cjs");
 //#region scripts/modeling/entity/namespace.ts
 const namespaceKind = require_kind.createKind("namespace");
 function createEntityNamespace(entityName) {
@@ -9,7 +8,6 @@ function createEntityNamespace(entityName) {
 		name: entityName,
 		createNewType: (name, structure, newTypeConstraints = []) => require_helper$1.createNewType(`${entityName}${name}`, structure, newTypeConstraints),
 		createEntity: (shape) => require_helper.createEntity(entityName, shape),
-		createFlag: (name) => require_base.createFlag(`${entityName}${name}`),
 		[namespaceKind.runTimeKey]: null
 	};
 }

package/dist/modeling/entity/namespace.d.ts

@@ -1,7 +1,6 @@
 import { ForbiddenTopLevelNewType, NewTypeStructure } from '../newType';
 import { ForbiddenMissingNewTypeInEntityShape } from './helper';
 import { EntityStructure } from './base';
-import { FlagHandler } from '../flag';
 import type * as DCommon from '../../common';
 import type * as DDataStructure from '../../dataStructure';
 import type * as DKind from '../../kind';
@@ -10,6 +9,5 @@ export interface EntityNamespace<GenericEntityName extends Capitalize<string> =
     readonly name: GenericEntityName;
     createNewType<GenericName extends Capitalize<string>, GenericStructure extends DDataStructure.Structure, const GenericNewTypeConstraint extends readonly DDataStructure.Constraint<DDataStructure.StructureValue<GenericStructure>>[] = readonly []>(name: (GenericName & DCommon.NeverCoalescing<ForbiddenTopLevelNewType<DDataStructure.StructureValue<GenericStructure>>, unknown>), structure: GenericStructure, newTypeConstraints?: GenericNewTypeConstraint): NewTypeStructure<`${GenericEntityName}${GenericName}`, DDataStructure.StructureValue<GenericStructure>, GenericNewTypeConstraint>;
     createEntity<GenericShape extends DDataStructure.ShapeObjectStructure>(shape: () => (GenericShape & DCommon.NeverCoalescing<ForbiddenMissingNewTypeInEntityShape<DDataStructure.ShapeObjectStructureValue<GenericShape>>, unknown>)): EntityStructure<GenericEntityName, DDataStructure.ShapeObjectStructureValue<GenericShape>>;
-    createFlag<GenericName extends Capitalize<string>, GenericEntityStructure extends EntityStructure<GenericEntityName>, GenericPayload extends unknown = {}>(name: DCommon.IsEqual<GenericName, Capitalize<string>> extends true ? never : NoInfer<GenericName>): FlagHandler<`${GenericEntityName}${GenericName}`, DDataStructure.StructureValue<GenericEntityStructure>, GenericPayload>;
 }
 export declare function createEntityNamespace<GenericName extends Capitalize<string>>(entityName: GenericName): EntityNamespace<GenericName>;

package/dist/modeling/entity/namespace.mjs

@@ -1,7 +1,6 @@
 import { createKind } from "../kind.mjs";
 import { createEntity } from "./helper.mjs";
 import { createNewType } from "../newType/helper.mjs";
-import { createFlag } from "../flag/base.mjs";
 //#region scripts/modeling/entity/namespace.ts
 const namespaceKind = createKind("namespace");
 function createEntityNamespace(entityName) {
@@ -9,7 +8,6 @@ function createEntityNamespace(entityName) {
 		name: entityName,
 		createNewType: (name, structure, newTypeConstraints = []) => createNewType(`${entityName}${name}`, structure, newTypeConstraints),
 		createEntity: (shape) => createEntity(entityName, shape),
-		createFlag: (name) => createFlag(`${entityName}${name}`),
 		[namespaceKind.runTimeKey]: null
 	};
 }

package/dist/modeling/fact/base.cjs

@@ -0,0 +1,36 @@
+const require_create = require("../../either/right/create.cjs");
+const require_kind = require("../kind.cjs");
+//#region scripts/modeling/fact/base.ts
+const factKind = require_kind.createKind("fact");
+const factHandlerKind = require_kind.createKind("fact-handler");
+function createFact(name) {
+	function applyFact(...args) {
+		if (args.length === 1) {
+			const [payload] = args;
+			return (entity) => applyFact(entity, payload);
+		}
+		const [entity, payload] = args;
+		const entityWithFact = {
+			...entity,
+			[factKind.runTimeKey]: {
+				name,
+				payload
+			}
+		};
+		return require_create.right(`fact-result-${name}`, entityWithFact);
+	}
+	return (createRun) => ({
+		name,
+		run: createRun({ applyFact }),
+		getPayload(entity) {
+			return factKind.getValue(entity).payload;
+		},
+		has(entity) {
+			return factKind.has(entity) && factKind.getValue(entity).name === name;
+		},
+		[factHandlerKind.runTimeKey]: null
+	});
+}
+//#endregion
+exports.createFact = createFact;
+exports.factKind = factKind;

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

@@ -0,0 +1,29 @@
+import { EntityStructure, Entity } from '../entity';
+import type * as DCommon from '../../common';
+import type * as DKind from '../../kind';
+import type * as DDataStructure from '../../dataStructure';
+import * as DEither from '../../either';
+export interface FactValue<GenericName extends string = string, GenericPayload extends unknown = unknown> {
+    name: GenericName;
+    payload: GenericPayload;
+}
+export declare const factKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/fact", FactValue<string, unknown>>>;
+export interface Fact<GenericName extends Capitalize<string> = Capitalize<string>, GenericValue extends unknown = unknown> extends DKind.Kind<typeof factKind, FactValue<GenericName, GenericValue>> {
+}
+export type GetFactName<GenericHandler extends Fact> = GenericHandler extends Fact<infer InferredName extends Capitalize<string>> ? InferredName : never;
+export type GetFactPayload<GenericHandler extends Fact> = GenericHandler extends Fact<any, infer InferredPayload extends object> ? InferredPayload : never;
+export type FactRun<GenericName extends string = string> = DCommon.AnyFunction<any[], DEither.Left | DEither.Right<`fact-result-${GenericName}`, unknown>>;
+declare const factHandlerKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/fact-handler", unknown>>;
+export interface FactHandler<GenericName extends Capitalize<string> = Capitalize<string>, GenericEntity extends Entity = Entity, GenericPayload extends object = object, GenericRun extends FactRun<GenericName> = FactRun<GenericName>> extends DKind.Kind<typeof factHandlerKind> {
+    readonly name: GenericName;
+    run: GenericRun;
+    getPayload<GenericInputEntity extends Fact<GenericName, GenericPayload>>(entity: GenericInputEntity): DKind.GetValue<typeof factKind, GenericInputEntity>["payload"];
+    has<GenericInputEntity extends GenericEntity>(entity: GenericInputEntity): entity is Extract<GenericInputEntity, Fact<GenericName>>;
+}
+type RemoveFact<GenericEntity extends Entity> = GenericEntity extends Fact<infer InferredName, infer InferredValue> ? GenericEntity extends (infer InferredEntity & Fact<InferredName, InferredValue>) ? InferredEntity : GenericEntity : GenericEntity;
+export interface CreateFactConstructorParams<GenericName extends Capitalize<string> = Capitalize<string>, GenericEntity extends Entity = Entity, GenericPayload extends object = object> {
+    applyFact<GenericInputEntity extends GenericEntity, GenericInputPayload extends GenericPayload>(payload: GenericInputPayload): (entity: GenericInputEntity) => DEither.Right<`fact-result-${GenericName}`, RemoveFact<GenericInputEntity> & Fact<GenericName, GenericInputPayload>>;
+    applyFact<GenericInputEntity extends GenericEntity, GenericInputPayload extends GenericPayload>(entity: GenericInputEntity, payload: GenericInputPayload): DEither.Right<`fact-result-${GenericName}`, RemoveFact<GenericInputEntity> & Fact<GenericName, GenericInputPayload>>;
+}
+export declare function createFact<GenericFact extends Fact, GenericEntityStructure extends EntityStructure>(name: GetFactName<GenericFact>): <GenericRun extends FactRun<GetFactName<GenericFact>>>(createRun: (params: CreateFactConstructorParams<GetFactName<GenericFact>, DDataStructure.StructureValue<GenericEntityStructure>, GetFactPayload<GenericFact>>) => GenericRun) => FactHandler<GetFactName<GenericFact>, DDataStructure.StructureValue<GenericEntityStructure>, GetFactPayload<GenericFact>, GenericRun>;
+export {};

package/dist/modeling/fact/base.mjs

@@ -0,0 +1,35 @@
+import { right } from "../../either/right/create.mjs";
+import { createKind } from "../kind.mjs";
+//#region scripts/modeling/fact/base.ts
+const factKind = createKind("fact");
+const factHandlerKind = createKind("fact-handler");
+function createFact(name) {
+	function applyFact(...args) {
+		if (args.length === 1) {
+			const [payload] = args;
+			return (entity) => applyFact(entity, payload);
+		}
+		const [entity, payload] = args;
+		const entityWithFact = {
+			...entity,
+			[factKind.runTimeKey]: {
+				name,
+				payload
+			}
+		};
+		return right(`fact-result-${name}`, entityWithFact);
+	}
+	return (createRun) => ({
+		name,
+		run: createRun({ applyFact }),
+		getPayload(entity) {
+			return factKind.getValue(entity).payload;
+		},
+		has(entity) {
+			return factKind.has(entity) && factKind.getValue(entity).name === name;
+		},
+		[factHandlerKind.runTimeKey]: null
+	});
+}
+//#endregion
+export { createFact, factKind };

package/dist/modeling/fact/index.d.ts

@@ -0,0 +1 @@
+export * from './base';

package/dist/modeling/flag/base.cjs

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