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

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/facts/cancel.ts

@@ -0,0 +1,26 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DCommon from "@duplojs/lang/common";
+import { WaitingListEntry } from "..";
+
+export const CancelWaitingListEntryFact = DModeling.createFact<
+	"CancelWaitingListEntry",
+	WaitingListEntry.CancelledState,
+	typeof WaitingListEntry.Entity
+>("CancelWaitingListEntry")(
+	({ applyFact }) => (
+		params: {
+			waitingListEntry: WaitingListEntry.Entity & (WaitingListEntry.PendingFlag | WaitingListEntry.ReadyFlag);
+			reason: WaitingListEntry.CancelledState["reason"];
+		},
+	) => {
+		const state = WaitingListEntry.CancelledState.new({ reason: params.reason });
+
+		return DCommon.pipe(
+			params.waitingListEntry,
+			WaitingListEntry.Entity.update({ state }),
+			WaitingListEntry.CancelledFlag.append(state),
+			applyFact(state),
+		);
+	},
+);
+export type CancelWaitingListEntryFact = DModeling.GetFact<typeof CancelWaitingListEntryFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/facts/create.ts

@@ -0,0 +1,33 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DCommon from "@duplojs/lang/common";
+import { WaitingListEntry } from "..";
+import { type Book } from "../../book";
+import { type Client } from "../../client";
+
+export const CreateWaitingListEntryFact = DModeling.createFact<
+	"CreateWaitingListEntry",
+	WaitingListEntry.PendingState,
+	typeof WaitingListEntry.Entity
+>("CreateWaitingListEntry")(
+	({ applyFact }) => (params: {
+		id: WaitingListEntry.Id;
+		book: Book.Entity & (Book.AvailableFlag | Book.BorrowedFlag | Book.ReservedFlag);
+		client: Client.Entity;
+		requestedAt: WaitingListEntry.RequestedAt;
+	}) => {
+		const state = WaitingListEntry.PendingState.new({});
+
+		return DCommon.pipe(
+			WaitingListEntry.Entity.new({
+				id: params.id,
+				bookId: params.book.id,
+				clientId: params.client.id,
+				requestedAt: params.requestedAt,
+				state,
+			}),
+			WaitingListEntry.PendingFlag.append(state),
+			applyFact(state),
+		);
+	},
+);
+export type CreateWaitingListEntryFact = DModeling.GetFact<typeof CreateWaitingListEntryFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/facts/index.ts

@@ -0,0 +1,3 @@
+export * from "./create";
+export * from "./prepare";
+export * from "./cancel";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/facts/prepare.ts

@@ -0,0 +1,23 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DCommon from "@duplojs/lang/common";
+import { WaitingListEntry } from "..";
+
+export const PrepareWaitingListEntryFact = DModeling.createFact<
+	"PrepareWaitingListEntry",
+	WaitingListEntry.ReadyState,
+	typeof WaitingListEntry.Entity
+>("PrepareWaitingListEntry")(
+	({ applyFact }) => (
+		waitingListEntry: WaitingListEntry.Entity & WaitingListEntry.PendingFlag,
+	) => {
+		const state = WaitingListEntry.ReadyState.new({});
+
+		return DCommon.pipe(
+			waitingListEntry,
+			WaitingListEntry.Entity.update({ state }),
+			WaitingListEntry.ReadyFlag.append(state),
+			applyFact(state),
+		);
+	},
+);
+export type PrepareWaitingListEntryFact = DModeling.GetFact<typeof PrepareWaitingListEntryFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/index.ts

@@ -0,0 +1,79 @@
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DEither from "@duplojs/lang/either";
+import { Book } from "../book";
+import { Client } from "../client";
+import { type CreateWaitingListEntryFact, type PrepareWaitingListEntryFact, type CancelWaitingListEntryFact } from "./facts";
+
+export * from "./facts";
+
+export namespace WaitingListEntry {
+	const namespace = DModeling.createEntityNamespace("WaitingListEntry");
+
+	export const Id = namespace.createNewType("Id", DDataStructure.string(), [DDataStructure.uuid()]);
+	export type Id = DDataStructure.StructureValue<typeof Id>;
+
+	export const RequestedAt = namespace.createNewType("RequestedAt", DDataStructure.date());
+	export type RequestedAt = DDataStructure.StructureValue<typeof RequestedAt>;
+
+	export const PendingState = DModeling.createTaggedObject("PendingWaitingListEntryState", {});
+	export type PendingState = DDataStructure.StructureValue<typeof PendingState>;
+
+	export const ReadyState = DModeling.createTaggedObject("ReadyWaitingListEntryState", {});
+	export type ReadyState = DDataStructure.StructureValue<typeof ReadyState>;
+
+	export const CancelledState = DModeling.createTaggedObject("CancelledWaitingListEntryState", {
+		reason: DDataStructure.literal(["book-withdrawn", "client-cancelled"]),
+	});
+	export type CancelledState = DDataStructure.StructureValue<typeof CancelledState>;
+
+	export const Entity = namespace.createEntity(() => ({
+		id: Id,
+		bookId: Book.Id,
+		clientId: Client.Id,
+		requestedAt: RequestedAt,
+		state: DDataStructure.union([PendingState, ReadyState, CancelledState]),
+	}));
+	export type Entity = DDataStructure.StructureValue<typeof Entity>;
+
+	export type Facts = CreateWaitingListEntryFact | PrepareWaitingListEntryFact | CancelWaitingListEntryFact;
+
+	export const PendingFlag = DModeling.createFlag<
+		"PendingWaitingListEntry",
+		PendingState,
+		typeof Entity
+	>("PendingWaitingListEntry");
+	export type PendingFlag = DModeling.GetFlag<typeof PendingFlag>;
+
+	export const ReadyFlag = DModeling.createFlag<
+		"ReadyWaitingListEntry",
+		ReadyState,
+		typeof Entity
+	>("ReadyWaitingListEntry");
+	export type ReadyFlag = DModeling.GetFlag<typeof ReadyFlag>;
+
+	export const CancelledFlag = DModeling.createFlag<
+		"CancelledWaitingListEntry",
+		CancelledState,
+		typeof Entity
+	>("CancelledWaitingListEntry");
+	export type CancelledFlag = DModeling.GetFlag<typeof CancelledFlag>;
+
+	export function refineState<GenericEntity extends Entity>(waitingListEntry: GenericEntity) {
+		return DPattern.matchWithTaggedObject(waitingListEntry.state, {
+			PendingWaitingListEntryState: (state) => DEither.result(
+				"PendingWaitingListEntry",
+				PendingFlag.append(waitingListEntry, state),
+			),
+			ReadyWaitingListEntryState: (state) => DEither.result(
+				"ReadyWaitingListEntry",
+				ReadyFlag.append(waitingListEntry, state),
+			),
+			CancelledWaitingListEntryState: (state) => DEither.result(
+				"CancelledWaitingListEntry",
+				CancelledFlag.append(waitingListEntry, state),
+			),
+		});
+	}
+}

package/docs/concepts/05-type-driven-design/fixtures/business/domains/index.ts

@@ -1,3 +1,4 @@
 export * from "./aggregates";
 export * from "./entities";
+export * from "./refinements";
 export type * from "./repositories";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/refinements/index.ts

@@ -0,0 +1 @@
+export * from "./refineLinkBetweenClientAndBorrowedBook";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/refinements/refineLinkBetweenClientAndBorrowedBook.ts

@@ -0,0 +1,34 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DArray from "@duplojs/lang/array";
+import { Book, type Client } from "../entities";
+import * as DInvocation from "@duplojs/lang/invocation";
+
+export function refineLinkBetweenClientAndBorrowedBook(
+	client: Client.Entity,
+	book: Book.Entity & Book.BorrowedFlag,
+) {
+	if (
+		DArray.includes(client.borrowedBooks, book.id)
+		&& client.id === Book.BorrowedFlag.getPayload(book).currentBorrowerId
+	) {
+		return DCommon.pipe(
+			{
+				client,
+				book,
+			},
+			DInvocation.evidenceResult(
+				"client-with-borrowed-book",
+			),
+		);
+	}
+
+	return DCommon.pipe(
+		{
+			client,
+			book,
+		},
+		DInvocation.evidenceResult(
+			"client-and-book-without-link",
+		),
+	);
+}

package/docs/concepts/05-type-driven-design/fixtures/business/domains/repositories/book.ts

@@ -10,7 +10,7 @@ export interface BookRepository {
 	>;
 	rankAvailability: DInvocation.SignedFunction<
 		"rankAvailability",
-		(params: { book: Book.Entity }) => Promise<void>
+		(book: Book.Entity) => Promise<void>
 	>;
 	findById(id: Book.Id): Promise<DEither.Maybe<Book.Entity>>;
 }

package/docs/concepts/05-type-driven-design/fixtures/business/domains/repositories/index.ts

@@ -1,3 +1,4 @@
 export type * from "./book";
 export type * from "./client";
 export type * from "./email";
+export type * from "./waitingListEntry";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/repositories/waitingListEntry.ts

@@ -0,0 +1,19 @@
+import type * as DInvocation from "@duplojs/lang/invocation";
+import { type Book, type WaitingListEntry } from "../entities";
+
+export interface WaitingListEntryRepository {
+	findNextPendingForBook(book: Book.Entity & Book.AvailableFlag): Promise<
+		| DInvocation.EvidenceResult<"next-pending-waiting-list-entry", {
+			book: Book.Entity & Book.AvailableFlag;
+			waitingListEntry: WaitingListEntry.Entity & WaitingListEntry.PendingFlag;
+		}>
+		| DInvocation.EvidenceResult<"no-pending-waiting-list-entry", {
+			book: Book.Entity & Book.AvailableFlag;
+			waitingListEntry: null;
+		}>
+	>;
+	findAllActiveByBook(book: Book.Entity & Book.WithdrawnFlag): AsyncGenerator<{
+		book: Book.Entity & Book.WithdrawnFlag;
+		waitingListEntry: WaitingListEntry.Entity & (WaitingListEntry.PendingFlag | WaitingListEntry.ReadyFlag);
+	} & DInvocation.Evidence<"active-waiting-list-entry-for-withdrawn-book">>;
+}

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/command/clientRentBook.ts

@@ -43,6 +43,8 @@ export const clientRentBookCommand = DSCommand.create(
 				"book.notfound": true,
 				"client.notfound": true,
 				BorrowedState: true,
+				ReservedState: true,
+				WithdrawnState: true,
 				NoBookRentalSlotsAvailable: true,
 				success: false,
 			})
@@ -51,12 +53,10 @@ export const clientRentBookCommand = DSCommand.create(
 			return;
 		}
 
-		const result = await DCommon.pipe(
+		await DCommon.pipe(
 			inputResult,
 			DEither.unwrapRight,
 			useCases.clientRentBookUseCase,
 		);
-
-		console.log(JSON.stringify(result));
 	},
 );

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/http/checkers/bookExist.ts

@@ -1,4 +1,4 @@
-import { createPresetChecker, ResponseContract, useCheckerBuilder } from "@duplojs/http";
+import { createPresetChecker, useCheckerBuilder } from "@duplojs/http";
 import * as DEither from "@duplojs/lang/either";
 import { type Book } from "../../../business/domains";
 import { bookRepository } from "../../ports";
@@ -15,5 +15,5 @@ export const bookExist = useCheckerBuilder()
 
 export const iWantBookExist = createPresetChecker(bookExist, {
 	result: "book.find",
-	otherwise: ResponseContract.notFound("book.notfound"),
+	otherwise: ({ response }) => response.notFound("book.notfound"),
 });

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/http/checkers/clientExist.ts

@@ -1,4 +1,4 @@
-import { createPresetChecker, ResponseContract, useCheckerBuilder } from "@duplojs/http";
+import { createPresetChecker, useCheckerBuilder } from "@duplojs/http";
 import * as DEither from "@duplojs/lang/either";
 import { type Client } from "../../../business/domains";
 import { clientRepository } from "../../ports";
@@ -15,5 +15,5 @@ export const clientExist = useCheckerBuilder()
 
 export const iWantClientExist = createPresetChecker(clientExist, {
 	result: "client.find",
-	otherwise: ResponseContract.notFound("client.notfound"),
+	otherwise: ({ response }) => response.notFound("client.notfound"),
 });

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/http/routes/clientGiveBackBook.ts

@@ -1,7 +1,6 @@
-import { ResponseContract, useRouteBuilder } from "@duplojs/http";
-import * as DDataStructure from "@duplojs/lang/dataStructure";
+import { useRouteBuilder } from "@duplojs/http";
 import * as DEither from "@duplojs/lang/either";
-import { Book, Client } from "../../../business/domains";
+import { Book, Client, refineLinkBetweenClientAndBorrowedBook } from "../../../business/domains";
 import { useCases } from "../../useCases";
 import { iWantBookExist, iWantClientExist } from "../checkers";
 
@@ -15,23 +14,33 @@ export const clientGiveBackBookRoute = useRouteBuilder("POST", "/book-rentals/re
 	.presetCheck(iWantClientExist.indexing("client"), ({ clientId }) => clientId)
 	.presetCheck(iWantBookExist.indexing("book"), ({ bookId }) => bookId)
 	.cut(
-		ResponseContract.conflict("client.notHaveBook"),
+		({ book }, { response, output }) => DEither.matchInformation(
+			Book.refineState(book),
+			{
+				BorrowedState: (book) => output({ book }),
+				AvailableState: () => response.conflict("book.notBorrowed"),
+				ReservedState: () => response.conflict("book.notBorrowed"),
+				WithdrawnState: () => response.conflict("book.notBorrowed"),
+			},
+		),
+	)
+	.cut(
 		({ client, book }, { response, output }) => DEither.matchInformation(
-			Client.clientHaveBook(client, book),
+			refineLinkBetweenClientAndBorrowedBook(client, book),
 			{
-				"client-have-book": (clientWithFlag) => output({ client: clientWithFlag }),
-				"client-not-have-book": () => response("client.notHaveBook"),
+				"client-with-borrowed-book": (clientWithBorrowedBook) => output({ clientWithBorrowedBook }),
+				"client-and-book-without-link": () => response.conflict("client.notHaveBook"),
 			},
 		),
 	)
 	.handler(
-		ResponseContract.ok("book.returned", DDataStructure.object({
-			client: Client.Entity,
-			book: Book.Entity,
-		})),
-		async({ client }, { response }) => {
-			const result = await useCases.clientGiveBackBookUseCase({ client });
+		async({ clientWithBorrowedBook }, { response }) => {
+			const result = await useCases.clientGiveBackBookUseCase(clientWithBorrowedBook);
 
-			return response("book.returned", DEither.unwrapRight(result));
+			return DEither.matchInformation(result, {
+				"book-returned-without-waiting-list-entry": () => response.ok("book.returned", null),
+				"book-returned-and-reserved": () => response.ok("book.returnedAndReserved", null),
+				"waiting-list-selection-unavailable": () => response.serviceUnavailable("waiting-list.selectionUnavailable"),
+			});
 		},
 	);

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/http/routes/clientRentBook.ts

@@ -1,5 +1,4 @@
-import { ResponseContract, useRouteBuilder } from "@duplojs/http";
-import * as DDataStructure from "@duplojs/lang/dataStructure";
+import { useRouteBuilder } from "@duplojs/http";
 import * as DEither from "@duplojs/lang/either";
 import { Book, Client } from "../../../business/domains";
 import { useCases } from "../../useCases";
@@ -15,36 +14,32 @@ export const clientRentBookRoute = useRouteBuilder("POST", "/book-rentals")
 	.presetCheck(iWantClientExist.indexing("client"), ({ clientId }) => clientId)
 	.presetCheck(iWantBookExist.indexing("book"), ({ bookId }) => bookId)
 	.cut(
-		ResponseContract.conflict("client.noBookRentalSlotsAvailable"),
 		({ client }, { response, output }) => DEither.matchInformation(
 			Client.canRentBook(client),
 			{
 				CanRentBook: (client) => output({ client }),
-				NoBookRentalSlotsAvailable: () => response("client.noBookRentalSlotsAvailable"),
+				NoBookRentalSlotsAvailable: () => response.conflict("client.noBookRentalSlotsAvailable"),
 			},
 		),
 	)
 	.cut(
-		ResponseContract.conflict("book.unavailable"),
 		({ book }, { response, output }) => DEither.matchInformation(
 			Book.refineState(book),
 			{
 				AvailableState: (book) => output({ book }),
-				BorrowedState: () => response("book.unavailable"),
+				BorrowedState: () => response.conflict("book.unavailable"),
+				ReservedState: () => response.conflict("book.unavailable"),
+				WithdrawnState: () => response.conflict("book.unavailable"),
 			},
 		),
 	)
 	.handler(
-		ResponseContract.created("book.rented", DDataStructure.object({
-			client: Client.Entity,
-			book: Book.Entity,
-		})),
 		async({ client, book }, { response }) => {
-			const result = await useCases.clientRentBookUseCase({
+			await useCases.clientRentBookUseCase({
 				client,
 				book,
 			});
 
-			return response("book.rented", DEither.unwrapRight(result));
+			return response.created("book.rented");
 		},
 	);

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/ports/book.ts

@@ -15,7 +15,7 @@ export const bookRepository = BookRepositoryPort.createImplementation({
 	save: (entity) => Promise.resolve(entity),
 	rankAvailability: DInvocation.signedFunction(
 		"rankAvailability",
-		async({ book }) => {
+		async(book) => {
 
 		},
 	),

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/ports/index.ts

@@ -1,3 +1,4 @@
 export * from "./book";
 export * from "./client";
 export * from "./email";
+export * from "./waitingListEntry";

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/ports/waitingListEntry.ts

@@ -0,0 +1,17 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import * as DGenerator from "@duplojs/lang/generator";
+import { WaitingListEntryRepositoryPort } from "../../business/applications/ports";
+import * as DEither from "@duplojs/lang/either";
+
+export const waitingListEntryRepository = WaitingListEntryRepositoryPort.createImplementation({
+	findNextPendingForBook: (book) => Promise.resolve(
+		DInvocation.evidenceResult("no-pending-waiting-list-entry", {
+			book,
+			waitingListEntry: null,
+		}),
+	),
+	findAllActiveByBook: DInvocation.withAdditionalResult((book) => true
+		? DGenerator.asyncLoop(({ exit }) => exit())
+		: Promise.resolve(DEither.left("waiting-list-stream-unavailable", book.id))),
+	save: (entity) => Promise.resolve(entity),
+});

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/useCases/index.ts

@@ -1,6 +1,6 @@
 import * as DInvocation from "@duplojs/lang/invocation";
 import * as UseCases from "../../business/applications/useCases";
-import { bookRepository, clientRepository, emailRepository } from "../ports";
+import { bookRepository, clientRepository, emailRepository, waitingListEntryRepository } from "../ports";
 
 export const useCases = DInvocation.resolveReaders(
 	UseCases,
@@ -8,5 +8,6 @@ export const useCases = DInvocation.resolveReaders(
 		bookRepository,
 		clientRepository,
 		emailRepository,
+		waitingListEntryRepository,
 	},
 );

package/docs/concepts/05-type-driven-design/index.md

@@ -1,3 +1,3 @@
-# Type Driven Design
+# Type-Driven Design
 
-Architecture en couches, modélisation du domaine et orchestration applicative pour faire vivre les cycles de vie métier.
+Concevoir un domaine qui impose les états, les preuves et le déroulement des opérations métier, puis satisfaire ses contrats dans l'application et l'infrastructure.

package/docs/concepts.llms.md

@@ -78,6 +78,11 @@ const normalizedTags = DCommon.pipe(
 	DArray.filter(DString.isNotEmpty),
 	DArray.map(DString.toLowerCase),
 );
+type _CheckNormalizedTags = DCommon.ExpectType<
+	typeof normalizedTags,
+	readonly (Lowercase<string> & DString.MinCharacters<1>)[] & DArray.MaxElements<3>,
+	"strict"
+>;
 // Résultat : ["typescript", "duplojs", "functional"].
 // Chaque étape reçoit la sortie précédente ; les types suivent ces transformations.
 // On peut ajouter, retirer ou réordonner les étapes sans restructurer le traitement.
@@ -294,6 +299,28 @@ Sélectionner les variantes sans identité explicite par des patterns, y compris
 
 Affiner les branches et réduire les cas restants, avec sélection positive ou inverse.
  
+## Kind
+
+Identité et métadonnées internes des objets de l'écosystème, reconnaissables au typage et au runtime.
+
+### Identité des objets avec les kinds
+
+De nombreux objets DuploJS portent des kinds pour être reconnus et distingués malgré le typage structurel de TypeScript.
+
+Ces clés textuelles au runtime, représentées sous un symbole dans les types, portent identité et métadonnées. Leur reconnaissance survit au transport si la sérialisation les préserve.
+
+Les kinds servent surtout à construire les outils ; utiliser DuploJS ne demande généralement pas de les manipuler directement.
+
+### [Métadonnées internes des kinds](concepts/01-fundamental/08-kind/20-metadata.md)
+
+Un petit store attaché à l'objet, exploitable dans les types ou au runtime selon son contrat.
+
+
+### [Transport de l'identité entre programmes](concepts/01-fundamental/08-kind/30-transport.md)
+
+Reconnaître une donnée après désérialisation sans dépendre du constructeur de son runtime d'origine.
+
+
 # Serveur
 
 ## Manipuler des fichiers
@@ -310,15 +337,15 @@ Contraintes `Path`, `Absolute` et `Segment` pour valider, extraire et résoudre
  
 ## HTTP
 
-Interfaces HTTP côté serveur : réception et validation des requêtes, orchestration des traitements et contrats de réponse typés partageables avec les clients.
+Développement d’API HTTP avec DuploJS, de la définition des routes au démarrage du serveur.
 
 ### [Créer une application HTTP](concepts/02-server/20-http/10-init.ts)
 
-Configuration d'un `Hub`, plugins et enregistrement des routes d'une application HTTP.
+Configuration d'un `Hub` et enregistrement des routes d'une application HTTP.
  
 ### [Créer une route HTTP](concepts/02-server/20-http/20-route.ts)
 
-Construction du flux d’une route : entrées validées, contexte de traitement et réponses contextualisées.
+Définir les entrées d'une route, préparer les données du traitement et produire sa réponse HTTP.
  
 ### [Faire une routine de vérification](concepts/02-server/20-http/30-routine.ts)
 
@@ -328,9 +355,9 @@ Vérifications dans les flux HTTP, réutilisation des traitements et adaptation
 
 Déclaration d'une politique unique pour créer et vérifier une famille de tokens.
  
-### [Comment partager des ressources](concepts/02-server/20-http/50-codegen.ts)
+### [Générer la documentation OpenAPI d'une API HTTP.](concepts/02-server/20-http/50-open-api.ts)
 
-Génération du typage des routes et des `DataStructure` pour partager un contrat statique.
+Décrire les réponses des routes et exposer leur documentation.
  
 ## Environnement
 
@@ -367,9 +394,7 @@ Communication typée avec des API HTTP.
 
 ### [Initialiser un client HTTP](concepts/03-client/10-http/10-init.ts)
 
-Création d'un client à partir du contrat statique des routes, configuration
-globale et conservation du typage des requêtes et réponses exposées par le
-serveur.
+Configuration d'un client HTTP typé et des paramètres communs aux requêtes.
  
 ### [Effectuer une requête HTTP](concepts/03-client/10-http/20-request.ts)
 
@@ -383,6 +408,11 @@ Comportements transversaux et instrumentation du cycle des échanges HTTP.
 
 Création et gestion de formulaires typés pour les interfaces utilisateur.
 
+## [Intégrer un formulaire dans une page Vue](concepts/03-client/20-form/50-integration.md)
+
+Séparer la logique d'un formulaire de son rendu dans une page Vue.
+
+
 ### [Créer un formulaire](concepts/03-client/20-form/10-init.ts)
 
 Initialisation et cycle de vie d’un formulaire Vue typé.
@@ -429,47 +459,63 @@ Organisation d’une suite E2E selon les pages et les composants du site testé.
 
 Scénarios utilisateur, interactions et vérifications avec les objets du site.
  
-# Type Driven Design
+# Type-Driven Design
 
-Architecture en couches, modélisation du domaine et orchestration applicative pour faire vivre les cycles de vie métier.
+Concevoir un domaine qui impose les états, les preuves et le déroulement des opérations métier, puis satisfaire ses contrats dans l'application et l'infrastructure.
 
 ## Architecture
 
-Responsabilités des couches, sens des dépendances, opérations autorisées aux frontières et exposition des résultats aux consommateurs.
+Répartir la décision métier, la satisfaction des contrats et la réalisation technique entre domaine, application et infrastructure.
 
 ### [Frontières entre domaine, application et infrastructure](concepts/05-type-driven-design/01-architecture/10-boundaries.md)
 
-Déterminer les dépendances autorisées, les opérations utilisables depuis chaque couche et le traitement des données et erreurs aux frontières du système.
+Responsabilités des couches, sens des dépendances et préparation des garanties aux frontières du système.
+
 
 ## Domaines
 
-Modélisation du métier et contrats de ses opérations : entités, invariants, transitions, agrégats et repositories.
+États et transitions des entités, orchestration par les agrégats, capacités des repositories et preuves de contexte produites par les refinements.
+
+### [Entités, qualifications et faits](concepts/05-type-driven-design/02-domains/10-entities.md)
+
+Modéliser les données et leurs invariants, certifier leurs conditions actuelles et rendre explicites les préconditions des transitions métier.
+
+
+### [Agrégats, preuves et workflows](concepts/05-type-driven-design/02-domains/20-aggregates.md)
+
+Définir le déroulement d'une opération métier, les preuves qui l'autorisent et les demandes commit, resolve et iterate que l'application doit satisfaire.
 
-### [Conception des entités en Type-Driven Design](concepts/05-type-driven-design/02-domains/10-entities.md)
 
-Organisation des modèles métier, de leurs invariants, qualifications et transitions dans le domaine.
+### [Repositories : capacités extérieures du domaine](concepts/05-type-driven-design/02-domains/30-repositories.md)
 
-### [Conception des agrégats en Type-Driven Design](concepts/05-type-driven-design/02-domains/20-aggregates.md)
+Définir les opérations extérieures utiles au métier, leurs résultats et leurs garanties sans exposer leur réalisation technique.
 
-Contrats des transactions métier, préconditions et orchestration de faits réutilisables.
 
-### [Conception des repositories en Type-Driven Design](concepts/05-type-driven-design/02-domains/30-repositories.md)
+### [Refinements : qualifier un contexte métier](concepts/05-type-driven-design/02-domains/40-refinements.md)
+
+Vérifier une combinaison d'entités ou de valeurs et produire la preuve de cet état commun sans réaliser de transition.
 
-Contrats des opérations nécessaires au métier dont l'implémentation technique reste extérieure au domaine.
 
 ## Applications
 
-Orchestration des agrégats, ports de capacités, injection des dépendances, effets et persistance.
+Use cases pour satisfaire les agrégats et ports pour définir leurs capacités extérieures, leurs extensions techniques et leurs dépendances injectables.
+
+### [Use cases : satisfaire les agrégats](concepts/05-type-driven-design/03-applications/10-use-case.md)
+
+Préparer les garanties requises, raccorder les workflows aux ports applicatifs et encadrer leur exécution, notamment transactionnelle.
 
-### [Conception des use cases en Type-Driven Design](concepts/05-type-driven-design/03-applications/10-use-case.md)
 
-Orchestration applicative des agrégats, sélection et propagation des résultats Either, ports et injection avec Reader, résolution des effets et persistance.
+### [Ports : contrats des dépendances applicatives](concepts/05-type-driven-design/03-applications/20-ports.md)
+
+Définir les capacités requises par l'application, étendre les résultats des contrats du domaine et rendre leurs implémentations injectables sans dépendre d'une technologie.
+
 
 ## Infrastructure
 
-Assemblage concret de l'application : implémentation des ports, résolution des use cases et raccordement aux points d'entrée.
+Réaliser les garanties des ports, résoudre les use cases et adapter leurs entrées et résultats aux systèmes concrets.
+
+### [Infrastructure : réaliser et raccorder les contrats](concepts/05-type-driven-design/04-infrastructure/10-implementation.md)
 
-### [Assembler l'application dans l'infrastructure](concepts/05-type-driven-design/04-infrastructure/10-implementation.md)
+Implémenter les capacités techniques demandées par l'application, établir réellement leurs garanties et exposer les opérations aux consommateurs.
 
-Fournir les dépendances concrètes de l'application et raccorder ses capacités aux points d'entrée du système.