@nodefony/http 10.0.0-beta.6 → 10.0.0-beta.7

package/dist/_virtual/{_@oxc-project_runtime@0.157.0 → _@oxc-project_runtime@0.158.0}/helpers/esm/decorate.js

@@ -1,4 +1,4 @@
-// \0@oxc-project+runtime@0.157.0/helpers/esm/decorate.js
+// \0@oxc-project+runtime@0.158.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);

package/dist/_virtual/{_@oxc-project_runtime@0.157.0 → _@oxc-project_runtime@0.158.0}/helpers/esm/decorateParam.js

@@ -1,4 +1,4 @@
-// \0@oxc-project+runtime@0.157.0/helpers/esm/decorateParam.js
+// \0@oxc-project+runtime@0.158.0/helpers/esm/decorateParam.js
 function __decorateParam(paramIndex, decorator) {
 	return function(target, key) {
 		decorator(target, key, paramIndex);

package/dist/index.js

@@ -33,12 +33,13 @@ import HttpContext from "./nodefony/src/context/http/HttpContext.js";
 import WebsocketContext from "./nodefony/src/context/websocket/WebsocketContext.js";
 import HttpRequest from "./nodefony/src/context/http/Request.js";
 import Http2Request from "./nodefony/src/context/http2/Request.js";
-import __decorate from "./_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorate.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorate.js";
 import { parseRequestTarget } from "./nodefony/src/context/http/urlFastPath.js";
 import { decideSend, readBackpressureOptions } from "./nodefony/src/context/websocket/wsBackpressure.js";
 import { FRAME_RATE_WINDOW_MS, admitFrame, frameRateRejectedTotal, readFrameRateBound, readFrameRateCloseAfter } from "./nodefony/src/context/websocket/wsFrameRate.js";
 import { isWebsocketContext } from "./nodefony/src/context/websocket/isWebsocketContext.js";
 import { REQUEST_TRACE_CHANNEL } from "./nodefony/src/context/requestTrace.js";
+import { rpcCorsLists } from "./nodefony/src/grpc/cors.js";
 import { compileDomainPattern, compileDomainPatterns, compileTrustedHosts, isDomainAllowed } from "./nodefony/src/context/domainMatcher.js";
 import { MemoryRateLimitStore } from "./nodefony/src/rateLimit/MemoryRateLimitStore.js";
 import { SSE_HEARTBEAT_MS, SseStream, acceptsEventStream, openSseStream } from "./nodefony/src/context/http/SseStream.js";
@@ -119,4 +120,4 @@ Http = __decorate([services([
 	upload_service_default
 ])], Http);
 var http_default = Http;
-export { ACTION_SELF_PHASE, Context, Cookie, DefaultErrorRenderer, DefaultRequestLogger, FRAME_RATE_WINDOW_MS, FrameProfile, Http2Request, Http2Response, HttpContext, HttpError, http_kernel_default as HttpKernel, HttpRequest, HttpResponse, HttpResponse as Response, JsonAuditLogger, MemoryRateLimitStore, NO_ROUTE, N_PLUS_ONE_MIN_REPEATS, PrebuiltUi, PrettyRequestLogger, Profiler, REQUEST_TRACE_CHANNEL, ReverseProxy, SESSION_COLUMN_ALIASES, SESSION_DEFAULT_ORDER, SESSION_DEFAULT_ORDER_SQL, SESSION_SORTABLE_FIELDS, SSE_HEARTBEAT_MS, Session, sessions_service_default as SessionsService, SseStream, TOOLING_URL_PREFIX, WebsocketContext, WebsocketResponse, WebsocketResponse as wsResponse, acceptsEventStream, admitFrame, aggregateProfiles, compileDomainPattern, compileDomainPatterns, compileTrustedHosts, createProfileAggregator, decideSend, http_default as default, defineHttpConfig, frameRateRejectedTotal, httpConfigJsonSchema, httpConfigSchema, isContentlessStatus, isDomainAllowed, isFailedProfile, isWebsocketContext, normalizePrefix, openByteStream, openSseStream, parseProxyOrigin, parseRequestTarget, proxyMountProblems, readBackpressureOptions, readFrameRateBound, readFrameRateCloseAfter, resolveUiDelivery, schemaMismatchOf, sqlShape, toValidationFields };
+export { ACTION_SELF_PHASE, Context, Cookie, DefaultErrorRenderer, DefaultRequestLogger, FRAME_RATE_WINDOW_MS, FrameProfile, Http2Request, Http2Response, HttpContext, HttpError, http_kernel_default as HttpKernel, HttpRequest, HttpResponse, HttpResponse as Response, JsonAuditLogger, MemoryRateLimitStore, NO_ROUTE, N_PLUS_ONE_MIN_REPEATS, PrebuiltUi, PrettyRequestLogger, Profiler, REQUEST_TRACE_CHANNEL, ReverseProxy, SESSION_COLUMN_ALIASES, SESSION_DEFAULT_ORDER, SESSION_DEFAULT_ORDER_SQL, SESSION_SORTABLE_FIELDS, SSE_HEARTBEAT_MS, Session, sessions_service_default as SessionsService, SseStream, TOOLING_URL_PREFIX, WebsocketContext, WebsocketResponse, WebsocketResponse as wsResponse, acceptsEventStream, admitFrame, aggregateProfiles, compileDomainPattern, compileDomainPatterns, compileTrustedHosts, createProfileAggregator, decideSend, http_default as default, defineHttpConfig, frameRateRejectedTotal, httpConfigJsonSchema, httpConfigSchema, isContentlessStatus, isDomainAllowed, isFailedProfile, isWebsocketContext, normalizePrefix, openByteStream, openSseStream, parseProxyOrigin, parseRequestTarget, proxyMountProblems, readBackpressureOptions, readFrameRateBound, readFrameRateCloseAfter, resolveUiDelivery, rpcCorsLists, schemaMismatchOf, sqlShape, toValidationFields };

package/dist/nodefony/config/config.js

@@ -1,4 +1,5 @@
 import { normalizePrefix, proxyMountProblems } from "../src/proxy/rules.js";
+import { GRPC_DEFAULT_MAX_MESSAGE_BYTES, GRPC_MAX_MESSAGE_BYTES } from "../src/grpc/limits.js";
 import { overlayField } from "nodefony";
 import { z } from "zod";
 // nodefony/config/config.ts
@@ -146,8 +147,8 @@ const httpServerSchema = z.looseObject({
 	maxHeadersCount: z.number().int().nonnegative().default(2e3).describe("Nombre max d'en-têtes par requête — anti header flooding."),
 	keepAliveTimeout: z.number().int().nonnegative().default(5e3).describe("Délai keep-alive (ms) entre deux requêtes sur la même socket TCP."),
 	timeout: z.number().int().nonnegative().default(3e4).describe("Timeout global de la socket (ms). 0 = désactivé. Aligné sur responseTimeout : node arme ce timer à la connexion, et le framework ne ré-arme que si la valeur diffère (`socket.timeout !== ms`) — l'alignement économise 1 setTimeout par requête sans changer le comportement effectif (l'arm framework 30 s dominait déjà)."),
-	requestTimeout: z.number().int().nonnegative().default(3e4).describe("Timeout de réception requête complète (ms) — anti slow-loris."),
-	responseTimeout: z.number().int().nonnegative().default(3e4).describe("Timeout d'envoi de la réponse complète (ms)."),
+	requestTimeout: z.number().int().nonnegative().default(3e4).describe("Timeout de réception requête complète (ms) — anti slow-loris. HTTP/1.1 : borne native de Node ; HTTP/2 : borne du framework (corps lu par le pipeline), 408 puis flux fermé. 0 désactive."),
+	responseTimeout: z.number().int().nonnegative().default(3e4).describe("Délai d'inactivité d'une action (ms) : au-delà, 503 et `ctx.signal` annulé. Une route le règle pour elle-même (option `responseTimeout`)."),
 	shutdownTimeout: z.number().int().nonnegative().default(5e3).describe("Drain graceful au shutdown (ms) : délai laissé aux requêtes in-flight avant destruction forcée des sockets (SIGTERM/docker stop). Doit rester < grace period de l'orchestrateur (30 s k8s, 10 s Docker)."),
 	headers: z.record(z.string(), z.string()).nullable().default(null).describe("En-têtes ajoutés à toutes les réponses. `null` = aucun.")
 }).describe("Serveur HTTP (node:http, port 5151). Loose : toute option `net.Server`/`http.Server` supplémentaire (insecureHTTPParser, maxRequestsPerSocket…) est transmise.");
@@ -221,6 +222,7 @@ const websocketSchema = z.looseObject({
 	})]).default(false).describe("Compression permessage-deflate (RFC 7692). Défaut false : la compression coûte CPU + mémoire et expose au zip-bomb (un petit payload compressé se décompresse en message géant). `true` = options par défaut, ou objet pour régler fenêtres / seuil / concurrence. N'activer que si le gain réseau le justifie."),
 	skipUTF8Validation: z.boolean().default(false).describe("Désactive la validation UTF-8 des frames texte (RFC 6455 §8.1). Gain CPU au prix de l'acceptation de frames texte invalides — laisser false sauf charge extrême maîtrisée."),
 	autoPong: z.boolean().default(true).describe("Répond automatiquement par un pong à chaque ping entrant (RFC 6455 §5.5.2-5.5.3). Laisser true — requis par le protocole et par le heartbeat des pairs."),
+	maxPendingAutoPongs: z.number().int().nonnegative().default(60).describe("Pongs automatiques en attente d'écriture au-delà desquels la connexion est COUPÉE (ws@8.23+). Borne la mémoire face à un pair qui inonde de pings sans jamais lire : chaque ping met un pong en file, et la file d'un pair qui ne lit pas grossit jusqu'à l'épuisement du process. Un pair sain n'a jamais plus de quelques pongs en vol. 0 = sans borne (vulnérable). Défaut 60, celui de `ws`."),
 	allowSynchronousEvents: z.boolean().default(true).describe("Émet les events ('message', 'ping'…) de plusieurs frames lues dans un même chunk réseau de façon synchrone (ws@8.18+). true = meilleur débit ; false = un event par tick d'event loop (latence plus régulière, plus équitable entre connexions)."),
 	maxBackpressure: z.number().int().nonnegative().default(4194304).describe("Seuil (octets) du buffer d'envoi par connexion (`ws.bufferedAmount`) au-delà duquel `backpressurePolicy` s'applique. Borne la RAM d'envoi face à un client LENT À RECEVOIR (anti-OOM) ; broadcast() amplifie (un seul lent peut plomber la diffusion). 0 = désactivé. Défaut 4 MiB."),
 	backpressureCloseAfterDrops: z.number().int().nonnegative().default(1e3).describe("SOLDE de frames refusées au-delà duquel la connexion est FERMÉE (1013), en politique 'drop' : +1 par frame refusée, −1 par frame envoyée. POURQUOI un solde et pas un second seuil d'octets : une fois qu'on jette, plus rien n'alimente la file — elle plafonne au seuil de drop et n'atteint jamais un seuil supérieur, qui serait donc inatteignable (mesuré). Et pas une série remise à zéro au premier envoi : la file d'un client bloqué oscille autour du seuil, chaque envoi effacerait la série et il ne serait jamais fermé. Le solde, lui, distingue le pic passager du client mort. 0 = ne jamais fermer. Défaut 1000."),
@@ -329,6 +331,21 @@ const proxySchema = z.strictObject({
 		});
 	}
 }).describe("Proxy inverse : relaie un préfixe d'URL (requêtes et, sur demande, WebSocket) vers un autre serveur, sur la MÊME origine que la page — un seul certificat, l'amont peut rester sur la boucle locale. En-têtes de connexion jamais transmis, `X-Forwarded-*` et `Via` posés, `trustedHosts` appliqué, 502/504 sur amont injoignable/muet, boucle détectée (508).");
+/**
+* Section `grpc` — ce que servent les points d'entrée gRPC d'une application
+* (ADR-0026 D3, point 5). Lue au premier appel d'un service : une application
+* qui n'en déclare aucun ne la lit jamais.
+*
+* @experimental Surface gRPC, ADR-0026 D11.
+*/
+const grpcSchema = z.strictObject({
+	grpc: z.boolean().default(true).describe("Sert le protocole gRPC (HTTP/2 seulement : 5152, et 5153 si h2c est activé). Défaut de l'adaptateur Connect."),
+	grpcWeb: z.boolean().default(true).describe("Sert le protocole gRPC-Web, sur tous les serveurs actifs."),
+	connect: z.boolean().default(true).describe("Sert le protocole Connect (JSON ou binaire, `curl` compris), sur tous les serveurs actifs."),
+	readMaxBytes: z.number().int().min(1).max(GRPC_MAX_MESSAGE_BYTES).default(GRPC_DEFAULT_MAX_MESSAGE_BYTES).describe("Taille maximale d'un message REÇU, en octets (défaut 4 Mio), après décompression : au-delà, statut 8 `RESOURCE_EXHAUSTED` et la méthode n'est pas appelée. Sans borne, quelques Ko compressés peuvent se décompresser en plusieurs Gio."),
+	writeMaxBytes: z.number().int().min(1).max(GRPC_MAX_MESSAGE_BYTES).default(GRPC_DEFAULT_MAX_MESSAGE_BYTES).describe("Taille maximale d'un message ÉMIS, en octets (défaut 4 Mio) : au-delà, statut 8 `RESOURCE_EXHAUSTED`, journalisé chez nous plutôt que refusé par un client borné à 4 Mio."),
+	requireConnectProtocolHeader: z.boolean().default(false).describe("Exige l'en-tête `Connect-Protocol-Version` sur les requêtes Connect (400 sans lui). Défaut `false` : le CSRF est déjà fermé par le type de contenu et CORS, et l'exiger casse `curl` et le JSON écrit à la main.")
+}).refine((grpc) => grpc.grpc || grpc.grpcWeb || grpc.connect, { message: "grpc : au moins un protocole doit rester servi (grpc, grpcWeb ou connect) — pour ne servir aucun service gRPC, n'en déclarer aucun." }).describe("Services gRPC déclarés par `@GrpcService` (ADR-0026) : protocoles servis et bornes des messages, pour toute l'application. Expérimental.");
 const httpConfigSchema = z.strictObject({
 	headerServer: z.string().nullable().default("nodefony").meta({
 		runtimeMutable: true,
@@ -366,6 +383,12 @@ const httpConfigSchema = z.strictObject({
 	rateLimit: rateLimitSchema.default(() => rateLimitSchema.parse({})),
 	health: healthSchema.default(() => healthSchema.parse({})),
 	proxy: proxySchema.default(() => proxySchema.parse({})),
+	/**
+	* Services gRPC servis par le pipeline (ADR-0026).
+	*
+	* @experimental Surface gRPC, ADR-0026 D11.
+	*/
+	grpc: grpcSchema.default(() => grpcSchema.parse({})),
 	wsMaxConnectionsPerIp: z.number().int().positive().nullable().default(null).meta({
 		runtimeMutable: true,
 		description: "Backstop OPT-IN : plafond de connexions LONGUES CONCURRENTES par IP cliente — sockets WebSocket ET flux SSE, un seul budget pour les deux. `null` (DÉFAUT) = désactivé. Distinct de `rateLimit` (qui borne le DÉBIT d'ouverture par fenêtre) : ici on borne le NOMBRE de connexions simultanément ouvertes par IP. Au-delà, l'upgrade WebSocket est fermé (RFC 6455 close 1013) et un flux SSE répond 429. ⚠️ PORTÉE PAR PROCESS (1 pod) : un vrai plafond GLOBAL/IP se fait à l'INGRESS/LB — nginx `limit_conn`, HAProxy `sc_conn_cur`, annotation k8s `nginx.ingress.kubernetes.io/limit-connections` — qui voit TOUT le trafic, rejette AVANT que l'app paie le fd + le handshake TLS, et couvre tous les pods. En cloud-native, laisser `null` et déléguer à l'edge. N'activer (ex. 20) que sur bare-metal/VPS SANS ingress, comme défense en profondeur. IP résolue forwarded-aware (RFC 7239 + trustProxy)."

package/dist/nodefony/grpc/GrpcCall.js

@@ -0,0 +1,298 @@
+import { grpcStatusName, grpcWireOf } from "../src/grpc/refusal.js";
+import { Code, ConnectError, createContextValues } from "@connectrpc/connect";
+// nodefony/grpc/GrpcCall.ts
+/** Code 0 `OK` : Connect n'en a pas dans son énumération (`Code` part de 1). */
+const OK = 0;
+/**
+* Fiche d'un appel gRPC : ce que Nodefony attache à l'appel, et le
+* `ContextValues` que Connect remet au gestionnaire (`ctx.values`).
+*
+* Connect alloue à chaque appel un `ContextValues` fait d'un objet littéral et
+* de trois fermetures (`context-values.js#createContextValues`), dont la forme
+* change à chaque `set`. La fiche le REMPLACE (option `contextValues` de
+* l'adaptateur) : une classe à champs déclarés, méthodes au prototype, une
+* allocation par appel au lieu de quatre.
+*
+* Les clés posées par un tiers (intercepteur, porte) sont confiées à un
+* `createContextValues()` créé au premier `set` : aucune allocation tant que
+* personne n'en pose, et aucune conversion de type — la valeur rendue est celle
+* que le magasin de Connect a typée.
+*
+* C'est aussi l'appel RPC du contexte (`HttpContext.rpc`, ADR-0026 D10) : à
+* l'échéance du délai de réponse, le noyau le termine par {@link expire} ; au
+* `close` de la réponse, il en fixe le code par {@link settle}, que lisent la
+* ligne d'accès, l'audit et le canal de traçage.
+*
+* @experimental Surface gRPC, ADR-0026 D11.
+*/
+var GrpcCall = class {
+	/**
+	* L'objet qui implémente le service pour CET appel : le contrôleur, une
+	* instance par appel sous `@Scope("request")`. `null` quand l'adaptateur est
+	* appelé hors de {@link GrpcEndpoint.serve} (jamais en service normal).
+	*/
+	target;
+	/**
+	* Le contexte de la requête qui porte l'appel : l'identité y est lue
+	* (`authenticatedUser()`) sur son magasin, jamais par l'ALS, pour choisir
+	* entre 16 et 7 (ADR-0026 D5, D7). `null` hors de {@link GrpcEndpoint.serve}.
+	*/
+	context;
+	/** Magasin des clés de tiers, créé au premier `set`. */
+	#values = null;
+	/** Contexte d'appel du gestionnaire en cours (unaire, flux). */
+	#ctx = null;
+	/** Rejet de la promesse rendue à l'adaptateur (réponse unique). */
+	#reject = null;
+	/**
+	* Pourquoi le serveur a interrompu l'appel — délai échu (4), identité
+	* révoquée (16), arrêt du serveur (14) —, `null` tant qu'il ne l'a pas fait. Posé une fois : la
+	* première cause gagne.
+	*/
+	#reason = null;
+	/**
+	* Le contexte d'appel que Connect crée AVANT de lire le corps (remis par
+	* {@link open}), gardé jusqu'au `close` : son signal porte la cause de la
+	* fin, refus de Connect avant le gestionnaire compris. `null` si l'appel n'a
+	* jamais commencé (refusé par le transport).
+	*/
+	#call = null;
+	/** Code de l'appel, fixé une fois par {@link settle}. */
+	#code = null;
+	/** `paquet.Service/Méthode`, tiré du chemin à la première lecture. */
+	#method = null;
+	constructor(target, context = null) {
+		this.target = target;
+		this.context = context;
+	}
+	/**
+	* Le protocole parlé sur le fil : celui du contexte d'appel (`grpc`,
+	* `grpc-web`, `connect`) ; à défaut, celui des en-têtes de la requête.
+	*/
+	get system() {
+		const call = this.#call;
+		if (call !== null) return call.protocolName;
+		const request = this.context?.request.request;
+		const wire = request === void 0 ? 0 : grpcWireOf(request.headers);
+		if (wire === 1) return "grpc";
+		if (wire === 2) return "grpc-web";
+		return "connect";
+	}
+	/**
+	* `paquet.Service/Méthode` : le chemin de la route, que l'adaptateur a
+	* reconnu à l'octet près. Lu à la première demande, puis retenu.
+	*/
+	get method() {
+		if (this.#method !== null) return this.#method;
+		const call = this.#call;
+		const path = this.context?.request.url.pathname;
+		this.#method = path !== void 0 ? path.slice(1) : call !== null ? `${call.service.typeName}/${call.method.name}` : "";
+		return this.#method;
+	}
+	/** Le code de l'appel (0 à 16), `null` avant {@link settle}. */
+	get code() {
+		return this.#code;
+	}
+	/** Le nom du code (`OK`, `UNAVAILABLE`…), `null` avec lui. */
+	get codeName() {
+		return this.#code === null ? null : grpcStatusName(this.#code);
+	}
+	/**
+	* Garde le contexte d'appel que Connect vient de créer, avant le corps
+	* (option `requestGate` de l'adaptateur, en simple observateur).
+	*
+	* @param ctx - le contexte d'appel.
+	*
+	* @internal
+	*/
+	open(ctx) {
+		this.#call = ctx;
+	}
+	/**
+	* Fixe le code de l'appel au `close` de la réponse (ADR-0026 D10 point 2) :
+	*
+	* - motif `ConnectError` → son code ; sa cause, si c'est une `Error`, part
+	*   à la ligne d'accès (exception traduite par D7). Réponse NON finie : 1,
+	*   sauf une fin posée par le serveur (échéance 4, interruption de la fiche)
+	*   — le client est parti, quel que soit le code de son `RST_STREAM` ;
+	* - `AbortError` ou aucun motif → 0 si la réponse est finie, sinon 1 (le
+	*   client est parti — le 499 du noyau, dit en gRPC) ;
+	* - autre valeur → 13, et elle part à la ligne d'accès.
+	*
+	* Une interruption du serveur (délai échu, identité révoquée) abaisse le
+	* signal avec sa `ConnectError` : elle suit la première règle. Sans contexte
+	* d'appel, le code reste `null`.
+	*
+	* @param ended - la réponse a-t-elle été terminée par le serveur ?
+	* @returns la cause à porter par la ligne d'accès, `null` sinon.
+	*/
+	settle(ended) {
+		const call = this.#call;
+		if (this.#code !== null || call === null) return null;
+		const reason = call.signal.reason;
+		if (reason instanceof ConnectError) {
+			if (!ended && reason !== this.#reason && reason.code !== Code.DeadlineExceeded) {
+				this.#code = Code.Canceled;
+				return null;
+			}
+			this.#code = reason.code;
+			return reason.cause instanceof Error ? reason.cause : null;
+		}
+		if (endsWithoutError(reason)) {
+			this.#code = ended ? OK : Code.Canceled;
+			return null;
+		}
+		this.#code = Code.Internal;
+		return reason instanceof Error ? reason : new Error("gRPC : le gestionnaire a levé une valeur qui n'est pas une Error", { cause: reason });
+	}
+	/**
+	* Lit une valeur posée par un tiers, ou la valeur par défaut de sa clé.
+	*
+	* @param key - la clé (`createContextKey`).
+	* @returns la valeur posée, sinon `key.defaultValue`.
+	*/
+	get(key) {
+		return this.#values === null ? key.defaultValue : this.#values.get(key);
+	}
+	/**
+	* Pose une valeur pour la durée de l'appel.
+	*
+	* @param key - la clé (`createContextKey`).
+	* @param value - la valeur.
+	* @returns la fiche, pour chaîner.
+	*/
+	set(key, value) {
+		(this.#values ??= createContextValues()).set(key, value);
+		return this;
+	}
+	/**
+	* Retire une valeur ; sa clé rendra de nouveau sa valeur par défaut.
+	*
+	* @param key - la clé (`createContextKey`).
+	* @returns la fiche, pour chaîner.
+	*/
+	delete(key) {
+		this.#values?.delete(key);
+		return this;
+	}
+	/**
+	* Le délai de réponse du serveur est échu : le signal de l'appel s'abaisse
+	* (`ctx.abort`) et l'appel se termine en 4 `DEADLINE_EXCEEDED`, même si le
+	* gestionnaire ne lit pas son signal. Échu avant que le gestionnaire ne
+	* démarre : il est terminé dès son démarrage. Sans effet après la fin.
+	*/
+	expire() {
+		if (this.#reason !== null) return;
+		this.#interrupt(new ConnectError("délai de réponse du serveur dépassé", Code.DeadlineExceeded));
+	}
+	/**
+	* L'identité qui a ouvert l'appel n'est plus valable : le signal de l'appel
+	* s'abaisse et l'appel se termine en 16 `UNAUTHENTICATED`. Réponse unique :
+	* sa promesse est rejetée. Flux : il s'arrête au message suivant, même si le
+	* gestionnaire ne lit pas son signal — au plus le message déjà en vol part.
+	* Sans effet après la fin, ou après une autre interruption.
+	*/
+	revoke() {
+		if (this.#reason !== null) return;
+		this.#interrupt(new ConnectError("identité révoquée", Code.Unauthenticated));
+	}
+	/**
+	* Le serveur s'arrête : le signal de l'appel s'abaisse et l'appel se termine
+	* en 14 `UNAVAILABLE` — le client le rejoue ailleurs (ADR-0026 D8). Flux : il
+	* s'arrête au message suivant, même si le gestionnaire ne lit pas son
+	* signal. Un gestionnaire bloqué qui n'écoute rien tombe avec sa connexion, à
+	* `shutdownTimeout`. Sans effet après la fin, ou après une autre interruption.
+	*/
+	shutdown() {
+		if (this.#reason !== null) return;
+		this.#interrupt(new ConnectError("le serveur s'arrête", Code.Unavailable));
+	}
+	/**
+	* L'interruption posée par le serveur, `null` tant qu'il n'y en a pas — lue
+	* par l'enrobage d'un flux avant chaque message.
+	*
+	* @internal
+	*/
+	get interruption() {
+		return this.#reason;
+	}
+	/**
+	* Suit un gestionnaire à réponse unique (unaire, flux client) jusqu'à sa
+	* fin : une interruption pourra rejeter sa promesse.
+	*
+	* @param ctx - le contexte d'appel remis au gestionnaire.
+	* @param reject - le rejet de la promesse rendue à l'adaptateur.
+	*
+	* @internal
+	*/
+	attach(ctx, reject) {
+		this.#ctx = ctx;
+		const reason = this.#reason;
+		if (reason !== null) {
+			this.#end(reason, reject);
+			return;
+		}
+		this.#reject = reject;
+	}
+	/**
+	* Suit un gestionnaire en flux (serveur, bidirectionnel) : une interruption
+	* abaissera son signal. Son itérateur s'arrête par {@link interruption}.
+	*
+	* @param ctx - le contexte d'appel remis au gestionnaire.
+	*
+	* @internal
+	*/
+	follow(ctx) {
+		this.#ctx = ctx;
+		const reason = this.#reason;
+		if (reason !== null && hasAbort(ctx)) ctx.abort(reason);
+	}
+	/**
+	* Le gestionnaire a répondu ou levé : plus rien à terminer.
+	*
+	* @internal
+	*/
+	detach() {
+		this.#ctx = null;
+		this.#reject = null;
+	}
+	#interrupt(reason) {
+		this.#reason = reason;
+		const reject = this.#reject;
+		if (reject !== null) {
+			this.#end(reason, reject);
+			return;
+		}
+		const ctx = this.#ctx;
+		if (ctx !== null && hasAbort(ctx)) ctx.abort(reason);
+	}
+	#end(reason, reject) {
+		const ctx = this.#ctx;
+		this.detach();
+		if (ctx !== null && hasAbort(ctx)) ctx.abort(reason);
+		reject(reason);
+	}
+};
+/**
+* Garde de type : le contexte d'appel porte-t-il `abort` ? Connect le pose sur
+* tout contexte qu'il crée ; le garde le CONSTATE au lieu de le supposer, pour
+* qu'une version de Connect qui le retirerait se voie à l'exécution (et au
+* test qui le garde) plutôt que par un appel qui ne s'interrompt plus.
+*
+* @param ctx - le contexte remis au gestionnaire.
+* @returns `true` si `ctx.abort` est une fonction.
+*
+* @experimental Surface gRPC, ADR-0026 D11.
+*/
+function hasAbort(ctx) {
+	return "abort" in ctx && typeof ctx.abort === "function";
+}
+/**
+* Le motif d'une fin SANS erreur : aucun (le signal n'est pas abaissé — en
+* HTTP/1.1, l'écouteur `close` du noyau passe avant celui de Connect), ou un
+* `AbortError` (fin normale, ou client parti).
+*/
+function endsWithoutError(reason) {
+	return reason === void 0 || reason instanceof Error && reason.name === "AbortError";
+}
+export { GrpcCall, hasAbort };