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

package/docs/API/10-lang/10-either/10-unwrapByInformationOrThrow.ts

@@ -0,0 +1,19 @@
+/**
+ * @title DEither.unwrapByInformationOrThrow
+ *
+ * Extraire une information ciblée ou lever une exception si elle est absente.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+const direct = DEither.unwrapByInformationOrThrow(DEither.success("saved"), "success");
+type _CheckDirect = DCommon.ExpectType<typeof direct, "saved", "strict">;
+
+// Appel curifié : l’information attendue est configurée dans le pipe.
+const piped = DCommon.pipe(
+	DEither.left("missing", new Error("missing")),
+	DEither.unwrapByInformationOrThrow("missing"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, Error, "strict">;
+
+// Une information absente provoque `HasNotInformationError` au runtime.

package/docs/API/10-lang/10-either/10-unwrapLeft.ts

@@ -0,0 +1,14 @@
+/**
+ * @title DEither.unwrapLeft
+ *
+ * Extraire la valeur d’un Left et laisser les autres valeurs inchangées.
+ */
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+const leftValue = DEither.unwrapLeft(DEither.left("invalid", "bad-input"));
+type _CheckLeft = DCommon.ExpectType<typeof leftValue, "bad-input", "strict">;
+
+const rightValue = DEither.unwrapLeft(DEither.success("saved"));
+// Un Right n’est pas extrait et reste présent dans la sortie.
+type _CheckRight = DCommon.ExpectType<typeof rightValue, DEither.Success<"saved">, "strict">;

package/docs/API/10-lang/10-either/10-unwrapLeftOrThrow.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DEither.unwrapLeftOrThrow
+ *
+ * Extraire un Left ou lever une exception lorsque le statut attendu n’est pas présent.
+ */
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+const value = DEither.unwrapLeftOrThrow(DEither.left("invalid", "bad-input"));
+
+// Pour une entrée connue comme Left, la valeur extraite est directement typée.
+type _CheckValue = DCommon.ExpectType<typeof value, "bad-input", "strict">;
+
+// Un Right provoque `NotLeftError` au runtime.
+declare const maybeLeft: DEither.Left<"invalid", string> | DEither.Success<"saved">;
+const narrowed = DEither.unwrapLeftOrThrow(maybeLeft);
+type _CheckNarrowed = DCommon.ExpectType<typeof narrowed, string, "strict">;

package/docs/API/10-lang/10-either/10-unwrapOr.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DEither.unwrapOr
+ *
+ * Extraire la valeur d’un Right ou fournir une valeur de remplacement.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+const direct = DEither.unwrapOr(DEither.success("saved"), "fallback");
+type _CheckDirect = DCommon.ExpectType<typeof direct, "saved" | "fallback", "strict">;
+
+const piped = DCommon.pipe(
+	DEither.left("missing"),
+	DEither.unwrapOr("fallback"),
+);
+// Le Left prend la valeur de remplacement.
+type _CheckPiped = DCommon.ExpectType<typeof piped, "fallback", "strict">;

package/docs/API/10-lang/10-either/10-unwrapOtherwise.ts

@@ -0,0 +1,20 @@
+/**
+ * @title DEither.unwrapOtherwise
+ *
+ * Extraire la valeur d’un Right ou calculer une valeur de remplacement pour les autres cas.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+const direct = DEither.unwrapOtherwise(
+	DEither.left("missing"),
+	() => "fallback",
+);
+type _CheckDirect = DCommon.ExpectType<typeof direct, "fallback", "strict">;
+
+const piped = DCommon.pipe(
+	DEither.success("saved"),
+	DEither.unwrapOtherwise(() => "fallback"),
+);
+// La callback de remplacement n’est pas utilisée pour un Right.
+type _CheckPiped = DCommon.ExpectType<typeof piped, "saved" | "fallback", "strict">;

package/docs/API/10-lang/10-either/10-unwrapRight.ts

@@ -0,0 +1,14 @@
+/**
+ * @title DEither.unwrapRight
+ *
+ * Extraire la valeur d’un Right et laisser les autres valeurs inchangées.
+ */
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+const rightValue = DEither.unwrapRight(DEither.success("saved"));
+type _CheckRight = DCommon.ExpectType<typeof rightValue, "saved", "strict">;
+
+const leftValue = DEither.unwrapRight(DEither.left("missing", "not-found"));
+// Un Left n’est pas extrait et reste présent dans la sortie.
+type _CheckLeft = DCommon.ExpectType<typeof leftValue, DEither.Left<"missing", "not-found">, "strict">;

package/docs/API/10-lang/10-either/10-unwrapRightOrThrow.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DEither.unwrapRightOrThrow
+ *
+ * Extraire un Right ou lever une exception lorsque le statut attendu n’est pas présent.
+ */
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+const value = DEither.unwrapRightOrThrow(DEither.success("saved"));
+
+// Pour une entrée connue comme Right, la valeur extraite est directement typée.
+type _CheckValue = DCommon.ExpectType<typeof value, "saved", "strict">;
+
+// Un Left provoque `NotRightError` au runtime.
+declare const maybeRight: DEither.Success<string> | DEither.Left<"missing", null>;
+const narrowed = DEither.unwrapRightOrThrow(maybeRight);
+type _CheckNarrowed = DCommon.ExpectType<typeof narrowed, string, "strict">;

package/docs/API/10-lang/10-either/10-unwrapSelection.ts

@@ -0,0 +1,26 @@
+/**
+ * @title DEither.unwrapSelection
+ *
+ * Extraire les variantes marquées `true` dans une sélection et transmettre les autres.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
+
+// Appel classique : la variante success est extraite, la variante missing reste enveloppée.
+const direct = DEither.unwrapSelection(input, {
+	success: true,
+	missing: false,
+});
+type _CheckDirect = DCommon.ExpectType<typeof direct, "saved" | DEither.Left<"missing", Error>, "strict">;
+
+// Appel curifié : la sélection est appliquée dans le pipe.
+const piped = DCommon.pipe(
+	input,
+	DEither.unwrapSelection({
+		success: true,
+		missing: false,
+	}),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "saved" | DEither.Left<"missing", Error>, "strict">;

package/docs/API/10-lang/10-either/10-unwrapSelectionOrThrow.ts

@@ -0,0 +1,19 @@
+/**
+ * @title DEither.unwrapSelectionOrThrow
+ *
+ * Extraire une variante sélectionnée ou lever une exception lorsqu’elle ne l’est pas.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+const direct = DEither.unwrapSelectionOrThrow(DEither.success("saved"), { success: true });
+type _CheckDirect = DCommon.ExpectType<typeof direct, "saved", "strict">;
+
+// Appel curifié : la sélection est configurée avant l’entrée du pipe.
+const piped = DCommon.pipe(
+	DEither.success("saved"),
+	DEither.unwrapSelectionOrThrow({ success: true }),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "saved", "strict">;
+
+// Une information associée à `false` provoque `HasNotSelectedInformationError` au runtime.

package/docs/API/10-lang/10-either/10-whenHasInformation.ts

@@ -0,0 +1,36 @@
+/**
+ * @title DEither.whenHasInformation
+ *
+ * Transformer la valeur des variantes portant une information donnée.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+const input = DEither.left("invalid", "bad-input");
+
+// Appel classique : la callback reçoit la valeur de l’information ciblée.
+const direct = DEither.whenHasInformation(
+	input,
+	"invalid",
+	(value) => `reason:${value}`,
+);
+type _CheckDirect = DCommon.ExpectType<typeof direct, "reason:bad-input", "strict">;
+
+// Appel curifié : l’information et la callback sont configurées dans le pipe.
+const piped = DCommon.pipe(
+	input,
+	DEither.whenHasInformation(
+		"invalid",
+		(value) => `reason:${value}`,
+	),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "reason:bad-input", "strict">;
+
+declare const mixedInput: DEither.Success<"saved"> | DEither.Left<"invalid", string>;
+const unchanged = DEither.whenHasInformation(
+	mixedInput,
+	["invalid"],
+	(value) => value,
+);
+// Une information non ciblée transmet le Right inchangé.
+type _CheckUnchanged = DCommon.ExpectType<typeof unchanged, string | DEither.Success<"saved">, "strict">;

package/docs/API/10-lang/10-either/10-whenHasInformationOtherwise.ts

@@ -0,0 +1,29 @@
+/**
+ * @title DEither.whenHasInformationOtherwise
+ *
+ * Traiter les variantes ciblées par information et fournir une branche de repli.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const input: DEither.Left<"invalid", string> | DEither.Success<"saved">;
+
+// Appel classique : la branche otherwise reçoit le résultat non ciblé.
+const direct = DEither.whenHasInformationOtherwise(
+	input,
+	"invalid",
+	(value) => `invalid:${value}`,
+	(value) => DEither.unwrapRight(value),
+);
+type _CheckDirect = DCommon.ExpectType<typeof direct, `invalid:${string}` | "saved", "strict">;
+
+// Appel curifié : les deux traitements sont configurés dans le pipe.
+const piped = DCommon.pipe(
+	input,
+	DEither.whenHasInformationOtherwise(
+		"invalid",
+		(value) => `invalid:${value}`,
+		(value) => DEither.unwrapRight(value),
+	),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, `invalid:${string}` | "saved", "strict">;

package/docs/API/10-lang/10-either/10-whenIsLeft.ts

@@ -0,0 +1,20 @@
+/**
+ * @title DEither.whenIsLeft
+ *
+ * Transformer la valeur d’un Left et transmettre les autres résultats inchangés.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+const input = DEither.left("invalid", "bad-input");
+
+// Appel classique : la callback ne reçoit que la valeur du Left.
+const direct = DEither.whenIsLeft(input, (value) => `reason:${value}`);
+type _CheckDirect = DCommon.ExpectType<typeof direct, "reason:bad-input", "strict">;
+
+// Appel curifié : la transformation est directement placée dans le pipe.
+const piped = DCommon.pipe(
+	input,
+	DEither.whenIsLeft((value) => `reason:${value}`),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "reason:bad-input", "strict">;

package/docs/API/10-lang/10-either/10-whenIsLeftOtherwise.ts

@@ -0,0 +1,27 @@
+/**
+ * @title DEither.whenIsLeftOtherwise
+ *
+ * Traiter séparément les Left et les autres résultats.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const input: DEither.Success<"saved"> | DEither.Left<"invalid", string>;
+
+// Appel classique : la seconde callback reçoit le résultat lorsqu’il n’est pas Left.
+const direct = DEither.whenIsLeftOtherwise(
+	input,
+	(value) => `left:${value}`,
+	(value) => DEither.unwrapRight(value),
+);
+type _CheckDirect = DCommon.ExpectType<typeof direct, `left:${string}` | "saved", "strict">;
+
+// Appel curifié : les deux branches sont configurées avant l’entrée du pipe.
+const piped = DCommon.pipe(
+	input,
+	DEither.whenIsLeftOtherwise(
+		(value) => `left:${value}`,
+		(value) => DEither.unwrapRight(value),
+	),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, `left:${string}` | "saved", "strict">;

package/docs/API/10-lang/10-either/10-whenIsRight.ts

@@ -0,0 +1,20 @@
+/**
+ * @title DEither.whenIsRight
+ *
+ * Transformer la valeur d’un Right et transmettre les autres résultats inchangés.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+const input = DEither.success("saved");
+
+// Appel classique : la callback ne reçoit que la valeur du Right.
+const direct = DEither.whenIsRight(input, (value) => `status:${value}`);
+type _CheckDirect = DCommon.ExpectType<typeof direct, "status:saved", "strict">;
+
+// Appel curifié : la transformation est directement placée dans le pipe.
+const piped = DCommon.pipe(
+	input,
+	DEither.whenIsRight((value) => `status:${value}`),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "status:saved", "strict">;

package/docs/API/10-lang/10-either/10-whenIsRightOtherwise.ts

@@ -0,0 +1,26 @@
+/**
+ * @title DEither.whenIsRightOtherwise
+ *
+ * Traiter séparément les Right et les autres résultats.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const input: DEither.Success<"saved"> | DEither.Left<"missing", string>;
+
+const direct = DEither.whenIsRightOtherwise(
+	input,
+	(value) => `right:${value}`,
+	(value) => `left:${DEither.unwrapLeft(value)}`,
+);
+type _CheckDirect = DCommon.ExpectType<typeof direct, "right:saved" | `left:${string}`, "strict">;
+
+// Appel curifié : les deux branches sont configurées avant l’entrée du pipe.
+const piped = DCommon.pipe(
+	input,
+	DEither.whenIsRightOtherwise(
+		(value) => `right:${value}`,
+		(value) => `left:${DEither.unwrapLeft(value)}`,
+	),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "right:saved" | `left:${string}`, "strict">;

package/docs/API/10-lang/10-either/10-whenIsSelected.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DEither.whenIsSelected
+ *
+ * Transformer la valeur des variantes marquées `true` dans une sélection.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const input: DEither.Left<"invalid", string> | DEither.Success<"saved">;
+
+// Appel classique : seule la variante invalid est transformée.
+const direct = DEither.whenIsSelected(
+	input,
+	{
+		invalid: true,
+		success: false,
+	},
+	(value) => `invalid:${value}`,
+);
+type _CheckDirect = DCommon.ExpectType<typeof direct, `invalid:${string}` | DEither.Success<"saved">, "strict">;
+
+// Appel curifié : la sélection et la callback sont configurées dans le pipe.
+const piped = DCommon.pipe(
+	input,
+	DEither.whenIsSelected(
+		{
+			invalid: true,
+			success: false,
+		},
+		(value) => `invalid:${value}`,
+	),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, `invalid:${string}` | DEither.Success<"saved">, "strict">;

package/docs/API/10-lang/10-either/10-whenIsSelectedOtherwise.ts

@@ -0,0 +1,35 @@
+/**
+ * @title DEither.whenIsSelectedOtherwise
+ *
+ * Transformer les variantes sélectionnées et traiter toutes les autres dans une branche de repli.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const input: DEither.Left<"invalid", string> | DEither.Success<"saved">;
+
+// Appel classique : la branche otherwise reçoit le Right non sélectionné.
+const direct = DEither.whenIsSelectedOtherwise(
+	input,
+	{
+		invalid: true,
+		success: false,
+	},
+	(value) => `invalid:${value}`,
+	(value) => DEither.unwrapRight(value),
+);
+type _CheckDirect = DCommon.ExpectType<typeof direct, `invalid:${string}` | "saved", "strict">;
+
+// Appel curifié : la sélection et les deux callbacks sont configurées dans le pipe.
+const piped = DCommon.pipe(
+	input,
+	DEither.whenIsSelectedOtherwise(
+		{
+			invalid: true,
+			success: false,
+		},
+		(value) => `invalid:${value}`,
+		(value) => DEither.unwrapRight(value),
+	),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, `invalid:${string}` | "saved", "strict">;

package/docs/API/10-lang/10-either/index.llms.md

@@ -0,0 +1,196 @@
+## DEither
+
+Création, discrimination, transformation et propagation des réussites ou des échecs représentés par `Either`.
+
+### [DEither.asyncGroup](10-asyncGroup.ts)
+
+Regrouper séquentiellement des résultats synchrones ou asynchrones dans un Success.
+ 
+### [DEither.asyncSafeCallback](10-asyncSafeCallback.ts)
+
+Convertir une callback ou une promesse et ses exceptions en résultat asynchrone.
+ 
+### [DEither.error](10-error.ts)
+
+Créer un Left standardisé avec l’information `error`.
+ 
+### [DEither.expect](10-expect.ts)
+
+Retourner un Either sans modifier sa valeur ni son type.
+ 
+### [DEither.extractErrorInLeft](10-extractErrorInLeft.ts)
+
+Extraire d’un Left les erreurs DuploJS sélectionnées par leur identifiant.
+ 
+### [DEither.fail](10-fail.ts)
+
+Créer un Left standardisé représentant un échec sans valeur.
+ 
+### [DEither.forwardAssertsSelection](10-forwardAssertsSelection.ts)
+
+Affirmer qu’une information est sélectionnée et lever une exception sinon.
+ 
+### [DEither.group](10-group.ts)
+
+Regrouper des Right dans un Success en arrêtant au premier Left.
+ 
+### [DEither.hasInformation](10-hasInformation.ts)
+
+Tester l’information d’un Either et affiner le statut et la valeur.
+ 
+### [DEither.isLeft](10-isLeft.ts)
+
+Vérifier le statut Left et affiner le type de la valeur.
+ 
+### [DEither.isRight](10-isRight.ts)
+
+Vérifier le statut Right et affiner le type de la valeur.
+ 
+### [DEither.isSelected](10-isSelected.ts)
+
+Tester une sélection d’informations et affiner l’union d’Either.
+ 
+### [DEither.keepAsRightByInformation](10-keepAsRightByInformation.ts)
+
+Reclasser comme Right les variantes portant certaines informations.
+ 
+### [DEither.keepAsRightSelection](10-keepAsRightSelection.ts)
+
+Reclasser les variantes selon une sélection exhaustive d’informations.
+ 
+### [DEither.left](10-left.ts)
+
+Créer un résultat Left avec une information et une valeur optionnelle.
+ 
+### [DEither.matchInformation](10-matchInformation.ts)
+
+Appliquer exhaustivement une callback selon l’information du résultat.
+ 
+### [DEither.matchInformationCombination](10-matchInformationCombination.ts)
+
+Appliquer un traitement pour chaque combinaison d’informations d’une collection d’Either.
+ 
+### [DEither.matchInformationCombinationOtherwise](10-matchInformationCombinationOtherwise.ts)
+
+Traiter les combinaisons d’informations choisies et fournir un cas de repli.
+ 
+### [DEither.matchInformationOtherwise](10-matchInformationOtherwise.ts)
+
+Appliquer une callback pour certaines informations et une branche de repli pour les autres.
+ 
+### [DEither.none](10-none.ts)
+
+Créer le Left représentant l’absence d’une valeur.
+ 
+### [DEither.ok](10-ok.ts)
+
+Créer un Right standardisé représentant une réussite sans valeur.
+ 
+### [DEither.result](10-result.ts)
+
+Créer un état contextualisé de type Result, sans lui attribuer un succès ou un échec.
+ 
+### [DEither.rewriteInformation](10-rewriteInformation.ts)
+
+Renommer certaines informations en conservant le statut et la valeur.
+ 
+### [DEither.right](10-right.ts)
+
+Créer un résultat Right avec une information et une valeur optionnelle.
+ 
+### [DEither.rightAsyncPipe](10-rightAsyncPipe.ts)
+
+Enchaîner des transformations asynchrones sur la valeur d’un Right en arrêtant au premier Left.
+ 
+### [DEither.rightPipe](10-rightPipe.ts)
+
+Enchaîner des transformations sur la valeur d’un Right en arrêtant au premier Left.
+ 
+### [DEither.safeCallback](10-safeCallback.ts)
+
+Convertir une valeur ou une exception d’une callback en Either.
+ 
+### [DEither.some](10-some.ts)
+
+Créer un Right représentant une valeur présente dans un Maybe.
+ 
+### [DEither.success](10-success.ts)
+
+Créer un Right standardisé avec l’information `success`.
+ 
+### [DEither.toMaybe](10-toMaybe.ts)
+
+Convertir une valeur, une absence ou un Either en représentation Maybe.
+ 
+### [DEither.unwrapByInformation](10-unwrapByInformation.ts)
+
+Extraire les variantes portant une information donnée et transmettre les autres.
+ 
+### [DEither.unwrapByInformationOrThrow](10-unwrapByInformationOrThrow.ts)
+
+Extraire une information ciblée ou lever une exception si elle est absente.
+ 
+### [DEither.unwrapLeft](10-unwrapLeft.ts)
+
+Extraire la valeur d’un Left et laisser les autres valeurs inchangées.
+ 
+### [DEither.unwrapLeftOrThrow](10-unwrapLeftOrThrow.ts)
+
+Extraire un Left ou lever une exception lorsque le statut attendu n’est pas présent.
+ 
+### [DEither.unwrapOr](10-unwrapOr.ts)
+
+Extraire la valeur d’un Right ou fournir une valeur de remplacement.
+ 
+### [DEither.unwrapOtherwise](10-unwrapOtherwise.ts)
+
+Extraire la valeur d’un Right ou calculer une valeur de remplacement pour les autres cas.
+ 
+### [DEither.unwrapRight](10-unwrapRight.ts)
+
+Extraire la valeur d’un Right et laisser les autres valeurs inchangées.
+ 
+### [DEither.unwrapRightOrThrow](10-unwrapRightOrThrow.ts)
+
+Extraire un Right ou lever une exception lorsque le statut attendu n’est pas présent.
+ 
+### [DEither.unwrapSelection](10-unwrapSelection.ts)
+
+Extraire les variantes marquées `true` dans une sélection et transmettre les autres.
+ 
+### [DEither.unwrapSelectionOrThrow](10-unwrapSelectionOrThrow.ts)
+
+Extraire une variante sélectionnée ou lever une exception lorsqu’elle ne l’est pas.
+ 
+### [DEither.whenHasInformation](10-whenHasInformation.ts)
+
+Transformer la valeur des variantes portant une information donnée.
+ 
+### [DEither.whenHasInformationOtherwise](10-whenHasInformationOtherwise.ts)
+
+Traiter les variantes ciblées par information et fournir une branche de repli.
+ 
+### [DEither.whenIsLeft](10-whenIsLeft.ts)
+
+Transformer la valeur d’un Left et transmettre les autres résultats inchangés.
+ 
+### [DEither.whenIsLeftOtherwise](10-whenIsLeftOtherwise.ts)
+
+Traiter séparément les Left et les autres résultats.
+ 
+### [DEither.whenIsRight](10-whenIsRight.ts)
+
+Transformer la valeur d’un Right et transmettre les autres résultats inchangés.
+ 
+### [DEither.whenIsRightOtherwise](10-whenIsRightOtherwise.ts)
+
+Traiter séparément les Right et les autres résultats.
+ 
+### [DEither.whenIsSelected](10-whenIsSelected.ts)
+
+Transformer la valeur des variantes marquées `true` dans une sélection.
+ 
+### [DEither.whenIsSelectedOtherwise](10-whenIsSelectedOtherwise.ts)
+
+Transformer les variantes sélectionnées et traiter toutes les autres dans une branche de repli.
+ 

package/docs/API/10-lang/10-either/index.md

@@ -0,0 +1,3 @@
+## DEither
+
+Création, discrimination, transformation et propagation des réussites ou des échecs représentés par `Either`.

package/docs/API/10-lang/10-generator/10-asyncChunk.ts

@@ -0,0 +1,55 @@
+/**
+ * @title DGenerator.asyncChunk
+ *
+ * Regrouper les valeurs d’un itérable asynchrone en sous-itérables de taille bornée.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+import * as DGenerator from "@duplojs/lang/generator";
+
+const input = (async function *() {
+	await DCommon.timeout();
+	yield 1 as number;
+	yield 2 as number;
+	yield 3 as number;
+})();
+
+// Appel classique : les valeurs sont produites dans des groupes d’au plus deux éléments.
+const result = DGenerator.asyncChunk(input, 2);
+
+// La sortie est un AsyncGenerator qui produit [[1, 2], [3]].
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	AsyncGenerator<
+		& readonly number[]
+		& DArray.MinElements<1>
+		& DArray.MaxElements<2>,
+		unknown,
+		unknown
+	>,
+	"strict"
+>;
+
+// Appel curifié : la taille est configurée dans l’étape du pipe.
+const piped = DCommon.pipe(
+	(async function *() {
+		await DCommon.timeout();
+		yield 1 as number;
+		yield 2 as number;
+		yield 3 as number;
+		yield 4 as number;
+	})(),
+	DGenerator.asyncChunk(3),
+	DArray.from,
+);
+
+// La promesse se résout vers [[1, 2, 3], [4]].
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	Promise<readonly (
+		& readonly number[]
+		& DArray.MinElements<1>
+		& DArray.MaxElements<3>
+	)[]>,
+	"strict"
+>;