@duplojs/lang 0.0.1-beta.8 → 0.0.1-beta.9

package/dist/invocation/index.cjs

@@ -10,7 +10,7 @@ const require_throttling = require("./flow/controller/defaults/throttling.cjs");
 const require_timeout = require("./flow/controller/defaults/timeout.cjs");
 const require_base$1 = require("./flow/base.cjs");
 const require_port = require("./port.cjs");
-const require_useCase = require("./useCase.cjs");
+const require_reader = require("./reader.cjs");
 //#region scripts/invocation/index.ts
 var invocation_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	AbortErrorFlowController: () => require_aborter.AbortErrorFlowController,
@@ -19,7 +19,7 @@ var invocation_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	createFlowController: () => require_base.createFlowController,
 	createKind: () => require_kind.createKind,
 	createPort: () => require_port.createPort,
-	createUseCase: () => require_useCase.createUseCase,
+	createReader: () => require_reader.createReader,
 	debounce: () => require_debounce.debounce,
 	evidenceResult: () => require_evidence.evidenceResult,
 	filter: () => require_filter.filter,
@@ -33,11 +33,11 @@ var invocation_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	flowControllerThrottlingKind: () => require_throttling.flowControllerThrottlingKind,
 	flowControllerTimeoutKind: () => require_timeout.flowControllerTimeoutKind,
 	portHandlerKind: () => require_port.portHandlerKind,
+	readerKind: () => require_reader.readerKind,
+	resolveReaders: () => require_reader.resolveReaders,
 	retry: () => require_retry.retry,
 	throttling: () => require_throttling.throttling,
-	timeout: () => require_timeout.timeout,
-	useCaseHandlerKind: () => require_useCase.useCaseHandlerKind,
-	wireUseCases: () => require_useCase.wireUseCases
+	timeout: () => require_timeout.timeout
 });
 //#endregion
 exports.AbortErrorFlowController = require_aborter.AbortErrorFlowController;
@@ -46,7 +46,7 @@ exports.appendEvidence = require_evidence.appendEvidence;
 exports.createFlowController = require_base.createFlowController;
 exports.createKind = require_kind.createKind;
 exports.createPort = require_port.createPort;
-exports.createUseCase = require_useCase.createUseCase;
+exports.createReader = require_reader.createReader;
 exports.debounce = require_debounce.debounce;
 exports.evidenceResult = require_evidence.evidenceResult;
 exports.filter = require_filter.filter;
@@ -66,8 +66,8 @@ Object.defineProperty(exports, "invocation_exports", {
 	}
 });
 exports.portHandlerKind = require_port.portHandlerKind;
+exports.readerKind = require_reader.readerKind;
+exports.resolveReaders = require_reader.resolveReaders;
 exports.retry = require_retry.retry;
 exports.throttling = require_throttling.throttling;
 exports.timeout = require_timeout.timeout;
-exports.useCaseHandlerKind = require_useCase.useCaseHandlerKind;
-exports.wireUseCases = require_useCase.wireUseCases;

package/dist/invocation/index.d.ts

@@ -2,4 +2,4 @@ export * from './evidence';
 export * from './flow';
 export * from './kind';
 export * from './port';
-export * from './useCase';
+export * from './reader';

package/dist/invocation/index.mjs

@@ -10,7 +10,7 @@ import { flowControllerThrottlingKind, throttling } from "./flow/controller/defa
 import { flowControllerTimeoutKind, timeout } from "./flow/controller/defaults/timeout.mjs";
 import { flow } from "./flow/base.mjs";
 import { createPort, portHandlerKind } from "./port.mjs";
-import { createUseCase, useCaseHandlerKind, wireUseCases } from "./useCase.mjs";
+import { createReader, readerKind, resolveReaders } from "./reader.mjs";
 //#region scripts/invocation/index.ts
 var invocation_exports = /* @__PURE__ */ __exportAll({
 	AbortErrorFlowController: () => AbortErrorFlowController,
@@ -19,7 +19,7 @@ var invocation_exports = /* @__PURE__ */ __exportAll({
 	createFlowController: () => createFlowController,
 	createKind: () => createKind,
 	createPort: () => createPort,
-	createUseCase: () => createUseCase,
+	createReader: () => createReader,
 	debounce: () => debounce,
 	evidenceResult: () => evidenceResult,
 	filter: () => filter,
@@ -33,11 +33,11 @@ var invocation_exports = /* @__PURE__ */ __exportAll({
 	flowControllerThrottlingKind: () => flowControllerThrottlingKind,
 	flowControllerTimeoutKind: () => flowControllerTimeoutKind,
 	portHandlerKind: () => portHandlerKind,
+	readerKind: () => readerKind,
+	resolveReaders: () => resolveReaders,
 	retry: () => retry,
 	throttling: () => throttling,
-	timeout: () => timeout,
-	useCaseHandlerKind: () => useCaseHandlerKind,
-	wireUseCases: () => wireUseCases
+	timeout: () => timeout
 });
 //#endregion
-export { AbortErrorFlowController, aborter, appendEvidence, createFlowController, createKind, createPort, createUseCase, debounce, evidenceResult, filter, flow, flowControllerAborterKind, flowControllerDebounceKind, flowControllerExitKind, flowControllerFilterKind, flowControllerKind, flowControllerRetryKind, flowControllerThrottlingKind, flowControllerTimeoutKind, invocation_exports, portHandlerKind, retry, throttling, timeout, useCaseHandlerKind, wireUseCases };
+export { AbortErrorFlowController, aborter, appendEvidence, createFlowController, createKind, createPort, createReader, debounce, evidenceResult, filter, flow, flowControllerAborterKind, flowControllerDebounceKind, flowControllerExitKind, flowControllerFilterKind, flowControllerKind, flowControllerRetryKind, flowControllerThrottlingKind, flowControllerTimeoutKind, invocation_exports, portHandlerKind, readerKind, resolveReaders, retry, throttling, timeout };

package/dist/invocation/reader.cjs

@@ -0,0 +1,26 @@
+const require_entries = require("../object/entries.cjs");
+const require_entry = require("../object/entry.cjs");
+const require_fromEntries = require("../object/fromEntries.cjs");
+const require_map = require("../array/map.cjs");
+const require_forward = require("../common/forward.cjs");
+const require_pipe = require("../common/pipe.cjs");
+const require_uncapitalize = require("../string/uncapitalize.cjs");
+//#region scripts/invocation/reader.ts
+const readerKind = require("./kind.cjs").createKind("reader");
+function createReader(dependencies, read) {
+	return {
+		dependencies,
+		run: (injectedDependencies) => read(require_pipe.pipe(require_forward.forward(dependencies), require_entries.entries, require_map.map(([key, value]) => {
+			const formattedKey = require_uncapitalize.uncapitalize(key);
+			return require_entry.entry(formattedKey, readerKind.has(value) && !injectedDependencies[formattedKey] ? value.run(injectedDependencies) : injectedDependencies[formattedKey]);
+		}), require_fromEntries.fromEntries)),
+		[readerKind.runTimeKey]: null
+	};
+}
+function resolveReaders(readers, ports) {
+	return require_pipe.pipe(readers, require_entries.entries, require_map.map(([key, reader]) => require_entry.entry(require_uncapitalize.uncapitalize(key), reader.run(ports))), require_fromEntries.fromEntries);
+}
+//#endregion
+exports.createReader = createReader;
+exports.readerKind = readerKind;
+exports.resolveReaders = resolveReaders;

package/dist/invocation/reader.d.ts

@@ -0,0 +1,28 @@
+import { PortHandler } from './port';
+import * as DCommon from '../common';
+import type * as DKind from '../kind';
+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;
+}>;
+export type GetAllPorts<GenericDependenciesValue extends ReaderDependencies> = GenericDependenciesValue extends any ? ({
+    [Prop in keyof GenericDependenciesValue]: (GenericDependenciesValue[Prop] extends PortHandler ? [
+        Uncapitalize<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> {
+    dependencies: GenericDependencies;
+    run(ports: DCommon.SimplifyTopLevel<(GetAllPorts<GenericDependencies> extends infer InferredEntriesDependenciesValue extends DCommon.ObjectEntry ? {
+        [Entry in InferredEntriesDependenciesValue as Entry[0]]: Entry[1];
+    } : never) & ({
+        [Prop in keyof GenericDependencies as GenericDependencies[Prop] extends Reader ? Uncapitalize<Extract<Prop, string>> : never]?: GenericDependencies[Prop] extends Reader ? ReturnType<GenericDependencies[Prop]["run"]> : never;
+    })>): GenericOutput;
+}
+export declare function createReader<const GenericDependencies extends ReaderDependencies, GenericOutput extends unknown>(dependencies: GenericDependencies, read: (dependenciesValue: ReaderDependenciesValue<GenericDependencies>) => GenericOutput): Reader<GenericDependencies, GenericOutput>;
+export declare function resolveReaders<GenericReaders extends Record<string, Reader>>(readers: GenericReaders, ports: DCommon.SimplifyTopLevel<DCommon.UnionToIntersection<{
+    [Prop in keyof GenericReaders]: GetAllPorts<GenericReaders[Prop]["dependencies"]> extends infer InferredEntriesDependenciesValue extends DCommon.ObjectEntry ? {
+        [Entry in InferredEntriesDependenciesValue as Entry[0]]: Entry[1];
+    } : never;
+}[keyof GenericReaders]>>): ReaderDependenciesValue<GenericReaders>;

package/dist/invocation/reader.mjs

@@ -0,0 +1,25 @@
+import { entries } from "../object/entries.mjs";
+import { entry } from "../object/entry.mjs";
+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 { uncapitalize } from "../string/uncapitalize.mjs";
+import { createKind } from "./kind.mjs";
+//#region scripts/invocation/reader.ts
+const readerKind = createKind("reader");
+function createReader(dependencies, read) {
+	return {
+		dependencies,
+		run: (injectedDependencies) => read(pipe(forward(dependencies), entries, map(([key, value]) => {
+			const formattedKey = uncapitalize(key);
+			return entry(formattedKey, readerKind.has(value) && !injectedDependencies[formattedKey] ? value.run(injectedDependencies) : injectedDependencies[formattedKey]);
+		}), fromEntries)),
+		[readerKind.runTimeKey]: null
+	};
+}
+function resolveReaders(readers, ports) {
+	return pipe(readers, entries, map(([key, reader]) => entry(uncapitalize(key), reader.run(ports))), fromEntries);
+}
+//#endregion
+export { createReader, readerKind, resolveReaders };

package/dist/modeling/entity/base.cjs

@@ -1,6 +1,10 @@
+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");
@@ -12,6 +16,13 @@ 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({
 	inner: require_memo.memo(() => require_object.ObjectStructure({
 		...shape(),
@@ -71,7 +82,7 @@ const EntityStructure = require_base.createStructure(entityStructureKind, ({ ini
 			return require_create$1.right("map-success", result);
 		});
 	},
-	asyncMap: (self, data) => require_justExec.justExec(async () => {
+	asyncMap: async (self, data) => {
 		const errorHandler = require_error.createGetErrorHandler();
 		const formattedData = require_isSimple.isSimple(data) ? {
 			...data,
@@ -79,9 +90,15 @@ const EntityStructure = require_base.createStructure(entityStructureKind, ({ ini
 		} : data;
 		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);
+	}
 }));
 //#endregion
+exports.EncodeEntityError = EncodeEntityError;
 exports.EntityStructure = EntityStructure;
 exports.entityKind = entityKind;
 exports.entityStructureKind = entityStructureKind;

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

@@ -1,5 +1,5 @@
 import { NewType, NewTypeMap } from '../newType';
-import type * as DKind from '../../kind';
+import * as DKind from '../../kind';
 import * as DCommon from '../../common';
 import * as DDataStructure from '../../dataStructure';
 import * as DEither from '../../either';
@@ -33,7 +33,7 @@ export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.Re
 ]> extends true ? {
     [Prop in keyof GenericRawValue]: EntityMap<GenericRawValue[Prop]>;
 } : GenericRawValue : GenericRawValue;
-export interface EntityStructure<GenericName extends string = string, GenericProperties extends Record<string, unknown> = Record<string, unknown>> extends DCommon.Forward<DDataStructure.Structure<Entity<GenericName> & GenericProperties, EntityStructureDefinition> & DKind.Kind<typeof entityStructureKind>> {
+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>);
@@ -42,5 +42,12 @@ export interface EntityStructure<GenericName extends string = string, GenericPro
     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);
 }
 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,6 +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";
@@ -12,6 +16,13 @@ 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(),
@@ -71,7 +82,7 @@ const EntityStructure = createStructure(entityStructureKind, ({ init }) => (name
 			return right("map-success", result);
 		});
 	},
-	asyncMap: (self, data) => justExec(async () => {
+	asyncMap: async (self, data) => {
 		const errorHandler = createGetErrorHandler();
 		const formattedData = isSimple(data) ? {
 			...data,
@@ -79,7 +90,12 @@ const EntityStructure = createStructure(entityStructureKind, ({ init }) => (name
 		} : data;
 		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);
+	}
 }));
 //#endregion
-export { EntityStructure, entityKind, entityStructureKind };
+export { EncodeEntityError, EntityStructure, entityKind, entityStructureKind };

package/dist/modeling/entity/namespace.cjs

@@ -9,7 +9,7 @@ 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: (entityStructure, name, valueStructure) => require_base.createFlag(entityStructure, `${entityName}${name}`, valueStructure),
+		createFlag: (name) => require_base.createFlag(`${entityName}${name}`),
 		[namespaceKind.runTimeKey]: null
 	};
 }

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

@@ -10,6 +10,6 @@ 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<GenericEntityStructure extends EntityStructure<GenericEntityName>, GenericName extends Capitalize<string>, GenericValueStructure extends DDataStructure.Structure>(entityStructure: GenericEntityStructure, name: GenericName, valueStructure: GenericValueStructure): FlagHandler<DDataStructure.StructureValue<GenericEntityStructure>, `${GenericEntityName}${GenericName}`, DDataStructure.StructureValue<GenericValueStructure>>;
+    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

@@ -9,7 +9,7 @@ function createEntityNamespace(entityName) {
 		name: entityName,
 		createNewType: (name, structure, newTypeConstraints = []) => createNewType(`${entityName}${name}`, structure, newTypeConstraints),
 		createEntity: (shape) => createEntity(entityName, shape),
-		createFlag: (entityStructure, name, valueStructure) => createFlag(entityStructure, `${entityName}${name}`, valueStructure),
+		createFlag: (name) => createFlag(`${entityName}${name}`),
 		[namespaceKind.runTimeKey]: null
 	};
 }

package/dist/modeling/flag/base.cjs

@@ -1,10 +1,8 @@
-const require_type = require("../../dataStructure/structure/defaults/type.cjs");
-const require_null = require("../../dataStructure/type/defaults/null.cjs");
 const require_kind = require("../kind.cjs");
 //#region scripts/modeling/flag/base.ts
 const flagKind = require_kind.createKind("flag");
 const flagHandlerKind = require_kind.createKind("flag-handler");
-function createFlag(entityStructure, name, valueStructure = require_type.TypeStructure(require_null.NullType(), [])) {
+function createFlag(name) {
 	function append(...args) {
 		if (args.length === 1) {
 			const [value] = args;
@@ -19,8 +17,6 @@ function createFlag(entityStructure, name, valueStructure = require_type.TypeStr
 	}
 	return {
 		name,
-		entityStructure,
-		valueStructure,
 		append,
 		getValue(entity) {
 			return flagKind.getValue(entity)[name];

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

@@ -1,19 +1,18 @@
-import { EntityStructure, Entity, GetEntityName } from '../entity';
+import { EntityStructure, Entity } from '../entity';
+import type * as DCommon from '../../common';
 import type * as DKind from '../../kind';
-import * as DDataStructure from '../../dataStructure';
+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>> {
 }
 declare const flagHandlerKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/flag-handler", unknown>>;
-export interface FlagHandler<GenericEntity extends Entity = Entity, GenericName extends string = string, GenericValue extends unknown = unknown> extends DKind.Kind<typeof flagHandlerKind> {
+export interface FlagHandler<GenericName extends string = string, GenericEntity extends Entity = Entity, GenericValue extends unknown = unknown> extends DKind.Kind<typeof flagHandlerKind> {
     readonly name: GenericName;
-    readonly entityStructure: EntityStructure<GetEntityName<GenericEntity>, Omit<GenericEntity, DKind.KeySymbol>>;
-    readonly valueStructure: DDataStructure.Structure<GenericValue>;
     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];
     has<GenericInputEntity extends GenericEntity>(entity: GenericInputEntity): entity is Extract<GenericInputEntity, Flag<GenericName, any>>;
 }
-export declare function createFlag<GenericEntityStructure extends EntityStructure, GenericName extends Capitalize<string>, GenericValueStructure extends DDataStructure.Structure = DDataStructure.Structure<null>>(entityStructure: GenericEntityStructure, name: GenericName, valueStructure?: GenericValueStructure): FlagHandler<DDataStructure.StructureValue<GenericEntityStructure>, GenericName, DDataStructure.StructureValue<GenericValueStructure>>;
-export type GetFlag<GenericHandler extends FlagHandler<any, any, any>> = GenericHandler extends FlagHandler<any, infer InferredName, infer InferredValue> ? Flag<InferredName, InferredValue> : never;
+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 {};

package/dist/modeling/flag/base.mjs

@@ -1,10 +1,8 @@
-import { TypeStructure } from "../../dataStructure/structure/defaults/type.mjs";
-import { NullType } from "../../dataStructure/type/defaults/null.mjs";
 import { createKind } from "../kind.mjs";
 //#region scripts/modeling/flag/base.ts
 const flagKind = createKind("flag");
 const flagHandlerKind = createKind("flag-handler");
-function createFlag(entityStructure, name, valueStructure = TypeStructure(NullType(), [])) {
+function createFlag(name) {
 	function append(...args) {
 		if (args.length === 1) {
 			const [value] = args;
@@ -19,8 +17,6 @@ function createFlag(entityStructure, name, valueStructure = TypeStructure(NullTy
 	}
 	return {
 		name,
-		entityStructure,
-		valueStructure,
 		append,
 		getValue(entity) {
 			return flagKind.getValue(entity)[name];

package/dist/modeling/index.cjs

@@ -10,6 +10,9 @@ const require_base$3 = 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,
@@ -31,6 +34,9 @@ var modeling_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	taggedObjectStructureKind: () => require_base$3.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;

package/dist/modeling/index.mjs

@@ -1,15 +1,18 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { createKind } from "./kind.mjs";
-import { EntityStructure, entityKind, entityStructureKind } from "./entity/base.mjs";
+import { EncodeEntityError, EntityStructure, entityKind, entityStructureKind } from "./entity/base.mjs";
 import { createEntity } from "./entity/helper.mjs";
-import { NewTypeStructure, newTypeStructureKind } from "./newType/base.mjs";
+import { EncodeNewTypeError, 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 { TaggedObjectStructure, objectTagKind, taggedObjectStructureKind } from "./taggedObject/base.mjs";
+import { EncodeTaggedObjectError, 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,
@@ -31,4 +34,4 @@ var modeling_exports = /* @__PURE__ */ __exportAll({
 	taggedObjectStructureKind: () => taggedObjectStructureKind
 });
 //#endregion
-export { EntityStructure, NewTypeStructure, TaggedObjectStructure, createEntity, createEntityNamespace, createFlag, createKind, createNewType, createTaggedObject, entityKind, entityStructureKind, flagKind, getTagValue, hasTagValue, modeling_exports, namespaceKind, newTypeStructureKind, objectTagKind, taggedObject, taggedObjectStructureKind };
+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 };

package/dist/modeling/newType/base.cjs

@@ -1,12 +1,24 @@
+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");
 //#region scripts/modeling/newType/base.ts
-const newTypeStructureKind = require("../kind.cjs").createKind("new-type-structure");
+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;
+	}
+};
 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);
 }
@@ -53,12 +65,18 @@ const NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ i
 			return require_create$1.right("map-success", result);
 		});
 	},
-	asyncMap: (self, data) => require_justExec.justExec(async () => {
+	asyncMap: async (self, data) => {
 		const errorHandler = require_error.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 type * as DKind from '../../kind';
+import * as DKind from '../../kind';
 import * as DCommon from '../../common';
 import type * as DArray from '../../array';
 import * as DEither from '../../either';
@@ -25,7 +25,7 @@ export interface NewTypeStructureDefinition<GenericNewTypeConstraint extends rea
     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 interface NewTypeStructure<GenericName extends string = string, GenericValue extends unknown = unknown, 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>> {
+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>);
@@ -33,5 +33,12 @@ export interface NewTypeStructure<GenericName extends string = string, GenericVa
     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);
 }
 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,6 +1,10 @@
+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";
@@ -8,6 +12,13 @@ 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);
 }
@@ -54,11 +65,16 @@ const NewTypeStructure = createStructure(newTypeStructureKind, ({ init }) => (na
 			return right("map-success", result);
 		});
 	},
-	asyncMap: (self, data) => justExec(async () => {
+	asyncMap: async (self, data) => {
 		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 { NewTypeStructure, newTypeStructureKind };
+export { EncodeNewTypeError, NewTypeStructure, newTypeStructureKind };