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

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

@@ -0,0 +1,80 @@
+## DPattern
+
+Sélectionner et traiter les variantes d’une union par identité, valeur littérale, motif structurel ou predicate, avec couverture exhaustive ou branche de repli.
+
+### [DPattern.exhaustive](10-exhaustive.ts)
+
+Terminer un traitement exhaustif en extrayant les valeurs des PatternResult.
+ 
+### [DPattern.isMatch](10-isMatch.ts)
+
+Vérifier un motif sur une valeur et affiner le type de la partie correspondante.
+ 
+### [DPattern.match](10-match.ts)
+
+Traiter une valeur selon un motif et conserver les cas qui ne correspondent pas.
+ 
+### [DPattern.matchWithEntity](10-matchWithEntity.ts)
+
+Router une union d’entités DuploJS vers un callback pour chaque nom d’entité.
+ 
+### [DPattern.matchWithEntityOtherwise](10-matchWithEntityOtherwise.ts)
+
+Router les entités sélectionnées et conserver dans le type du fallback les entités restantes.
+ 
+### [DPattern.matchWithError](10-matchWithError.ts)
+
+Traiter chaque variante d’une union d’erreurs DuploJS selon son identifiant typé.
+ 
+### [DPattern.matchWithErrorOtherwise](10-matchWithErrorOtherwise.ts)
+
+Traiter certains identifiants d’erreur et transmettre au fallback l’union d’erreurs non couverte.
+ 
+### [DPattern.matchWithFact](10-matchWithFact.ts)
+
+Router des facts par nom et exposer leur valeur ainsi que leur payload typé.
+ 
+### [DPattern.matchWithFactOtherwise](10-matchWithFactOtherwise.ts)
+
+Router les facts choisis et traiter les autres noms avec un callback recevant le fact restant.
+ 
+### [DPattern.matchWithNumber](10-matchWithNumber.ts)
+
+Associer chaque nombre littéral possible à un callback spécialisé pour cette valeur.
+ 
+### [DPattern.matchWithNumberOtherwise](10-matchWithNumberOtherwise.ts)
+
+Traiter certains nombres littéraux et recevoir les autres valeurs dans un fallback.
+ 
+### [DPattern.matchWithString](10-matchWithString.ts)
+
+Associer chaque chaîne littérale possible à un callback dont le paramètre est cette valeur exacte.
+ 
+### [DPattern.matchWithStringOtherwise](10-matchWithStringOtherwise.ts)
+
+Traiter certains littéraux de chaîne et transmettre au fallback l’union non couverte.
+ 
+### [DPattern.matchWithTaggedObject](10-matchWithTaggedObject.ts)
+
+Router une union d’objets marqués vers un callback par valeur de tag.
+ 
+### [DPattern.matchWithTaggedObjectOtherwise](10-matchWithTaggedObjectOtherwise.ts)
+
+Router les tags explicitement traités et transmettre les variantes restantes au fallback.
+ 
+### [DPattern.otherwise](10-otherwise.ts)
+
+Traiter la valeur non reconnue restante ou déballer un résultat déjà traité.
+ 
+### [DPattern.union](10-union.ts)
+
+Combiner plusieurs motifs en un seul motif correspondant à l’un d’eux.
+ 
+### [DPattern.when](10-when.ts)
+
+Exécuter un traitement lorsque le predicate correspond, en laissant la branche sinon inchangée.
+ 
+### [DPattern.whenNot](10-whenNot.ts)
+
+Exécuter un traitement pour les valeurs refusées par le predicate et laisser les autres non traitées.
+ 

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

@@ -0,0 +1,3 @@
+## DPattern
+
+Sélectionner et traiter les variantes d’une union par identité, valeur littérale, motif structurel ou predicate, avec couverture exhaustive ou branche de repli.

package/docs/API/10-lang/10-printer/10-bold.ts

@@ -0,0 +1,12 @@
+/**
+ * @title DPrinter.bold
+ *
+ * Encadrer une chaîne par les codes ANSI de mise en gras.
+ */
+import * as DPrinter from "@duplojs/lang/printer";
+import type * as DCommon from "@duplojs/lang/common";
+
+const emphasized = DPrinter.bold("Attention");
+
+// La valeur obtenue est "\x1B[1mAttention\x1B[0m".
+type _CheckEmphasized = DCommon.ExpectType<typeof emphasized, string, "strict">;

package/docs/API/10-lang/10-printer/10-colorized.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DPrinter.colorized
+ *
+ * Encadrer une chaîne par les codes ANSI d’une couleur sélectionnée.
+ */
+import * as DPrinter from "@duplojs/lang/printer";
+import * as DCommon from "@duplojs/lang/common";
+
+// Appel direct : la valeur obtenue est "\x1B[32mEnregistré\x1B[0m".
+const saved = DPrinter.colorized("Enregistré", "green");
+type _CheckSaved = DCommon.ExpectType<typeof saved, string, "strict">;
+
+// Appel curifié dans un pipe : la valeur obtenue est "\x1B[34mEn attente\x1B[0m".
+const status = DCommon.pipe(
+	"En attente",
+	DPrinter.colorized("blue"),
+);
+type _CheckStatus = DCommon.ExpectType<typeof status, string, "strict">;

package/docs/API/10-lang/10-printer/10-colorizedBold.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DPrinter.colorizedBold
+ *
+ * Appliquer une couleur ANSI et le style gras à une chaîne.
+ */
+import * as DPrinter from "@duplojs/lang/printer";
+import * as DCommon from "@duplojs/lang/common";
+
+// Appel direct : la valeur obtenue est "\x1B[1m\x1B[33mÀ vérifier\x1B[0m\x1B[0m".
+const warning = DPrinter.colorizedBold("À vérifier", "yellow");
+type _CheckWarning = DCommon.ExpectType<typeof warning, string, "strict">;
+
+// Appel curifié dans un pipe : la valeur obtenue est "\x1B[1m\x1B[36mRésumé\x1B[0m\x1B[0m".
+const heading = DCommon.pipe(
+	"Résumé",
+	DPrinter.colorizedBold("cyan"),
+);
+type _CheckHeading = DCommon.ExpectType<typeof heading, string, "strict">;

package/docs/API/10-lang/10-printer/10-indent.ts

@@ -0,0 +1,20 @@
+/**
+ * @title DPrinter.indent
+ *
+ * Produire une chaîne contenant le nombre demandé de tabulations.
+ */
+import * as DPrinter from "@duplojs/lang/printer";
+import type * as DCommon from "@duplojs/lang/common";
+
+// Deux niveaux produisent "\t\t".
+const nestedIndent = DPrinter.indent(2);
+type _CheckNestedIndent = DCommon.ExpectType<typeof nestedIndent, string, "strict">;
+
+// Une profondeur négative produit "".
+const rootIndent = DPrinter.indent(-1);
+type _CheckRootIndent = DCommon.ExpectType<typeof rootIndent, string, "strict">;
+
+// Les niveaux non finis sont ignorés ; une fraction positive est tronquée.
+const fractional = DPrinter.indent(2.5);
+// La valeur obtenue est "\t\t".
+type _CheckFractional = DCommon.ExpectType<typeof fractional, string, "strict">;

package/docs/API/10-lang/10-printer/10-primitives.md

@@ -0,0 +1,11 @@
+### Constantes et types de DPrinter
+
+Les constantes publiques fournissent les séparateurs textuels usuels, tandis que les types décrivent les couleurs et les valeurs acceptées par les fonctions de rendu.
+
+---
+
+Les constantes `back`, `dash` et `tab` valent respectivement `"\n"`, `"-"` et `"\t"`. Elles peuvent servir de séparateurs pour `render` ou pour assembler du texte dans d’autres traitements.
+
+`Colors` est l’union des couleurs ANSI disponibles : `"red"`, `"green"`, `"yellow"`, `"blue"`, `"magenta"`, `"cyan"` et `"gray"`. Les fonctions `colorized` et `colorizedBold` utilisent cette union pour sélectionner leur couleur.
+
+`RenderInput` décrit les valeurs acceptées par les fonctions de rendu : `string | boolean | null | undefined | readonly RenderInput[]`. Les tableaux peuvent contenir récursivement d’autres tableaux. À l’exécution, les tableaux imbriqués sont parcourus, `true` est rendu sous la forme `"true"`, tandis que `false`, `null` et `undefined` sont ignorés.

package/docs/API/10-lang/10-printer/10-render.ts

@@ -0,0 +1,29 @@
+/**
+ * @title DPrinter.render
+ *
+ * Assembler récursivement des valeurs rendables avec un séparateur choisi.
+ */
+import * as DPrinter from "@duplojs/lang/printer";
+import * as DCommon from "@duplojs/lang/common";
+
+// Appel direct : les tableaux imbriqués sont aplatis et true est rendu.
+// false, null et undefined sont ignorés.
+const summary = DPrinter.render(
+	["Éléments", [true, "validés"], false, null, undefined],
+	" ",
+);
+// La valeur obtenue est "Éléments true validés".
+type _CheckSummary = DCommon.ExpectType<typeof summary, string, "strict">;
+
+// Appel curifié dans un pipe : le séparateur est configuré avant de recevoir les valeurs.
+const compact = DCommon.pipe(
+	["nom", ["type", false], "statut"],
+	DPrinter.render(" · "),
+);
+// La valeur obtenue est "nom · type · statut".
+type _CheckCompact = DCommon.ExpectType<typeof compact, string, "strict">;
+
+// Une chaîne vide est conservée, contrairement à false, null et undefined.
+const emptyField = DPrinter.render(["nom", "", "statut"], "|");
+// La valeur obtenue est "nom||statut" ; un tableau sans élément rendable donnerait "".
+type _CheckEmptyField = DCommon.ExpectType<typeof emptyField, string, "strict">;

package/docs/API/10-lang/10-printer/10-renderLine.ts

@@ -0,0 +1,12 @@
+/**
+ * @title DPrinter.renderLine
+ *
+ * Assembler récursivement des valeurs en séparant les éléments par une espace.
+ */
+import * as DPrinter from "@duplojs/lang/printer";
+import type * as DCommon from "@duplojs/lang/common";
+
+const line = DPrinter.renderLine(["Nom", [true, "Ada"], false]);
+
+// La valeur obtenue est "Nom true Ada" ; false ne produit aucun texte.
+type _CheckLine = DCommon.ExpectType<typeof line, string, "strict">;

package/docs/API/10-lang/10-printer/10-renderParagraph.ts

@@ -0,0 +1,16 @@
+/**
+ * @title DPrinter.renderParagraph
+ *
+ * Assembler récursivement des valeurs en séparant les éléments par un saut de ligne.
+ */
+import * as DPrinter from "@duplojs/lang/printer";
+import type * as DCommon from "@duplojs/lang/common";
+
+const paragraph = DPrinter.renderParagraph([
+	"Première ligne",
+	["Deuxième ligne", false],
+	"Troisième ligne",
+]);
+
+// La valeur obtenue est "Première ligne\nDeuxième ligne\nTroisième ligne".
+type _CheckParagraph = DCommon.ExpectType<typeof paragraph, string, "strict">;

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

@@ -0,0 +1,37 @@
+## DPrinter
+
+Fonctions et constantes pour assembler du texte, formater des lignes et paragraphes, ajouter une indentation ou des styles ANSI.
+
+### [Constantes et types de DPrinter](10-primitives.md)
+
+Les constantes publiques fournissent les séparateurs textuels usuels, tandis que les types décrivent les couleurs et les valeurs acceptées par les fonctions de rendu.
+
+
+### [DPrinter.bold](10-bold.ts)
+
+Encadrer une chaîne par les codes ANSI de mise en gras.
+ 
+### [DPrinter.colorized](10-colorized.ts)
+
+Encadrer une chaîne par les codes ANSI d’une couleur sélectionnée.
+ 
+### [DPrinter.colorizedBold](10-colorizedBold.ts)
+
+Appliquer une couleur ANSI et le style gras à une chaîne.
+ 
+### [DPrinter.indent](10-indent.ts)
+
+Produire une chaîne contenant le nombre demandé de tabulations.
+ 
+### [DPrinter.render](10-render.ts)
+
+Assembler récursivement des valeurs rendables avec un séparateur choisi.
+ 
+### [DPrinter.renderLine](10-renderLine.ts)
+
+Assembler récursivement des valeurs en séparant les éléments par une espace.
+ 
+### [DPrinter.renderParagraph](10-renderParagraph.ts)
+
+Assembler récursivement des valeurs en séparant les éléments par un saut de ligne.
+ 

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

@@ -0,0 +1,3 @@
+## DPrinter
+
+Fonctions et constantes pour assembler du texte, formater des lignes et paragraphes, ajouter une indentation ou des styles ANSI.

package/docs/API/10-lang/10-string/10-at.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.at
+ *
+ * Lire le caractère situé à un index, avec `undefined` lorsque l'index est hors limites.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.at("hello", 1);
+// La valeur obtenue est "e".
+type _CheckResult = DCommon.ExpectType<typeof result, "e", "strict">;
+
+const piped = DCommon.pipe(
+	"hello",
+	DString.at(1),
+);
+// La forme curifiée s'intègre dans un pipe et conserve le caractère "e".
+type _CheckPiped = DCommon.ExpectType<typeof piped, "e", "strict">;

package/docs/API/10-lang/10-string/10-capitalize.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.capitalize
+ *
+ * Mettre en majuscule le premier caractère d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.capitalize("duplo");
+// La valeur obtenue est "Duplo".
+type _CheckResult = DCommon.ExpectType<typeof result, "Duplo", "strict">;
+
+const piped = DCommon.pipe(
+	"duplo",
+	DString.capitalize,
+);
+// La fonction unaire peut être passée directement au pipe.
+type _CheckPiped = DCommon.ExpectType<typeof piped, "Duplo", "strict">;

package/docs/API/10-lang/10-string/10-charAt.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.charAt
+ *
+ * Lire le caractère situé à un index positif ou nul.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.charAt("hello", 1);
+// La valeur obtenue est une chaîne d'au plus un caractère, ici "e".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MaxCharacters<1>, "strict">;
+
+const piped = DCommon.pipe(
+	"hello",
+	DString.charAt(1),
+);
+// La forme curifiée conserve la garantie de longueur maximale.
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MaxCharacters<1>, "strict">;

package/docs/API/10-lang/10-string/10-concat.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.concat
+ *
+ * Ajouter une ou plusieurs chaînes à la fin d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.concat("hello", " ", "world");
+// La valeur obtenue est "hello world".
+type _CheckResult = DCommon.ExpectType<typeof result, "hello world", "strict">;
+
+const piped = DCommon.pipe(
+	"hello",
+	DString.concat(" "),
+);
+// La forme curifiée fixe l'élément ajouté dans l'étape du pipe.
+type _CheckPiped = DCommon.ExpectType<typeof piped, "hello ", "strict">;

package/docs/API/10-lang/10-string/10-endsWith.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DString.endsWith
+ *
+ * Tester si une chaîne se termine par une sous-chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.endsWith("user-api", "api");
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.endsWith(value, "api")) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, `${string}api`, "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.endsWith("api"),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, `${string}api`, "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la chaîne affinée pour calculer sa longueur.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-extract.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.extract
+ *
+ * Extraire la première occurrence d'un motif avec ses groupes et sa position.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.extract("order-42", /(?<kind>order)-(?<id>\d+)/);
+// Le résultat contient la correspondance, les groupes, les groupes nommés, la position et la chaîne source.
+type _CheckResult = DCommon.ExpectType<typeof result, DString.ExtractOutput<"order-42"> | undefined, "strict">;
+
+const piped = DCommon.pipe(
+	"order-42",
+	DString.extract(/\d+/),
+);
+// La forme curifiée recherche le même motif sur la chaîne reçue par le pipe.
+type _CheckPiped = DCommon.ExpectType<typeof piped, DString.ExtractOutput<"order-42"> | undefined, "strict">;

package/docs/API/10-lang/10-string/10-extractAll.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.extractAll
+ *
+ * Produire les occurrences d'un motif global sous forme de génératrice.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.extractAll("order-42/order-43", /order-\d+/g);
+// La génératrice produit un objet d'extraction pour chaque occurrence.
+type _CheckResult = DCommon.ExpectType<typeof result, Generator<DString.ExtractOutput<"order-42/order-43">>, "strict">;
+
+const piped = DCommon.pipe(
+	"order-42/order-43",
+	DString.extractAll(/order-\d+/g),
+);
+// La forme curifiée conserve le type de la chaîne d'origine dans chaque extraction.
+type _CheckPiped = DCommon.ExpectType<typeof piped, Generator<DString.ExtractOutput<"order-42/order-43">>, "strict">;

package/docs/API/10-lang/10-string/10-first.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.first
+ *
+ * Lire le premier caractère d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.first("hello");
+// La valeur obtenue est "h".
+type _CheckResult = DCommon.ExpectType<typeof result, "h", "strict">;
+
+const piped = DCommon.pipe(
+	"hello",
+	DString.first,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "h", "strict">;

package/docs/API/10-lang/10-string/10-includes.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DString.includes
+ *
+ * Tester si une chaîne contient une sous-chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.includes("hello world", "world");
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.includes(value, "world")) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, `${string}world${string}`, "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.includes("world"),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, `${string}world${string}`, "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la chaîne affinée pour calculer sa longueur.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-indexOf.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.indexOf
+ *
+ * Retourner la position d'une sous-chaîne, ou `undefined` si elle est absente.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.indexOf("hello world", "world");
+// La valeur obtenue est 6.
+type _CheckResult = DCommon.ExpectType<typeof result, number | undefined, "strict">;
+
+const piped = DCommon.pipe(
+	"hello world",
+	DString.indexOf("world"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, number | undefined, "strict">;

package/docs/API/10-lang/10-string/10-isComposedOf.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DString.isComposedOf
+ *
+ * Vérifier qu'une chaîne ne contient que des caractères appartenant à une ou plusieurs plages.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.isComposedOf("abc123", ["a-z", "0-9"]);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.isComposedOf(value, "a-z")) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, string & DString.AllowedCharacters<"a-z">, "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.isComposedOf("a-z"),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, string & DString.AllowedCharacters<"a-z">, "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la chaîne affinée pour calculer sa longueur.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-isEmail.ts

@@ -0,0 +1,56 @@
+/**
+ * @title DString.isEmail
+ *
+ * Vérifier qu'une chaîne respecte le format d'une adresse e-mail.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DArray from "@duplojs/lang/array";
+import * as DString from "@duplojs/lang/string";
+
+declare const value: string;
+
+if (DString.isEmail(value)) {
+	// Le test établit la contrainte Email dans cette branche.
+	type _CheckValue = DCommon.ExpectType<typeof value, string & DString.Email, "strict">;
+}
+
+const result = DString.isEmail("contact@duplojs.dev");
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// `Email` est établi dans la branche, mais `split` ne peut pas déduire le séparateur
+// depuis cette contrainte : pour une entrée typée `string`, il garantit au moins un fragment.
+const emailParts = DString.split(value, "@");
+type _CheckEmailParts = DCommon.ExpectType<
+	typeof emailParts,
+	readonly string[] & DArray.MinElements<1>,
+	"strict"
+>;
+
+if (DString.isEmail(value)) {
+	type _CheckEmail = DCommon.ExpectType<typeof value, string & DString.Email, "strict">;
+	const parts = DString.split(value, "@");
+	type _CheckParts = DCommon.ExpectType<
+		typeof parts,
+		readonly string[] & DArray.MinElements<2>,
+		"strict"
+	>;
+}
+
+// Le même contrôle s’insère dans un pipe ; la longueur des fragments reste garantie.
+const partCount = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.isEmail,
+		(email) => {
+			type _CheckEmail = DCommon.ExpectType<typeof email, string & DString.Email, "strict">;
+
+			return DString.split(email, "@");
+		},
+	),
+);
+type _CheckPartCount = DCommon.ExpectType<
+	typeof partCount,
+	string | (readonly string[] & DArray.MinElements<2>),
+	"strict"
+>;

package/docs/API/10-lang/10-string/10-isIn.ts

@@ -0,0 +1,34 @@
+/**
+ * @title DString.isIn
+ *
+ * Vérifier qu'une chaîne appartient à une collection de valeurs autorisées.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+declare const values: readonly ["draft", "published"];
+const result = DString.isIn("draft", values);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.isIn(value, values)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, "draft" | "published", "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.isIn(values),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, "draft" | "published", "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la valeur réduite à l'union autorisée.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-isKeyof.ts

@@ -0,0 +1,37 @@
+/**
+ * @title DString.isKeyof
+ *
+ * Vérifier qu'une valeur est une clé de l'objet fourni et affiner son type.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+const source = {
+	name: "Alice",
+	email: "alice@example.com",
+};
+const result = DString.isKeyof("name", source);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const key: string;
+
+if (DString.isKeyof(key, source)) {
+	type _CheckIfKey = DCommon.ExpectType<typeof key, "name" | "email", "strict">;
+	const length = DString.length(key);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	key,
+	DCommon.when(
+		DString.isKeyof(source),
+		(key) => {
+			type _CheckKey = DCommon.ExpectType<typeof key, "name" | "email", "strict">;
+			return DString.length(key);
+		},
+	),
+);
+// La branche vraie peut exploiter la clé réduite aux propriétés de l'objet.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;