nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/config/envOverride.js

@@ -0,0 +1,423 @@
+//#region src/config/envOverride.ts
+/**
+* Override générique de configuration par variable d'environnement (ADR-0006 D3).
+*
+* Forme : `NF__<MODULE>__<CHEMIN…>=valeur`. Le **double underscore `__`** sépare
+* les niveaux (choix .NET Core / Docker — explicite, sans ambiguïté avec le
+* camelCase). Le 1ᵉʳ segment = le module (`SECURITY` → `@nodefony/security`), les
+* suivants = le chemin dans sa config. Les segments sont **insensibles à la casse**
+* et résolus contre les clés RÉELLES de la config (`ACCESSTTLS` → `accessTtlS`).
+*
+* Précédence (cf ADR-0006 D5) : appliqué APRÈS le merge de l'app (`use()` /
+* `module-<name>`) et AVANT la validation Zod du module → le schéma valide/rejette
+* la valeur surchargée (fail-closed). Résolu **1× au boot** (hors hot path).
+*
+* @example
+* ```bash
+* NF__SECURITY__JWT__ACCESSTTLS=300
+* NF__HTTP__SERVERS__HTTPS__PORT=8443
+* NF__SECURITY__CORS__ORIGINS=https://a.com,https://b.com   # CSV → array
+* ```
+*/
+/** Préfixe d'un override générique (double underscore). */
+const NF_PREFIX = "NF__";
+/**
+* Coerce une valeur d'environnement (toujours une chaîne) vers son type probable.
+*
+* Coercion **explicite** (le piège `z.coerce.boolean("false") === true` est évité) :
+* `"true"/"false"` → booléen ; entier/décimal → nombre ; `[…]`/`{…}` → JSON ;
+* une chaîne contenant `,` → tableau de chaînes (CSV) ; sinon la chaîne brute.
+*
+* @param raw - valeur brute de la variable d'environnement.
+* @returns la valeur typée.
+*/
+function coerceEnvValue(raw) {
+	const v = raw.trim();
+	if (v === "true") return true;
+	if (v === "false") return false;
+	if (/^-?\d+(\.\d+)?$/.test(v)) return Number(v);
+	if (v.startsWith("[") && v.endsWith("]") || v.startsWith("{") && v.endsWith("}")) try {
+		return JSON.parse(v);
+	} catch {}
+	if (v.includes(",")) return v.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+	return v;
+}
+/**
+* Scanne `env` et extrait tous les overrides `NF__<MODULE>__<CHEMIN…>`.
+*
+* Ignore les clés sans au moins un module + un champ (`NF__X` seul), et les
+* valeurs `undefined`. Ne touche PAS `env` (lecture seule).
+*
+* @param env - source d'environnement (typiquement `process.env`).
+* @returns la liste des overrides résolus (vide si aucun).
+*/
+function parseNfEnvOverrides(env) {
+	const out = [];
+	for (const envKey in env) {
+		if (!envKey.startsWith(NF_PREFIX)) continue;
+		const segs = envKey.slice(4).split("__").filter((s) => s.length > 0);
+		if (segs.length < 2) continue;
+		const raw = env[envKey];
+		if (raw === void 0) continue;
+		const [moduleSeg, ...path] = segs;
+		out.push({
+			envKey,
+			moduleSeg: moduleSeg.toLowerCase(),
+			path: path.map((s) => s.toLowerCase()),
+			value: coerceEnvValue(raw),
+			raw
+		});
+	}
+	return out;
+}
+/**
+* Les écritures d'un booléen qu'un environnement produit réellement.
+*
+* `1`/`0` d'abord, parce que c'est la forme naturelle en shell, en Docker et en
+* manifeste k8s — et celle qui cassait le boot. `on`/`off` et `yes`/`no` sont la
+* même intention écrite autrement ; les refuser obligerait l'utilisateur à
+* deviner laquelle des trois formes son framework accepte.
+*/
+const BOOLEANS_TRUE = /* @__PURE__ */ new Set([
+	"true",
+	"1",
+	"yes",
+	"on"
+]);
+const BOOLEANS_FALSE = /* @__PURE__ */ new Set([
+	"false",
+	"0",
+	"no",
+	"off"
+]);
+/**
+* La valeur d'environnement convertie vers le type de ce qu'elle REMPLACE.
+*
+* Une variable d'environnement est toujours une chaîne ; seul le schéma sait ce
+* qu'il attend. {@link coerceEnvValue} devine sans lui, et sa devinette rendait
+* un type FAUX que la validation Zod refusait ensuite : `NF__HTTP__TRUSTPROXY=1`
+* donnait `Number(1)`, qu'aucun membre de `z.union([boolean, string, array])`
+* n'accepte — une variable DOCUMENTÉE faisait échouer le boot, à rebours du
+* 12-factor que l'ADR-0006 revendique.
+*
+* L'information manquante est pourtant à portée : la config porte déjà le
+* DÉFAUT du schéma à cet endroit, et son type dit ce qui est attendu.
+*
+* ⚠️ **Le type existant ORIENTE, il ne décide pas.** Convertir aveuglément vers
+* le type de la valeur remplacée serait une faille : `trustProxy` a pour défaut
+* `false` mais accepte aussi une CIDR, et `10.0.0.0/8` deviendrait `true`,
+* c'est-à-dire une confiance TOTALE envers les `X-Forwarded-*`. Seuls des
+* littéraux booléens reconnus sont convertis ; tout le reste retombe sur la
+* devinette, qui garde la chaîne.
+*
+* Les cibles NON ambiguës (nombre, tableau, objet, valeur absente) gardent la
+* devinette : elle y est juste, et le CSV → tableau documenté en dépend.
+*
+* @param raw - la chaîne brute de la variable d'environnement.
+* @param existing - la valeur actuellement en place (le défaut du schéma).
+* @returns la valeur à poser.
+*/
+function coerceEnvValueLike(raw, existing) {
+	const v = raw.trim().toLowerCase();
+	if (typeof existing === "boolean") {
+		if (BOOLEANS_TRUE.has(v)) return true;
+		if (BOOLEANS_FALSE.has(v)) return false;
+		return coerceEnvValue(raw);
+	}
+	if (typeof existing === "string") return raw.trim();
+	return coerceEnvValue(raw);
+}
+/**
+* Résout un segment (minuscule) vers la clé réelle d'un objet : match exact
+* d'abord, sinon match insensible à la casse. `null` si aucune clé ne correspond.
+*/
+function resolveKey(node, seg) {
+	if (seg === "__proto__" || seg === "constructor" || seg === "prototype") return null;
+	if (Object.prototype.hasOwnProperty.call(node, seg)) return seg;
+	for (const k of Object.keys(node)) if (k.toLowerCase() === seg) return k;
+	return null;
+}
+/**
+* Type déclaré par un JSON Schema pour un chemin — `null` si le chemin n'y est
+* pas déclaré, ou si le schéma prend une forme que cette lecture ne comprend pas.
+*
+* **Le schéma dit ce que la VALEUR ignore.** Une clé optionnelle sans défaut
+* n'existe pas dans l'objet de configuration : la résolution par les clés
+* présentes la déclare donc « inconnue » et refuse la surcharge, pour une clé
+* pourtant déclarée, documentée et lue par le code. Ce sont précisément les
+* réglages dont l'ABSENCE est signifiante — ceux que le framework résout par
+* environnement quand on ne les écrit pas — et donc ceux qu'un exploitant a le
+* plus besoin de poser sur une image déjà construite.
+*
+* Le core n'importe PAS zod : chaque module publie son schéma en JSON pur
+* (`Module.configSchema()`), et cette fonction n'y navigue que par `properties`.
+* Toute autre forme — `anyOf`, `$ref`, union — rend `null` : on n'assouplit que
+* ce qu'on COMPREND, et le refus d'aujourd'hui reste le comportement par défaut.
+*
+* @param schema - JSON Schema du module, tel que `Module.configSchema()` le rend.
+* @param path - segments du chemin (minuscules).
+* @returns le `type` JSON Schema de la feuille, `"unknown"` si déclarée sans type, ou `null`.
+*/
+function declaredTypeAtPath(schema, path) {
+	if (path.length === 0 || schema === null || typeof schema !== "object") return null;
+	let node = schema;
+	for (let i = 0; i < path.length; i++) {
+		const props = node.properties;
+		if (props === null || typeof props !== "object") return null;
+		const bag = props;
+		const key = resolveKey(bag, path[i]);
+		if (key === null) return null;
+		const next = bag[key];
+		if (next === null || typeof next !== "object") return null;
+		node = next;
+	}
+	const t = node.type;
+	return typeof t === "string" ? t : "unknown";
+}
+/**
+* Convertit une chaîne d'environnement vers le type que le SCHÉMA déclare.
+*
+* Sert quand la clé est absente de la valeur : il n'y a alors rien à imiter, et
+* {@link coerceEnvValueLike} devinerait — `"1"` deviendrait le nombre `1` là où
+* un booléen est attendu, et le parse du module refuserait une surcharge
+* pourtant correcte.
+*
+* @param raw - la chaîne d'environnement.
+* @param type - le `type` JSON Schema de la feuille.
+* @returns la valeur convertie ; la devinette générique si le type est inconnu.
+*/
+function coerceEnvValueForType(raw, type) {
+	const t = raw.trim();
+	if (type === "string") return t;
+	if (type === "boolean") {
+		const lowered = t.toLowerCase();
+		if (BOOLEANS_TRUE.has(lowered)) return true;
+		if (BOOLEANS_FALSE.has(lowered)) return false;
+		return t;
+	}
+	if (type === "number" || type === "integer") {
+		const n = Number(t);
+		return Number.isNaN(n) ? t : n;
+	}
+	return coerceEnvValue(t);
+}
+/**
+* Pose `value` dans `target` au `path` donné, en résolvant chaque segment contre
+* les clés EXISTANTES (insensible à la casse). N'altère QUE des chemins déjà
+* présents dans la config (= champs ayant un défaut) — un chemin inconnu n'est pas
+* créé (évite une clé fantôme à la mauvaise casse que le Zod ignorerait
+* silencieusement) : la fonction renvoie alors `false` pour signalement.
+*
+* Quand `raw` est fourni, la valeur posée est RECALCULÉE contre celle qu'elle
+* remplace ({@link coerceEnvValueLike}) : c'est ici, et nulle part ailleurs,
+* qu'on connaît à la fois la chaîne d'origine et le type attendu. Sans `raw`, le
+* comportement est inchangé — aucun appelant existant ne bouge.
+*
+* Quand `schema` est fourni, un chemin ABSENT de la valeur mais DÉCLARÉ par le
+* schéma est créé — c'est le cas d'une clé optionnelle sans défaut, dont
+* l'absence est signifiante et que rien ne permettait de poser jusqu'ici. La
+* garde reste entière pour ce qui n'est ni présent ni déclaré : c'est elle qui
+* empêche une clé fantôme à la mauvaise casse, que le parse du module
+* strippe ensuite SANS un mot.
+*
+* @param target - objet de config du module (muté en place).
+* @param path - segments du chemin (minuscules).
+* @param value - valeur à poser (devinée par {@link coerceEnvValue}).
+* @param raw - la chaîne d'environnement d'origine, quand elle est connue.
+* @param schema - JSON Schema du module ({@link declaredTypeAtPath}), s'il en publie un.
+* @returns `true` si appliqué, `false` si le chemin n'est ni présent ni déclaré.
+*/
+function applyResolvedPath(target, path, value, raw, schema) {
+	if (path.length === 0) return false;
+	const declaredType = schema === void 0 ? null : declaredTypeAtPath(schema, path);
+	let node = target;
+	for (let i = 0; i < path.length - 1; i++) {
+		const key = resolveKey(node, path[i]);
+		if (key === null) {
+			if (declaredType === null) return false;
+			const neuf = {};
+			node[path[i]] = neuf;
+			node = neuf;
+			continue;
+		}
+		const next = node[key];
+		if (typeof next !== "object" || next === null || Array.isArray(next)) return false;
+		node = next;
+	}
+	const leafKey = path[path.length - 1];
+	const leaf = resolveKey(node, leafKey);
+	if (leaf === null) {
+		if (declaredType === null) return false;
+		node[leafKey] = raw === void 0 ? value : coerceEnvValueForType(raw, declaredType);
+		return true;
+	}
+	node[leaf] = raw === void 0 ? value : coerceEnvValueLike(raw, node[leaf]);
+	return true;
+}
+/**
+* Relit la valeur posée à `path` — la SYMÉTRIQUE de {@link applyResolvedPath}.
+*
+* Sert au journal du boot : depuis que la valeur est convertie contre le type
+* attendu, ce qui est écrit dans la config n'est plus forcément ce que
+* `coerceEnvValue` avait deviné. Journaliser la devinette afficherait
+* `TRUSTPROXY = 1` sur une config qui porte `true` — le genre d'écart qu'on
+* poursuit une heure avant de comprendre qu'il vient du journal.
+*
+* @param target - objet de config du module.
+* @param path - segments du chemin (minuscules).
+* @returns la valeur en place, ou `undefined` si le chemin ne résout pas.
+*/
+function readResolvedPath(target, path) {
+	if (path.length === 0) return void 0;
+	let node = target;
+	for (let i = 0; i < path.length - 1; i++) {
+		const key = resolveKey(node, path[i]);
+		if (key === null) return void 0;
+		const next = node[key];
+		if (typeof next !== "object" || next === null || Array.isArray(next)) return;
+		node = next;
+	}
+	const leaf = resolveKey(node, path[path.length - 1]);
+	return leaf === null ? void 0 : node[leaf];
+}
+/** Heuristique : ce chemin porte-t-il un secret (à rédiger dans les logs) ? */
+function pathLooksSecret(path) {
+	return path.some((s) => /secret|password|key|token|credential/i.test(s));
+}
+/**
+* Distance d'édition de Levenshtein entre deux chaînes (2 lignes glissantes, pas
+* de matrice complète). Sert au « did you mean » : proposer la clé la plus proche
+* quand un segment d'override `NF__*` est mal orthographié.
+*
+* @param a - première chaîne.
+* @param b - seconde chaîne.
+* @returns le nombre minimal d'insertions/suppressions/substitutions.
+*/
+function editDistance(a, b) {
+	const m = a.length;
+	const n = b.length;
+	if (m === 0) return n;
+	if (n === 0) return m;
+	let prev = new Array(n + 1);
+	let curr = new Array(n + 1);
+	for (let j = 0; j <= n; j++) prev[j] = j;
+	for (let i = 1; i <= m; i++) {
+		curr[0] = i;
+		for (let j = 1; j <= n; j++) {
+			const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+			curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+		}
+		[prev, curr] = [curr, prev];
+	}
+	return prev[n];
+}
+/**
+* Parmi `candidates`, renvoie le plus proche de `target` (insensible à la casse)
+* SI la distance d'édition reste plausible (≤ 40 % de la plus longue, plancher 2)
+* — sinon `null` (ne jamais suggérer une correspondance absurde). Calque le « the
+* most similar command is » de git : aide au debug d'un nom de variable d'env mal tapé.
+*
+* @param target - segment fourni par l'utilisateur (issu d'un `NF__…`).
+* @param candidates - clés réelles existantes à comparer.
+* @returns la meilleure suggestion, ou `null` si trop éloignée.
+*/
+function closestMatch(target, candidates) {
+	const t = target.toLowerCase();
+	let best = null;
+	let bestD = Infinity;
+	for (const c of candidates) {
+		const d = editDistance(t, c.toLowerCase());
+		if (d < bestD) {
+			bestD = d;
+			best = c;
+		}
+	}
+	if (best === null) return null;
+	const threshold = Math.max(2, Math.floor(Math.max(t.length, best.length) * .4));
+	return bestD <= threshold ? best : null;
+}
+/**
+* Rejoue la résolution de `path` contre `target` pour DIAGNOSTIQUER un échec :
+* renvoie le 1ᵉʳ segment qui ne correspond à aucune clé (ou qui traverse un
+* non-objet) + les clés disponibles à ce niveau. `null` si tout résout (pas un
+* échec). Miroir de lecture seule de {@link applyResolvedPath} — ne mute rien.
+*
+* @param target - objet de config du module (non muté).
+* @param path - segments du chemin (minuscules).
+* @returns le détail de l'échec, ou `null` si le chemin résout entièrement.
+*/
+function diagnoseResolveFailure(target, path) {
+	if (path.length === 0) return null;
+	let node = target;
+	for (let i = 0; i < path.length; i++) {
+		const key = resolveKey(node, path[i]);
+		if (key === null) return {
+			index: i,
+			segment: path[i],
+			available: Object.keys(node)
+		};
+		if (i < path.length - 1) {
+			const next = node[key];
+			if (typeof next !== "object" || next === null || Array.isArray(next)) return {
+				index: i,
+				segment: path[i],
+				available: Object.keys(node)
+			};
+			node = next;
+		}
+	}
+	return null;
+}
+/**
+* Clés déclarées par le schéma au niveau `prefix` — vide si le schéma ne dit
+* rien de ce niveau, ou s'il prend une forme que cette lecture ne comprend pas.
+*
+* @param schema - JSON Schema du module, ou `undefined`.
+* @param prefix - segments déjà traversés (minuscules).
+* @returns les noms de propriétés déclarés à ce niveau.
+*/
+function declaredKeysAtPath(schema, prefix) {
+	if (schema === null || typeof schema !== "object") return [];
+	let node = schema;
+	for (const seg of prefix) {
+		const props = node.properties;
+		if (props === null || typeof props !== "object") return [];
+		const bag = props;
+		const key = resolveKey(bag, seg);
+		if (key === null) return [];
+		const next = bag[key];
+		if (next === null || typeof next !== "object") return [];
+		node = next;
+	}
+	const props = node.properties;
+	return props !== null && typeof props === "object" ? Object.keys(props) : [];
+}
+/**
+* Construit le suffixe de message « did you mean » d'un chemin d'override qui n'a
+* pas résolu contre `target` : nomme le segment fautif, propose la clé la plus
+* proche et liste les clés disponibles. Chaîne vide si rien d'exploitable.
+* Partagé par les overrides de MODULE (Kernel) et d'APP (defineConfig).
+*
+* **Les clés DÉCLARÉES comptent autant que les présentes.** Une clé optionnelle
+* sans défaut n'existe pas dans la valeur : ne lister que celle-ci proposerait à
+* l'utilisateur une liste amputée, et lui ferait chercher une faute de frappe
+* dans un nom parfaitement écrit — l'inverse du service qu'un « did you mean »
+* doit rendre.
+*
+* @param target - objet de config cible (lu seul, non muté).
+* @param path - segments du chemin de l'override (minuscules).
+* @param schema - JSON Schema du module, quand il en publie un.
+* @returns un suffixe commençant par ` — …`, ou `""`.
+*/
+function resolveFailureHint(target, path, schema) {
+	const diag = diagnoseResolveFailure(target, path);
+	if (!diag) return "";
+	const declaredKeys = declaredKeysAtPath(schema, path.slice(0, diag.index));
+	const available = [.../* @__PURE__ */ new Set([...diag.available, ...declaredKeys])].sort();
+	if (available.length === 0) return "";
+	const suggestion = closestMatch(diag.segment, available);
+	const keys = available.join(", ");
+	return suggestion ? ` — segment "${diag.segment}" inconnu, vouliez-vous dire « ${suggestion} » ? (clés: ${keys})` : ` — segment "${diag.segment}" inconnu (clés disponibles: ${keys})`;
+}
+//#endregion
+export { applyResolvedPath, closestMatch, coerceEnvValue, coerceEnvValueForType, coerceEnvValueLike, declaredKeysAtPath, declaredTypeAtPath, diagnoseResolveFailure, editDistance, parseNfEnvOverrides, pathLooksSecret, readResolvedPath, resolveFailureHint };

package/dist/node/config/infra.js

@@ -0,0 +1,163 @@
+//#region src/config/infra.ts
+const SQL_SCHEMES = Object.assign(Object.create(null), {
+	sqlite: "sqlite",
+	postgres: "postgres",
+	postgresql: "postgres",
+	mysql: "mysql",
+	mariadb: "mysql"
+});
+const MONGO_SCHEMES = /* @__PURE__ */ new Set(["mongodb", "mongodb+srv"]);
+/** Première valeur non vide parmi les clés candidates (préfixe `NF_` prioritaire). */
+function pick(env, keys) {
+	for (const key of keys) {
+		const value = env[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+}
+/**
+* Parse l'URL du infra `database` : scheme → famille + dialecte.
+*
+* @throws Error si le scheme n'est pas supporté — fail-loud au boot : une URL
+*   de base inconnue ne doit JAMAIS retomber silencieusement sur sqlite.
+*/
+function parseDatabaseUrl(url) {
+	const sep = url.indexOf(":");
+	const scheme = sep > 0 ? url.slice(0, sep).toLowerCase() : "";
+	const dialect = scheme ? SQL_SCHEMES[scheme] : void 0;
+	if (dialect) return {
+		url,
+		scheme,
+		family: "sql",
+		dialect
+	};
+	if (MONGO_SCHEMES.has(scheme)) return {
+		url,
+		scheme,
+		family: "mongo",
+		dialect: null
+	};
+	throw new Error(`NF_DATABASE_URL : scheme "${scheme || url}" non supporté — attendu sqlite:, postgres://, postgresql://, mysql://, mariadb://, mongodb:// ou mongodb+srv://`);
+}
+/**
+* Fichier SQLite d'une URL `sqlite:` du infra `database`.
+* Formes acceptées : `sqlite::memory:`, `sqlite:./relatif.db`, `sqlite:/abs.db`,
+* `sqlite:///abs.db`. URL vide après le scheme → `:memory:`.
+*/
+function sqliteFilenameFromUrl(url) {
+	let rest = url.slice(url.indexOf(":") + 1);
+	if (rest.startsWith("//")) rest = rest.slice(2);
+	return rest.length === 0 ? ":memory:" : rest;
+}
+/**
+* Résout les 3 infra déclarée depuis l'environnement. Fonction PURE
+* (aucun kernel) : consommée par le Kernel (1 fois, mémoïsé), par le contexte
+* `defineConfig` (`ctx.infra`) et par les builders de config des modules
+* adapters (drizzle/mongoose/redis) dans leur couche env.
+*
+* @param env - source d'environnement (défaut `process.env`).
+* @throws Error si l'URL du infra `database` a un scheme non supporté.
+*/
+function resolveInfra(env = process.env) {
+	const databaseUrl = pick(env, ["NF_DATABASE_URL", "DATABASE_URL"]);
+	const cacheUrl = pick(env, ["NF_REDIS_URL", "REDIS_URL"]);
+	const lokiUrl = pick(env, ["NF_LOKI_URL"]);
+	const opensearchUrl = pick(env, ["NF_OPENSEARCH_URL"]);
+	let logs = null;
+	if (lokiUrl || opensearchUrl) {
+		logs = {};
+		if (lokiUrl) logs.lokiUrl = lokiUrl;
+		if (opensearchUrl) logs.opensearchUrl = opensearchUrl;
+	}
+	const forceStore = pick(env, ["NF_STORE"]);
+	return {
+		database: databaseUrl ? parseDatabaseUrl(databaseUrl) : null,
+		cache: cacheUrl ? { url: cacheUrl } : null,
+		logs,
+		forceStore: forceStore ?? null
+	};
+}
+/** Sentinelle des champs `store` : « laisser le framework choisir selon l'infra déclarée ». */
+const AUTO_STORE = "auto";
+/** Infra vide (rien de déclaré) — fallback sûr quand le kernel est absent (tests). */
+const EMPTY_INFRA = Object.freeze({
+	database: null,
+	cache: null,
+	logs: null
+});
+/**
+* Résout la sentinelle `"auto"` d'une brique en nom de backend, borné aux
+* backends RÉELLEMENT enregistrés (`available` = `listXStores()` du registre —
+* reflète l'auto-register des adapters chargés). Couverture partielle d'une infra
+* (ex. audit sans impl mongoose) → repli `fallback` avec raison ANNONCÉE,
+* jamais d'échec : le principe « fallback annoncé, pas de dégradation
+* silencieuse » vit dans la raison retournée, que l'appelant DOIT logger.
+*
+* @param kind - nature de la donnée ({@link StoreKind}).
+* @param infra - infra résolue ({@link resolveInfra}).
+* @param available - backends enregistrés dans le registre de la brique.
+* @param fallback - backend de repli (défaut `"memory"` — c'est aussi ce que passe
+*   le service de session : aucun appelant ne demande un autre repli).
+*/
+function resolveAutoStore(kind, infra, available, fallback = "memory") {
+	if (infra.forceStore && available.includes(infra.forceStore)) return {
+		store: infra.forceStore,
+		reason: `NF_STORE=${infra.forceStore} (override global — banc de charge)`
+	};
+	const preferences = [];
+	if (kind !== "durable" && infra.cache) preferences.push({
+		store: "redis",
+		reason: "infra cache (NF_REDIS_URL)"
+	});
+	if (infra.database) {
+		const store = infra.database.family === "mongo" ? "mongoose" : "drizzle";
+		preferences.push({
+			store,
+			reason: `infra database (${infra.database.scheme})`
+		});
+	}
+	for (const preference of preferences) if (available.includes(preference.store)) return preference;
+	if (preferences.length > 0) return {
+		store: fallback,
+		reason: `backend d'infra ${preferences.map((p) => p.store).join("/")} indisponible sur cette brique (enregistrés : ${available.join(", ") || "aucun"}) — repli "${fallback}"`
+	};
+	for (const local of ["drizzle", "mongoose"]) if (available.includes(local)) return {
+		store: local,
+		reason: `aucune infra déclarée — backend local persistant "${local}" (mono-nœud)`
+	};
+	return {
+		store: fallback,
+		reason: `aucune infra déclarée, aucun backend persistant chargé — repli "${fallback}"` + (fallback === "memory" ? " (volatil)" : "")
+	};
+}
+/**
+* Déduit le nom court du backend d'un store à partir de la classe concrète de
+* son instance (convention de nommage `<Backend>XxxStore` → `drizzle`, `mongoose`,
+* `redis`, `memory`, `file`). Sert à retrouver le backend RÉEL d'un adapter posé
+* au container quand la brique a été résolue en `"auto"` (l'adapter court-circuite
+* la fabrique nommée). Classe non reconnue → nom de classe brut (honnête).
+*
+* @param store - instance de store (lue défensivement — seul `constructor.name`).
+* @returns nom court du backend, ou `"inconnu"` si l'instance n'expose pas de classe.
+*/
+function deriveStoreBackend(store) {
+	const name = store?.constructor?.name;
+	if (!name) return "inconnu";
+	const match = /^(Drizzle|Mongoose|Redis|Memory|File)/.exec(name);
+	return match ? match[1].toLowerCase() : name;
+}
+/**
+* Lit l'emplacement PHYSIQUE d'un store depuis son instance (getter public
+* `location`), pour l'écran Studio « Stores » — répond à « où mes données sont-elles
+* écrites ? ». Un store fichier (passkeys, TOTP, sessions) expose le chemin de son
+* fichier/dossier ; un store `memory` ou un backend réseau (drizzle/redis/mongoose)
+* n'expose rien → `undefined` (l'UI dérive « en mémoire » ou renvoie à l'infra).
+*
+* @param store - instance de store (lue défensivement — seul un getter `location` string).
+* @returns chemin lisible, ou `undefined` si le store n'expose pas d'emplacement.
+*/
+function readStoreLocation(store) {
+	const location = store?.location;
+	return typeof location === "string" && location.length > 0 ? location : void 0;
+}
+//#endregion
+export { AUTO_STORE, EMPTY_INFRA, deriveStoreBackend, parseDatabaseUrl, readStoreLocation, resolveAutoStore, resolveInfra, sqliteFilenameFromUrl };

package/dist/node/config/reactivity.js

@@ -0,0 +1,23 @@
+//#region src/config/reactivity.ts
+/**
+* Champs applicables À CHAUD (chemin en dot-notation). Tout champ absent est `boot`.
+*
+* `log.active` / `log.debug` / `log.requestFormat` = exactement le cadre de la
+* « fenêtre d'audit » (élever la verbosité prod temporairement sans reboot).
+*/
+const configReactivity = {
+	"log.active": "hot",
+	"log.debug": "hot",
+	"log.requestFormat": "hot"
+};
+/**
+* Réactivité d'un champ par son chemin dot-notation ; `boot` par défaut (sûr).
+*
+* @param path - chemin du champ, ex. `"log.debug"` ou `"servers.http.port"`.
+* @returns `"hot"` si le champ peut s'appliquer à chaud, sinon `"boot"`.
+*/
+function getConfigReactivity(path) {
+	return configReactivity[path] ?? "boot";
+}
+//#endregion
+export { configReactivity, getConfigReactivity };