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

package/docs/concepts/01-fundamental/07-discrimination/40-error.ts

@@ -23,34 +23,50 @@ declare const error: OperationError;
 // impose donc de compléter le matcher.
 // Chaque callback reçoit l'erreur précise, avec ses propriétés et sa cause typées.
 
-// string | Error
 const matchedError = DPattern.matchWithError(
 	error,
 	{
-		// InvalidInputError ; cause est undefined.
-		"invalid-input": (invalidInput) => invalidInput.message,
+		"invalid-input": (invalidInput) => {
+			type _CheckInvalidInput = DCommon.ExpectType<typeof invalidInput, InvalidInputError, "strict">;
+			return invalidInput.message;
+		},
 
-		// UnavailableServiceError ; cause est Error.
-		"unavailable-service": (unavailableService) => unavailableService.cause,
+		"unavailable-service": (unavailableService) => {
+			type _CheckUnavailableService = DCommon.ExpectType<typeof unavailableService, UnavailableServiceError, "strict">;
+			return unavailableService.cause;
+		},
 	},
 );
+type _CheckMatchedErrorLine27 = DCommon.ExpectType<
+	typeof matchedError,
+	string | Error,
+	"strict"
+>;
 
 // matchWithErrorOtherwise sélectionne explicitement une partie des identifiants.
 // Le callback otherwise reçoit uniquement les erreurs non prises en charge.
 // Les deux fonctions existent en forme directe et curried, utilisable dans un pipe.
 
-// string | Error
 const matchedErrorOtherwise = DCommon.pipe(
 	error,
 	DPattern.matchWithErrorOtherwise(
 		{
-			// InvalidInputError
-			"invalid-input": (invalidInput) => invalidInput.message,
+			"invalid-input": (invalidInput) => {
+				type _CheckInvalidInput = DCommon.ExpectType<typeof invalidInput, InvalidInputError, "strict">;
+				return invalidInput.message;
+			},
+		},
+		(unavailableService) => {
+			type _CheckUnavailableService = DCommon.ExpectType<typeof unavailableService, UnavailableServiceError, "strict">;
+			return unavailableService.cause;
 		},
-		// UnavailableServiceError
-		(unavailableService) => unavailableService.cause,
 	),
 );
+type _CheckMatchedErrorOtherwiseLine43 = DCommon.ExpectType<
+	typeof matchedErrorOtherwise,
+	string | Error,
+	"strict"
+>;
 
 // Ces matchers attendent des DuploJSError dont les identifiants sont des types
 // littéraux connus. Conserver l'union précise : Error natif et DuploJSError

package/docs/concepts/01-fundamental/07-discrimination/50-literal.ts

@@ -16,24 +16,24 @@ declare const status: "pending" | "ready" | "failed";
 // Chaque valeur possible doit posséder un handler et chaque callback reçoit
 // précisément le literal correspondant.
 
-// "wait" | "run" | "error"
 const matchedStatus = DPattern.matchWithString(
 	status,
 	{
-		// "pending"
 		pending: () => "wait" as const,
 
-		// "ready"
 		ready: () => "run" as const,
 
-		// "failed"
 		failed: () => "error" as const,
 	},
 );
+type _CheckMatchedStatusLine20 = DCommon.ExpectType<
+	typeof matchedStatus,
+	"wait" | "run" | "error",
+	"strict"
+>;
 
 // La forme curried peut être utilisée directement dans un pipe.
 
-// "wait" | "run" | "error"
 const matchedStatusInPipe = DCommon.pipe(
 	status,
 	DPattern.matchWithString({
@@ -42,26 +42,36 @@ const matchedStatusInPipe = DCommon.pipe(
 		failed: () => "error" as const,
 	}),
 );
+type _CheckMatchedStatusInPipeLine37 = DCommon.ExpectType<
+	typeof matchedStatusInPipe,
+	"wait" | "run" | "error",
+	"strict"
+>;
 
 // La variante `otherwise` permet de ne sélectionner qu'une partie de l'union.
 //
 // Le callback `otherwise` reçoit précisément les literals non traités.
 
-// "run" | "not-ready"
 const matchedStatusOtherwise = DPattern.matchWithStringOtherwise(
 	status,
 	{
 		ready: () => "run" as const,
 	},
-	// "pending" | "failed"
-	() => "not-ready" as const,
+	(otherStatus) => {
+		type _CheckOtherwiseStatus = DCommon.ExpectType<typeof otherStatus, "pending" | "failed", "strict">;
+		return "not-ready" as const;
+	},
 );
+type _CheckMatchedStatusOtherwiseLine51 = DCommon.ExpectType<
+	typeof matchedStatusOtherwise,
+	"run" | "not-ready",
+	"strict"
+>;
 
 declare const code: 200 | 404 | 500;
 
 // `matchWithNumber` applique le même principe aux unions de number literals.
 
-// "success" | "not-found" | "error"
 const matchedCode = DPattern.matchWithNumber(
 	code,
 	{
@@ -70,10 +80,14 @@ const matchedCode = DPattern.matchWithNumber(
 		500: () => "error" as const,
 	},
 );
+type _CheckMatchedCodeLine65 = DCommon.ExpectType<
+	typeof matchedCode,
+	"success" | "not-found" | "error",
+	"strict"
+>;
 
 // `matchWithNumberOtherwise` permet également une sélection partielle.
 
-// "success" | "error"
 const matchedCodeOtherwise = DPattern.matchWithNumberOtherwise(
 	code,
 	{
@@ -82,6 +96,11 @@ const matchedCodeOtherwise = DPattern.matchWithNumberOtherwise(
 	// 404 | 500
 	() => "error" as const,
 );
+type _CheckMatchedCodeOtherwiseLine77 = DCommon.ExpectType<
+	typeof matchedCodeOtherwise,
+	"success" | "error",
+	"strict"
+>;
 
 // Un matcher exhaustif doit couvrir chaque valeur possible et refuse les clés étrangères à l’union.
 // Ajouter une valeur au contrat impose de réviser les branches, contrairement à une sélection partielle.

package/docs/concepts/01-fundamental/07-discrimination/60-shape.ts

@@ -49,7 +49,6 @@ declare const externalProduct: ExternalProduct;
 // La dernière branche peut donc devenir exhaustive même sans discriminant
 // explicite sur la donnée.
 
-// string
 const productLabel = DPattern.match(externalProduct)
 	.with(
 		{
@@ -85,6 +84,11 @@ const productLabel = DPattern.match(externalProduct)
 		(product) => `unavailable:${product.unavailable.reason}`,
 	)
 	.exhaustive();
+type _CheckProductLabelLine53 = DCommon.ExpectType<
+	typeof productLabel,
+	string,
+	"strict"
+>;
 
 // Les patterns peuvent être profondément imbriqués.
 //
@@ -102,7 +106,6 @@ const productLabel = DPattern.match(externalProduct)
 // Chaque étape travaille donc uniquement avec les valeurs qui n'ont pas encore
 // été traitées.
 
-// string
 const productLabelInPipe = DCommon.pipe(
 	externalProduct,
 	DPattern.match(
@@ -137,6 +140,11 @@ const productLabelInPipe = DCommon.pipe(
 	),
 	DPattern.exhaustive,
 );
+type _CheckProductLabelInPipeLine106 = DCommon.ExpectType<
+	typeof productLabelInPipe,
+	`merchant:${string}` | `second-hand:${number}` | "unavailable:deleted" | "unavailable:out-of-stock",
+	"strict"
+>;
 
 // Une sélection partielle peut se terminer par otherwise plutôt que par exhaustive.
 // Le callback de repli reçoit précisément les formes qui restent à traiter.

package/docs/concepts/01-fundamental/07-discrimination/70-predicate.ts

@@ -17,7 +17,6 @@ import * as DString from "@duplojs/lang/string";
 
 declare const externalValue: string | number | null;
 
-// string | number | "empty"
 const normalizedValue = DCommon.pipe(
 	externalValue,
 	DPattern.when(
@@ -37,6 +36,11 @@ const normalizedValue = DCommon.pipe(
 	),
 	DPattern.exhaustive,
 );
+type _CheckNormalizedValueLine21 = DCommon.ExpectType<
+	typeof normalizedValue,
+	(string & DString.Trimmed) | number | "empty",
+	"strict"
+>;
 
 // `whenNot` applique le predicate de manière inverse.
 //
@@ -50,21 +54,29 @@ const normalizedValue = DCommon.pipe(
 
 declare const framework: "duplojs" | "other";
 
-// "known" | "unknown"
 const frameworkResult = DCommon.pipe(
 	framework,
 	DPattern.whenNot(
 		DCommon.equal("other"),
-		// "duplojs"
-		() => "known" as const,
+		(value) => {
+			type _CheckKnownFramework = DCommon.ExpectType<typeof value, "duplojs", "strict">;
+			return "known" as const;
+		},
 	),
 	DPattern.when(
 		DCommon.equal("other"),
-		// "other"
-		() => "unknown" as const,
+		(value) => {
+			type _CheckUnknownFramework = DCommon.ExpectType<typeof value, "other", "strict">;
+			return "unknown" as const;
+		},
 	),
 	DPattern.exhaustive,
 );
+type _CheckFrameworkResultLine54 = DCommon.ExpectType<
+	typeof frameworkResult,
+	"known" | "unknown",
+	"strict"
+>;
 
 // `match`, `when` et `whenNot` sont donc principalement utiles lorsque
 // la discrimination doit être déduite de la donnée elle-même.

package/docs/concepts/01-fundamental/08-kind/01-identity.md

@@ -0,0 +1,7 @@
+### 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.

package/docs/concepts/01-fundamental/08-kind/20-metadata.md

@@ -0,0 +1,11 @@
+### Métadonnées internes des kinds
+
+Un petit store attaché à l'objet, exploitable dans les types ou au runtime selon son contrat.
+
+---
+
+Un objet peut porter plusieurs kinds. Dans un `Right`, ils contiennent notamment le statut, l'information contextuelle et la valeur. Un kind peut aussi n'être qu'un marqueur, avec une valeur `null`.
+
+Certaines informations associées au kind servent uniquement au typage et ne reflètent pas nécessairement la valeur stockée. Consulter le contrat du domaine avant de les exploiter au runtime. Contrairement aux kinds, les [contraintes de typage](../01-constraint/index.md) n'ajoutent aucune propriété à la valeur.
+
+Ces métadonnées sont internes, mais restent observables dans l'objet JavaScript. Le `has` d'un gestionnaire vérifie seulement la présence de sa clé ; la validation du contenu relève des [DataStructure](../04-data-structure/index.md).

package/docs/concepts/01-fundamental/08-kind/30-transport.md

@@ -0,0 +1,11 @@
+### Transport de l'identité entre programmes
+
+Reconnaître une donnée après désérialisation sans dépendre du constructeur de son runtime d'origine.
+
+---
+
+Les clés runtime des kinds dépendent de leur nom et de leur namespace. Un autre programme connaissant cette convention peut donc reconnaître la donnée, sans partager le gestionnaire en mémoire qui l'a créée.
+
+Une sérialisation JSON conserve ces clés textuelles énumérables et leurs valeurs compatibles. Un objet taggé peut ainsi rester reconnaissable après transport entre deux serveurs. À l'inverse, JSON ne rétablit pas le prototype permettant la reconnaissance habituelle d'une instance de classe par `instanceof`.
+
+Le transport doit préserver les marqueurs nécessaires : une propriété valant `undefined` est omise et une fonction n'est pas transportée. La présence d'un kind ne valide pas les données reçues ; utiliser le contrat de validation du domaine à la frontière externe.

package/docs/concepts/01-fundamental/08-kind/index.md

@@ -0,0 +1,3 @@
+## Kind
+
+Identité et métadonnées internes des objets de l'écosystème, reconnaissables au typage et au runtime.

package/docs/concepts/02-server/10-file/10-manipulation.ts

@@ -16,14 +16,26 @@ const textResourcePath: string & DPath.Path = DCommon.cast("/path/to/text/resour
 const readTextResourceResult = await DSFile.readTextFile(textResourcePath);
 
 if (DEither.isRight(readTextResourceResult)) {
-	// DEither.Right<"file-system-read-text-file", string>
+	type _CheckReadTextRight = DCommon.ExpectType<
+		typeof readTextResourceResult,
+		DEither.Right<"file-system-read-text-file", string>,
+		"strict"
+	>;
 	void readTextResourceResult;
 
-	// string
 	const textResource = DEither.unwrapRight(readTextResourceResult);
+	type _CheckTextResourceLine23 = DCommon.ExpectType<
+	typeof textResource,
+	string,
+	"strict"
+	>;
 } else {
 	// Le Left porte l'échec de l'opération ; sa valeur porte l'erreur précise.
-	// DEither.Left<"file-system-read-text-file-error", DSFile.ReadTextFileErrors>
+	type _CheckReadTextLeft = DCommon.ExpectType<
+		typeof readTextResourceResult,
+		DEither.Left<"file-system-read-text-file-error", DSFile.ReadTextFileErrors>,
+		"strict"
+	>;
 	const error = DEither.unwrapLeft(readTextResourceResult);
 
 	type _CheckError = DCommon.ExpectType<typeof error, DSFile.ReadTextFileErrors, "strict">;

package/docs/concepts/02-server/10-file/20-path.ts

@@ -18,22 +18,33 @@ declare const unsafePath: string;
 const pathResult = DPath.create(unsafePath);
 
 if (DEither.isRight(pathResult)) {
-	// string & DPath.Path
 	const path = DEither.unwrapRight(pathResult);
+	type _CheckPathLine22 = DCommon.ExpectType<
+	typeof path,
+	string & DPath.Path,
+	"strict"
+	>;
 }
 
 // Les helpers extraient des parties contraintes sans retravailler la string.
-// (string & DPath.Segment) | null
 const fileName = DPath.getBaseName(imagePath);
+type _CheckFileName = DCommon.ExpectType<typeof fileName, (string & DPath.Segment & DPath.Path) | null, "strict">;
 
-// (string & DPath.Segment) | null
 const extensionName = DPath.getExtensionName(imagePath);
+type _CheckExtensionNameLine30 = DCommon.ExpectType<
+	typeof extensionName,
+	(string & DPath.Segment & DPath.Path) | null,
+	"strict"
+>;
 
-// (string & DPath.Path) | null
 const parentFolderPath = DPath.getParentFolderPath(imagePath);
+type _CheckParentFolderPathLine33 = DCommon.ExpectType<
+	typeof parentFolderPath,
+	(string & DPath.Path) | null,
+	"strict"
+>;
 
 // Les fonctions de résolution assemblent des `Path` et `Segment` validés.
-// (string & DPath.Absolute) | null
 const resolvedPath = DPath.resolveFrom(
 	rootPath,
 	[
@@ -44,9 +55,13 @@ const resolvedPath = DPath.resolveFrom(
 		stayInOrigin: true,
 	},
 );
+type _CheckResolvedPath = DCommon.ExpectType<
+	typeof resolvedPath,
+	(string & DPath.Path & DPath.Absolute) | null,
+	"strict"
+>;
 
 // Résolution sans origine protectrice.
-// string & DPath.Path & DPath.Absolute
 const relativePath = DPath.resolveRelative(
 	[
 		rootPath,
@@ -54,3 +69,4 @@ const relativePath = DPath.resolveRelative(
 		DCommon.infer("logo1.png"),
 	],
 );
+type _CheckRelativePath = DCommon.ExpectType<typeof relativePath, string & DPath.Path & DPath.Absolute, "strict">;

package/docs/concepts/02-server/20-http/10-init.ts

@@ -1,19 +1,11 @@
 /**
  * @title Créer une application HTTP
  *
- * 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.
  */
 import { createHub, routeStore } from "@duplojs/http";
-import { codeGeneratorPlugin } from "@duplojs/http/codeGenerator";
-import * as DCommon from "@duplojs/lang/common";
 
 export const hub = createHub({ environment: "DEV" })
-	.plug(
-		// Les plugins ajoutent des capacités au `Hub`.
-		codeGeneratorPlugin({
-			outputFile: DCommon.infer("types.d.ts"),
-		}),
-	)
 	// Les modules de routes doivent être chargés avant l'enregistrement du store.
 	.register(
 		routeStore.getAll(),

package/docs/concepts/02-server/20-http/20-route.ts

@@ -1,9 +1,10 @@
 /**
  * @title Créer une route HTTP
  *
- * 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.
  */
-import { ResponseContract, useRouteBuilder, controlBodyAsFormData } from "@duplojs/http";
+import { useRouteBuilder, controlBodyAsFormData, type RouteDeclarationToContract } from "@duplojs/http";
+import type * as DCommon from "@duplojs/lang/common";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 import * as DSDataStructure from "@duplojs/server/dataStructure";
 
@@ -22,7 +23,7 @@ declare function getUsers(params: {
 
 // Une route est une suite de steps exécutées dans l'ordre.
 // Elles partagent leurs données via le `floor`; `handler` clôture la route.
-useRouteBuilder("GET", "/users")
+export const usersRoute = useRouteBuilder("GET", "/users")
 	.extract({
 		query: {
 			page: DDataStructure.number([
@@ -37,30 +38,37 @@ useRouteBuilder("GET", "/users")
 		},
 	})
 	.handler(
-		ResponseContract.ok("users.findMany", DDataStructure.array(userStructure)),
 		async({ page, quantityPerPage }, { response }) => {
 			const users = await getUsers({
 				page,
 				quantityPerPage,
 			});
 
-			return response("users.findMany", users);
+			return response.ok("users.findMany", users);
 		},
 	);
 
-// Un `ResponseContract` associe un statut HTTP, un body éventuel et une
-// `information` littérale.
-//
-// L'information contextualise la réponse et sert de discriminant principal.
-// Le statut HTTP garde son rôle de convention protocolaire, mais c'est
-// l'information qui identifie finement le résultat du flux, y compris lorsqu'une
-// réponse n'a pas besoin de body.
-ResponseContract.ok("superResponse", DDataStructure.string());
-ResponseContract.created("user.created", userStructure);
-ResponseContract.noContent("user.deleted");
-ResponseContract.conflict("email.alreadyUse");
-ResponseContract.notFound("user.notfound");
-ResponseContract.notFound("product.notfound");
+// `response.ok` construit une réponse 200 avec une information et un body.
+// L'information identifie le résultat de l'opération, même lorsque plusieurs
+// réponses partagent le même statut HTTP.
+// Le type de la route reprend les réponses retournées par ses étapes :
+// ici le résultat du handler et le refus d'extraction par défaut.
+export type UsersRouteContract = RouteDeclarationToContract<typeof usersRoute>;
+
+type _CheckResponses = DCommon.ExpectType<
+	UsersRouteContract["responses"],
+	| {
+		readonly code: "200";
+		readonly information: "users.findMany";
+		readonly body: User[];
+	}
+	| {
+		readonly code: "422";
+		readonly information: "extract-error";
+		readonly body: string;
+	},
+	"strict"
+>;
 
 // `extract` valide les entrées de requête avant de les ajouter au `floor`.
 // Il peut cibler params, query, headers et body.
@@ -83,7 +91,6 @@ useRouteBuilder("POST", "/users/{userId}")
 		}),
 	})
 	.handler(
-		ResponseContract.noContent("user.received"),
 		(
 			{
 				userId,
@@ -99,26 +106,29 @@ useRouteBuilder("POST", "/users/{userId}")
 			void body.username;
 			void body.age;
 
-			return response("user.received");
+			return response.noContent("user.received");
 		},
 	);
 
 // Si une source utilise directement une `DataStructure`, elle garde son nom :
 // le body sera disponible dans `floor.body`.
 useRouteBuilder("POST", "/profile")
-	.extract({
-		body: DDataStructure.object({
-			name: DDataStructure.string(),
-			age: DDataStructure.number(),
-		}),
-	})
+	.extract(
+		{
+			body: DDataStructure.object({
+				name: DDataStructure.string(),
+				age: DDataStructure.number(),
+			}),
+		},
+		// Cette réponse locale remplace le refus d'extraction du Hub pour cette étape.
+		({ response }) => response.badRequest("profile.invalid"),
+	)
 	.handler(
-		ResponseContract.noContent("profile.updated"),
 		({ body }, { response }) => {
 			void body.name;
 			void body.age;
 
-			return response("profile.updated");
+			return response.noContent("profile.updated");
 		},
 	);
 
@@ -132,12 +142,11 @@ useRouteBuilder("GET", "/search")
 		},
 	})
 	.handler(
-		ResponseContract.noContent("search.done"),
 		({ page, search }, { response }) => {
 			void page;
 			void search;
 
-			return response("search.done");
+			return response.noContent("search.done");
 		},
 	);
 
@@ -163,12 +172,11 @@ useRouteBuilder(
 		},
 	})
 	.handler(
-		ResponseContract.noContent("documents.received"),
 		({ title, userId, files }, { response }) => {
 			void title;
 			void userId;
 			void files;
 
-			return response("documents.received");
+			return response.noContent("documents.received");
 		},
 	);

package/docs/concepts/02-server/20-http/30-routine.ts

@@ -3,7 +3,7 @@
  *
  * Vérifications dans les flux HTTP, réutilisation des traitements et adaptation de leurs résultats au contexte.
  */
-import { ResponseContract, createPresetChecker, useCheckerBuilder, usePreflightBuilder, useProcessBuilder, useRouteBuilder } from "@duplojs/http";
+import { createPresetChecker, useCheckerBuilder, usePreflightBuilder, useProcessBuilder, useRouteBuilder } from "@duplojs/http";
 import * as DEither from "@duplojs/lang/either";
 import * as DCommon from "@duplojs/lang/common";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
@@ -59,23 +59,21 @@ useRouteBuilder("POST", "/users/{userId}/confirm-email")
 		{
 			input: ({ userId }) => userId,
 			result: "user.find",
-			otherwise: ResponseContract.notFound("user.notfound"),
+			otherwise: ({ response }) => response.notFound("user.notfound"),
 			indexing: "user",
 		},
 	)
 	.cut(
-		ResponseContract.conflict("user.emailConfirmation.mismatch"),
 		({ user, email }, { response, output }) => {
 			if (user.email !== email) {
-				return response("user.emailConfirmation.mismatch");
+				return response.conflict("user.emailConfirmation.mismatch");
 			}
 
 			return output({ confirmedUser: user });
 		},
 	)
 	.handler(
-		ResponseContract.ok("user.emailConfirmed", userStructure),
-		({ confirmedUser }, { response }) => response("user.emailConfirmed", confirmedUser),
+		({ confirmedUser }, { response }) => response.ok("user.emailConfirmed", confirmedUser),
 	);
 
 // `check` interprète un checker pour un flux donné : input, résultat attendu,
@@ -91,13 +89,12 @@ useRouteBuilder("GET", "/users/{userId}")
 		{
 			input: ({ userId }) => userId,
 			result: "user.find",
-			otherwise: ResponseContract.notFound("user.notfound"),
+			otherwise: ({ response }) => response.notFound("user.notfound"),
 			indexing: "user",
 		},
 	)
 	.handler(
-		ResponseContract.ok("user.find", userStructure),
-		({ user }, { response }) => response("user.find", user),
+		({ user }, { response }) => response.ok("user.find", user),
 	);
 
 // Un preset nomme une interprétation récurrente du checker.
@@ -107,7 +104,7 @@ export const iWantUserExist = createPresetChecker(
 	userExist,
 	{
 		result: "user.find",
-		otherwise: ResponseContract.notFound("user.notfound"),
+		otherwise: ({ response }) => response.notFound("user.notfound"),
 	},
 );
 
@@ -123,8 +120,7 @@ useRouteBuilder("GET", "/users/{userId}")
 		({ userId }) => userId,
 	)
 	.handler(
-		ResponseContract.ok("user.find", userStructure),
-		({ user }, { response }) => response("user.find", user),
+		({ user }, { response }) => response.ok("user.find", user),
 	);
 
 // Un `process` réutilise une séquence complète de steps.
@@ -136,7 +132,6 @@ export const authenticationProcess = useProcessBuilder()
 		},
 	})
 	.cut(
-		ResponseContract.unauthorized("token.invalid"),
 		({ authorization }, { response, output }) => DCommon.pipe(
 			authorization,
 			checkToken,
@@ -144,7 +139,7 @@ export const authenticationProcess = useProcessBuilder()
 				(user) => output({
 					authenticatedUserId: user.id,
 				}),
-				() => response("token.invalid"),
+				() => response.unauthorized("token.invalid"),
 			),
 		),
 	)
@@ -153,7 +148,7 @@ export const authenticationProcess = useProcessBuilder()
 		{
 			input: DObject.getProperty("authenticatedUserId"),
 			result: "user.find",
-			otherwise: ResponseContract.notFound("token.user.notfound"),
+			otherwise: ({ response }) => response.notFound("token.user.notfound"),
 			indexing: "user",
 		},
 	)
@@ -168,8 +163,7 @@ useRouteBuilder("GET", "/some-action")
 		},
 	)
 	.handler(
-		ResponseContract.ok("some-information.send", userStructure),
-		({ user }, { response }) => response(
+		({ user }, { response }) => response.ok(
 			"some-information.send",
 			user,
 		),
@@ -187,8 +181,7 @@ export const useAuthenticatedRouteBuilder = usePreflightBuilder()
 
 useAuthenticatedRouteBuilder("GET", "/some-action")
 	.handler(
-		ResponseContract.ok("some-information.send", userStructure),
-		({ user }, { response }) => response(
+		({ user }, { response }) => response.ok(
 			"some-information.send",
 			user,
 		),