@nodefony/http 10.0.0-beta.1 → 10.0.0-beta.3

package/dist/nodefony/src/servers/portBinder.js

@@ -1,5 +1,51 @@
 import { isPortListening, resolvePortPolicy } from "nodefony";
+import cluster from "node:cluster";
 //#region nodefony/src/servers/portBinder.ts
+/**
+* **portBinder** — écoute sur le port désiré, ou sur le prochain port libre.
+*
+* Pourquoi ce fichier existe : lancer deux apps Nodefony côte à côte (le repo et
+* une app générée, deux projets, un banc et une démo…) faisait mourir la seconde
+* en `EADDRINUSE`. Le port désiré est une PRÉFÉRENCE en développement ; il reste
+* un CONTRAT en production.
+*
+* ## Pourquoi retenter au `listen()` plutôt que sonder d'abord
+*
+* La tentation est d'appeler « le port 5151 est-il libre ? » puis de binder. C'est
+* une **course** (TOCTOU) : entre la réponse et le bind, un autre process peut
+* prendre le port — et on échoue quand même, après avoir cru le contraire. Le
+* `listen()` est, lui, **atomique** : soit il réussit, soit le noyau dit
+* `EADDRINUSE`. On retente donc sur l'échec réel, jamais sur une prédiction.
+*
+* ## Pourquoi une SONDE malgré cela
+*
+* Le `listen()` est atomique, mais il ne dit pas tout : un port peut être **déjà
+* servi** et le noyau l'accorder quand même. Lier `0.0.0.0:P` alors qu'un autre
+* processus tient `127.0.0.1:P` **réussit** sur macOS et les BSD — ce sont deux
+* liaisons distinctes, et les connexions locales partent à la PLUS SPÉCIFIQUE.
+* Entre familles d'adresses (`::1` tenu, `0.0.0.0` demandé), même linux
+* l'accorde. L'application annonce alors `READY`, publie ses ports… et ne reçoit
+* rien : une panne muette, et un banc qui interroge le serveur du VOISIN.
+*
+* On constate donc, AVANT de binder, qu'aucun serveur ne répond déjà là où notre
+* liaison va recevoir (`isPortListening` — une connexion en boucle locale, aucun
+* outil système, même verdict sur les trois plateformes). Ce n'est pas la sonde
+* « ce port est-il libre ? » écartée plus haut : elle ne remplace pas le repli
+* atomique, qui reste le seul à trancher la course — elle ajoute le seul conflit
+* que le noyau n'exprime JAMAIS. La course résiduelle (un tiers prend le port
+* entre la sonde et le bind) retombe donc sur `EADDRINUSE`, inchangé.
+*
+* ## Pourquoi sauter les ports réservés
+*
+* HTTP veut 5151, HTTPS veut 5152. Si 5151 est pris, incrémenter naïvement ferait
+* voler 5152 à HTTPS — qui se décalerait à son tour, en cascade. Les ports que les
+* AUTRES serveurs convoitent sont donc sautés d'emblée.
+*
+* ## Fail-loud
+*
+* Un décalage est TOUJOURS annoncé (`onShift`) : une app qui écoute ailleurs que
+* là où on l'attend sans le dire est une dégradation silencieuse.
+*/
 /** Nombre de ports essayés après le désiré, en `auto`. */
 const DEFAULT_PORT_RETRY_ATTEMPTS = 20;
 /** Port configuré d'un serveur, ou `0` (désactivé / non précisé → choix noyau). */
@@ -127,12 +173,21 @@ function isPortUnavailable(code, port) {
 * handler d'erreur durable s'installe APRÈS, sur le serveur qui écoute — sinon il
 * verrait passer les `EADDRINUSE` de repli et croirait à une panne).
 *
+* @param server - serveur à mettre en écoute.
+* @param host - hôte passé à `listen`.
+* @param plan - port désiré et nombre de replis permis.
+* @param probe - sonde de présence (injectée par le banc).
+* @param sharedListener - vrai dans un worker `node:cluster` : le port y est
+*   PARTAGÉ par le maître, et un voisin qui y répond est un frère, pas un
+*   conflit. Sans cette exception, `nodefony cluster -w N` ne gardait qu'un
+*   worker en vie — les autres mouraient sur « port déjà servi » et
+*   bouclaient en relance.
 * @returns l'adresse obtenue + le port désiré si un décalage a eu lieu.
 * @throws l'erreur de `listen` : soit un code qui ne dit pas « ce port est pris »
 *   (`ENOTFOUND`, `EACCES` sous 1024 — cf `isPortUnavailable`), soit un port
 *   indisponible après épuisement des essais (le fallback n'est PAS infini).
 */
-async function bindWithFallback(server, host, plan, probe = isPortListening) {
+async function bindWithFallback(server, host, plan, probe = isPortListening, sharedListener = cluster.isWorker) {
 	let candidate = plan.desired;
 	let used = 0;
 	/**
@@ -154,7 +209,7 @@ async function bindWithFallback(server, host, plan, probe = isPortListening) {
 		server.listen(port, host);
 	});
 	for (;;) {
-		const conflict = plan.desired === 0 || candidate !== plan.desired ? null : await detectPortConflict(candidate, host, probe);
+		const conflict = sharedListener || plan.desired === 0 || candidate !== plan.desired ? null : await detectPortConflict(candidate, host, probe);
 		const failure = conflict ? portConflictError(candidate, conflict) : await listenOnce(candidate);
 		if (failure === null) return {
 			address: server.address(),

package/dist/nodefony/src/servers/upgradeDispatch.js

@@ -0,0 +1,49 @@
+import { refuseUpgrade } from "../proxy/forward.js";
+import { STATUS_CODES } from "node:http";
+//#region nodefony/src/servers/upgradeDispatch.ts
+/**
+* Pose l'UNIQUE écouteur `upgrade` d'un serveur : le proxy inverse d'abord,
+* puis le serveur WebSocket de Nodefony.
+*
+* Pourquoi un seul écouteur : `ws` attaché par son option `server` prend TOUS
+* les upgrades et répond `400` à ceux qu'il ne reconnaît pas. Un second
+* écouteur, même posé avant, ne l'empêcherait pas de répondre sur un socket
+* déjà relayé. Le serveur `ws` est donc créé en `noServer`, et c'est ici que
+* l'upgrade lui est confié — avec ses propres contrôles intacts (`path`,
+* `verifyClient`, `maxPayload`…), que `handleUpgrade` applique.
+*
+* Entre les deux, `refusal` tranche ce qui doit être refusé AVANT le `101`
+* (RFC 6455 §4.2.2) : un chemin sans route WebSocket reçoit un statut HTTP,
+* jamais une ouverture suivie d'une fermeture.
+*
+* Sans montage, le coût par connexion est une lecture de champ.
+*
+* @param server - serveur HTTP(S) qui reçoit les upgrades
+* @param wss - serveur WebSocket de Nodefony (`noServer: true`)
+* @param relay - proxy inverse, lu à chaque upgrade (il peut naître après)
+* @param refusal - statut HTTP qui refuse l'upgrade, `null` pour l'admettre
+*   (cf `HttpKernel.websocketUpgradeRefusal`)
+* @returns la fonction qui retire l'écouteur — à appeler à l'arrêt
+*/
+function attachUpgradeDispatch(server, wss, relay, refusal) {
+	const onUpgrade = (req, socket, head) => {
+		const proxy = relay();
+		if (proxy !== null && proxy.mounts !== null) {
+			if (proxy.handleUpgrade(req, socket, head)) return;
+		}
+		const status = refusal(req);
+		if (status !== null) {
+			refuseUpgrade(socket, status, STATUS_CODES[status] ?? "Refused");
+			return;
+		}
+		wss.handleUpgrade(req, socket, head, (ws) => {
+			wss.emit("connection", ws, req);
+		});
+	};
+	server.on("upgrade", onUpgrade);
+	return () => {
+		server.removeListener("upgrade", onUpgrade);
+	};
+}
+//#endregion
+export { attachUpgradeDispatch };

package/dist/nodefony/src/session/session.js

@@ -9,6 +9,20 @@ const defaultSessionOptions = {
 };
 /** Taille de l'identifiant opaque (octets CSPRNG → base64url, 43 chars). */
 const SESSION_ID_BYTES = 32;
+/** Un sac de session relu du storage : objet, ni `null` ni tableau. */
+function isBag(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+* Une date relue du storage : `Date` d'un store mémoire, chaîne ou nombre d'un
+* store sérialisé. Toute autre forme → `undefined` (la valeur courante reste).
+* Convertie UNE fois à la lecture : `created`/`updated` sont alors toujours des
+* `Date`, et les contrôles du chemin chaud lisent `getTime()` sans allouer.
+*/
+function toDate(v) {
+	if (v instanceof Date) return v;
+	return typeof v === "string" || typeof v === "number" ? new Date(v) : void 0;
+}
 /**
 * Session serveur Nodefony — état persistant lié à une identité, indexé par un
 * identifiant **opaque** (porté par le cookie) dans un {@link ISessionStorage}
@@ -157,16 +171,19 @@ var Session = class {
 	* `onSaveSession`.
 	*
 	* @param user - principal authentifié (string) lié au blob ; défaut courant.
+	*   Fourni, il DEVIENT le principal de la session : une sauvegarde suivante,
+	*   dans la même requête, le garde sans qu'on le lui redonne.
 	*/
 	async save(user) {
+		if (user !== void 0) this.user = user;
 		if (this.readOnly) {
 			if (this.mutated) this.log(`READONLY SESSION mutated — write skipped : ${this.name}`, "WARNING");
 			return this;
 		}
 		if (!this.mutated) return this;
 		const stored = await this.storage.write(this.id, this.serialize(user));
-		this.created = stored.createdAt ?? this.created;
-		this.updated = stored.updatedAt ?? this.updated;
+		this.created = toDate(stored.createdAt) ?? this.created;
+		this.updated = toDate(stored.updatedAt) ?? this.updated;
 		this.mutated = false;
 		this.saved = true;
 		if (this.context) await this.context.fireAsync("onSaveSession", this);
@@ -234,15 +251,14 @@ var Session = class {
 		}
 		const now = Date.now();
 		if (this.options.absoluteTimeoutS && this.created) {
-			if (now - new Date(this.created).getTime() > this.options.absoluteTimeoutS * 1e3) {
+			if (!(now - this.created.getTime() <= this.options.absoluteTimeoutS * 1e3)) {
 				this.log(`SESSION EXPIRED (absolute) ==> ${this.name} : ${this.id}`, "WARNING");
 				return false;
 			}
 		}
 		const idleS = this.options.idleTimeoutS;
 		if (idleS && idleS > 0 && this.updated) {
-			const lastUsed = new Date(this.updated).getTime();
-			if (lastUsed && lastUsed + idleS * 1e3 < now) {
+			if (!(this.updated.getTime() + idleS * 1e3 >= now)) {
 				this.log(`SESSION EXPIRED (idle) ==> ${this.name} : ${this.id}`, "WARNING");
 				return false;
 			}
@@ -270,7 +286,7 @@ var Session = class {
 		if (typeof storage.touch !== "function") return;
 		if (!this.updated) return;
 		const now = Date.now();
-		const lastUsed = new Date(this.updated).getTime();
+		const lastUsed = this.updated.getTime();
 		if (lastUsed && now - lastUsed < idleS * 1e3 / 2) return;
 		await storage.touch(this.id, idleS);
 		this.updated = new Date(now);
@@ -356,12 +372,12 @@ var Session = class {
 	}
 	deSerialize(serialized) {
 		const data = serialized;
-		if (data.Attributes) for (const k in data.Attributes) this.attributesBag[k] = data.Attributes[k];
-		if (data.metaBag) for (const k in data.metaBag) this.metaBagStore[k] = data.metaBag[k];
-		if (data.flashBag) for (const k in data.flashBag) this.flashBag[k] = data.flashBag[k];
-		this.created = data.createdAt ?? this.created;
-		this.updated = data.updatedAt ?? this.updated;
-		if (data.user) this.user = data.user;
+		if (isBag(data.Attributes)) for (const k in data.Attributes) this.attributesBag[k] = data.Attributes[k];
+		if (isBag(data.metaBag)) for (const k in data.metaBag) this.metaBagStore[k] = data.metaBag[k];
+		if (isBag(data.flashBag)) for (const k in data.flashBag) this.flashBag[k] = data.flashBag[k];
+		this.created = toDate(data.createdAt) ?? this.created;
+		this.updated = toDate(data.updatedAt) ?? this.updated;
+		if (typeof data.user === "string" && data.user) this.user = data.user;
 	}
 	/** Réinitialise les trois sacs (attributs, métas, flash) — état vide. */
 	clear() {

package/dist/types/index.d.ts

@@ -76,10 +76,15 @@ export type { DomainPattern, ITrustedHostsConfig, } from "./nodefony/src/context
 export { MemoryRateLimitStore } from "./nodefony/src/rateLimit/MemoryRateLimitStore.js";
 export type { IRateLimitStore, IRateLimitOptions, RateLimitVerdict, } from "./nodefony/src/rateLimit/IRateLimitStore.js";
 export { Context, Session, SessionsService, HttpError, HttpKernel, Response, Http2Response, Response as HttpResponse, wsResponse, wsResponse as WebsocketResponse, Cookie, HttpContext, WebsocketContext, HttpRequest, Http2Request, DefaultErrorRenderer, DefaultRequestLogger, JsonAuditLogger, PrettyRequestLogger, Profiler, };
+export { SseStream, openSseStream, acceptsEventStream, SSE_HEARTBEAT_MS, } from "./nodefony/src/context/http/SseStream.js";
+export type { ISseStreamOptions, ISseSendOptions, } from "./nodefony/src/context/http/SseStream.js";
 export { schemaMismatchOf, type SchemaMismatchConfidence, } from "./nodefony/service/error-renderer.js";
 export type { ProfileEntry, ProfileSummary, ProfilePhase, ProfileQuery, ProfileSecurity, } from "./nodefony/src/profiler/Profiler.js";
 export { FrameProfile } from "./nodefony/src/profiler/FrameProfile.js";
 export type { FrameProfileInit, ProfiledArea, ProfiledResolver, } from "./nodefony/src/profiler/FrameProfile.js";
+export { default as ReverseProxy } from "./nodefony/service/reverse-proxy.js";
+export { parseProxyOrigin, normalizePrefix, proxyMountProblems, } from "./nodefony/src/proxy/rules.js";
+export type { IProxyMount, IProxyMountOptions, ProxyTarget, } from "./nodefony/interfaces/IReverseProxy.js";
 export { resolveUiDelivery, PrebuiltUi, } from "./nodefony/src/assets/prebuiltUi.js";
 export type { UiDeliveryMode, UiDeliveryResolved, IUiDeliveryResolution, IUiDeliveryOptions, IPrebuiltUiOptions, } from "./nodefony/src/assets/prebuiltUi.js";
 export type { IContext, IHttpContext, IWebsocketContext, ServerType, SchemeType, WebSocketStateType, CookiesMap, ISecurityTrace, SecurityOutcome, } from "./nodefony/interfaces/IContext.js";

package/dist/types/nodefony/config/config.d.ts

@@ -67,6 +67,7 @@ export declare const httpConfigSchema: z.ZodObject<{
         key: z.ZodDefault<z.ZodString>;
         cert: z.ZodDefault<z.ZodString>;
         privateKeyMode: z.ZodDefault<z.ZodNumber>;
+        extraCaFiles: z.ZodDefault<z.ZodArray<z.ZodString>>;
         san: z.ZodDefault<z.ZodObject<{
             dns: z.ZodDefault<z.ZodArray<z.ZodString>>;
             ip: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -87,6 +88,7 @@ export declare const httpConfigSchema: z.ZodObject<{
                 name: z.ZodOptional<z.ZodString>;
                 value: z.ZodOptional<z.ZodString>;
                 shortName: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodString>;
             }, z.core.$loose>>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
@@ -183,6 +185,21 @@ export declare const httpConfigSchema: z.ZodObject<{
         readinessPath: z.ZodDefault<z.ZodString>;
         shutdownDelay: z.ZodDefault<z.ZodNumber>;
     }, z.core.$loose>>;
+    proxy: z.ZodDefault<z.ZodObject<{
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        connectTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxSockets: z.ZodDefault<z.ZodNumber>;
+        mounts: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            target: z.ZodString;
+            methods: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            websocket: z.ZodDefault<z.ZodBoolean>;
+            stripPrefix: z.ZodDefault<z.ZodBoolean>;
+            preserveHost: z.ZodDefault<z.ZodBoolean>;
+            stripHeaders: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            secure: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
     wsMaxConnectionsPerIp: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strict>;
 /** Type de sortie (config normalisée + défauts appliqués). */

package/dist/types/nodefony/interfaces/IContext.d.ts

@@ -86,6 +86,8 @@ export interface IContext {
     cookieSession: ICookie | null | undefined;
     cookies: CookiesMap;
     user: unknown;
+    /** Identifiant de l'appelant authentifié (pare-feu), lisible au démontage. */
+    userIdentifier: string | null;
     error: Error | null | undefined;
     metaData: object;
     readonly phases: PhaseTiming[];

package/dist/types/nodefony/interfaces/IErrorRenderer.d.ts

@@ -46,7 +46,7 @@ export interface IErrorWebsocketResult {
  *
  * Override via `httpKernel.setErrorRenderer(custom)` to customise:
  *   - hide stack traces in prod
- *   - emit RFC 7807 problem+json
+ *   - emit RFC 9457 problem+json
  *   - inject auth challenge headers
  */
 export interface IErrorRenderer {

package/dist/types/nodefony/interfaces/IReverseProxy.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Origine d'un amont relayé : `scheme://hôte[:port]`, sans chemin.
+ *
+ * Une fonction quand l'origine n'est connue qu'à l'exécution (un serveur
+ * enfant qui choisit son port au démarrage) : elle est rappelée à chaque
+ * requête, et `undefined` signifie « l'amont n'est pas prêt » — la requête
+ * reçoit `503` (`Retry-After: 1`), l'upgrade WebSocket `503` avant tout `101` :
+ * le préfixe appartient à l'amont, le routage n'a rien à y répondre.
+ */
+export type ProxyTarget = string | (() => string | undefined);
+/**
+ * Réglages d'un montage du proxy inverse (`ReverseProxy.mount`).
+ *
+ * Les défauts sont ceux d'un relais sans surprise : toutes les méthodes, le
+ * chemin transmis tel quel, l'en-tête `Host` réécrit sur la cible, aucun
+ * en-tête retiré au-delà des en-têtes de connexion, certificat de la cible
+ * vérifié.
+ */
+export interface IProxyMountOptions {
+    /** Origine de l'amont (cf {@link ProxyTarget}). */
+    target: ProxyTarget;
+    /**
+     * Méthodes relayées (majuscules). Une autre méthode n'est PAS relayée : la
+     * requête poursuit jusqu'au routage. Absent = toutes.
+     */
+    methods?: readonly string[] | undefined;
+    /**
+     * Relaie aussi l'upgrade WebSocket du préfixe. Sans ce drapeau, un upgrade
+     * sur le préfixe reste au serveur WebSocket de Nodefony.
+     */
+    websocket?: boolean | undefined;
+    /**
+     * Retire le préfixe avant de transmettre le chemin (`/svc/a` → `/a`).
+     * Défaut `false` : l'amont reçoit le chemin complet — c'est le cas d'un
+     * serveur qui connaît déjà son préfixe (Vite et son `base`).
+     */
+    stripPrefix?: boolean | undefined;
+    /**
+     * Garde l'en-tête `Host` du client au lieu de le réécrire sur la cible.
+     * Défaut `false` : un amont qui filtre les noms d'hôte (Vite et son
+     * `allowedHosts`) reçoit le sien, et le nom d'origine part dans
+     * `X-Forwarded-Host`.
+     */
+    preserveHost?: boolean | undefined;
+    /**
+     * En-têtes de requête à ne pas transmettre (insensible à la casse) — ce
+     * dont l'amont n'a pas l'usage ne doit pas lui parvenir (`cookie`,
+     * `authorization` vers un serveur de sources, par exemple).
+     */
+    stripHeaders?: readonly string[] | undefined;
+    /**
+     * Délai d'inactivité de l'échange avec l'amont, en ms. Dépassé avant la
+     * réponse : 504. Absent = `proxy.timeoutMs` de la configuration (30 s par
+     * défaut). Ne s'applique pas à un WebSocket établi.
+     */
+    timeoutMs?: number | undefined;
+    /**
+     * Vérifie le certificat d'une cible `https:`. Défaut `true` — `false` n'est
+     * ACCEPTÉ que vers la boucle locale (refus au montage sinon).
+     */
+    secure?: boolean | undefined;
+}
+/** Un montage tel que le proxy le garde : préfixe normalisé + réglages. */
+export interface IProxyMount extends IProxyMountOptions {
+    /** Préfixe d'URL normalisé (`/` en tête et en fin). */
+    readonly prefix: string;
+}

package/dist/types/nodefony/interfaces/IRouting.d.ts

@@ -75,6 +75,22 @@ export interface IRequestRouter {
      * @returns le résolveur (`resolve === true` si une route a matché)
      */
     resolve(context: ContextType, cleanPathOverride?: string, methodOverride?: string): IRouteResolver;
+    /**
+     * Dit si au moins une route déclare le transport `WEBSOCKET` pour ce chemin.
+     *
+     * Lu AVANT le `101` : une socket vers un chemin sans route se refuse par un
+     * statut HTTP (RFC 6455 §4.2.2), jamais par une ouverture suivie d'une
+     * fermeture — un client qui sonde par une ouverture conclurait que le
+     * serveur l'a acceptée. La réponse est un SUR-ENSEMBLE de ce que
+     * {@link IRequestRouter.resolve} acceptera : l'hôte (`@Domain`), le
+     * sous-protocole et les exigences de variables ne sont pas jugés ici, ils
+     * restent des fermetures après ouverture — refuser à tort coûterait une
+     * connexion légitime.
+     *
+     * @param pathname - chemin de l'URL d'upgrade (WHATWG), barres finales comprises
+     * @returns `false` si aucune route WebSocket ne peut répondre à ce chemin
+     */
+    servesWebsocket(pathname: string): boolean;
     /**
      * Instance partagée d'un controller `scope: "singleton"`, créée une seule fois.
      *

package/dist/types/nodefony/interfaces/ISecurity.d.ts

@@ -42,4 +42,10 @@ export interface IFirewallGate {
     handleCors(context: ContextType): number | undefined;
     /** Pose les en-têtes de sécurité (CSP, HSTS…) de la réponse. */
     applySecurityHeaders(context: ContextType): void;
+    /**
+     * Le revalidateur de l'identité authentifiée de la requête courante, pour une
+     * connexion longue qui la gardera (flux SSE) : la même règle que les sockets
+     * WebSocket. `null` pour un anonyme — rien à révoquer.
+     */
+    currentRevalidator?(): ((nowMs?: number) => Promise<boolean>) | null;
 }

package/dist/types/nodefony/interfaces/index.d.ts

@@ -7,3 +7,4 @@ export type { IContext, IHttpContext, IWebsocketContext, ServerType, SchemeType,
 export type { IHttpKernel } from "./IHttpKernel.js";
 export type { IResolvedRoute, IRouteResolver, IRequestRouter, } from "./IRouting.js";
 export type { ISecurityZone, IFirewallGate } from "./ISecurity.js";
+export type { IProxyMount, IProxyMountOptions, ProxyTarget, } from "./IReverseProxy.js";

package/dist/types/nodefony/service/audit-logger.d.ts

@@ -17,7 +17,8 @@ import type { IHttpContext, IWebsocketContext, PhaseTiming } from "../interfaces
 export interface AuditLogEntry {
     ts: string;
     requestId: string;
-    userId: string | null;
+    /** Identifiant de l'appelant authentifié (`context.userIdentifier`), `null` sinon. */
+    userIdentifier: string | null;
     type: "http" | "ws";
     scheme: string;
     method: string | null;