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

package/README.md

@@ -14,24 +14,24 @@ Read the relevant pages by resolving their links relative to the summary. Before
 
 Use each API domain's `index.llms.md` to find a public function by its exported namespace and name, such as `DArray.map` in [`docs/API/10-lang/10-array/index.llms.md`](docs/API/10-lang/10-array/index.llms.md). The other current domains are [Chrono](docs/API/10-lang/10-chrono/index.llms.md), [Common](docs/API/10-lang/10-common/index.llms.md), [DataStructure](docs/API/10-lang/10-dataStructure/index.llms.md), [Either](docs/API/10-lang/10-either/index.llms.md), and [Generator](docs/API/10-lang/10-generator/index.llms.md). API sources are primarily TypeScript files combining descriptions and typed usage examples. Each summary exposes their headers and links to those files.
 
-The `install` command creates symbolic links to the package's skills by default.
+The `install-skill` command creates symbolic links to the package's skills by default.
 The boolean `--copy` option copies the skills instead.
 Each installation removes the skill's destination and replaces it with the requested copy or link. The target of any existing symbolic link is preserved.
 
 ```sh
-pnpm exec duplojs-agents-kit install
-pnpm exec duplojs-agents-kit install http-server --type codex
-pnpm exec duplojs-agents-kit install http-client --copy
-pnpm exec duplojs-agents-kit install command --type codex
-pnpm exec duplojs-agents-kit install server --type codex
-pnpm exec duplojs-agents-kit install modeling --type codex
-pnpm exec duplojs-agents-kit install test --type codex
+pnpm exec duplojs-agents-kit install-skill
+pnpm exec duplojs-agents-kit install-skill http-server --type codex
+pnpm exec duplojs-agents-kit install-skill http-client --copy
+pnpm exec duplojs-agents-kit install-skill command --type codex
+pnpm exec duplojs-agents-kit install-skill server --type codex
+pnpm exec duplojs-agents-kit install-skill modeling --type codex
+pnpm exec duplojs-agents-kit install-skill test --type codex
 ```
 
 Two independently installable skills cover HTTP:
 
-- `http-server` (`duplojs-http-server`) guides server setup, routes, reusable flows, and contract and schema generation.
-- `http-client` (`duplojs-http-client`) guides typed calls to DuploJS or external APIs, response expectations, hooks, Predicted mode, SSE, and streams. It accepts generated or handwritten route types.
+- `http-server` (`duplojs-http-server`) guides server setup, routes, and reusable flows.
+- `http-client` (`duplojs-http-client`) guides typed calls to DuploJS or external APIs, response expectations, hooks, Predicted mode, SSE, and streams.
 
 The `server` skill (`duplojs-server`) guides filesystem operations, typed I/O errors, file and folder structures, environment configuration, and process capabilities through `@duplojs/server`. It prioritizes the package's runtime abstractions and distinguishes the process working directory from the module directory.
 
@@ -39,7 +39,7 @@ The `modeling` skill (`duplojs-modeling`) guides business system modeling and im
 
 The `test` skill (`duplojs-test`) guides testing DuploJS results and type contracts, selecting expected Either information, monitoring new result variants with exhaustive selectors, and isolating server dependencies through `TESTImplementation`. It also points to the concepts for organizing E2E tests with `@duplojs/playwright`.
 
-The `command` skill guides the creation of typed CLI commands with `@duplojs/server/command`, including arguments, options, subcommands, help, and executable entry points. Running `install` without a skill installs all supported skills. References and checked TypeScript examples are included in both copied and linked installations.
+The `command` skill guides the creation of typed CLI commands with `@duplojs/server/command`, including arguments, options, subcommands, help, and executable entry points. Running `install-skill` without a skill installs all supported skills. References and checked TypeScript examples are included in both copied and linked installations.
 
 The `setup` command creates `AGENTS.md` by default, or `CLAUDE.md` with `--type claude`, in the current project if needed and synchronizes a marked coding conventions block while preserving the surrounding content:
 

package/dist/bin/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { installCommand } from "./install/index.mjs";
+import { installSkillCommand } from "./installSkill/index.mjs";
 import { setupCommand } from "./setup/index.mjs";
 import * as DSCommand from "@duplojs/server/command";
 //#region scripts/bin/index.ts
-await DSCommand.exec({ subjects: [installCommand, setupCommand] }, () => {});
+await DSCommand.exec({ subjects: [installSkillCommand, setupCommand] }, () => {});
 //#endregion

package/dist/bin/installSkill/index.d.ts

@@ -0,0 +1,2 @@
+import * as DSCommand from "@duplojs/server/command";
+export declare const installSkillCommand: DSCommand.Command<"install-skill">;

package/dist/bin/{install → installSkill}/index.mjs

@@ -7,8 +7,8 @@ import * as DPath from "@duplojs/lang/path";
 import * as DSFile from "@duplojs/server/file";
 import * as DEither from "@duplojs/lang/either";
 import * as DArray from "@duplojs/lang/array";
-//#region scripts/bin/install/index.ts
-const installCommand = DSCommand.create("install", {
+//#region scripts/bin/installSkill/index.ts
+const installSkillCommand = DSCommand.create("install-skill", {
 	options: [DSCommand.createBooleanOption("copy", { description: "Copy skills instead of creating symbolic links" }), DSCommand.createOption("type", DDataStructure.literal(AgentTypeEnum.toTuple()))],
 	subjects: [DSCommand.createArgument("skill", DDataStructure.literal(SkillEnum.toTuple()), { optional: true })]
 }, async ({ args, options }) => {
@@ -22,4 +22,4 @@ const installCommand = DSCommand.create("install", {
 	await DEither.rightAsyncPipe(DSFile.readDirectory(skillsPath), DArray.filter(SkillEnum.has), DArray.map((value) => installSkill(agentType, value)), DCommon.promiseAll);
 });
 //#endregion
-export { installCommand };
+export { installSkillCommand };

package/dist/bin/{install → installSkill}/skill.mjs

@@ -5,7 +5,7 @@ import * as DSCommon from "@duplojs/server/common";
 import * as DSFile from "@duplojs/server/file";
 import * as DEither from "@duplojs/lang/either";
 import * as DPattern from "@duplojs/lang/pattern";
-//#region scripts/bin/install/skill.ts
+//#region scripts/bin/installSkill/skill.ts
 const AgentTypeEnum = DCommon.createEnum([
 	"default",
 	"claude",

package/dist/bin/setup/instructions.d.ts

@@ -4,5 +4,5 @@ import type * as DPath from "@duplojs/lang/path";
 declare const InvalidInstructionsMarkersError_base: abstract new (error: string) => DCommon.DuploJSError<"agents-kit-invalid-instructions-markers", string> & import('@duplojs/lang/kind').Kind<import('@duplojs/lang/kind').Handler<import('@duplojs/lang/kind').Definition<"@DuplojsLangCommon/duplojs-error-agents-kit-invalid-instructions-markers", unknown>>, unknown>;
 export declare class InvalidInstructionsMarkersError extends InvalidInstructionsMarkersError_base {
 }
-export declare function synchronizeInstructions(content: string, instructions: string, packagePath: string & DPath.Path): DEither.Left<"agents-kit-invalid-instructions-markers", InvalidInstructionsMarkersError> | DEither.Success<string>;
+export declare function synchronizeInstructions(content: string, instructions: string, packagePath: DPath.AnyPath): DEither.Left<"agents-kit-invalid-instructions-markers", InvalidInstructionsMarkersError> | DEither.Success<string>;
 export {};

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

@@ -6,12 +6,12 @@
 import * as DArray from "@duplojs/lang/array";
 import * as DCommon from "@duplojs/lang/common";
 
-const colors = ["red", "green", "blue"] as const;
+declare const colors: readonly ["red", "green", "blue"];
 
 // Appel classique : l’index couvert renvoie l’union des éléments du tableau.
 const color = DArray.at(colors, 1);
 
-// La valeur obtenue est « green » au runtime, mais le type conserve les trois valeurs possibles.
+// La valeur obtenue est l’un des trois éléments du tuple.
 type _CheckColor = DCommon.ExpectType<
 	typeof color,
 	"red" | "green" | "blue",
@@ -24,7 +24,7 @@ const firstColor = DCommon.pipe(
 	DArray.at(0),
 );
 
-// La valeur obtenue est « red » au runtime.
+// La valeur obtenue est le premier élément du tuple.
 type _CheckFirstColor = DCommon.ExpectType<
 	typeof firstColor,
 	"red" | "green" | "blue",
@@ -34,7 +34,7 @@ type _CheckFirstColor = DCommon.ExpectType<
 // Un index littéral hors limites est identifié statiquement.
 const missingColor = DArray.at(colors, 3);
 
-// La valeur obtenue est undefined au runtime.
+// Un index connu hors limites produit undefined.
 type _CheckMissingColor = DCommon.ExpectType<
 	typeof missingColor,
 	undefined,

package/docs/API/10-lang/10-array/10-coalescing.ts

@@ -13,7 +13,8 @@ const value = DArray.coalescing(42);
 type _CheckValue = DCommon.ExpectType<typeof value, readonly [42], "strict">;
 
 // Un tableau est conservé avec sa forme et ses éléments.
-const array = DArray.coalescing([1, 2] as const);
+declare const input: readonly [1, 2];
+const array = DArray.coalescing(input);
 
 // La valeur obtenue est [1, 2].
-type _CheckArray = DCommon.ExpectType<typeof array, [1, 2], "strict">;
+type _CheckArray = DCommon.ExpectType<typeof array, readonly [1, 2], "strict">;

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

@@ -6,7 +6,7 @@
 import * as DArray from "@duplojs/lang/array";
 import * as DCommon from "@duplojs/lang/common";
 
-const values = ["a", "b", "a"] as const;
+const values = ["a", "b", "a"];
 
 // Appel classique : la recherche commence au début par défaut.
 const result = DArray.indexOf(values, "a");

package/docs/API/10-lang/10-array/10-is.ts

@@ -4,12 +4,26 @@
  * Vérifier au runtime qu’une valeur est un tableau et affiner son type TypeScript.
  */
 import * as DArray from "@duplojs/lang/array";
-import type * as DCommon from "@duplojs/lang/common";
+import * as DCommon from "@duplojs/lang/common";
 
-declare const input: unknown;
+declare const input: DCommon.AnyValue;
 
 // Le test runtime réussit uniquement pour une valeur qui est effectivement un tableau.
 if (DArray.is(input)) {
 	// Dans cette branche, input est affiné en tableau de valeurs inconnues.
-	type _CheckInput = DCommon.ExpectType<typeof input, readonly unknown[], "strict">;
+	type _CheckInput = DCommon.ExpectType<typeof input, DCommon.AnyValue[], "strict">;
 }
+
+// Dans un pipe, le même predicate unaire fournit le tableau à l’étape de traitement.
+const first = DCommon.pipe(
+	input,
+	DCommon.when(
+		DArray.is,
+		(array) => {
+			type _CheckArray = DCommon.ExpectType<typeof array, DCommon.AnyValue[], "strict">;
+
+			return DArray.first(array);
+		},
+	),
+);
+type _CheckFirst = DCommon.ExpectType<typeof first, DCommon.AnyValue | undefined, "strict">;

package/docs/API/10-lang/10-array/10-lastIndexOf.ts

@@ -6,7 +6,7 @@
 import * as DArray from "@duplojs/lang/array";
 import * as DCommon from "@duplojs/lang/common";
 
-const values = ["a", "b", "a"] as const;
+const values = ["a", "b", "a"];
 
 // Appel classique : la recherche commence à la fin par défaut.
 const result = DArray.lastIndexOf(values, "a");

package/docs/API/10-lang/10-chrono/10-addTime.ts

@@ -15,7 +15,7 @@ type _CheckTime = DCommon.ExpectType<typeof timeResult, DChrono.TheTime, "strict
 
 // La forme curifiée s’applique aussi dans un pipe.
 const piped = DCommon.pipe(
-	"time1000+" as const,
+	"time1000+",
 	DChrono.addTime("time500+"),
 );
 type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheTime, "strict">;

package/docs/API/10-lang/10-chrono/10-closestTo.ts

@@ -6,10 +6,7 @@
 import * as DChrono from "@duplojs/lang/chrono";
 import * as DCommon from "@duplojs/lang/common";
 
-const dates = [
-	DChrono.createDate("2021-01-10"),
-	DChrono.createDate("2021-01-20"),
-] as const;
+declare const dates: readonly [DChrono.TheDate, DChrono.TheDate];
 const target = DChrono.createDate("2021-01-15");
 
 const closest = DChrono.closestTo(dates, target);
@@ -33,10 +30,10 @@ const piped = DCommon.pipe(
 type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate | undefined, "strict">;
 
 // Les collections peuvent mélanger TheDate et dates sérialisées.
-const mixedDates = [
-	"date1609459200000+",
-	DChrono.createDate("2021-01-10"),
-] as const;
+declare const mixedDates: readonly [
+	DChrono.TheDate | DChrono.SerializedTheDate,
+	DChrono.TheDate | DChrono.SerializedTheDate,
+];
 const mixedClosest = DChrono.closestTo(
 	mixedDates,
 	"date1609804800000+",

package/docs/API/10-lang/10-chrono/10-isDate.ts

@@ -4,9 +4,9 @@
  * Identifier si une valeur est une instance de TheDate et réduire son type.
  */
 import * as DChrono from "@duplojs/lang/chrono";
-import type * as DCommon from "@duplojs/lang/common";
+import * as DCommon from "@duplojs/lang/common";
 
-const value: unknown = DChrono.createDate("2021-01-15");
+declare const value: DCommon.AnyValue;
 const isDate = DChrono.isDate(value);
 
 // Le résultat indique si la valeur est une TheDate.
@@ -21,3 +21,16 @@ if (DChrono.isDate(value)) {
 	type _CheckNarrowed = DCommon.ExpectType<typeof timestamp, number, "strict">;
 }
 
+// Le predicate unaire peut aussi établir TheDate dans le callback d’un pipe.
+const timestamp = DCommon.pipe(
+	value,
+	DCommon.when(
+		DChrono.isDate,
+		(date) => {
+			type _CheckDate = DCommon.ExpectType<typeof date, DChrono.TheDate, "strict">;
+
+			return DChrono.toTimestamp(date);
+		},
+	),
+);
+type _CheckTimestamp = DCommon.ExpectType<typeof timestamp, DCommon.AnyValue, "strict">;

package/docs/API/10-lang/10-chrono/10-isSerializedTheDate.ts

@@ -4,7 +4,7 @@
  * Vérifier qu’une chaîne respecte le format sérialisé sûr d’une TheDate.
  */
 import * as DChrono from "@duplojs/lang/chrono";
-import type * as DCommon from "@duplojs/lang/common";
+import * as DCommon from "@duplojs/lang/common";
 
 const value = "date1609459200000+";
 const isSerialized = DChrono.isSerializedTheDate(value);
@@ -24,3 +24,18 @@ if (DChrono.isSerializedTheDate(value)) {
 	type _CheckNarrowed = DCommon.ExpectType<typeof timestamp, number, "strict">;
 }
 
+declare const checkedValue: string;
+
+// Le pipe valide la chaîne avant de la convertir en timestamp.
+const timestamp = DCommon.pipe(
+	checkedValue,
+	DCommon.when(
+		DChrono.isSerializedTheDate,
+		(serializedDate) => {
+			type _CheckDate = DCommon.ExpectType<typeof serializedDate, DChrono.SerializedTheDate, "strict">;
+
+			return DChrono.toTimestamp(serializedDate);
+		},
+	),
+);
+type _CheckTimestamp = DCommon.ExpectType<typeof timestamp, string | number, "strict">;

package/docs/API/10-lang/10-chrono/10-isSerializedTheTime.ts

@@ -4,7 +4,7 @@
  * Vérifier qu’une chaîne respecte le format sérialisé sûr d’une TheTime.
  */
 import * as DChrono from "@duplojs/lang/chrono";
-import type * as DCommon from "@duplojs/lang/common";
+import * as DCommon from "@duplojs/lang/common";
 
 const value = "time90000+";
 const isSerialized = DChrono.isSerializedTheTime(value);
@@ -24,3 +24,18 @@ if (DChrono.isSerializedTheTime(value)) {
 	type _CheckNarrowed = DCommon.ExpectType<typeof timeValue, number, "strict">;
 }
 
+declare const checkedValue: string;
+
+// Le pipe valide la chaîne avant de lire sa valeur temporelle.
+const timeValue = DCommon.pipe(
+	checkedValue,
+	DCommon.when(
+		DChrono.isSerializedTheTime,
+		(serializedTime) => {
+			type _CheckTime = DCommon.ExpectType<typeof serializedTime, DChrono.SerializedTheTime, "strict">;
+
+			return DChrono.toTimeValue(serializedTime);
+		},
+	),
+);
+type _CheckTimeValue = DCommon.ExpectType<typeof timeValue, string | number, "strict">;

package/docs/API/10-lang/10-chrono/10-isTime.ts

@@ -4,9 +4,9 @@
  * Identifier si une valeur est une instance de TheTime et réduire son type.
  */
 import * as DChrono from "@duplojs/lang/chrono";
-import type * as DCommon from "@duplojs/lang/common";
+import * as DCommon from "@duplojs/lang/common";
 
-const value: unknown = DChrono.createTimeOrThrow(90_000);
+declare const value: DCommon.AnyValue;
 const isTime = DChrono.isTime(value);
 
 // Le résultat indique si la valeur est une TheTime.
@@ -21,3 +21,16 @@ if (DChrono.isTime(value)) {
 	type _CheckNarrowed = DCommon.ExpectType<typeof timeValue, number, "strict">;
 }
 
+// Le predicate unaire peut aussi établir TheTime dans le callback d’un pipe.
+const timeValue = DCommon.pipe(
+	value,
+	DCommon.when(
+		DChrono.isTime,
+		(time) => {
+			type _CheckTime = DCommon.ExpectType<typeof time, DChrono.TheTime, "strict">;
+
+			return DChrono.toTimeValue(time);
+		},
+	),
+);
+type _CheckTimeValue = DCommon.ExpectType<typeof timeValue, DCommon.AnyValue, "strict">;

package/docs/API/10-lang/10-chrono/10-maxDate.ts

@@ -6,18 +6,14 @@
 import * as DChrono from "@duplojs/lang/chrono";
 import type * as DCommon from "@duplojs/lang/common";
 
-const latest = DChrono.maxDate([
-	DChrono.createDate("2021-01-01"),
-	DChrono.createDate("2021-01-15"),
-] as const);
+declare const dates: [DChrono.TheDate, DChrono.TheDate];
+const latest = DChrono.maxDate(dates);
 
 // La valeur obtenue est la date du 15 janvier.
 type _CheckLatest = DCommon.ExpectType<typeof latest, DChrono.TheDate, "strict">;
 
 // Les éléments peuvent être un mélange de TheDate et de dates sérialisées.
-const latestMixed = DChrono.maxDate([
-	"date1609459200000+",
-	DChrono.createDate("2021-01-15"),
-] as const);
+declare const mixedDates: [DChrono.TheDate | DChrono.SerializedTheDate, DChrono.TheDate | DChrono.SerializedTheDate];
+const latestMixed = DChrono.maxDate(mixedDates);
 type _CheckMixed = DCommon.ExpectType<typeof latestMixed, DChrono.TheDate, "strict">;
 

package/docs/API/10-lang/10-chrono/10-maxTime.ts

@@ -6,18 +6,14 @@
 import * as DChrono from "@duplojs/lang/chrono";
 import type * as DCommon from "@duplojs/lang/common";
 
-const longest = DChrono.maxTime([
-	DChrono.createTimeOrThrow(1_000),
-	DChrono.createTimeOrThrow(2_000),
-] as const);
+declare const times: [DChrono.TheTime, DChrono.TheTime];
+const longest = DChrono.maxTime(times);
 
 // La valeur obtenue représente 2 000 millisecondes.
 type _CheckLongest = DCommon.ExpectType<typeof longest, DChrono.TheTime, "strict">;
 
 // Les éléments peuvent être un mélange de TheTime et de durées sérialisées.
-const longestMixed = DChrono.maxTime([
-	"time1000+",
-	DChrono.createTimeOrThrow(2_000),
-] as const);
+declare const mixedTimes: [DChrono.TheTime | DChrono.SerializedTheTime, DChrono.TheTime | DChrono.SerializedTheTime];
+const longestMixed = DChrono.maxTime(mixedTimes);
 type _CheckMixed = DCommon.ExpectType<typeof longestMixed, DChrono.TheTime, "strict">;
 

package/docs/API/10-lang/10-chrono/10-minDate.ts

@@ -6,18 +6,14 @@
 import * as DChrono from "@duplojs/lang/chrono";
 import type * as DCommon from "@duplojs/lang/common";
 
-const earliest = DChrono.minDate([
-	DChrono.createDate("2021-01-15"),
-	DChrono.createDate("2021-01-01"),
-] as const);
+declare const dates: [DChrono.TheDate, DChrono.TheDate];
+const earliest = DChrono.minDate(dates);
 
 // La valeur obtenue est la date du 1er janvier.
 type _CheckEarliest = DCommon.ExpectType<typeof earliest, DChrono.TheDate, "strict">;
 
 // Les éléments peuvent être un mélange de TheDate et de dates sérialisées.
-const earliestMixed = DChrono.minDate([
-	"date1609459200000+",
-	DChrono.createDate("2021-01-15"),
-] as const);
+declare const mixedDates: [DChrono.TheDate | DChrono.SerializedTheDate, DChrono.TheDate | DChrono.SerializedTheDate];
+const earliestMixed = DChrono.minDate(mixedDates);
 type _CheckMixed = DCommon.ExpectType<typeof earliestMixed, DChrono.TheDate, "strict">;
 

package/docs/API/10-lang/10-chrono/10-minTime.ts

@@ -6,18 +6,14 @@
 import * as DChrono from "@duplojs/lang/chrono";
 import type * as DCommon from "@duplojs/lang/common";
 
-const shortest = DChrono.minTime([
-	DChrono.createTimeOrThrow(1_000),
-	DChrono.createTimeOrThrow(2_000),
-] as const);
+declare const times: [DChrono.TheTime, DChrono.TheTime];
+const shortest = DChrono.minTime(times);
 
 // La valeur obtenue représente 1 000 millisecondes.
 type _CheckShortest = DCommon.ExpectType<typeof shortest, DChrono.TheTime, "strict">;
 
 // Les éléments peuvent être un mélange de TheTime et de durées sérialisées.
-const shortestMixed = DChrono.minTime([
-	"time1000+",
-	DChrono.createTimeOrThrow(2_000),
-] as const);
+declare const mixedTimes: [DChrono.TheTime | DChrono.SerializedTheTime, DChrono.TheTime | DChrono.SerializedTheTime];
+const shortestMixed = DChrono.minTime(mixedTimes);
 type _CheckMixed = DCommon.ExpectType<typeof shortestMixed, DChrono.TheTime, "strict">;
 

package/docs/API/10-lang/10-chrono/10-sortDates.ts

@@ -7,10 +7,7 @@ import * as DArray from "@duplojs/lang/array";
 import * as DChrono from "@duplojs/lang/chrono";
 import * as DCommon from "@duplojs/lang/common";
 
-const dates = [
-	DChrono.createDate("2021-01-15"),
-	DChrono.createDate("2021-01-01"),
-] as const;
+declare const dates: readonly [DChrono.TheDate, DChrono.TheDate];
 const ascending = DChrono.sortDates(dates, "ASC");
 
 // La nouvelle collection est triée du 1er au 15 janvier.
@@ -24,9 +21,10 @@ const descending = DCommon.pipe(
 type _CheckDescending = DCommon.ExpectType<typeof descending, DChrono.TheDate[], "strict">;
 
 // Une collection peut mélanger dates sérialisées et TheDate.
-const mixed = DChrono.sortDates([
-	"date1609545600000+",
-	DChrono.createDate("2021-01-01"),
-] as const, "ASC");
+declare const mixedDates: readonly [
+	DChrono.TheDate | DChrono.SerializedTheDate,
+	DChrono.TheDate | DChrono.SerializedTheDate,
+];
+const mixed = DChrono.sortDates(mixedDates, "ASC");
 type _CheckMixed = DCommon.ExpectType<typeof mixed, DChrono.TheDate[], "strict">;
 

package/docs/API/10-lang/10-chrono/10-sortTimes.ts

@@ -6,10 +6,7 @@
 import * as DChrono from "@duplojs/lang/chrono";
 import * as DCommon from "@duplojs/lang/common";
 
-const times = [
-	DChrono.createTimeOrThrow(2_000),
-	DChrono.createTimeOrThrow(1_000),
-] as const;
+declare const times: readonly [DChrono.TheTime, DChrono.TheTime];
 const ascending = DChrono.sortTimes(times, "ASC");
 
 // La nouvelle collection est triée de 1 000 à 2 000 millisecondes.
@@ -23,9 +20,10 @@ const descending = DCommon.pipe(
 type _CheckDescending = DCommon.ExpectType<typeof descending, DChrono.TheTime[], "strict">;
 
 // Une collection peut mélanger durées sérialisées et TheTime.
-const mixed = DChrono.sortTimes([
-	"time2000+",
-	DChrono.createTimeOrThrow(1_000),
-] as const, "ASC");
+declare const mixedTimes: readonly [
+	DChrono.TheTime | DChrono.SerializedTheTime,
+	DChrono.TheTime | DChrono.SerializedTheTime,
+];
+const mixed = DChrono.sortTimes(mixedTimes, "ASC");
 type _CheckMixed = DCommon.ExpectType<typeof mixed, DChrono.TheTime[], "strict">;
 

package/docs/API/10-lang/10-chrono/10-subtractTime.ts

@@ -15,7 +15,7 @@ type _CheckTime = DCommon.ExpectType<typeof timeResult, DChrono.TheTime, "strict
 
 // La forme curifiée s’applique aussi dans un pipe.
 const piped = DCommon.pipe(
-	"date1000+" as const,
+	"date1000+",
 	DChrono.subtractTime("time500+"),
 );
 type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;

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

@@ -17,6 +17,12 @@ type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
 
 declare const source: string | number;
 
+if (DCommon.and(source, [DCommon.isType("string"), DCommon.truthy])) {
+	type _CheckIfValue = DCommon.ExpectType<typeof source, string, "strict">;
+	const uppercase = DString.toUpperCase(source);
+	type _CheckUppercase = DCommon.ExpectType<typeof uppercase, Uppercase<string>, "strict">;
+}
+
 // Appel curifié : le predicate composé est passé directement à DCommon.when.
 const transformed = DCommon.pipe(
 	source,

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

@@ -4,13 +4,14 @@
  * Créer une file d’attente typée avec une capacité optionnelle.
  */
 import * as DCommon from "@duplojs/lang/common";
+import type * as DEither from "@duplojs/lang/either";
 
 const queue = DCommon.createQueue({ concurrency: 1 });
 const result = queue.add(() => "done");
 
-// Chaque tâche est exécutée dans une Promise et ses erreurs sont représentées par un Left.
+// Le résultat contient la valeur de la tâche, ou un Left si son exécution lève une erreur.
 type _CheckResult = DCommon.ExpectType<
 	typeof result,
-	Promise<"done">,
-	"two-extends-one"
+	Promise<string | DEither.Left<"execution-error", unknown>>,
+	"strict"
 >;

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

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

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

@@ -14,6 +14,12 @@ type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
 
 declare const source: string | number;
 
+if (DCommon.equal(source, "value")) {
+	type _CheckIfValue = DCommon.ExpectType<typeof source, "value", "strict">;
+	const uppercase = DString.toUpperCase(source);
+	type _CheckUppercase = DCommon.ExpectType<typeof uppercase, "VALUE", "strict">;
+}
+
 // Appel curifié : le prédicat est passé directement à DCommon.when.
 const transformed = DCommon.pipe(
 	source,

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

@@ -10,3 +10,22 @@ const result = DCommon.falsy(input);
 
 // Le prédicat produit un booléen et distingue la branche falsy de l’union.
 type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// L’appel direct expose la branche falsy dans le if.
+if (DCommon.falsy(input)) {
+	type _CheckInput = DCommon.ExpectType<typeof input, "" | null, "strict">;
+}
+
+// Le predicate unaire s’utilise directement avec DCommon.when.
+const preserved = DCommon.pipe(
+	input,
+	DCommon.when(
+		DCommon.falsy,
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, "" | null, "strict">;
+
+			return DCommon.forward(value);
+		},
+	),
+);
+type _CheckPreserved = DCommon.ExpectType<typeof preserved, string | null, "strict">;

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

@@ -4,6 +4,7 @@
  * Créer un prédicat basé sur un constructeur avec narrowing de l’instance.
  */
 import * as DCommon from "@duplojs/lang/common";
+import * as DChrono from "@duplojs/lang/chrono";
 
 declare const input: Date | string;
 const result = DCommon.instanceOf(input, Date);
@@ -11,13 +12,23 @@ const result = DCommon.instanceOf(input, Date);
 // Le test runtime produit un booléen.
 type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
 
+if (DCommon.instanceOf(input, Date)) {
+	type _CheckInput = DCommon.ExpectType<typeof input, Date, "strict">;
+	const chronoDate = DChrono.createDateOrThrow(input);
+	type _CheckChronoDate = DCommon.ExpectType<typeof chronoDate, DChrono.TheDate, "strict">;
+}
+
 // La forme curifiée s’utilise directement comme predicate dans DCommon.when.
-const preserved = DCommon.pipe(
+const converted = DCommon.pipe(
 	input,
 	DCommon.when(
 		DCommon.instanceOf(Date),
-		DCommon.forward,
+		(date) => {
+			type _CheckDate = DCommon.ExpectType<typeof date, Date, "strict">;
+
+			return DChrono.createDateOrThrow(date);
+		},
 	),
 );
 
-type _CheckPreserved = DCommon.ExpectType<typeof preserved, Date | string, "strict">;
+type _CheckConverted = DCommon.ExpectType<typeof converted, DChrono.TheDate | string, "strict">;

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

@@ -12,6 +12,12 @@ declare const input: string | number;
 const result = DCommon.isType(input, "string");
 type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
 
+if (DCommon.isType(input, "string")) {
+	type _CheckInput = DCommon.ExpectType<typeof input, string, "strict">;
+	const uppercase = DString.toUpperCase(input);
+	type _CheckUppercase = DCommon.ExpectType<typeof uppercase, Uppercase<string>, "strict">;
+}
+
 // Appel curifié : le predicate est passé directement à DCommon.when.
 const transformed = DCommon.pipe(
 	input,