@duplojs/agents-kit 0.0.0-stage → 0.1.0-beta.6

package/docs/API/10-lang/10-pattern/10-matchWithError.ts

@@ -0,0 +1,45 @@
+/**
+ * @title DPattern.matchWithError
+ *
+ * Traiter chaque variante d’une union d’erreurs DuploJS selon son identifiant typé.
+ */
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DCommon from "@duplojs/lang/common";
+
+class ValidationError extends DCommon.DuploJSError.parentClass("validation") {}
+class StorageError extends DCommon.DuploJSError.parentClass("storage") {}
+declare const error: ValidationError | StorageError;
+
+// Appel direct : chaque nom de l’union exige une branche, sans clé étrangère.
+const result = DPattern.matchWithError(error, {
+	validation: (value) => {
+		type _CheckValue = DCommon.ExpectType<typeof value, ValidationError, "strict">;
+		return value.message;
+	},
+	storage: (value) => {
+		type _CheckValue = DCommon.ExpectType<typeof value, StorageError, "strict">;
+		return value.message;
+	},
+});
+// La sortie est le message de l’erreur sélectionnée.
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;
+
+// Appel curifié : configurer les branches directement dans le pipe.
+const piped = DCommon.pipe(
+	error,
+	DPattern.matchWithError({
+		validation: (value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, ValidationError, "strict">;
+			return value.message;
+		},
+		storage: (value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, StorageError, "strict">;
+			return value.message;
+		},
+	}),
+);
+// Même sélection : le message de l’erreur sélectionnée.
+type _CheckPiped = DCommon.ExpectType<typeof piped, string, "strict">;
+
+// Les clés sont les identifiants fixés par parentClass, pas le nom de classe
+// ni le message. Un Error natif ne porte pas ce contrat de discrimination.

package/docs/API/10-lang/10-pattern/10-matchWithErrorOtherwise.ts

@@ -0,0 +1,48 @@
+/**
+ * @title DPattern.matchWithErrorOtherwise
+ *
+ * Traiter certains identifiants d’erreur et transmettre au fallback l’union d’erreurs non couverte.
+ */
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DCommon from "@duplojs/lang/common";
+
+class ValidationError extends DCommon.DuploJSError.parentClass("validation") {}
+class StorageError extends DCommon.DuploJSError.parentClass("storage") {}
+class NetworkError extends DCommon.DuploJSError.parentClass("network") {}
+declare const error: ValidationError | StorageError | NetworkError;
+
+// Appel direct : traiter certains noms ; le repli reçoit uniquement le reste.
+const result = DPattern.matchWithErrorOtherwise(
+	error,
+	{
+		validation: (value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, ValidationError, "strict">;
+			return value.message;
+		},
+	},
+	(value) => {
+		type _CheckRemaining = DCommon.ExpectType<typeof value, StorageError | NetworkError, "strict">;
+		return value.message;
+	},
+);
+// validation produit son résultat ; les autres variantes fournissent leur message.
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;
+
+// Appel curifié dans un pipe : le repli conserve le même affinement.
+const piped = DCommon.pipe(
+	error,
+	DPattern.matchWithErrorOtherwise(
+		{
+			validation: (value) => {
+				type _CheckValue = DCommon.ExpectType<typeof value, ValidationError, "strict">;
+				return value.message;
+			},
+		},
+		(value) => {
+			type _CheckRemaining = DCommon.ExpectType<typeof value, StorageError | NetworkError, "strict">;
+			return value.message;
+		},
+	),
+);
+// validation produit son résultat ; les autres variantes fournissent leur message.
+type _CheckPiped = DCommon.ExpectType<typeof piped, string, "strict">;

package/docs/API/10-lang/10-pattern/10-matchWithFact.ts

@@ -0,0 +1,49 @@
+/**
+ * @title DPattern.matchWithFact
+ *
+ * Router des facts par nom et exposer leur valeur ainsi que leur payload typé.
+ */
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DCommon from "@duplojs/lang/common";
+import type * as DModeling from "@duplojs/lang/modeling";
+
+interface Created extends DModeling.Fact<"Created", { title: string }> {}
+interface Deleted extends DModeling.Fact<"Deleted", { reason: string }> {}
+declare const event: Created | Deleted;
+
+// Appel direct : chaque nom de l’union exige une branche, sans clé étrangère.
+// Le nom de Fact, et non celui d’Entity, sélectionne la branche.
+// Le second argument de chaque callback contient le payload.
+const result = DPattern.matchWithFact(event, {
+	Created: (value, payload) => {
+		type _CheckValue = DCommon.ExpectType<typeof value, Created, "strict">;
+		type _CheckPayload = DCommon.ExpectType<typeof payload, { title: string }, "strict">;
+		return payload.title;
+	},
+	Deleted: (value, payload) => {
+		type _CheckValue = DCommon.ExpectType<typeof value, Deleted, "strict">;
+		type _CheckPayload = DCommon.ExpectType<typeof payload, { reason: string }, "strict">;
+		return payload.reason;
+	},
+});
+// La sortie est le titre de Created ou la raison de Deleted.
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;
+
+// Appel curifié : configurer les branches directement dans le pipe.
+const piped = DCommon.pipe(
+	event,
+	DPattern.matchWithFact({
+		Created: (value, payload) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, Created, "strict">;
+			type _CheckPayload = DCommon.ExpectType<typeof payload, { title: string }, "strict">;
+			return payload.title;
+		},
+		Deleted: (value, payload) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, Deleted, "strict">;
+			type _CheckPayload = DCommon.ExpectType<typeof payload, { reason: string }, "strict">;
+			return payload.reason;
+		},
+	}),
+);
+// Même sélection : le titre de Created ou la raison de Deleted.
+type _CheckPiped = DCommon.ExpectType<typeof piped, string, "strict">;

package/docs/API/10-lang/10-pattern/10-matchWithFactOtherwise.ts

@@ -0,0 +1,49 @@
+/**
+ * @title DPattern.matchWithFactOtherwise
+ *
+ * Router les facts choisis et traiter les autres noms avec un callback recevant le fact restant.
+ */
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DCommon from "@duplojs/lang/common";
+import type * as DModeling from "@duplojs/lang/modeling";
+
+interface Created extends DModeling.Fact<"Created", { title: string }> {}
+interface Deleted extends DModeling.Fact<"Deleted", { reason: string }> {}
+interface Renamed extends DModeling.Fact<"Renamed", { title: string }> {}
+declare const event: Created | Deleted | Renamed;
+
+// Appel direct : traiter certains noms ; le repli reçoit uniquement le reste.
+const result = DPattern.matchWithFactOtherwise(
+	event,
+	{
+		Created: (value, payload) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, Created, "strict">;
+			return payload.title;
+		},
+	},
+	(value) => {
+		type _CheckRemaining = DCommon.ExpectType<typeof value, Deleted | Renamed, "strict">;
+		return value;
+	},
+);
+// Created produit son résultat ; les autres variantes fournissent leur valeur complète.
+type _CheckResult = DCommon.ExpectType<typeof result, string | Deleted | Renamed, "strict">;
+
+// Appel curifié dans un pipe : le repli conserve le même affinement.
+const piped = DCommon.pipe(
+	event,
+	DPattern.matchWithFactOtherwise(
+		{
+			Created: (value, payload) => {
+				type _CheckValue = DCommon.ExpectType<typeof value, Created, "strict">;
+				return payload.title;
+			},
+		},
+		(value) => {
+			type _CheckRemaining = DCommon.ExpectType<typeof value, Deleted | Renamed, "strict">;
+			return value;
+		},
+	),
+);
+// Created produit son résultat ; les autres variantes fournissent leur valeur complète.
+type _CheckPiped = DCommon.ExpectType<typeof piped, string | Deleted | Renamed, "strict">;

package/docs/API/10-lang/10-pattern/10-matchWithNumber.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DPattern.matchWithNumber
+ *
+ * Associer chaque nombre littéral possible à un callback spécialisé pour cette valeur.
+ */
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const responseCode: 200 | 404;
+
+const result = DPattern.matchWithNumber(responseCode, {
+	200: (code) => {
+		type _CheckValue = DCommon.ExpectType<typeof code, 200, "strict">;
+		return `success ${code}`;
+	},
+	404: (code) => {
+		type _CheckValue = DCommon.ExpectType<typeof code, 404, "strict">;
+		return `missing ${code}`;
+	},
+});
+// Le handler sélectionné retourne le libellé de réussite ou d’absence.
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;
+
+// Appel curifié : toutes les valeurs de l’union sont couvertes dans le pipe.
+const piped = DCommon.pipe(
+	responseCode,
+	DPattern.matchWithNumber({
+		200: () => true,
+		404: () => false,
+	}),
+);
+// La sortie vaut true pour 200, false pour 404.
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;

package/docs/API/10-lang/10-pattern/10-matchWithNumberOtherwise.ts

@@ -0,0 +1,37 @@
+/**
+ * @title DPattern.matchWithNumberOtherwise
+ *
+ * Traiter certains nombres littéraux et recevoir les autres valeurs dans un fallback.
+ */
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const responseCode: 200 | 404 | 503;
+
+const label = DPattern.matchWithNumberOtherwise(
+	responseCode,
+	{
+		200: () => "success",
+		404: () => "missing",
+	},
+	(code) => {
+		type _CheckRemaining = DCommon.ExpectType<typeof code, 503, "strict">;
+		return `retry ${code}`;
+	},
+);
+// Les codes 200 et 404 ont leurs libellés ; 503 fournit « retry 503 » au fallback.
+type _CheckLabel = DCommon.ExpectType<typeof label, string, "strict">;
+
+// Appel curifié : seul 200 est traité ; le repli conserve 404 | 503.
+const piped = DCommon.pipe(
+	responseCode,
+	DPattern.matchWithNumberOtherwise(
+		{ 200: () => "success" },
+		(code) => {
+			type _CheckRemaining = DCommon.ExpectType<typeof code, 404 | 503, "strict">;
+			return code;
+		},
+	),
+);
+// La sortie vaut "success" pour 200, sinon le code d’origine.
+type _CheckPiped = DCommon.ExpectType<typeof piped, string | 404 | 503, "strict">;

package/docs/API/10-lang/10-pattern/10-matchWithString.ts

@@ -0,0 +1,34 @@
+/**
+ * @title DPattern.matchWithString
+ *
+ * Associer chaque chaîne littérale possible à un callback dont le paramètre est cette valeur exacte.
+ */
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+declare const status: "queued" | "sent";
+
+// Tous les littéraux de l’union ont leur branche ; chaque callback reçoit sa clé comme type.
+const message = DPattern.matchWithString(status, {
+	queued: (value) => {
+		type _CheckValue = DCommon.ExpectType<typeof value, "queued", "strict">;
+		return DString.prepend(value, "Waiting: ");
+	},
+	sent: (value) => {
+		type _CheckValue = DCommon.ExpectType<typeof value, "sent", "strict">;
+		return DString.prepend(value, "Delivered: ");
+	},
+});
+// La sortie vaut « Waiting: queued » ou « Delivered: sent » selon le statut.
+type _CheckMessage = DCommon.ExpectType<typeof message, "Waiting: queued" | "Delivered: sent", "strict">;
+
+const piped = DCommon.pipe(
+	status,
+	DPattern.matchWithString({
+		queued: () => 0,
+		sent: () => 1,
+	}),
+);
+// Le code de sortie vaut 0 pour queued et 1 pour sent.
+type _CheckPiped = DCommon.ExpectType<typeof piped, number, "strict">;

package/docs/API/10-lang/10-pattern/10-matchWithStringOtherwise.ts

@@ -0,0 +1,35 @@
+/**
+ * @title DPattern.matchWithStringOtherwise
+ *
+ * Traiter certains littéraux de chaîne et transmettre au fallback l’union non couverte.
+ */
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+declare const status: "queued" | "sent" | "cancelled";
+
+const description = DPattern.matchWithStringOtherwise(
+	status,
+	{
+		queued: () => "Waiting",
+		sent: () => "Delivered",
+	},
+	(value) => {
+		type _CheckRemaining = DCommon.ExpectType<typeof value, "cancelled", "strict">;
+		return DString.prepend(value, "Stopped: ");
+	},
+);
+// Le statut sélectionné fournit son libellé ; cancelled donne « Stopped: cancelled ».
+type _CheckDescription = DCommon.ExpectType<typeof description, string, "strict">;
+
+// La forme curifiée fixe les handlers avant de recevoir le statut dans un pipe.
+const piped = DCommon.pipe(
+	status,
+	DPattern.matchWithStringOtherwise(
+		{ sent: () => 200 },
+		DString.toUpperCase,
+	),
+);
+// Sent retourne un code ; queued et cancelled sont convertis en majuscules.
+type _CheckPiped = DCommon.ExpectType<typeof piped, number | "QUEUED" | "CANCELLED", "strict">;

package/docs/API/10-lang/10-pattern/10-matchWithTaggedObject.ts

@@ -0,0 +1,43 @@
+/**
+ * @title DPattern.matchWithTaggedObject
+ *
+ * Router une union d’objets marqués vers un callback par valeur de tag.
+ */
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DCommon from "@duplojs/lang/common";
+import type * as DModeling from "@duplojs/lang/modeling";
+
+interface Success extends DModeling.ObjectTag<"success"> { value: number }
+interface Failure extends DModeling.ObjectTag<"failure"> { reason: string }
+declare const outcome: Success | Failure;
+
+// Appel direct : chaque nom de l’union exige une branche, sans clé étrangère.
+const result = DPattern.matchWithTaggedObject(outcome, {
+	success: (value) => {
+		type _CheckValue = DCommon.ExpectType<typeof value, Success, "strict">;
+		return value.value;
+	},
+	failure: (value) => {
+		type _CheckValue = DCommon.ExpectType<typeof value, Failure, "strict">;
+		return value.reason;
+	},
+});
+// La sortie est le nombre de réussite ou la raison du refus.
+type _CheckResult = DCommon.ExpectType<typeof result, number | string, "strict">;
+
+// Appel curifié : configurer les branches directement dans le pipe.
+const piped = DCommon.pipe(
+	outcome,
+	DPattern.matchWithTaggedObject({
+		success: (value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, Success, "strict">;
+			return value.value;
+		},
+		failure: (value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, Failure, "strict">;
+			return value.reason;
+		},
+	}),
+);
+// Même sélection : le nombre de réussite ou la raison du refus.
+type _CheckPiped = DCommon.ExpectType<typeof piped, number | string, "strict">;

package/docs/API/10-lang/10-pattern/10-matchWithTaggedObjectOtherwise.ts

@@ -0,0 +1,49 @@
+/**
+ * @title DPattern.matchWithTaggedObjectOtherwise
+ *
+ * Router les tags explicitement traités et transmettre les variantes restantes au fallback.
+ */
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DCommon from "@duplojs/lang/common";
+import type * as DModeling from "@duplojs/lang/modeling";
+
+interface Success extends DModeling.ObjectTag<"success"> { value: number }
+interface Failure extends DModeling.ObjectTag<"failure"> { reason: string }
+interface Pending extends DModeling.ObjectTag<"pending"> { task: string }
+declare const outcome: Success | Failure | Pending;
+
+// Appel direct : traiter certains noms ; le repli reçoit uniquement le reste.
+const result = DPattern.matchWithTaggedObjectOtherwise(
+	outcome,
+	{
+		success: (value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, Success, "strict">;
+			return value.value;
+		},
+	},
+	(value) => {
+		type _CheckRemaining = DCommon.ExpectType<typeof value, Failure | Pending, "strict">;
+		return value;
+	},
+);
+// success produit son résultat ; les autres variantes fournissent leur objet complet.
+type _CheckResult = DCommon.ExpectType<typeof result, number | Failure | Pending, "strict">;
+
+// Appel curifié dans un pipe : le repli conserve le même affinement.
+const piped = DCommon.pipe(
+	outcome,
+	DPattern.matchWithTaggedObjectOtherwise(
+		{
+			success: (value) => {
+				type _CheckValue = DCommon.ExpectType<typeof value, Success, "strict">;
+				return value.value;
+			},
+		},
+		(value) => {
+			type _CheckRemaining = DCommon.ExpectType<typeof value, Failure | Pending, "strict">;
+			return value;
+		},
+	),
+);
+// success produit son résultat ; les autres variantes fournissent leur objet complet.
+type _CheckPiped = DCommon.ExpectType<typeof piped, number | Failure | Pending, "strict">;

package/docs/API/10-lang/10-pattern/10-otherwise.ts

@@ -0,0 +1,28 @@
+/**
+ * @title DPattern.otherwise
+ *
+ * Traiter la valeur non reconnue restante ou déballer un résultat déjà traité.
+ */
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DCommon from "@duplojs/lang/common";
+
+type Input = {
+	kind: "ready";
+	value: number;
+} | {
+	kind: "pending";
+	task: string;
+};
+declare const input: Input;
+const output = DCommon.pipe(
+	input,
+	DPattern.when(
+		DPattern.isMatch({ kind: "ready" }),
+		(value) => value.value,
+	),
+	DPattern.otherwise(
+		(remaining) => remaining.task,
+	),
+);
+// La branche déjà traitée fournit un nombre ; pending fournit son identifiant de tâche.
+type _CheckOutput = DCommon.ExpectType<typeof output, number | string, "strict">;

package/docs/API/10-lang/10-pattern/10-union.ts

@@ -0,0 +1,47 @@
+/**
+ * @title DPattern.union
+ *
+ * Combiner plusieurs motifs en un seul motif correspondant à l’un d’eux.
+ */
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+type Input = {
+	kind: "draft";
+	id: number;
+} | {
+	kind: "published";
+	id: number;
+} | {
+	kind: "archived";
+	id: number;
+};
+declare const input: Input;
+const result = DCommon.pipe(
+	input,
+	DPattern.when(
+		DPattern.isMatch(DPattern.union({ kind: "draft" }, { kind: "published" })),
+		(value) => value.id,
+	),
+	DPattern.otherwise(
+		(value) => value.id,
+	),
+);
+// Draft, published et archived fournissent leur id numérique.
+type _CheckResult = DCommon.ExpectType<typeof result, number, "strict">;
+
+// Motifs de valeurs : union exprime un OU, y compris avec un predicate fourni.
+declare const status: "ready" | "draft" | "archived";
+const label = DCommon.pipe(
+	status,
+	DPattern.match(
+		DPattern.union("ready", DString.startsWith("draft")),
+		DString.toUpperCase,
+	),
+	DPattern.otherwise(
+		(value) => value,
+	),
+);
+// Ready et draft donnent leur majuscule ; archived reste inchangé.
+type _CheckLabel = DCommon.ExpectType<typeof label, "READY" | "DRAFT" | "archived", "strict">;

package/docs/API/10-lang/10-pattern/10-when.ts

@@ -0,0 +1,46 @@
+/**
+ * @title DPattern.when
+ *
+ * Exécuter un traitement lorsque le predicate correspond, en laissant la branche sinon inchangée.
+ */
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+import * as DNumber from "@duplojs/lang/number";
+
+type Input = {
+	kind: "number";
+	value: number;
+} | {
+	kind: "text";
+	value: string;
+};
+// Les PatternResult issus d’une étape précédente sont transmis sans nouveau test.
+declare const input: Input;
+const result = DCommon.pipe(
+	input,
+	DPattern.when(
+		DPattern.isMatch({ kind: "number" }),
+		(value) => DNumber.sum([value.value, 1]),
+	),
+	DPattern.otherwise(
+		(value) => value.value,
+	),
+);
+// La branche number fournit son résultat ; otherwise récupère la valeur et traite le cas text.
+type _CheckResult = DCommon.ExpectType<typeof result, number | string, "strict">;
+
+// Predicate booléen : le test RegExp ne permet pas d’éliminer une variante du type.
+declare const text: string;
+const conditional = DCommon.pipe(
+	text,
+	DPattern.when(
+		DString.test(/^ready/),
+		DString.toUpperCase,
+	),
+	DPattern.otherwise(
+		DString.toUpperCase,
+	),
+);
+// Les textes commençant par ready sont mis en majuscules ; les autres restent inchangés.
+type _CheckConditional = DCommon.ExpectType<typeof conditional, Uppercase<string>, "strict">;

package/docs/API/10-lang/10-pattern/10-whenNot.ts

@@ -0,0 +1,123 @@
+/**
+ * @title DPattern.whenNot
+ *
+ * Exécuter un traitement pour les valeurs refusées par le predicate et laisser les autres non traitées.
+ */
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+import * as DNumber from "@duplojs/lang/number";
+
+type Input = {
+	kind: "known";
+	id: number;
+} | {
+	kind: "other";
+	value: string;
+};
+declare const input: Input;
+
+// Appel classique : traiter la branche other et conserver known pour la suite.
+const selected = DPattern.whenNot(input, DPattern.isMatch({ kind: "known" }), (value) => {
+	type _CheckValue = DCommon.ExpectType<typeof value, {
+		kind: "other";
+		value: string;
+	}, "strict">;
+
+	return DString.toUpperCase(value.value);
+});
+// Other produit un texte enveloppé ; known reste une valeur non traitée.
+type _CheckSelected = DCommon.ExpectType<
+	typeof selected,
+	{
+		kind: "known";
+		id: number;
+	} | DPattern.PatternResult<Uppercase<string>>,
+	"strict"
+>;
+
+// Appel curifié : préserver les résultats précédents, puis terminer les cas restants.
+declare const partiallyHandled: Input | DPattern.PatternResult<Uppercase<string>>;
+const piped = DCommon.pipe(
+	partiallyHandled,
+	DPattern.whenNot(
+		DPattern.isMatch({ kind: "known" }),
+		(value) => DString.toUpperCase(value.value),
+	),
+	DPattern.otherwise(
+		(value) => value.id,
+	),
+);
+// Les résultats précédents sont transmis ; other est normalisé et known fournit son id.
+// otherwise déballe le résultat final : aucun PatternResult ne subsiste dans la sortie.
+type _CheckPiped = DCommon.ExpectType<typeof piped, Uppercase<string> | number, "strict">;
+
+// Predicates imbriqués : étiqueter les états tout en conservant leurs littéraux.
+declare const state: "ready" | "queued" | "blocked";
+const pendingState = DPattern.whenNot(
+	state,
+	DCommon.or([DCommon.equal("ready"), DCommon.equal("queued")]),
+	DString.prepend("Attention : "),
+);
+type _CheckPendingState = DCommon.ExpectType<
+	typeof pendingState,
+	"ready" | "queued" | DPattern.PatternResult<"Attention : blocked">,
+	"strict"
+>;
+
+const labeledState = DCommon.pipe(
+	pendingState,
+	DPattern.when(
+		DCommon.equal("ready"),
+		DString.toUpperCase,
+	),
+	DPattern.otherwise(
+		DString.prepend("En attente : "),
+	),
+);
+// Une branche déjà enveloppée n'est pas traitée une seconde fois par les étapes suivantes.
+type _CheckLabeledState = DCommon.ExpectType<
+	typeof labeledState,
+	"Attention : blocked" | "READY" | "En attente : queued",
+	"strict"
+>;
+
+// Test booléen : ajouter les frais de livraison seulement sous un seuil dynamique.
+declare const orderTotal: number;
+declare const freeShippingThreshold: number;
+declare const shippingFee: number;
+const shippingApplied = DPattern.whenNot(
+	orderTotal,
+	DNumber.greaterThanOrEqual(freeShippingThreshold),
+	(value) => {
+		type _CheckValue = DCommon.ExpectType<typeof value, number, "strict">;
+
+		return DNumber.sum([value, shippingFee]);
+	},
+);
+// Les petites commandes sont enveloppées après ajout des frais ; les autres restent brutes.
+type _CheckShippingApplied = DCommon.ExpectType<
+	typeof shippingApplied,
+	number | DPattern.PatternResult<number>,
+	"strict"
+>;
+
+const pricedTotal = DCommon.pipe(
+	shippingApplied,
+	DPattern.otherwise(
+		DCommon.forward,
+	),
+);
+// otherwise conserve le total des commandes sans frais ou déballe le total avec frais.
+// Le test booléen laisse number parmi les cas restants : exhaustive ne conviendrait pas.
+type _CheckPricedTotal = DCommon.ExpectType<typeof pricedTotal, number, "strict">;
+
+// Contrainte préservée : signaler les découverts et garder les soldes positifs ou nuls.
+declare const balance: number;
+const checkedBalance = DPattern.whenNot(balance, DNumber.isPositive, DCommon.justReturn("à découvert"));
+// Un solde négatif donne un PatternResult ; zéro et les soldes positifs restent des nombres.
+type _CheckCheckedBalance = DCommon.ExpectType<
+	typeof checkedBalance,
+	(number & DNumber.Positive) | DPattern.PatternResult<"à découvert">,
+	"strict"
+>;