@duplojs/agents-kit 0.1.0-beta.3 → 0.1.0-beta.6

package/docs/concepts/01-fundamental/04-data-structure/20-constraint.ts

@@ -3,66 +3,74 @@
  *
  * Ajouter et cumuler des contraintes compatibles, fournies ou personnalisées.
  */
+import type * as DCommon from "@duplojs/lang/common";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DString from "@duplojs/lang/string";
+import type * as DNumber from "@duplojs/lang/number";
+import type * as DArray from "@duplojs/lang/array";
 
 // Une structure vérifie la nature de la donnée, puis ses propriétés supplémentaires.
 // Les contraintes sont vérifiées au runtime et enrichissent le type obtenu par StructureValue.
 // Toute structure peut en recevoir, à condition que la contrainte soit compatible.
 
-// string & DString.Email
 const emailStructure = DDataStructure.string([DDataStructure.email()]);
+type _CheckEmailStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof emailStructure>,
+	string & DString.Email,
+	"strict"
+>;
 
 // Une contrainte ne remplace pas le type de base.
 // Elle apporte une information supplémentaire garantie après validation.
 
-// number & DNumber.Integer & DNumber.GreaterThanOrEqual<18>
 const ageStructure = DDataStructure.number([
 	DDataStructure.integer(),
 	DDataStructure.greaterThanOrEqual(18),
 ]);
+type _CheckAgeStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof ageStructure>,
+	number & DNumber.Integer & DNumber.GreaterThanOrEqual<18>,
+	"strict"
+>;
 
 type Age = DDataStructure.StructureValue<typeof ageStructure>;
 
 // Plusieurs contraintes peuvent être cumulées.
 // Toutes doivent être vérifiées pour que la donnée soit valide.
 
-// string & DString.MinCharacters<3> & DString.Trimmed
 const usernameStructure = DDataStructure.string([
 	DDataStructure.minCharacters(3),
 	DDataStructure.trimmed(),
 ]);
+type _CheckUsernameStructure = DCommon.ExpectType<DDataStructure.StructureValue<typeof usernameStructure>, string & DString.MinCharacters<3> & DString.Trimmed, "strict">;
 
 // Les contraintes ne concernent pas uniquement les `TypeStructure`.
 // Elles peuvent s'appliquer aux autres structures comme les tableaux.
 
-// readonly string[] & DArray.MinElements<1>
 const tagsStructure = DDataStructure.array(
 	DDataStructure.string(),
 	[DDataStructure.minElements(1)],
 );
+type _CheckTagsStructure = DCommon.ExpectType<DDataStructure.StructureValue<typeof tagsStructure>, readonly string[] & DArray.MinElements<1>, "strict">;
 
 // Une contrainte peut également être ajoutée après la création d'une structure.
 // La structure originale n'est pas modifiée.
 
-// string
 const stringStructure = DDataStructure.string();
+type _CheckStringStructure = DCommon.ExpectType<DDataStructure.StructureValue<typeof stringStructure>, string, "strict">;
 
-// string & DString.Email
 const constrainedStringStructure = stringStructure.addConstraint(
 	DDataStructure.email(),
 );
+type _CheckConstrainedStringStructure = DCommon.ExpectType<DDataStructure.StructureValue<typeof constrainedStringStructure>, string & DString.Email, "strict">;
 
 // `refine` permet de définir une contrainte spécifique au domaine.
 // Un type predicate permet également d'affiner le type produit par la structure.
 
 type UserId = `user:${string}`;
 
-// `user:${string}`
-const userIdStructure = DDataStructure.string([
-	DDataStructure.refine(
-		(value): value is UserId => value.startsWith("user:"),
-	),
-]);
+const userIdStructure = DDataStructure.string([DDataStructure.refine(DString.startsWith("user:"))]);
+type _CheckUserIdStructure = DCommon.ExpectType<DDataStructure.StructureValue<typeof userIdStructure>, UserId, "strict">;
 
 // Une contrainte ne peut être utilisée que sur une structure compatible.
 

package/docs/concepts/01-fundamental/04-data-structure/30-validation.ts

@@ -4,6 +4,8 @@
  * Vérification, conversion et narrowing aux frontières du logiciel, en synchrone ou asynchrone.
  */
 import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DString from "@duplojs/lang/string";
 
 // La structure décrit la donnée attendue à la fois dans TypeScript et au runtime.
 // Les opérations ci-dessous s’appliquent aux frontières du logiciel, avant de considérer
@@ -22,15 +24,17 @@ const componentStructure = DDataStructure.object({
 // Le type TypeScript correspondant à une structure peut être récupéré
 // avec `StructureValue`.
 //
-// {
-//     readonly id: bigint;
-//     readonly name: string;
-//     readonly alt?: string | undefined;
-//     readonly image: {
-//         readonly src: string & DString.Url;
-//     };
-// }
 type Component = DDataStructure.StructureValue<typeof componentStructure>;
+type _CheckComponent = DCommon.ExpectType<
+	Component,
+	{
+		readonly id: bigint;
+		readonly name: string;
+		readonly alt?: string | undefined;
+		readonly image: { readonly src: string & DString.Url };
+	},
+	"strict"
+>;
 
 declare const unknownComponent: unknown;
 
@@ -78,7 +82,7 @@ declare const value: unknown;
 // Contrairement à `check`, il ne retourne pas les détails de l'erreur.
 // Il agit également comme un type predicate TypeScript.
 if (componentStructure.is(value)) {
-	// Component
+	type _CheckNarrowedComponent = DCommon.ExpectType<typeof value, Component, "strict">;
 	void value;
 }
 

package/docs/concepts/01-fundamental/04-data-structure/40-codecs.ts

@@ -3,8 +3,11 @@
  *
  * Encoder et décoder les données avec un même contrat, selon leur type fondamental.
  */
+import type * as DCommon from "@duplojs/lang/common";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 import * as DString from "@duplojs/lang/string";
+import type * as DEither from "@duplojs/lang/either";
+import type * as DNumber from "@duplojs/lang/number";
 
 // Un codec fait transiter les données entre deux représentations d’une même structure.
 // encode convertit la représentation interne vers l’externe ; decode effectue l’inverse.
@@ -55,16 +58,6 @@ const productStructure = DDataStructure.object({
 	]),
 });
 
-// DEither.Right<
-//     "encode-success",
-//     {
-//         readonly name: string;
-//         readonly price: string & DString.Number;
-//         readonly quantity: string & DString.Number;
-//     }
-// >
-// | DEither.Left<"async-error", DDataStructure.ErrorPromise>
-// | DEither.Left<"encode-error", DDataStructure.Error>
 const encodedProduct = productStructure.encode(
 	codecs,
 	{
@@ -73,6 +66,20 @@ const encodedProduct = productStructure.encode(
 		quantity: 2,
 	},
 );
+type _CheckEncodedProductLine68 = DCommon.ExpectType<
+	typeof encodedProduct,
+	DEither.Right<
+		"encode-success",
+		{
+			readonly name: string;
+			readonly price: string & DString.Number;
+			readonly quantity: string & DString.Number;
+		}
+	>
+| DEither.Left<"async-error", DDataStructure.ErrorPromise>
+| DEither.Left<"encode-error", DDataStructure.Error>,
+	"strict"
+>;
 
 // Pendant l'encode, la structure est parcourue.
 //
@@ -83,16 +90,6 @@ const encodedProduct = productStructure.encode(
 // Le codec associé à `TheNumber` transforme donc automatiquement
 // leurs valeurs de `number` vers `string`.
 
-// DEither.Right<
-//     "decode-success",
-//     {
-//         readonly name: string;
-//         readonly price: number;
-//         readonly quantity: number & DNumber.Integer & DNumber.Positive;
-//     }
-// >
-// | DEither.Left<"async-error", DDataStructure.ErrorPromise>
-// | DEither.Left<"decode-error", DDataStructure.Error>
 const decodedProduct = productStructure.decode(
 	codecs,
 	{
@@ -101,6 +98,20 @@ const decodedProduct = productStructure.decode(
 		quantity: "2",
 	},
 );
+type _CheckDecodedProductLine96 = DCommon.ExpectType<
+	typeof decodedProduct,
+	DEither.Right<
+		"decode-success",
+		{
+			readonly name: string;
+			readonly price: number;
+			readonly quantity: number & DNumber.Integer & DNumber.Positive;
+		}
+	>
+| DEither.Left<"async-error", DDataStructure.ErrorPromise>
+| DEither.Left<"decode-error", DDataStructure.Error>,
+	"strict"
+>;
 
 // Le decode parcourt exactement la même structure dans le sens inverse.
 //

package/docs/concepts/01-fundamental/04-data-structure/50-recursive.ts

@@ -4,6 +4,8 @@
  * Références différées et cohérence entre un type déclaré et sa structure runtime.
  */
 import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DEither from "@duplojs/lang/either";
 
 // Une structure récursive se référence elle-même. Le type attendu est déclaré en amont
 // pour permettre à TypeScript de typer cette dépendance récursive.
@@ -12,13 +14,13 @@ interface Tree {
 	readonly children: readonly Tree[];
 }
 
-// Tree
 const treeStructure: DDataStructure.Structure<Tree> = DDataStructure.object({
 	value: DDataStructure.string(),
 	children: DDataStructure.array(
 		DDataStructure.lazy(() => treeStructure),
 	),
 }).contract();
+type _CheckTreeStructure = DCommon.ExpectType<DDataStructure.StructureValue<typeof treeStructure>, Tree, "strict">;
 
 // `lazy` retarde la résolution de `treeStructure`.
 //
@@ -46,3 +48,10 @@ const tree = {
 };
 
 const result = treeStructure.check(tree);
+type _CheckTreeResult = DCommon.ExpectType<
+	typeof result,
+	DEither.Left<"async-error", DDataStructure.ErrorPromise>
+		| DEither.Left<"check-error", DDataStructure.Error>
+		| DEither.Right<"check-success", Tree>,
+	"strict"
+>;

package/docs/concepts/01-fundamental/05-chrono/10-creation.ts

@@ -3,7 +3,9 @@
  *
  * Valeurs connues statiquement ou reçues au runtime, et gestion des entrées invalides.
  */
+import type * as DCommon from "@duplojs/lang/common";
 import * as DChrono from "@duplojs/lang/chrono";
+import type * as DEither from "@duplojs/lang/either";
 
 // TheDate représente un instant absolu ; TheTime représente une quantité de temps.
 // Lorsque le typage peut établir la validité de l’entrée, la création retourne directement
@@ -11,49 +13,73 @@ import * as DChrono from "@duplojs/lang/chrono";
 
 // Les dates littérales au format YYYY-MM-DD sont vérifiées par le typage.
 
-// DChrono.TheDate
 const date = DChrono.createDate("2026-09-30");
+type _CheckDateLine15 = DCommon.ExpectType<
+	typeof date,
+	DChrono.TheDate,
+	"strict"
+>;
 
 // Les temps sont également sûrs lorsque la valeur littérale
 // et son unité permettent d'être vérifiées par le typage.
 
-// DChrono.TheTime
 const time = DChrono.createTime(2, "hour");
+type _CheckTimeLine21 = DCommon.ExpectType<
+	typeof time,
+	DChrono.TheTime,
+	"strict"
+>;
 
 // Lorsque la valeur provient du runtime, sa validité n'est plus garantie.
 declare const dateInput: string;
 declare const timeInput: number;
 
-// DChrono.MayBeDate
-// DEither.Right<"date-created", DChrono.TheDate>
-// | DEither.Left<"date-created-error", null>
 const maybeDate = DChrono.createDate({
 	value: dateInput,
 });
+type _CheckMaybeDateLine30 = DCommon.ExpectType<
+	typeof maybeDate,
+	DEither.Right<"date-created", DChrono.TheDate> | DEither.Left<"date-created-error", null>,
+	"strict"
+>;
 
-// DChrono.MayBeTime
-// DEither.Right<"time-created", DChrono.TheTime>
-// | DEither.Left<"time-created-error", null>
 // Sans unité explicite, l’entrée numérique représente des millisecondes.
 const maybeTime = DChrono.createTime(timeInput);
+type _CheckMaybeTime = DCommon.ExpectType<typeof maybeTime, DChrono.MayBeTime, "strict">;
 
 // Les variantes `OrThrow` permettent de récupérer directement la valeur.
 // Une entrée invalide provoquera une `CreateTheDateError`
 // ou une `CreateTheTimeError`.
 
-// DChrono.TheDate
 const dateOrThrow = DChrono.createDateOrThrow({
 	value: dateInput,
 });
+type _CheckDateOrThrowLine45 = DCommon.ExpectType<
+	typeof dateOrThrow,
+	DChrono.TheDate,
+	"strict"
+>;
 
-// DChrono.TheTime
 const timeOrThrow = DChrono.createTimeOrThrow(timeInput);
+type _CheckTimeOrThrowLine50 = DCommon.ExpectType<
+	typeof timeOrThrow,
+	DChrono.TheTime,
+	"strict"
+>;
 
 // Les objets natifs et timestamps sont également considérés
 // comme des valeurs runtime potentiellement invalides.
 
-// DChrono.MayBeDate
 const maybeNativeDate = DChrono.createDate(new Date());
+type _CheckMaybeNativeDateLine56 = DCommon.ExpectType<
+	typeof maybeNativeDate,
+	DChrono.MayBeDate,
+	"strict"
+>;
 
-// DChrono.MayBeDate
-const maybeTimestampDate = DChrono.createDate(Date.now());
+const currentDate = DChrono.now();
+type _CheckCurrentDate = DCommon.ExpectType<
+	typeof currentDate,
+	DChrono.TheDate,
+	"strict"
+>;

package/docs/concepts/01-fundamental/05-chrono/20-manipulation.ts

@@ -12,39 +12,55 @@ const date = DChrono.createDate("2026-09-30");
 
 // Les unités peuvent être ajoutées ou retirées directement sur une date.
 
-// DChrono.TheDate
 const nextWeek = DCommon.pipe(
 	date,
 	DChrono.addWeeks(1),
 	DChrono.addDays(2),
 	DChrono.subtractHours(3),
 );
+type _CheckNextWeekLine16 = DCommon.ExpectType<
+	typeof nextWeek,
+	DChrono.TheDate,
+	"strict"
+>;
 
 // `TheTime` permet de représenter une durée puis de l'appliquer
 // à une date ou à un autre temps.
 const duration = DChrono.createTime(2, "hour");
 
-// DChrono.TheDate
 const later = DCommon.pipe(
 	date,
 	DChrono.addTime(duration),
 );
+type _CheckLaterLine28 = DCommon.ExpectType<
+	typeof later,
+	DChrono.TheDate,
+	"strict"
+>;
 
-// DChrono.TheTime
 const totalDuration = DCommon.pipe(
 	duration,
 	DChrono.addTime(DChrono.createTime(30, "minute")),
 );
+type _CheckTotalDurationLine34 = DCommon.ExpectType<
+	typeof totalDuration,
+	DChrono.TheTime,
+	"strict"
+>;
 
 // La différence entre deux dates produit un TheTime signé : date moins date de référence.
 const startDate = DChrono.createDate("2026-09-01");
 const endDate = DChrono.createDate("2026-09-30");
 
-// DChrono.TheTime
 const difference = DCommon.pipe(
 	endDate,
 	DChrono.getDifference(startDate),
 );
+type _CheckDifferenceLine44 = DCommon.ExpectType<
+	typeof difference,
+	DChrono.TheTime,
+	"strict"
+>;
 
 // `computeTime` permet d'exprimer un `TheTime` dans une unité donnée.
 

package/docs/concepts/01-fundamental/05-chrono/30-serialized.ts

@@ -3,6 +3,7 @@
  *
  * Sérialiser, reconnaître et reconstruire les instants et durées en conservant leur valeur.
  */
+import type * as DCommon from "@duplojs/lang/common";
 import * as DChrono from "@duplojs/lang/chrono";
 
 // Chrono possède un format dédié qui conserve la valeur numérique et identifie sa nature.
@@ -13,15 +14,21 @@ const time = DChrono.createTime(2, "hour");
 // Une `TheDate` est sérialisée avec le préfixe `date`,
 // suivi de son timestamp et de son signe.
 
-// DChrono.SerializedTheDate
-// "date1790726400000+"
 const serializedDate = DChrono.serialize(date);
+type _CheckSerializedDateLine18 = DCommon.ExpectType<
+	typeof serializedDate,
+	`date${number}-` | `date${number}+`,
+	"strict"
+>;
 
 // Un `TheTime` utilise le même principe avec le préfixe `time`.
 
-// DChrono.SerializedTheTime
-// "time7200000+"
 const serializedTime = DChrono.serialize(time);
+type _CheckSerializedTimeLine24 = DCommon.ExpectType<
+	typeof serializedTime,
+	`time${number}-` | `time${number}+`,
+	"strict"
+>;
 
 // Le format permet de conserver exactement la valeur transportée,
 // tout en distinguant une date d'un simple nombre ou d'une string classique.
@@ -33,6 +40,7 @@ const payload = JSON.stringify({
 	date,
 	time,
 });
+type _CheckPayload = DCommon.ExpectType<typeof payload, string, "strict">;
 
 // {
 //     "date": "date1790726400000+",
@@ -45,13 +53,21 @@ const payload = JSON.stringify({
 declare const input: string;
 
 if (DChrono.isSerializedTheDate(input)) {
-	// DChrono.SerializedTheDate
 	const serializedDate = input;
+	type _CheckSerializedDateLine49 = DCommon.ExpectType<
+	typeof serializedDate,
+	`date${number}-` | `date${number}+`,
+	"strict"
+	>;
 }
 
 if (DChrono.isSerializedTheTime(input)) {
-	// DChrono.SerializedTheTime
 	const serializedTime = input;
+	type _CheckSerializedTimeLine54 = DCommon.ExpectType<
+	typeof serializedTime,
+	`time${number}-` | `time${number}+`,
+	"strict"
+	>;
 }
 
 // Une valeur sérialisée peut ensuite être reconstruite.

package/docs/concepts/01-fundamental/05-chrono/40-timezone.ts

@@ -31,11 +31,15 @@ const localDate = DChrono.createDate("2026-09-30", {
 	hour: "09",
 });
 
-// DChrono.TheDate
 const instant = DCommon.pipe(
 	localDate,
 	DChrono.applyTimezone("Europe/Paris"),
 );
+type _CheckInstantLine35 = DCommon.ExpectType<
+	typeof instant,
+	DChrono.TheDate,
+	"strict"
+>;
 
 // `getTimezoneOffset` retourne le décalage du fuseau pour une date donnée.
 // Ce décalage dépend notamment des changements d'heure saisonniers.

package/docs/concepts/01-fundamental/06-modeling/20-entity.ts

@@ -8,6 +8,8 @@ import * as DDataStructure from "@duplojs/lang/dataStructure";
 import * as DModeling from "@duplojs/lang/modeling";
 import * as DArray from "@duplojs/lang/array";
 import * as DCommon from "@duplojs/lang/common";
+import type * as DString from "@duplojs/lang/string";
+import type * as DNumber from "@duplojs/lang/number";
 
 // Une Entity représente un objet métier doté d’une identité explicite.
 // Ses valeurs primitives sont définies par des NewType qui associent un sens métier
@@ -21,15 +23,14 @@ export namespace User {
 	// préfixés par le nom de l'entité.
 	const namespace = DModeling.createEntityNamespace("User");
 
-	// string & DModeling.NewType<"UserId", DString.Uuid>
 	export const Id = namespace.createNewType(
 		"Id",
 		DDataStructure.string(),
 		[DDataStructure.uuid()],
 	);
 	export type Id = DDataStructure.StructureValue<typeof Id>;
+	type _CheckId = DCommon.ExpectType<Id, string & DModeling.NewType<"UserId", DString.Uuid>, "strict">;
 
-	// number & DModeling.NewType<"UserAge", Integer | Positive>
 	export const Age = namespace.createNewType(
 		"Age",
 		DDataStructure.number(),
@@ -39,8 +40,12 @@ export namespace User {
 		],
 	);
 	export type Age = DDataStructure.StructureValue<typeof Age>;
+	type _CheckAge = DCommon.ExpectType<
+		Age,
+		number & DModeling.NewType<"UserAge", DNumber.Integer | DNumber.Positive>,
+		"strict"
+	>;
 
-	// string & DModeling.NewType<"UserName", DString.Trimmed | DString.MinCharacters<3> | DString.MaxCharacters<45>>
 	export const Name = namespace.createNewType(
 		"Name",
 		DDataStructure.string(),
@@ -51,8 +56,12 @@ export namespace User {
 		],
 	);
 	export type Name = DDataStructure.StructureValue<typeof Name>;
+	type _CheckName = DCommon.ExpectType<
+		Name,
+		string & DModeling.NewType<"UserName", DString.Trimmed | DString.MinCharacters<3> | DString.MaxCharacters<45>>,
+		"strict"
+	>;
 
-	// string & DModeling.NewType<"UserTag", DString.Trimmed | DString.MinCharacters<2> | DString.MaxCharacters<20>>
 	export const Tag = namespace.createNewType(
 		"Tag",
 		DDataStructure.string(),
@@ -63,19 +72,10 @@ export namespace User {
 		],
 	);
 	export type Tag = DDataStructure.StructureValue<typeof Tag>;
+	type _CheckTag = DCommon.ExpectType<Tag, string & DModeling.NewType<"UserTag", DString.Trimmed | DString.MinCharacters<2> | DString.MaxCharacters<20>>, "strict">;
 
 	// L'entité est ensuite déclarée à partir de ses différentes propriétés.
 	//
-	// DModeling.Entity<"User"> & {
-	//  readonly name: string
-	//    & DModeling.NewType<"UserName", DString.Trimmed | DString.MinCharacters<3> | DString.MaxCharacters<45>>;
-	//  readonly id: string
-	//    & DModeling.NewType<"UserId", DString.Uuid>;
-	//  readonly age: number & DModeling.NewType<"UserAge", DNumber.Integer | DNumber.Positive>;
-	//  readonly tags: readonly (
-	//    string & DModeling.NewType<"UserTag", DString.Trimmed | DString.MinCharacters<2> | DString.MaxCharacters<20>>
-	// )[];
-	// };
 	export const Entity = namespace.createEntity(
 		() => ({
 			id: Id,
@@ -85,6 +85,12 @@ export namespace User {
 		}),
 	);
 	export type Entity = DDataStructure.StructureValue<typeof Entity>;
+	type _CheckEntity = DCommon.ExpectType<Entity, DModeling.Entity<"User"> & {
+		readonly id: Id;
+		readonly age: Age;
+		readonly name: Name;
+		readonly tags: readonly Tag[];
+	}, "strict">;
 }
 
 // L’hydratation fait entrer dans le modèle métier des données de repository ou de base de données.
@@ -99,21 +105,13 @@ export namespace User {
 // Les contraintes sont vérifiées pendant cette opération.
 // Le mapping pouvant échouer, son résultat est représenté par un `Either`.
 
-// DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>
-// | DEither.Right<"map-success", DModeling.Entity<"User"> & {
-//     readonly name: string & DModeling.NewType<"UserName", Trimmed | MinCharacters<3> | MaxCharacters<45>>;
-//     readonly id: string & DModeling.NewType<"UserId", Uuid>;
-//     readonly age: number & DModeling.NewType<"UserAge", Integer | Positive>;
-//     readonly tags: readonly (
-//         DModeling.NewType<"UserTag", DString.Trimmed | DString.MinCharacters<2> | DString.MaxCharacters<20>>
-//     )[];
-// }>
 const maybeMapUser = User.Entity.map({
 	id: "invalid-id",
 	name: "SuperName",
 	age: 12,
 	tags: ["superTag"],
 });
+type _CheckMaybeMapUser = DCommon.ExpectType<typeof maybeMapUser, DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error> | DEither.Right<"map-success", User.Entity>, "strict">;
 
 // `decodeMap` applique le même principe à une donnée encodée.
 //
@@ -124,21 +122,13 @@ const maybeMapUser = User.Entity.map({
 // L'âge de l'entité est donc ici fourni dans sa représentation encodée
 // plutôt que directement comme un `number`.
 
-// DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>
-// | DEither.Right<"map-success", DModeling.Entity<"User"> & {
-//     readonly name: string & DModeling.NewType<"UserName", Trimmed | MinCharacters<3> | MaxCharacters<45>>;
-//     readonly id: string & DModeling.NewType<"UserId", Uuid>;
-//     readonly age: number & DModeling.NewType<"UserAge", Integer | Positive>;
-//     readonly tags: readonly (
-//         DModeling.NewType<"UserTag", DString.Trimmed | DString.MinCharacters<2> | DString.MaxCharacters<20>>
-//     )[];
-// }>
 const maybeDecodeMapUser = User.Entity.decodeMap(DDataStructure.codecsString, {
 	id: "550e8400-e29b-41d4-a716-446655440000",
 	name: "SuperName",
 	age: DCommon.cast("12"),
 	tags: ["superTag"],
 });
+type _CheckMaybeDecodeMapUser = DCommon.ExpectType<typeof maybeDecodeMapUser, DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error> | DEither.Right<"map-success", User.Entity>, "strict">;
 
 // `new` est utilisé lorsque les propriétés possèdent déjà leur typage métier.
 //
@@ -152,15 +142,6 @@ const maybeDecodeMapUser = User.Entity.decodeMap(DDataStructure.codecsString, {
 // Le résultat du `rightPipe` conserve la monade `Success` produite après
 // regroupement des différentes validations.
 
-// DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error>
-// | DEither.Success<DModeling.Entity<"User"> & {
-//     readonly id: string & DModeling.NewType<"UserId", Uuid>;
-//     readonly name: string & DModeling.NewType<"UserName", Trimmed | MinCharacters<3> | MaxCharacters<45>>;
-//     readonly age: number & DModeling.NewType<"UserAge", Integer | Positive>;
-//     readonly tags: readonly [
-//         DModeling.NewType<"UserTag", DString.Trimmed | DString.MinCharacters<2> | DString.MaxCharacters<20>>
-//     ];
-// }>
 const maybeUser = DEither.rightPipe(
 	DEither.group({
 		id: User.Id.map("550e8400-e29b-41d4-a716-446655440000"),
@@ -173,17 +154,23 @@ const maybeUser = DEither.rightPipe(
 	}),
 	User.Entity.new,
 );
+type _CheckMaybeUser = DCommon.ExpectType<typeof maybeUser, DEither.Left<"async-error", DDataStructure.ErrorPromise> | DEither.Left<"map-error", DDataStructure.Error> | DEither.Success<DModeling.Entity<"User"> & {
+	readonly id: User.Id;
+	readonly name: User.Name;
+	readonly age: User.Age;
+	readonly tags: readonly [User.Tag];
+}>, "strict">;
 
 declare const user: User.Entity;
 declare const maybeAge: User.Age | undefined;
 
-// User.Entity
 const updatedUser = User.Entity.update(
 	user,
 	{
 		age: maybeAge,
 	},
 );
+type _CheckUpdatedUser = DCommon.ExpectType<typeof updatedUser, User.Entity, "strict">;
 
 // `update` retourne une nouvelle entité en remplaçant uniquement
 // les propriétés dont la nouvelle valeur n'est pas `undefined`.