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

package/docs/API/10-lang/10-common/10-justExec.ts

@@ -9,14 +9,14 @@ declare const input: number;
 
 const result = DCommon.justExec(() => {
 	if (input > 10) {
-		return "large" as const;
+		return "large";
 	}
 
 	if (input > 0) {
-		return "positive" as const;
+		return "positive";
 	}
 
-	return "non-positive" as const;
+	return "non-positive";
 });
 
 // Le bloc est exécuté immédiatement : son résultat est directement affecté à `result`.

package/docs/API/10-lang/10-common/10-or.ts

@@ -4,8 +4,9 @@
  * Combiner plusieurs prédicats en une condition satisfaite par au moins l’un d’eux.
  */
 import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
 
-declare const input: string | number;
+declare const input: string | number | boolean;
 
 // Appel classique : un seul predicate accepté suffit.
 const result = DCommon.or(input, [
@@ -14,6 +15,10 @@ const result = DCommon.or(input, [
 ]);
 type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
 
+if (DCommon.or(input, [DCommon.isType("string"), DCommon.isType("number")])) {
+	type _CheckInput = DCommon.ExpectType<typeof input, string | number, "strict">;
+}
+
 // Appel curifié : le predicate composé est passé à DCommon.when.
 const preserved = DCommon.pipe(
 	input,
@@ -22,8 +27,17 @@ const preserved = DCommon.pipe(
 			DCommon.isType("string"),
 			DCommon.isType("number"),
 		]),
-		DCommon.forward,
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, string | number, "strict">;
+
+			return DString.to(value);
+		},
 	),
 );
 
-type _CheckPreserved = DCommon.ExpectType<typeof preserved, string | number, "strict">;
+// Les chaînes et les nombres sélectionnés deviennent des chaînes ; le booléen reste inchangé.
+type _CheckPreserved = DCommon.ExpectType<
+	typeof preserved,
+	string | boolean | (string & DString.Number),
+	"strict"
+>;

package/docs/API/10-lang/10-common/10-tap.ts

@@ -0,0 +1,28 @@
+/**
+ * @title DCommon.tap
+ *
+ * Exécuter un traitement secondaire tout en conservant la valeur d’entrée.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const input = {
+	status: "saved",
+	revision: 3,
+};
+declare function recordStatus(status: Uppercase<string>): void;
+
+// Appel classique : enregistrer le statut sans remplacer l’objet d’entrée.
+const direct = DCommon.tap(input, (entry) => {
+	recordStatus(DString.toUpperCase(entry.status));
+});
+type _CheckDirect = DCommon.ExpectType<typeof direct, typeof input, "strict">;
+
+declare function persistAudit(entry: typeof input): Promise<void>;
+
+// Appel curifié : attendre l’audit asynchrone puis conserver l’objet dans le pipe.
+const piped = DCommon.pipe(
+	input,
+	DCommon.tap(persistAudit),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, Promise<typeof input>, "strict">;

package/docs/API/10-lang/10-common/10-toJSON.ts

@@ -7,7 +7,7 @@ import * as DCommon from "@duplojs/lang/common";
 
 const result = DCommon.toJSON({
 	toJSON() {
-		return "json" as const;
+		return "json";
 	},
 });
 

package/docs/API/10-lang/10-common/10-toNative.ts

@@ -7,7 +7,7 @@ import * as DCommon from "@duplojs/lang/common";
 
 const result = DCommon.toNative({
 	toNative() {
-		return "native" as const;
+		return "native";
 	},
 });
 

package/docs/API/10-lang/10-common/10-toRegExp.ts

@@ -6,7 +6,7 @@
 import * as DCommon from "@duplojs/lang/common";
 
 const fromString = DCommon.toRegExp("file.name");
-const fromTuple = DCommon.toRegExp(["pending", "done"] as const);
+const fromTuple = DCommon.toRegExp(["pending", "done"]);
 const existing = /^(pending|done)$/;
 const fromRegExp = DCommon.toRegExp(existing);
 

package/docs/API/10-lang/10-common/10-truthy.ts

@@ -10,3 +10,22 @@ const result = DCommon.truthy(input);
 
 // Le predicate produit un booléen et peut affiner input vers une chaîne.
 type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// L’appel direct affine dans le if ; la branche peut alors transformer la chaîne.
+if (DCommon.truthy(input)) {
+	type _CheckInput = DCommon.ExpectType<typeof input, string, "strict">;
+}
+
+// Une fonction déjà unaire se passe telle quelle à DCommon.when.
+const transformed = DCommon.pipe(
+	input,
+	DCommon.when(
+		DCommon.truthy,
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, string, "strict">;
+
+			return DCommon.forward(value);
+		},
+	),
+);
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | null, "strict">;

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

@@ -4,23 +4,54 @@
  * Transformer une valeur uniquement lorsqu’un prédicat n’est pas satisfait.
  */
 import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
 
-declare const input: string | number;
-
-// Appel classique : transformer seulement la branche qui ne satisfait pas le predicate.
-const result = DCommon.whenNot(
-	input,
-	DCommon.isType("string"),
-	DCommon.forward,
+// Appel classique : remplacer un nom vide, sans modifier les noms déjà renseignés.
+declare const displayName: string;
+const named = DCommon.whenNot(
+	displayName,
+	DString.isNotEmpty,
+	DCommon.justReturn("Anonyme"),
 );
-type _CheckResult = DCommon.ExpectType<typeof result, string | number, "strict">;
+// La chaîne vide devient "Anonyme" ; les autres noms conservent la preuve NotEmpty.
+type _CheckNamed = DCommon.ExpectType<typeof named, (string & DString.NotEmpty) | "Anonyme", "strict">;
 
-// Appel curifié : placer le traitement conditionnel dans un pipe.
-const piped = DCommon.pipe(
-	input,
+// Appel curifié : convertir les références numériques avant de normaliser leur casse.
+declare const reference: string | number;
+const normalizedReference = DCommon.pipe(
+	reference,
 	DCommon.whenNot(
 		DCommon.isType("string"),
-		DCommon.forward,
+		DString.to,
 	),
+	DString.toUpperCase,
+);
+// Par exemple, 42 donne "42" et "ticket-ab" donne "TICKET-AB".
+type _CheckNormalizedReference = DCommon.ExpectType<typeof normalizedReference, Uppercase<string>, "strict">;
+
+// Predicates composés : signaler seulement les états qui ne sont ni prêts ni en attente.
+declare const state: "ready" | "queued" | "blocked";
+const labeledState = DCommon.whenNot(
+	state,
+	DCommon.or([DCommon.equal("ready"), DCommon.equal("queued")]),
+	DString.prepend("Attention : "),
+);
+// "blocked" devient "Attention : blocked" ; les deux autres littéraux sont conservés.
+type _CheckLabeledState = DCommon.ExpectType<
+	typeof labeledState,
+	"ready" | "queued" | "Attention : blocked",
+	"strict"
+>;
+
+// Test booléen : appliquer un délai minimum calculé à l'exécution.
+declare const delay: number;
+declare const minimumDelay: number;
+const boundedDelay = DCommon.whenNot(
+	delay,
+	DNumber.greaterThanOrEqual(minimumDelay),
+	DCommon.justReturn(minimumDelay),
 );
-type _CheckPiped = DCommon.ExpectType<typeof piped, string | number, "strict">;
+// Les délais trop courts sont relevés au minimum ; les autres restent inchangés.
+// La borne dynamique ne peut pas être représentée comme une contrainte littérale.
+type _CheckBoundedDelay = DCommon.ExpectType<typeof boundedDelay, number, "strict">;

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

@@ -182,6 +182,10 @@ Convertir une quantité en octets écrite avec une unité ou déjà numérique.
 
 Additionner des durées écrites avec une unité ou exprimées en millisecondes.
  
+### [DCommon.tap](10-tap.ts)
+
+Exécuter un traitement secondaire tout en conservant la valeur d’entrée.
+ 
 ### [DCommon.timeout](10-timeout.ts)
 
 Créer une promise résolue après un délai en millisecondes.

package/docs/API/10-lang/10-dataStructure/10-typeStructureIdentifier.ts

@@ -28,6 +28,6 @@ const result = DCommon.when(
 
 type _CheckResult = DCommon.ExpectType<
 	typeof result,
-	DDataStructure.Structure | typeof DDataStructure.TheNumber,
-	"one-extends-two"
+	DDataStructure.Structure | DDataStructure.FundamentalType,
+	"strict"
 >;

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

@@ -40,5 +40,5 @@ type _CheckError = DCommon.ExpectType<
 const tupleResult = DEither.asyncGroup([
 	() => Promise.resolve(DEither.success("Alice")),
 	() => Promise.resolve(DEither.success(2)),
-] as const);
+]);
 type _CheckTuple = DCommon.ExpectType<typeof tupleResult, Promise<DEither.Success<["Alice", 2]>>, "strict">;

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

@@ -6,7 +6,8 @@
 import * as DEither from "@duplojs/lang/either";
 import type * as DCommon from "@duplojs/lang/common";
 
-const result = DEither.asyncSafeCallback(() => Promise.resolve("saved" as const));
+declare const saved: "saved";
+const result = DEither.asyncSafeCallback(() => Promise.resolve(saved));
 
 // La sortie est toujours une Promise et inclut le Left standard des erreurs capturées.
 type _CheckResult = DCommon.ExpectType<
@@ -15,7 +16,8 @@ type _CheckResult = DCommon.ExpectType<
 	"strict"
 >;
 
-const promiseInput = DEither.asyncSafeCallback(Promise.resolve("saved" as const));
+const savedPromise = Promise.resolve(saved);
+const promiseInput = DEither.asyncSafeCallback(savedPromise);
 type _CheckPromiseInput = DCommon.ExpectType<
 	typeof promiseInput,
 	Promise<DEither.SafeCallbackSuccess<"saved"> | DEither.SafeCallbackError>,

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

@@ -0,0 +1,45 @@
+/**
+ * @title DEither.extractErrorInLeft
+ *
+ * Extraire d’un Left les erreurs DuploJS sélectionnées par leur identifiant.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+class MissingError extends DCommon.DuploJSError.parentClass("missing") {}
+class ForbiddenError extends DCommon.DuploJSError.parentClass("forbidden") {}
+class UnexpectedError extends DCommon.DuploJSError.parentClass("unexpected") {}
+
+type LoadResult = (
+	| DEither.Left<"load-error", MissingError | ForbiddenError | UnexpectedError>
+	| DEither.Right<"success", string>
+	| null
+);
+
+declare const result: LoadResult;
+
+// Appel classique : l’erreur sélectionnée reçoit son identifiant comme information.
+const extracted = DEither.extractErrorInLeft(result, "missing");
+type _CheckExtracted = DCommon.ExpectType<
+	typeof extracted,
+	| DEither.Left<"load-error", ForbiddenError | UnexpectedError>
+	| DEither.Left<"missing", MissingError>
+	| DEither.Right<"success", string>
+	| null,
+	"strict"
+>;
+
+// Appel curifié : extraire plusieurs erreurs avant de traiter l’erreur restante.
+const separated = DCommon.pipe(
+	result,
+	DEither.extractErrorInLeft(["missing", "forbidden"]),
+);
+type _CheckSeparated = DCommon.ExpectType<
+	typeof separated,
+	| DEither.Left<"load-error", UnexpectedError>
+	| DEither.Left<"missing", MissingError>
+	| DEither.Left<"forbidden", ForbiddenError>
+	| DEither.Right<"success", string>
+	| null,
+	"strict"
+>;

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

@@ -6,7 +6,7 @@
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 
-const input = DEither.success("saved") as DEither.Success<"saved"> | DEither.Left<"missing", Error>;
+declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
 
 // Appel classique : le type est réduit aux informations sélectionnées.
 const direct = DEither.forwardAssertsSelection(input, {

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

@@ -53,6 +53,6 @@ type _CheckError = DCommon.ExpectType<
 const tupleResult = DEither.group([
 	DEither.success("Alice"),
 	DEither.success(2),
-] as const);
+]);
 // La forme tuple conserve sa longueur et déballe chaque Right.
 type _CheckTuple = DCommon.ExpectType<typeof tupleResult, DEither.Success<["Alice", 2]>, "strict">;

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

@@ -8,6 +8,12 @@ import * as DCommon from "@duplojs/lang/common";
 
 declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
 
+if (DEither.hasInformation(input, "missing")) {
+	type _CheckInput = DCommon.ExpectType<typeof input, DEither.Left<"missing", Error>, "strict">;
+	const reason = DEither.unwrapLeft(input);
+	type _CheckReason = DCommon.ExpectType<typeof reason, Error, "strict">;
+}
+
 // La forme curifiée est directement utilisable comme predicate de DCommon.when.
 const result = DCommon.pipe(
 	input,

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

@@ -4,7 +4,7 @@
  * Vérifier le statut Left et affiner le type de la valeur.
  */
 import * as DEither from "@duplojs/lang/either";
-import type * as DCommon from "@duplojs/lang/common";
+import * as DCommon from "@duplojs/lang/common";
 
 declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
 
@@ -14,3 +14,12 @@ if (DEither.isLeft(input)) {
 	const value = DEither.unwrapLeft(input);
 	type _CheckValue = DCommon.ExpectType<typeof value, Error, "strict">;
 }
+
+const result = DCommon.pipe(
+	input,
+	DCommon.when(
+		DEither.isLeft,
+		DEither.unwrapLeft,
+	),
+);
+type _CheckResult = DCommon.ExpectType<typeof result, Error | DEither.Success<"saved">, "strict">;

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

@@ -4,7 +4,7 @@
  * Vérifier le statut Right et affiner le type de la valeur.
  */
 import * as DEither from "@duplojs/lang/either";
-import type * as DCommon from "@duplojs/lang/common";
+import * as DCommon from "@duplojs/lang/common";
 
 declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
 
@@ -14,3 +14,12 @@ if (DEither.isRight(input)) {
 	const value = DEither.unwrapRight(input);
 	type _CheckValue = DCommon.ExpectType<typeof value, "saved", "strict">;
 }
+
+const result = DCommon.pipe(
+	input,
+	DCommon.when(
+		DEither.isRight,
+		DEither.unwrapRight,
+	),
+);
+type _CheckResult = DCommon.ExpectType<typeof result, "saved" | DEither.Left<"missing", Error>, "strict">;

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

@@ -7,6 +7,16 @@ import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 
 declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
+
+if (DEither.isSelected(input, {
+	success: true,
+	missing: false,
+})) {
+	type _CheckInput = DCommon.ExpectType<typeof input, DEither.Success<"saved">, "strict">;
+	const value = DEither.unwrapRight(input);
+	type _CheckValue = DCommon.ExpectType<typeof value, "saved", "strict">;
+}
+
 // La forme curifiée est directement utilisable comme predicate de DCommon.when.
 const result = DCommon.pipe(
 	input,
@@ -24,6 +34,8 @@ type _CheckResult = DCommon.ExpectType<typeof result, "saved" | DEither.Left<"mi
 
 const matches = DEither.isSelected(
 	DEither.left("missing", new Error("missing")),
-	{ missing: true },
+	{
+		missing: true,
+	},
 );
 type _CheckMatches = DCommon.ExpectType<typeof matches, boolean, "strict">;

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

@@ -19,5 +19,5 @@ const piped = DCommon.pipe(
 );
 type _CheckPiped = DCommon.ExpectType<typeof piped, DEither.Right<"validated", "Alice">, "strict">;
 
-const rejected = DEither.keepAsRightSelection(DEither.success("saved"), { success: false } as const);
+const rejected = DEither.keepAsRightSelection(DEither.success("saved"), { success: false });
 type _CheckRejected = DCommon.ExpectType<typeof rejected, DEither.Left<"success", "saved">, "strict">;

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

@@ -6,12 +6,14 @@
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 
-const input = DEither.success("saved") as DEither.Success<"saved"> | DEither.Left<"missing", Error>;
+declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
+declare const stored: "stored";
+declare const rejected: "rejected";
 
 // Appel classique : chaque information de l’union possède une callback.
 const direct = DEither.matchInformation(input, {
-	success: (value) => "stored" as const,
-	missing: (value) => "rejected" as const,
+	success: (value) => stored,
+	missing: (value) => rejected,
 });
 type _CheckDirect = DCommon.ExpectType<typeof direct, "stored" | "rejected", "strict">;
 
@@ -19,8 +21,8 @@ type _CheckDirect = DCommon.ExpectType<typeof direct, "stored" | "rejected", "st
 const piped = DCommon.pipe(
 	input,
 	DEither.matchInformation({
-		success: (value) => "stored" as const,
-		missing: (value) => "rejected" as const,
+		success: (value) => stored,
+		missing: (value) => rejected,
 	}),
 );
 type _CheckPiped = DCommon.ExpectType<typeof piped, "stored" | "rejected", "strict">;

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

@@ -0,0 +1,61 @@
+/**
+ * @title DEither.matchInformationCombination
+ *
+ * Appliquer un traitement pour chaque combinaison d’informations d’une collection d’Either.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+type Combination = readonly [
+	DEither.Success<42> | DEither.Error<"message">,
+	DEither.Right<"found", 1> | DEither.Left<"missing", undefined>,
+];
+
+declare const combination: Combination;
+
+// Appel classique : les quatre combinaisons possibles sont traitées explicitement.
+const direct = DEither.matchInformationCombination(combination, {
+	"success/found": (values) => {
+		type _CheckValues = DCommon.ExpectType<typeof values, readonly [42, 1], "strict">;
+		return values;
+	},
+	"success/missing": (values) => {
+		type _CheckValues = DCommon.ExpectType<typeof values, readonly [42, undefined], "strict">;
+		return values;
+	},
+	"error/found": (values) => {
+		type _CheckValues = DCommon.ExpectType<typeof values, readonly ["message", 1], "strict">;
+		return values;
+	},
+	"error/missing": (values) => {
+		type _CheckValues = DCommon.ExpectType<typeof values, readonly ["message", undefined], "strict">;
+		return values;
+	},
+});
+type _CheckDirect = DCommon.ExpectType<
+	typeof direct,
+	| readonly [42, 1]
+	| readonly [42, undefined]
+	| readonly ["message", 1]
+	| readonly ["message", undefined],
+	"strict"
+>;
+
+// Appel curifié : le matcher exhaustif est directement placé dans le pipe.
+const piped = DCommon.pipe(
+	combination,
+	DEither.matchInformationCombination({
+		"success/found": (values) => values,
+		"success/missing": (values) => values,
+		"error/found": (values) => values,
+		"error/missing": (values) => values,
+	}),
+);
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	| readonly [42, 1]
+	| readonly [42, undefined]
+	| readonly ["message", 1]
+	| readonly ["message", undefined],
+	"strict"
+>;

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

@@ -0,0 +1,62 @@
+/**
+ * @title DEither.matchInformationCombinationOtherwise
+ *
+ * Traiter les combinaisons d’informations choisies et fournir un cas de repli.
+ */
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+
+type Combination = readonly [
+	DEither.Success<42> | DEither.Error<"message">,
+	DEither.Right<"found", 1> | DEither.Left<"missing", undefined>,
+];
+
+declare const combination: Combination;
+
+// Appel classique : traiter success/found et transmettre les autres cas au repli.
+const direct = DEither.matchInformationCombinationOtherwise(
+	combination,
+	{
+		"success/found": (values) => {
+			type _CheckValues = DCommon.ExpectType<typeof values, readonly [42, 1], "strict">;
+			return values;
+		},
+	},
+	(values) => {
+		type _CheckRemaining = DCommon.ExpectType<
+			typeof values,
+			| readonly [DEither.Success<42>, DEither.Left<"missing", undefined>]
+			| readonly [DEither.Error<"message">, DEither.Right<"found", 1>]
+			| readonly [DEither.Error<"message">, DEither.Left<"missing", undefined>],
+			"strict"
+		>;
+		return values;
+	},
+);
+type _CheckDirect = DCommon.ExpectType<
+	typeof direct,
+	| readonly [42, 1]
+	| readonly [DEither.Success<42>, DEither.Left<"missing", undefined>]
+	| readonly [DEither.Error<"message">, DEither.Right<"found", 1>]
+	| readonly [DEither.Error<"message">, DEither.Left<"missing", undefined>],
+	"strict"
+>;
+
+// Appel curifié : la sélection et le repli sont configurés dans le pipe.
+const piped = DCommon.pipe(
+	combination,
+	DEither.matchInformationCombinationOtherwise(
+		{
+			"error/missing": (values) => values,
+		},
+		(values) => values,
+	),
+);
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	| readonly [DEither.Success<42>, DEither.Right<"found", 1>]
+	| readonly [DEither.Success<42>, DEither.Left<"missing", undefined>]
+	| readonly [DEither.Error<"message">, DEither.Right<"found", 1>]
+	| readonly ["message", undefined],
+	"strict"
+>;

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

@@ -6,13 +6,15 @@
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 
-const input = DEither.success("saved") as DEither.Success<"saved"> | DEither.Left<"missing", Error>;
+declare const input: DEither.Success<"saved"> | DEither.Left<"missing", Error>;
+declare const stored: "stored";
+declare const unhandled: "unhandled";
 
 // Appel classique : seules les informations documentées dans le matcher sont ciblées.
 const direct = DEither.matchInformationOtherwise(
 	input,
-	{ success: (value: "saved") => "stored" as const },
-	(value) => "unhandled" as const,
+	{ success: (value: "saved") => stored },
+	(value) => unhandled,
 );
 type _CheckDirect = DCommon.ExpectType<typeof direct, "stored" | "unhandled", "strict">;
 
@@ -20,8 +22,8 @@ type _CheckDirect = DCommon.ExpectType<typeof direct, "stored" | "unhandled", "s
 const piped = DCommon.pipe(
 	input,
 	DEither.matchInformationOtherwise(
-		{ success: (value: "saved") => "stored" as const },
-		(value) => "unhandled" as const,
+		{ success: (value: "saved") => stored },
+		(value) => unhandled,
 	),
 );
 type _CheckPiped = DCommon.ExpectType<typeof piped, "stored" | "unhandled", "strict">;

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

@@ -44,6 +44,7 @@ type _CheckFinalRight = DCommon.ExpectType<
 >;
 
 declare const input: Promise<DEither.Success<"saved"> | DEither.Error<"missing">>;
+declare const neverReached: "never-reached";
 
 // Un Left initial est propagé et les étapes suivantes ne sont pas exécutées.
 const propagated = DEither.rightAsyncPipe(
@@ -60,7 +61,7 @@ type _CheckPropagated = DCommon.ExpectType<
 const stopped = DEither.rightAsyncPipe(
 	Promise.resolve(DEither.success("saved")),
 	() => Promise.resolve(DEither.error("not-found")),
-	() => Promise.resolve("never-reached" as const),
+	() => Promise.resolve(neverReached),
 );
 type _CheckStopped = DCommon.ExpectType<
 	typeof stopped,

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

@@ -63,7 +63,7 @@ type _CheckPropagated = DCommon.ExpectType<
 const stopped = DEither.rightPipe(
 	DEither.success("saved"),
 	() => DEither.error("not-found"),
-	() => "never-reached" as const,
+	() => "never-reached",
 );
 type _CheckStopped = DCommon.ExpectType<
 	typeof stopped,

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

@@ -6,7 +6,7 @@
 import * as DEither from "@duplojs/lang/either";
 import type * as DCommon from "@duplojs/lang/common";
 
-const success = DEither.safeCallback(() => "saved" as const);
+const success = DEither.safeCallback(() => "saved");
 // Une valeur brute devient SafeCallbackSuccess ; la capture d’une exception reste dans le contrat.
 type _CheckSuccess = DCommon.ExpectType<
 	typeof success,