@duplojs/lang 0.0.0 → 0.0.1-beta.10

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';
@@ -7,6 +7,8 @@ declare module '../../dataStructure' {
     interface StructuresStore {
         entity: EntityStructure;
     }
+}
+declare module '../../dataStructure/common' {
     interface EncodeStructure<GenericValue extends unknown, GenericCodecs extends DDataStructure.Codecs> {
         entity: GenericValue extends Entity<infer InferredName> ? (Entity<InferredName> & {
             [Prop in Exclude<keyof GenericValue, DKind.KeySymbol>]: DDataStructure.EncodedValue<GenericValue[Prop], GenericCodecs>;
@@ -17,6 +19,7 @@ export declare const entityKind: DKind.Handler<DKind.Definition<"@DuplojsLangMod
 export interface Entity<GenericName extends string = string> extends DKind.Kind<typeof entityKind, GenericName> {
 }
 export type GetEntityName<GenericEntity extends Entity> = GenericEntity extends Entity<infer InferredName> ? InferredName : never;
+export type ExtractByEntityName<GenericValue extends unknown, GenericEntityName extends string> = GenericValue extends Entity<GenericEntityName> ? GenericValue : never;
 export declare const entityStructureKind: DKind.Handler<DKind.Definition<"@DuplojsLangModeling/entity-structure", unknown>>;
 export interface EntityStructureDefinition extends DDataStructure.StructureDefinition<readonly []> {
     readonly inner: DCommon.Memoized<DDataStructure.ObjectStructure>;
@@ -28,16 +31,28 @@ export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.Re
         DCommon.Not<DCommon.IsExtends<DCommon.AnyFunction, GenericRawValue[keyof GenericRawValue]>>
     ]>
 ]> extends true ? {
-    [Prop in keyof GenericRawValue]: NewTypeMap<GenericRawValue[Prop]>;
-} : GenericRawValue extends Entity ? EntityMap<DKind.Remove<GenericRawValue>> : GenericRawValue : GenericRawValue;
-export interface EntityStructure<GenericName extends string = string, GenericProperties extends Record<string, unknown> = Record<string, unknown>> extends DCommon.UnionToIntersection<DDataStructure.Structure<Entity<GenericName> & GenericProperties, EntityStructureDefinition> & DKind.Kind<typeof entityStructureKind>> {
+    [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>;
+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<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<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<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<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<DDataStructure.StructureValue<this>>, GenericCodecs>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
-    asyncMap(data: EntityMap<DDataStructure.StructureValue<this>>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | 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>);
+    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>>;
+    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>;
+}
+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,21 +1,34 @@
+import { parentClass } from "../../kind/parentClass.mjs";
 import { isSimple } from "../../object/isSimple.mjs";
+import { override } from "../../object/override.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 { 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";
 import { createKind } from "../kind.mjs";
-import { EntityNameStructure } from "./entityName.mjs";
+import { objectTagKind } from "../taggedObject/base.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(),
-		[entityKind.runTimeKey]: EntityNameStructure(name)
+		[entityKind.runTimeKey]: NonEncodableStringStructure(name)
 	}, [])),
 	constraints: []
 }, {
@@ -71,7 +84,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 +92,20 @@ 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);
+	},
+	update: (self, ...args) => {
+		if (args.length === 1) {
+			const [update] = args;
+			return (input) => self.update(input, update);
+		}
+		const [input, { [objectTagKind.runTimeKey]: __, ...update }] = args;
+		return override(input, update);
+	}
 }));
 //#endregion
-export { EntityStructure, entityKind, entityStructureKind };
+export { EncodeEntityError, EntityStructure, entityKind, entityStructureKind };

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

@@ -3,7 +3,7 @@ import { NewType } from '../newType';
 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<[
+export type ForbiddenMissingNewTypeInEntityShape<GenericValue extends unknown, GenericPath extends readonly string[] = readonly []> = GenericValue extends NewType | null ? never : GenericValue extends object ? DCommon.Or<[
     DCommon.IsExtends<GenericValue, readonly any[]>,
     DCommon.And<[
         DCommon.IsExtends<keyof GenericValue, string>,

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

@@ -1,4 +1,3 @@
 export * from './base';
-export * from './entityName';
 export * from './helper';
 export * from './namespace';

package/dist/modeling/entity/namespace.cjs

@@ -7,9 +7,9 @@ const namespaceKind = require_kind.createKind("namespace");
 function createEntityNamespace(entityName) {
 	return {
 		name: entityName,
-		createNewType: (name, structure, newTypeConstraints = []) => require_helper$1.createNewEntity(`${entityName}${name}`, structure, newTypeConstraints),
+		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

@@ -1,15 +1,15 @@
 import { createKind } from "../kind.mjs";
 import { createEntity } from "./helper.mjs";
-import { createNewEntity } from "../newType/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) {
 	return {
 		name: entityName,
-		createNewType: (name, structure, newTypeConstraints = []) => createNewEntity(`${entityName}${name}`, structure, newTypeConstraints),
+		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

@@ -1,42 +1,56 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_kind = require("./kind.cjs");
-const require_entityName = require("./entity/entityName.cjs");
-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_base = require("./taggedObject/base.cjs");
+const require_helper = require("./taggedObject/helper.cjs");
+const require_base$1 = require("./entity/base.cjs");
+const require_helper$1 = require("./entity/helper.cjs");
+const require_base$2 = require("./newType/base.cjs");
+const require_helper$2 = require("./newType/helper.cjs");
+const require_base$3 = require("./flag/base.cjs");
 const require_namespace = require("./entity/namespace.cjs");
 //#region scripts/modeling/index.ts
 var modeling_exports = /* @__PURE__ */ require_runtime.__exportAll({
-	EntityNameStructure: () => require_entityName.EntityNameStructure,
-	EntityStructure: () => require_base.EntityStructure,
-	NewTypeStructure: () => require_base$1.NewTypeStructure,
-	createEntity: () => require_helper.createEntity,
+	EncodeEntityError: () => require_base$1.EncodeEntityError,
+	EncodeNewTypeError: () => require_base$2.EncodeNewTypeError,
+	EncodeTaggedObjectError: () => require_base.EncodeTaggedObjectError,
+	EntityStructure: () => require_base$1.EntityStructure,
+	NewTypeStructure: () => require_base$2.NewTypeStructure,
+	TaggedObjectStructure: () => require_base.TaggedObjectStructure,
+	createEntity: () => require_helper$1.createEntity,
 	createEntityNamespace: () => require_namespace.createEntityNamespace,
-	createFlag: () => require_base$2.createFlag,
+	createFlag: () => require_base$3.createFlag,
 	createKind: () => require_kind.createKind,
-	createNewEntity: () => require_helper$1.createNewEntity,
-	entityKind: () => require_base.entityKind,
-	entityNameStructureKind: () => require_entityName.entityNameStructureKind,
-	entityStructureKind: () => require_base.entityStructureKind,
-	flagKind: () => require_base$2.flagKind,
+	createNewType: () => require_helper$2.createNewType,
+	createTaggedObject: () => require_helper.createTaggedObject,
+	entityKind: () => require_base$1.entityKind,
+	entityStructureKind: () => require_base$1.entityStructureKind,
+	flagKind: () => require_base$3.flagKind,
+	getTagValue: () => require_helper.getTagValue,
+	hasTagValue: () => require_helper.hasTagValue,
 	namespaceKind: () => require_namespace.namespaceKind,
-	newTypeStructureKind: () => require_base$1.newTypeStructureKind
+	newTypeStructureKind: () => require_base$2.newTypeStructureKind,
+	objectTagKind: () => require_base.objectTagKind,
+	taggedObject: () => require_helper.taggedObject,
+	taggedObjectStructureKind: () => require_base.taggedObjectStructureKind
 });
 //#endregion
-exports.EntityNameStructure = require_entityName.EntityNameStructure;
-exports.EntityStructure = require_base.EntityStructure;
-exports.NewTypeStructure = require_base$1.NewTypeStructure;
-exports.createEntity = require_helper.createEntity;
+exports.EncodeEntityError = require_base$1.EncodeEntityError;
+exports.EncodeNewTypeError = require_base$2.EncodeNewTypeError;
+exports.EncodeTaggedObjectError = require_base.EncodeTaggedObjectError;
+exports.EntityStructure = require_base$1.EntityStructure;
+exports.NewTypeStructure = require_base$2.NewTypeStructure;
+exports.TaggedObjectStructure = require_base.TaggedObjectStructure;
+exports.createEntity = require_helper$1.createEntity;
 exports.createEntityNamespace = require_namespace.createEntityNamespace;
-exports.createFlag = require_base$2.createFlag;
+exports.createFlag = require_base$3.createFlag;
 exports.createKind = require_kind.createKind;
-exports.createNewEntity = require_helper$1.createNewEntity;
-exports.entityKind = require_base.entityKind;
-exports.entityNameStructureKind = require_entityName.entityNameStructureKind;
-exports.entityStructureKind = require_base.entityStructureKind;
-exports.flagKind = require_base$2.flagKind;
+exports.createNewType = require_helper$2.createNewType;
+exports.createTaggedObject = require_helper.createTaggedObject;
+exports.entityKind = require_base$1.entityKind;
+exports.entityStructureKind = require_base$1.entityStructureKind;
+exports.flagKind = require_base$3.flagKind;
+exports.getTagValue = require_helper.getTagValue;
+exports.hasTagValue = require_helper.hasTagValue;
 Object.defineProperty(exports, "modeling_exports", {
 	enumerable: true,
 	get: function() {
@@ -44,4 +58,7 @@ Object.defineProperty(exports, "modeling_exports", {
 	}
 });
 exports.namespaceKind = require_namespace.namespaceKind;
-exports.newTypeStructureKind = require_base$1.newTypeStructureKind;
+exports.newTypeStructureKind = require_base$2.newTypeStructureKind;
+exports.objectTagKind = require_base.objectTagKind;
+exports.taggedObject = require_helper.taggedObject;
+exports.taggedObjectStructureKind = require_base.taggedObjectStructureKind;

package/dist/modeling/index.d.ts

@@ -2,3 +2,4 @@ export * from './entity';
 export * from './flag';
 export * from './kind';
 export * from './newType';
+export * from './taggedObject';

package/dist/modeling/index.mjs

@@ -1,28 +1,37 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { createKind } from "./kind.mjs";
-import { EntityNameStructure, entityNameStructureKind } from "./entity/entityName.mjs";
-import { EntityStructure, entityKind, entityStructureKind } from "./entity/base.mjs";
+import { EncodeTaggedObjectError, TaggedObjectStructure, objectTagKind, taggedObjectStructureKind } from "./taggedObject/base.mjs";
+import { createTaggedObject, getTagValue, hasTagValue, taggedObject } from "./taggedObject/helper.mjs";
+import { EncodeEntityError, EntityStructure, entityKind, entityStructureKind } from "./entity/base.mjs";
 import { createEntity } from "./entity/helper.mjs";
-import { NewTypeStructure, newTypeStructureKind } from "./newType/base.mjs";
-import { createNewEntity } from "./newType/helper.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";
 //#region scripts/modeling/index.ts
 var modeling_exports = /* @__PURE__ */ __exportAll({
-	EntityNameStructure: () => EntityNameStructure,
+	EncodeEntityError: () => EncodeEntityError,
+	EncodeNewTypeError: () => EncodeNewTypeError,
+	EncodeTaggedObjectError: () => EncodeTaggedObjectError,
 	EntityStructure: () => EntityStructure,
 	NewTypeStructure: () => NewTypeStructure,
+	TaggedObjectStructure: () => TaggedObjectStructure,
 	createEntity: () => createEntity,
 	createEntityNamespace: () => createEntityNamespace,
 	createFlag: () => createFlag,
 	createKind: () => createKind,
-	createNewEntity: () => createNewEntity,
+	createNewType: () => createNewType,
+	createTaggedObject: () => createTaggedObject,
 	entityKind: () => entityKind,
-	entityNameStructureKind: () => entityNameStructureKind,
 	entityStructureKind: () => entityStructureKind,
 	flagKind: () => flagKind,
+	getTagValue: () => getTagValue,
+	hasTagValue: () => hasTagValue,
 	namespaceKind: () => namespaceKind,
-	newTypeStructureKind: () => newTypeStructureKind
+	newTypeStructureKind: () => newTypeStructureKind,
+	objectTagKind: () => objectTagKind,
+	taggedObject: () => taggedObject,
+	taggedObjectStructureKind: () => taggedObjectStructureKind
 });
 //#endregion
-export { EntityNameStructure, EntityStructure, NewTypeStructure, createEntity, createEntityNamespace, createFlag, createKind, createNewEntity, entityKind, entityNameStructureKind, entityStructureKind, flagKind, modeling_exports, namespaceKind, newTypeStructureKind };
+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,20 +1,35 @@
+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_base = require("../../dataStructure/common/error/base.cjs");
+const require_base$1 = 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 NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ init }) => (name, structure, newTypeConstraints) => init({
+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);
+}
+const NewTypeStructure = require_base$1.createStructure(newTypeStructureKind, ({ init }) => (name, structure, newTypeConstraints) => init({
 	constraints: [],
 	newTypeConstraints,
 	inner: structure
 }, {
-	executeCheck: (self, data, errorHandler) => require_callThen.callThen(self.definition.inner.executeCheck(data, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : self.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : constraint.executeCheck(data, errorHandler)), require_resultSymbol.SuccessSymbol)),
-	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(self.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : constraint.executeCheck(data, errorHandler)), require_resultSymbol.SuccessSymbol), (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(self.definition.newTypeConstraints.reduce((accumulator, constraint) => require_callThen.callThen(accumulator, (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : constraint.executeCheck(awaitedInnerResult, errorHandler)), require_resultSymbol.SuccessSymbol), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(self.executeConstraints(awaitedInnerResult, errorHandler), (result) => result === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : awaitedInnerResult))),
+	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))),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous() || self.definition.newTypeConstraints.some((value) => value.isAsynchronous())
 }, {
 	name,
@@ -23,7 +38,7 @@ 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);
@@ -31,7 +46,7 @@ const NewTypeStructure = require_base.createStructure(newTypeStructureKind, ({ i
 		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 === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
@@ -43,19 +58,25 @@ 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());
 			return require_create$1.right("map-success", result);
 		});
 	},
-	asyncMap: (self, data) => require_justExec.justExec(async () => {
-		const errorHandler = require_error.createGetErrorHandler();
+	asyncMap: async (self, data) => {
+		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 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.UnionToIntersection<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 {};